1	/*M///////////////////////////////////////////////////////////////////////////////////////
2	//
3	// IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
4	//
5	// By downloading, copying, installing or using the software you agree to this license.
6	// If you do not agree to this license, do not download, install,
7	// copy or use the software.
8	//
9	//
10	// License Agreement
11	// For Open Source Computer Vision Library
12	//
13	// Copyright (C) 2000-2008, Intel Corporation, all rights reserved.
14	// Copyright (C) 2009, Willow Garage Inc., all rights reserved.
15	// Third party copyrights are property of their respective owners.
16	//
17	// Redistribution and use in source and binary forms, with or without modification,
18	// are permitted provided that the following conditions are met:
19	//
20	// * Redistribution's of source code must retain the above copyright notice,
21	// this list of conditions and the following disclaimer.
22	//
23	// * Redistribution's in binary form must reproduce the above copyright notice,
24	// this list of conditions and the following disclaimer in the documentation
25	// and/or other materials provided with the distribution.
26	//
27	// * The name of the copyright holders may not be used to endorse or promote products
28	// derived from this software without specific prior written permission.
29	//
30	// This software is provided by the copyright holders and contributors "as is" and
31	// any express or implied warranties, including, but not limited to, the implied
32	// warranties of merchantability and fitness for a particular purpose are disclaimed.
33	// In no event shall the Intel Corporation or contributors be liable for any direct,
34	// indirect, incidental, special, exemplary, or consequential damages
35	// (including, but not limited to, procurement of substitute goods or services;
36	// loss of use, data, or profits; or business interruption) however caused
37	// and on any theory of liability, whether in contract, strict liability,
38	// or tort (including negligence or otherwise) arising in any way out of
39	// the use of this software, even if advised of the possibility of such damage.
40	//
41	//M*/
42
43	#ifndef OPENCV_IMGPROC_HPP
44	#define OPENCV_IMGPROC_HPP
45
46	#include "opencv2/core.hpp"
47
48	/**
49	@defgroup imgproc Image Processing
50
51	This module offers a comprehensive suite of image processing functions, enabling tasks such as those listed above.
52
53	@{
54	@defgroup imgproc_filter Image Filtering
55
56	Functions and classes described in this section are used to perform various linear or non-linear
57	filtering operations on 2D images (represented as Mat's). It means that for each pixel location
58	\f$(x,y)\f$ in the source image (normally, rectangular), its neighborhood is considered and used to
59	compute the response. In case of a linear filter, it is a weighted sum of pixel values. In case of
60	morphological operations, it is the minimum or maximum values, and so on. The computed response is
61	stored in the destination image at the same location \f$(x,y)\f$. It means that the output image
62	will be of the same size as the input image. Normally, the functions support multi-channel arrays,
63	in which case every channel is processed independently. Therefore, the output image will also have
64	the same number of channels as the input one.
65
66	Another common feature of the functions and classes described in this section is that, unlike
67	simple arithmetic functions, they need to extrapolate values of some non-existing pixels. For
68	example, if you want to smooth an image using a Gaussian \f$3 \times 3\f$ filter, then, when
69	processing the left-most pixels in each row, you need pixels to the left of them, that is, outside
70	of the image. You can let these pixels be the same as the left-most image pixels ("replicated
71	border" extrapolation method), or assume that all the non-existing pixels are zeros ("constant
72	border" extrapolation method), and so on. OpenCV enables you to specify the extrapolation method.
73	For details, see #BorderTypes
74
75	@anchor filter_depths
76	### Depth combinations
77	Input depth (src.depth()) | Output depth (ddepth)
78	--------------------------|----------------------
79	CV_8U | -1/CV_16S/CV_32F/CV_64F
80	CV_16U/CV_16S | -1/CV_32F/CV_64F
81	CV_32F | -1/CV_32F
82	CV_64F | -1/CV_64F
83
84	@note when ddepth=-1, the output image will have the same depth as the source.
85
86	@note if you need double floating-point accuracy and using single floating-point input data
87	(CV_32F input and CV_64F output depth combination), you can use @ref Mat.convertTo to convert
88	the input data to the desired precision.
89
90	@defgroup imgproc_transform Geometric Image Transformations
91
92	The functions in this section perform various geometrical transformations of 2D images. They do not
93	change the image content but deform the pixel grid and map this deformed grid to the destination
94	image. In fact, to avoid sampling artifacts, the mapping is done in the reverse order, from
95	destination to the source. That is, for each pixel \f$(x, y)\f$ of the destination image, the
96	functions compute coordinates of the corresponding "donor" pixel in the source image and copy the
97	pixel value:
98
99	\f[\texttt{dst} (x,y)= \texttt{src} (f_x(x,y), f_y(x,y))\f]
100
101	In case when you specify the forward mapping \f$\left<g_x, g_y\right>: \texttt{src} \rightarrow
102	\texttt{dst}\f$, the OpenCV functions first compute the corresponding inverse mapping
103	\f$\left<f_x, f_y\right>: \texttt{dst} \rightarrow \texttt{src}\f$ and then use the above formula.
104
105	The actual implementations of the geometrical transformations, from the most generic remap and to
106	the simplest and the fastest resize, need to solve two main problems with the above formula:
107
108	- Extrapolation of non-existing pixels. Similarly to the filtering functions described in the
109	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
110	of them may fall outside of the image. In this case, an extrapolation method needs to be used.
111	OpenCV provides the same selection of extrapolation methods as in the filtering functions. In
112	addition, it provides the method #BORDER_TRANSPARENT. This means that the corresponding pixels in
113	the destination image will not be modified at all.
114
115	- Interpolation of pixel values. Usually \f$f_x(x,y)\f$ and \f$f_y(x,y)\f$ are floating-point
116	numbers. This means that \f$\left<f_x, f_y\right>\f$ can be either an affine or perspective
117	transformation, or radial lens distortion correction, and so on. So, a pixel value at fractional
118	coordinates needs to be retrieved. In the simplest case, the coordinates can be just rounded to the
119	nearest integer coordinates and the corresponding pixel can be used. This is called a
120	nearest-neighbor interpolation. However, a better result can be achieved by using more
121	sophisticated [interpolation methods](https://en.wikipedia.org/wiki/Multivariate_interpolation) ,
122	where a polynomial function is fit into some neighborhood of the computed pixel \f$(f_x(x,y),
123	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
124	interpolated pixel value. In OpenCV, you can choose between several interpolation methods. See
125	#resize for details.
126
127	@note The geometrical transformations do not work with `CV_8S` or `CV_32S` images.
128
129	@defgroup imgproc_misc Miscellaneous Image Transformations
130	@defgroup imgproc_draw Drawing Functions
131
132	Drawing functions work with matrices/images of arbitrary depth. The boundaries of the shapes can be
133	rendered with antialiasing (implemented only for 8-bit images for now). All the functions include
134	the parameter color that uses an RGB value (that may be constructed with the Scalar constructor )
135	for color images and brightness for grayscale images. For color images, the channel ordering is
136	normally *Blue, Green, Red*. This is what imshow, imread, and imwrite expect. So, if you form a
137	color using the Scalar constructor, it should look like:
138
139	\f[\texttt{Scalar} (blue \_ component, green \_ component, red \_ component[, alpha \_ component])\f]
140
141	If you are using your own image rendering and I/O functions, you can use any channel ordering. The
142	drawing functions process each channel independently and do not depend on the channel order or even
143	on the used color space. The whole image can be converted from BGR to RGB or to a different color
144	space using cvtColor .
145
146	If a drawn figure is partially or completely outside the image, the drawing functions clip it. Also,
147	many drawing functions can handle pixel coordinates specified with sub-pixel accuracy. This means
148	that the coordinates can be passed as fixed-point numbers encoded as integers. The number of
149	fractional bits is specified by the shift parameter and the real point coordinates are calculated as
150	\f$\texttt{Point}(x,y)\rightarrow\texttt{Point2f}(x*2^{-shift},y*2^{-shift})\f$ . This feature is
151	especially effective when rendering antialiased shapes.
152
153	@note The functions do not support alpha-transparency when the target image is 4-channel. In this
154	case, the color[3] is simply copied to the repainted pixels. Thus, if you want to paint
155	semi-transparent shapes, you can paint them in a separate buffer and then blend it with the main
156	image.
157
158	@defgroup imgproc_color_conversions Color Space Conversions
159	@defgroup imgproc_colormap ColorMaps in OpenCV
160
161	The human perception isn't built for observing fine changes in grayscale images. Human eyes are more
162	sensitive to observing changes between colors, so you often need to recolor your grayscale images to
163	get a clue about them. OpenCV now comes with various colormaps to enhance the visualization in your
164	computer vision application.
165
166	In OpenCV you only need applyColorMap to apply a colormap on a given image. The following sample
167	code reads the path to an image from command line, applies a Jet colormap on it and shows the
168	result:
169
170	@include snippets/imgproc_applyColorMap.cpp
171
172	@see #ColormapTypes
173
174	@defgroup imgproc_subdiv2d Planar Subdivision
175
176	The Subdiv2D class described in this section is used to perform various planar subdivision on
177	a set of 2D points (represented as vector of Point2f). OpenCV subdivides a plane into triangles
178	using the Delaunay's algorithm, which corresponds to the dual graph of the Voronoi diagram.
179	In the figure below, the Delaunay's triangulation is marked with black lines and the Voronoi
180	diagram with red lines.
181
182	
183
184	The subdivisions can be used for the 3D piece-wise transformation of a plane, morphing, fast
185	location of points on the plane, building special graphs (such as NNG,RNG), and so forth.
186
187	@defgroup imgproc_hist Histograms
188	@defgroup imgproc_shape Structural Analysis and Shape Descriptors
189	@defgroup imgproc_motion Motion Analysis and Object Tracking
190	@defgroup imgproc_feature Feature Detection
191	@defgroup imgproc_object Object Detection
192	@defgroup imgproc_segmentation Image Segmentation
193	@defgroup imgproc_hal Hardware Acceleration Layer
194	@{
195	@defgroup imgproc_hal_functions Functions
196	@defgroup imgproc_hal_interface Interface
197	@}
198	@}
199	*/
200
201	namespace cv
202	{
203
204	/** @addtogroup imgproc
205	@{
206	*/
207
208	//! @addtogroup imgproc_filter
209	//! @{
210
211	enum SpecialFilter {
212	FILTER_SCHARR = -1
213	};
214
215	//! type of morphological operation
216	enum MorphTypes{
217	MORPH_ERODE = 0, //!< see #erode
218	MORPH_DILATE = 1, //!< see #dilate
219	MORPH_OPEN = 2, //!< an opening operation
220	//!< \f[\texttt{dst} = \mathrm{open} ( \texttt{src} , \texttt{element} )= \mathrm{dilate} ( \mathrm{erode} ( \texttt{src} , \texttt{element} ))\f]
221	MORPH_CLOSE = 3, //!< a closing operation
222	//!< \f[\texttt{dst} = \mathrm{close} ( \texttt{src} , \texttt{element} )= \mathrm{erode} ( \mathrm{dilate} ( \texttt{src} , \texttt{element} ))\f]
223	MORPH_GRADIENT = 4, //!< a morphological gradient
224	//!< \f[\texttt{dst} = \mathrm{morph\_grad} ( \texttt{src} , \texttt{element} )= \mathrm{dilate} ( \texttt{src} , \texttt{element} )- \mathrm{erode} ( \texttt{src} , \texttt{element} )\f]
225	MORPH_TOPHAT = 5, //!< "top hat"
226	//!< \f[\texttt{dst} = \mathrm{tophat} ( \texttt{src} , \texttt{element} )= \texttt{src} - \mathrm{open} ( \texttt{src} , \texttt{element} )\f]
227	MORPH_BLACKHAT = 6, //!< "black hat"
228	//!< \f[\texttt{dst} = \mathrm{blackhat} ( \texttt{src} , \texttt{element} )= \mathrm{close} ( \texttt{src} , \texttt{element} )- \texttt{src}\f]
229	MORPH_HITMISS = 7 //!< "hit or miss"
230	//!< .- Only supported for CV_8UC1 binary images. A tutorial can be found in the documentation
231	};
232
233	//! shape of the structuring element
234	enum MorphShapes {
235	MORPH_RECT = 0, //!< a rectangular structuring element: \f[E_{ij}=1\f]
236	MORPH_CROSS = 1, //!< a cross-shaped structuring element:
237	//!< \f[E_{ij} = \begin{cases} 1 & \texttt{if } {i=\texttt{anchor.y } {or } {j=\texttt{anchor.x}}} \\0 & \texttt{otherwise} \end{cases}\f]
238	MORPH_ELLIPSE = 2, //!< an elliptic structuring element, that is, a filled ellipse inscribed
239	//!< into the rectangle Rect(0, 0, esize.width, esize.height)
240	MORPH_DIAMOND = 3 //!< a diamond structuring element defined by Manhattan distance
241	};
242
243	//! @} imgproc_filter
244
245	//! @addtogroup imgproc_transform
246	//! @{
247
248	//! interpolation algorithm
249	enum InterpolationFlags{
250	/** nearest neighbor interpolation */
251	INTER_NEAREST = 0,
252	/** bilinear interpolation */
253	INTER_LINEAR = 1,
254	/** bicubic interpolation */
255	INTER_CUBIC = 2,
256	/** resampling using pixel area relation. It may be a preferred method for image decimation, as
257	it gives moire'-free results. But when the image is zoomed, it is similar to the INTER_NEAREST
258	method. */
259	INTER_AREA = 3,
260	/** Lanczos interpolation over 8x8 neighborhood */
261	INTER_LANCZOS4 = 4,
262	/** Bit exact bilinear interpolation */
263	INTER_LINEAR_EXACT = 5,
264	/** Bit exact nearest neighbor interpolation. This will produce same results as
265	the nearest neighbor method in PIL, scikit-image or Matlab. */
266	INTER_NEAREST_EXACT = 6,
267	/** mask for interpolation codes */
268	INTER_MAX = 7,
269	/** flag, fills all of the destination image pixels. If some of them correspond to outliers in the
270	source image, they are set to zero */
271	WARP_FILL_OUTLIERS = 8,
272	/** flag, inverse transformation
273
274	For example, #linearPolar or #logPolar transforms:
275	- flag is __not__ set: \f$dst( \rho , \phi ) = src(x,y)\f$
276	- flag is set: \f$dst(x,y) = src( \rho , \phi )\f$
277	*/
278	WARP_INVERSE_MAP = 16,
279	WARP_RELATIVE_MAP = 32
280	};
281
282	/** \brief Specify the polar mapping mode
283	@sa warpPolar
284	*/
285	enum WarpPolarMode
286	{
287	WARP_POLAR_LINEAR = 0, ///< Remaps an image to/from polar space.
288	WARP_POLAR_LOG = 256 ///< Remaps an image to/from semilog-polar space.
289	};
290
291	enum InterpolationMasks {
292	INTER_BITS = 5,
293	INTER_BITS2 = INTER_BITS * 2,
294	INTER_TAB_SIZE = 1 << INTER_BITS,
295	INTER_TAB_SIZE2 = INTER_TAB_SIZE * INTER_TAB_SIZE
296	};
297
298	//! @} imgproc_transform
299
300	//! @addtogroup imgproc_misc
301	//! @{
302
303	//! Distance types for Distance Transform and M-estimators
304	//! @see distanceTransform, fitLine
305	enum DistanceTypes {
306	DIST_USER = -1, //!< User defined distance
307	DIST_L1 = 1, //!< distance = |x1-x2| + |y1-y2|
308	DIST_L2 = 2, //!< the simple euclidean distance
309	DIST_C = 3, //!< distance = max(|x1-x2|,|y1-y2|)
310	DIST_L12 = 4, //!< L1-L2 metric: distance = 2(sqrt(1+x*x/2) - 1))
311	DIST_FAIR = 5, //!< distance = c^2(|x|/c-log(1+|x|/c)), c = 1.3998
312	DIST_WELSCH = 6, //!< distance = c^2/2(1-exp(-(x/c)^2)), c = 2.9846
313	DIST_HUBER = 7 //!< distance = |x|<c ? x^2/2 : c(|x|-c/2), c=1.345
314	};
315
316	//! Mask size for distance transform
317	enum DistanceTransformMasks {
318	DIST_MASK_3 = 3, //!< mask=3
319	DIST_MASK_5 = 5, //!< mask=5
320	DIST_MASK_PRECISE = 0 //!<
321	};
322
323	//! type of the threshold operation
324	//! 
325	enum ThresholdTypes {
326	THRESH_BINARY = 0, //!< \f[\texttt{dst} (x,y) = \fork{\texttt{maxval}}{if \(\texttt{src}(x,y) > \texttt{thresh}\)}{0}{otherwise}\f]
327	THRESH_BINARY_INV = 1, //!< \f[\texttt{dst} (x,y) = \fork{0}{if \(\texttt{src}(x,y) > \texttt{thresh}\)}{\texttt{maxval}}{otherwise}\f]
328	THRESH_TRUNC = 2, //!< \f[\texttt{dst} (x,y) = \fork{\texttt{threshold}}{if \(\texttt{src}(x,y) > \texttt{thresh}\)}{\texttt{src}(x,y)}{otherwise}\f]
329	THRESH_TOZERO = 3, //!< \f[\texttt{dst} (x,y) = \fork{\texttt{src}(x,y)}{if \(\texttt{src}(x,y) > \texttt{thresh}\)}{0}{otherwise}\f]
330	THRESH_TOZERO_INV = 4, //!< \f[\texttt{dst} (x,y) = \fork{0}{if \(\texttt{src}(x,y) > \texttt{thresh}\)}{\texttt{src}(x,y)}{otherwise}\f]
331	THRESH_MASK = 7,
332	THRESH_OTSU = 8, //!< flag, use Otsu algorithm to choose the optimal threshold value
333	THRESH_TRIANGLE = 16, //!< flag, use Triangle algorithm to choose the optimal threshold value
334	THRESH_DRYRUN = 128 //!< flag, compute threshold only (useful for OTSU/TRIANGLE) but does not actually run thresholding
335	};
336
337	//! adaptive threshold algorithm
338	//! @see adaptiveThreshold
339	enum AdaptiveThresholdTypes {
340	/** the threshold value \f$T(x,y)\f$ is a mean of the \f$\texttt{blockSize} \times
341	\texttt{blockSize}\f$ neighborhood of \f$(x, y)\f$ minus C */
342	ADAPTIVE_THRESH_MEAN_C = 0,
343	/** the threshold value \f$T(x, y)\f$ is a weighted sum (cross-correlation with a Gaussian
344	window) of the \f$\texttt{blockSize} \times \texttt{blockSize}\f$ neighborhood of \f$(x, y)\f$
345	minus C . The default sigma (standard deviation) is used for the specified blockSize . See
346	#getGaussianKernel*/
347	ADAPTIVE_THRESH_GAUSSIAN_C = 1
348	};
349
350	//! class of the pixel in GrabCut algorithm
351	enum GrabCutClasses {
352	GC_BGD = 0, //!< an obvious background pixels
353	GC_FGD = 1, //!< an obvious foreground (object) pixel
354	GC_PR_BGD = 2, //!< a possible background pixel
355	GC_PR_FGD = 3 //!< a possible foreground pixel
356	};
357
358	//! GrabCut algorithm flags
359	enum GrabCutModes {
360	/** The function initializes the state and the mask using the provided rectangle. After that it
361	runs iterCount iterations of the algorithm. */
362	GC_INIT_WITH_RECT = 0,
363	/** The function initializes the state using the provided mask. Note that GC_INIT_WITH_RECT
364	and GC_INIT_WITH_MASK can be combined. Then, all the pixels outside of the ROI are
365	automatically initialized with GC_BGD .*/
366	GC_INIT_WITH_MASK = 1,
367	/** The value means that the algorithm should just resume. */
368	GC_EVAL = 2,
369	/** The value means that the algorithm should just run the grabCut algorithm (a single iteration) with the fixed model */
370	GC_EVAL_FREEZE_MODEL = 3
371	};
372
373	//! distanceTransform algorithm flags
374	enum DistanceTransformLabelTypes {
375	/** each connected component of zeros in src (as well as all the non-zero pixels closest to the
376	connected component) will be assigned the same label */
377	DIST_LABEL_CCOMP = 0,
378	/** each zero pixel (and all the non-zero pixels closest to it) gets its own label. */
379	DIST_LABEL_PIXEL = 1
380	};
381
382	//! floodfill algorithm flags
383	enum FloodFillFlags {
384	/** If set, the difference between the current pixel and seed pixel is considered. Otherwise,
385	the difference between neighbor pixels is considered (that is, the range is floating). */
386	FLOODFILL_FIXED_RANGE = 1 << 16,
387	/** If set, the function does not change the image ( newVal is ignored), and only fills the
388	mask with the value specified in bits 8-16 of flags as described above. This option only make
389	sense in function variants that have the mask parameter. */
390	FLOODFILL_MASK_ONLY = 1 << 17
391	};
392
393	//! @} imgproc_misc
394
395	//! @addtogroup imgproc_shape
396	//! @{
397
398	//! connected components statistics
399	enum ConnectedComponentsTypes {
400	CC_STAT_LEFT = 0, //!< The leftmost (x) coordinate which is the inclusive start of the bounding
401	//!< box in the horizontal direction.
402	CC_STAT_TOP = 1, //!< The topmost (y) coordinate which is the inclusive start of the bounding
403	//!< box in the vertical direction.
404	CC_STAT_WIDTH = 2, //!< The horizontal size of the bounding box
405	CC_STAT_HEIGHT = 3, //!< The vertical size of the bounding box
406	CC_STAT_AREA = 4, //!< The total area (in pixels) of the connected component
407	#ifndef CV_DOXYGEN
408	CC_STAT_MAX = 5 //!< Max enumeration value. Used internally only for memory allocation
409	#endif
410	};
411
412	//! connected components algorithm
413	enum ConnectedComponentsAlgorithmsTypes {
414	CCL_DEFAULT = -1, //!< Spaghetti @cite Bolelli2019 algorithm for 8-way connectivity, Spaghetti4C @cite Bolelli2021 algorithm for 4-way connectivity.
415	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.
416	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.
417	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.
418	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).
419	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).
420	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).
421	};
422
423	//! mode of the contour retrieval algorithm
424	enum RetrievalModes {
425	/** retrieves only the extreme outer contours. It sets `hierarchy[i][2]=hierarchy[i][3]=-1` for
426	all the contours. */
427	RETR_EXTERNAL = 0,
428	/** retrieves all of the contours without establishing any hierarchical relationships. */
429	RETR_LIST = 1,
430	/** retrieves all of the contours and organizes them into a two-level hierarchy. At the top
431	level, there are external boundaries of the components. At the second level, there are
432	boundaries of the holes. If there is another contour inside a hole of a connected component, it
433	is still put at the top level. */
434	RETR_CCOMP = 2,
435	/** retrieves all of the contours and reconstructs a full hierarchy of nested contours.*/
436	RETR_TREE = 3,
437	RETR_FLOODFILL = 4 //!<
438	};
439
440	//! the contour approximation algorithm
441	enum ContourApproximationModes {
442	/** stores absolutely all the contour points. That is, any 2 subsequent points (x1,y1) and
443	(x2,y2) of the contour will be either horizontal, vertical or diagonal neighbors, that is,
444	max(abs(x1-x2),abs(y2-y1))==1. */
445	CHAIN_APPROX_NONE = 1,
446	/** compresses horizontal, vertical, and diagonal segments and leaves only their end points.
447	For example, an up-right rectangular contour is encoded with 4 points. */
448	CHAIN_APPROX_SIMPLE = 2,
449	/** applies one of the flavors of the Teh-Chin chain approximation algorithm @cite TehChin89 */
450	CHAIN_APPROX_TC89_L1 = 3,
451	/** applies one of the flavors of the Teh-Chin chain approximation algorithm @cite TehChin89 */
452	CHAIN_APPROX_TC89_KCOS = 4
453	};
454
455	/** @brief Shape matching methods
456
457	\f$A\f$ denotes object1,\f$B\f$ denotes object2
458
459	\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$
460
461	and \f$h^A_i, h^B_i\f$ are the Hu moments of \f$A\f$ and \f$B\f$ , respectively.
462	*/
463	enum ShapeMatchModes {
464	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]
465	CONTOURS_MATCH_I2 =2, //!< \f[I_2(A,B) = \sum _{i=1...7} \left | m^A_i - m^B_i \right |\f]
466	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]
467	};
468
469	//! @} imgproc_shape
470
471	//! @addtogroup imgproc_feature
472	//! @{
473
474	//! Variants of a Hough transform
475	enum HoughModes {
476
477	/** classical or standard Hough transform. Every line is represented by two floating-point
478	numbers \f$(\rho, \theta)\f$ , where \f$\rho\f$ is a distance between (0,0) point and the line,
479	and \f$\theta\f$ is the angle between x-axis and the normal to the line. Thus, the matrix must
480	be (the created sequence will be) of CV_32FC2 type */
481	HOUGH_STANDARD = 0,
482	/** probabilistic Hough transform (more efficient in case if the picture contains a few long
483	linear segments). It returns line segments rather than the whole line. Each segment is
484	represented by starting and ending points, and the matrix must be (the created sequence will
485	be) of the CV_32SC4 type. */
486	HOUGH_PROBABILISTIC = 1,
487	/** multi-scale variant of the classical Hough transform. The lines are encoded the same way as
488	HOUGH_STANDARD. */
489	HOUGH_MULTI_SCALE = 2,
490	HOUGH_GRADIENT = 3, //!< basically *21HT*, described in @cite Yuen90
491	HOUGH_GRADIENT_ALT = 4, //!< variation of HOUGH_GRADIENT to get better accuracy
492	};
493
494	//! Variants of Line Segment %Detector
495	enum LineSegmentDetectorModes {
496	LSD_REFINE_NONE = 0, //!< No refinement applied
497	LSD_REFINE_STD = 1, //!< Standard refinement is applied. E.g. breaking arches into smaller straighter line approximations.
498	LSD_REFINE_ADV = 2 //!< Advanced refinement. Number of false alarms is calculated, lines are
499	//!< refined through increase of precision, decrement in size, etc.
500	};
501
502	//! @} imgproc_feature
503
504	/** Histogram comparison methods
505	@ingroup imgproc_hist
506	*/
507	enum HistCompMethods {
508	/** Correlation
509	\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]
510	where
511	\f[\bar{H_k} = \frac{1}{N} \sum _J H_k(J)\f]
512	and \f$N\f$ is a total number of histogram bins. */
513	HISTCMP_CORREL = 0,
514	/** Chi-Square
515	\f[d(H_1,H_2) = \sum _I \frac{\left(H_1(I)-H_2(I)\right)^2}{H_1(I)}\f] */
516	HISTCMP_CHISQR = 1,
517	/** Intersection
518	\f[d(H_1,H_2) = \sum _I \min (H_1(I), H_2(I))\f] */
519	HISTCMP_INTERSECT = 2,
520	/** Bhattacharyya distance
521	(In fact, OpenCV computes Hellinger distance, which is related to Bhattacharyya coefficient.)
522	\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] */
523	HISTCMP_BHATTACHARYYA = 3,
524	HISTCMP_HELLINGER = HISTCMP_BHATTACHARYYA, //!< Synonym for HISTCMP_BHATTACHARYYA
525	/** Alternative Chi-Square
526	\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]
527	This alternative formula is regularly used for texture comparison. See e.g. @cite Puzicha1997 */
528	HISTCMP_CHISQR_ALT = 4,
529	/** Kullback-Leibler divergence
530	\f[d(H_1,H_2) = \sum _I H_1(I) \log \left(\frac{H_1(I)}{H_2(I)}\right)\f] */
531	HISTCMP_KL_DIV = 5
532	};
533
534	/** the color conversion codes
535	@see @ref imgproc_color_conversions
536	@ingroup imgproc_color_conversions
537	*/
538	enum ColorConversionCodes {
539	COLOR_BGR2BGRA = 0, //!< add alpha channel to RGB or BGR image
540	COLOR_RGB2RGBA = COLOR_BGR2BGRA,
541
542	COLOR_BGRA2BGR = 1, //!< remove alpha channel from RGB or BGR image
543	COLOR_RGBA2RGB = COLOR_BGRA2BGR,
544
545	COLOR_BGR2RGBA = 2, //!< convert between RGB and BGR color spaces (with or without alpha channel)
546	COLOR_RGB2BGRA = COLOR_BGR2RGBA,
547
548	COLOR_RGBA2BGR = 3,
549	COLOR_BGRA2RGB = COLOR_RGBA2BGR,
550
551	COLOR_BGR2RGB = 4,
552	COLOR_RGB2BGR = COLOR_BGR2RGB,
553
554	COLOR_BGRA2RGBA = 5,
555	COLOR_RGBA2BGRA = COLOR_BGRA2RGBA,
556
557	COLOR_BGR2GRAY = 6, //!< convert between RGB/BGR and grayscale, @ref color_convert_rgb_gray "color conversions"
558	COLOR_RGB2GRAY = 7,
559	COLOR_GRAY2BGR = 8,
560	COLOR_GRAY2RGB = COLOR_GRAY2BGR,
561	COLOR_GRAY2BGRA = 9,
562	COLOR_GRAY2RGBA = COLOR_GRAY2BGRA,
563	COLOR_BGRA2GRAY = 10,
564	COLOR_RGBA2GRAY = 11,
565
566	COLOR_BGR2BGR565 = 12, //!< convert between RGB/BGR and BGR565 (16-bit images)
567	COLOR_RGB2BGR565 = 13,
568	COLOR_BGR5652BGR = 14,
569	COLOR_BGR5652RGB = 15,
570	COLOR_BGRA2BGR565 = 16,
571	COLOR_RGBA2BGR565 = 17,
572	COLOR_BGR5652BGRA = 18,
573	COLOR_BGR5652RGBA = 19,
574
575	COLOR_GRAY2BGR565 = 20, //!< convert between grayscale to BGR565 (16-bit images)
576	COLOR_BGR5652GRAY = 21,
577
578	COLOR_BGR2BGR555 = 22, //!< convert between RGB/BGR and BGR555 (16-bit images)
579	COLOR_RGB2BGR555 = 23,
580	COLOR_BGR5552BGR = 24,
581	COLOR_BGR5552RGB = 25,
582	COLOR_BGRA2BGR555 = 26,
583	COLOR_RGBA2BGR555 = 27,
584	COLOR_BGR5552BGRA = 28,
585	COLOR_BGR5552RGBA = 29,
586
587	COLOR_GRAY2BGR555 = 30, //!< convert between grayscale and BGR555 (16-bit images)
588	COLOR_BGR5552GRAY = 31,
589
590	COLOR_BGR2XYZ = 32, //!< convert RGB/BGR to CIE XYZ, @ref color_convert_rgb_xyz "color conversions"
591	COLOR_RGB2XYZ = 33,
592	COLOR_XYZ2BGR = 34,
593	COLOR_XYZ2RGB = 35,
594
595	COLOR_BGR2YCrCb = 36, //!< convert RGB/BGR to luma-chroma (aka YCC), @ref color_convert_rgb_ycrcb "color conversions"
596	COLOR_RGB2YCrCb = 37,
597	COLOR_YCrCb2BGR = 38,
598	COLOR_YCrCb2RGB = 39,
599
600	COLOR_BGR2HSV = 40, //!< convert RGB/BGR to HSV (hue saturation value) with H range 0..180 if 8 bit image, @ref color_convert_rgb_hsv "color conversions"
601	COLOR_RGB2HSV = 41,
602
603	COLOR_BGR2Lab = 44, //!< convert RGB/BGR to CIE Lab, @ref color_convert_rgb_lab "color conversions"
604	COLOR_RGB2Lab = 45,
605
606	COLOR_BGR2Luv = 50, //!< convert RGB/BGR to CIE Luv, @ref color_convert_rgb_luv "color conversions"
607	COLOR_RGB2Luv = 51,
608	COLOR_BGR2HLS = 52, //!< convert RGB/BGR to HLS (hue lightness saturation) with H range 0..180 if 8 bit image, @ref color_convert_rgb_hls "color conversions"
609	COLOR_RGB2HLS = 53,
610
611	COLOR_HSV2BGR = 54, //!< backward conversions HSV to RGB/BGR with H range 0..180 if 8 bit image
612	COLOR_HSV2RGB = 55,
613
614	COLOR_Lab2BGR = 56,
615	COLOR_Lab2RGB = 57,
616	COLOR_Luv2BGR = 58,
617	COLOR_Luv2RGB = 59,
618	COLOR_HLS2BGR = 60, //!< backward conversions HLS to RGB/BGR with H range 0..180 if 8 bit image
619	COLOR_HLS2RGB = 61,
620
621	COLOR_BGR2HSV_FULL = 66, //!< convert RGB/BGR to HSV (hue saturation value) with H range 0..255 if 8 bit image, @ref color_convert_rgb_hsv "color conversions"
622	COLOR_RGB2HSV_FULL = 67,
623	COLOR_BGR2HLS_FULL = 68, //!< convert RGB/BGR to HLS (hue lightness saturation) with H range 0..255 if 8 bit image, @ref color_convert_rgb_hls "color conversions"
624	COLOR_RGB2HLS_FULL = 69,
625
626	COLOR_HSV2BGR_FULL = 70, //!< backward conversions HSV to RGB/BGR with H range 0..255 if 8 bit image
627	COLOR_HSV2RGB_FULL = 71,
628	COLOR_HLS2BGR_FULL = 72, //!< backward conversions HLS to RGB/BGR with H range 0..255 if 8 bit image
629	COLOR_HLS2RGB_FULL = 73,
630
631	COLOR_LBGR2Lab = 74,
632	COLOR_LRGB2Lab = 75,
633	COLOR_LBGR2Luv = 76,
634	COLOR_LRGB2Luv = 77,
635
636	COLOR_Lab2LBGR = 78,
637	COLOR_Lab2LRGB = 79,
638	COLOR_Luv2LBGR = 80,
639	COLOR_Luv2LRGB = 81,
640
641	COLOR_BGR2YUV = 82, //!< convert between RGB/BGR and YUV
642	COLOR_RGB2YUV = 83,
643	COLOR_YUV2BGR = 84,
644	COLOR_YUV2RGB = 85,
645
646	COLOR_YUV2RGB_NV12 = 90, //!< 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
647	COLOR_YUV2BGR_NV12 = 91, //!< 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
648	COLOR_YUV2RGB_NV21 = 92, //!< 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
649	COLOR_YUV2BGR_NV21 = 93, //!< 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
650	COLOR_YUV420sp2RGB = COLOR_YUV2RGB_NV21, //!< synonym to NV21
651	COLOR_YUV420sp2BGR = COLOR_YUV2BGR_NV21, //!< synonym to NV21
652
653	COLOR_YUV2RGBA_NV12 = 94, //!< 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
654	COLOR_YUV2BGRA_NV12 = 95, //!< 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
655	COLOR_YUV2RGBA_NV21 = 96, //!< 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
656	COLOR_YUV2BGRA_NV21 = 97, //!< 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
657	COLOR_YUV420sp2RGBA = COLOR_YUV2RGBA_NV21, //!< synonym to NV21
658	COLOR_YUV420sp2BGRA = COLOR_YUV2BGRA_NV21, //!< synonym to NV21
659
660	COLOR_YUV2RGB_YV12 = 98, //!< 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
661	COLOR_YUV2BGR_YV12 = 99, //!< 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
662	COLOR_YUV2RGB_IYUV = 100, //!< 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
663	COLOR_YUV2BGR_IYUV = 101, //!< 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
664	COLOR_YUV2RGB_I420 = COLOR_YUV2RGB_IYUV, //!< synonym to IYUV
665	COLOR_YUV2BGR_I420 = COLOR_YUV2BGR_IYUV, //!< synonym to IYUV
666	COLOR_YUV420p2RGB = COLOR_YUV2RGB_YV12, //!< synonym to YV12
667	COLOR_YUV420p2BGR = COLOR_YUV2BGR_YV12, //!< synonym to YV12
668
669	COLOR_YUV2RGBA_YV12 = 102, //!< 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
670	COLOR_YUV2BGRA_YV12 = 103, //!< 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
671	COLOR_YUV2RGBA_IYUV = 104, //!< 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
672	COLOR_YUV2BGRA_IYUV = 105, //!< 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
673	COLOR_YUV2RGBA_I420 = COLOR_YUV2RGBA_IYUV, //!< synonym to IYUV
674	COLOR_YUV2BGRA_I420 = COLOR_YUV2BGRA_IYUV, //!< synonym to IYUV
675	COLOR_YUV420p2RGBA = COLOR_YUV2RGBA_YV12, //!< synonym to YV12
676	COLOR_YUV420p2BGRA = COLOR_YUV2BGRA_YV12, //!< synonym to YV12
677
678	COLOR_YUV2GRAY_420 = 106, //!< extract Y channel from YUV 4:2:0 image
679	COLOR_YUV2GRAY_NV21 = COLOR_YUV2GRAY_420, //!< synonym to COLOR_YUV2GRAY_420
680	COLOR_YUV2GRAY_NV12 = COLOR_YUV2GRAY_420, //!< synonym to COLOR_YUV2GRAY_420
681	COLOR_YUV2GRAY_YV12 = COLOR_YUV2GRAY_420, //!< synonym to COLOR_YUV2GRAY_420
682	COLOR_YUV2GRAY_IYUV = COLOR_YUV2GRAY_420, //!< synonym to COLOR_YUV2GRAY_420
683	COLOR_YUV2GRAY_I420 = COLOR_YUV2GRAY_420, //!< synonym to COLOR_YUV2GRAY_420
684	COLOR_YUV420sp2GRAY = COLOR_YUV2GRAY_420, //!< synonym to COLOR_YUV2GRAY_420
685	COLOR_YUV420p2GRAY = COLOR_YUV2GRAY_420, //!< synonym to COLOR_YUV2GRAY_420
686
687	COLOR_YUV2RGB_UYVY = 107, //!< 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
688	COLOR_YUV2BGR_UYVY = 108, //!< 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
689	//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
690	//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
691	COLOR_YUV2RGB_Y422 = COLOR_YUV2RGB_UYVY, //!< synonym to UYVY
692	COLOR_YUV2BGR_Y422 = COLOR_YUV2BGR_UYVY, //!< synonym to UYVY
693	COLOR_YUV2RGB_UYNV = COLOR_YUV2RGB_UYVY, //!< synonym to UYVY
694	COLOR_YUV2BGR_UYNV = COLOR_YUV2BGR_UYVY, //!< synonym to UYVY
695
696	COLOR_YUV2RGBA_UYVY = 111, //!< 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
697	COLOR_YUV2BGRA_UYVY = 112, //!< 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
698	//COLOR_YUV2RGBA_VYUY = 113, //!< 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
699	//COLOR_YUV2BGRA_VYUY = 114, //!< 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
700	COLOR_YUV2RGBA_Y422 = COLOR_YUV2RGBA_UYVY, //!< synonym to UYVY
701	COLOR_YUV2BGRA_Y422 = COLOR_YUV2BGRA_UYVY, //!< synonym to UYVY
702	COLOR_YUV2RGBA_UYNV = COLOR_YUV2RGBA_UYVY, //!< synonym to UYVY
703	COLOR_YUV2BGRA_UYNV = COLOR_YUV2BGRA_UYVY, //!< synonym to UYVY
704
705	COLOR_YUV2RGB_YUY2 = 115, //!< 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
706	COLOR_YUV2BGR_YUY2 = 116, //!< 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
707	COLOR_YUV2RGB_YVYU = 117, //!< 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
708	COLOR_YUV2BGR_YVYU = 118, //!< 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
709	COLOR_YUV2RGB_YUYV = COLOR_YUV2RGB_YUY2, //!< synonym to YUY2
710	COLOR_YUV2BGR_YUYV = COLOR_YUV2BGR_YUY2, //!< synonym to YUY2
711	COLOR_YUV2RGB_YUNV = COLOR_YUV2RGB_YUY2, //!< synonym to YUY2
712	COLOR_YUV2BGR_YUNV = COLOR_YUV2BGR_YUY2, //!< synonym to YUY2
713
714	COLOR_YUV2RGBA_YUY2 = 119, //!< 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
715	COLOR_YUV2BGRA_YUY2 = 120, //!< 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
716	COLOR_YUV2RGBA_YVYU = 121, //!< 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
717	COLOR_YUV2BGRA_YVYU = 122, //!< 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
718	COLOR_YUV2RGBA_YUYV = COLOR_YUV2RGBA_YUY2, //!< synonym to YUY2
719	COLOR_YUV2BGRA_YUYV = COLOR_YUV2BGRA_YUY2, //!< synonym to YUY2
720	COLOR_YUV2RGBA_YUNV = COLOR_YUV2RGBA_YUY2, //!< synonym to YUY2
721	COLOR_YUV2BGRA_YUNV = COLOR_YUV2BGRA_YUY2, //!< synonym to YUY2
722
723	COLOR_YUV2GRAY_UYVY = 123, //!< extract Y channel from YUV 4:2:2 image
724	COLOR_YUV2GRAY_YUY2 = 124, //!< extract Y channel from YUV 4:2:2 image
725	//CV_YUV2GRAY_VYUY = CV_YUV2GRAY_UYVY, //!< synonym to COLOR_YUV2GRAY_UYVY
726	COLOR_YUV2GRAY_Y422 = COLOR_YUV2GRAY_UYVY, //!< synonym to COLOR_YUV2GRAY_UYVY
727	COLOR_YUV2GRAY_UYNV = COLOR_YUV2GRAY_UYVY, //!< synonym to COLOR_YUV2GRAY_UYVY
728	COLOR_YUV2GRAY_YVYU = COLOR_YUV2GRAY_YUY2, //!< synonym to COLOR_YUV2GRAY_YUY2
729	COLOR_YUV2GRAY_YUYV = COLOR_YUV2GRAY_YUY2, //!< synonym to COLOR_YUV2GRAY_YUY2
730	COLOR_YUV2GRAY_YUNV = COLOR_YUV2GRAY_YUY2, //!< synonym to COLOR_YUV2GRAY_YUY2
731
732	//! alpha premultiplication
733	COLOR_RGBA2mRGBA = 125,
734	COLOR_mRGBA2RGBA = 126,
735
736	COLOR_RGB2YUV_I420 = 127, //!< 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
737	COLOR_BGR2YUV_I420 = 128, //!< 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
738	COLOR_RGB2YUV_IYUV = COLOR_RGB2YUV_I420, //!< synonym to I420
739	COLOR_BGR2YUV_IYUV = COLOR_BGR2YUV_I420, //!< synonym to I420
740
741	COLOR_RGBA2YUV_I420 = 129, //!< 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
742	COLOR_BGRA2YUV_I420 = 130, //!< 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
743	COLOR_RGBA2YUV_IYUV = COLOR_RGBA2YUV_I420, //!< synonym to I420
744	COLOR_BGRA2YUV_IYUV = COLOR_BGRA2YUV_I420, //!< synonym to I420
745	COLOR_RGB2YUV_YV12 = 131, //!< 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
746	COLOR_BGR2YUV_YV12 = 132, //!< 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
747	COLOR_RGBA2YUV_YV12 = 133, //!< 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
748	COLOR_BGRA2YUV_YV12 = 134, //!< 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
749
750	//! Demosaicing, see @ref color_convert_bayer "color conversions" for additional information
751	COLOR_BayerBG2BGR = 46, //!< equivalent to RGGB Bayer pattern
752	COLOR_BayerGB2BGR = 47, //!< equivalent to GRBG Bayer pattern
753	COLOR_BayerRG2BGR = 48, //!< equivalent to BGGR Bayer pattern
754	COLOR_BayerGR2BGR = 49, //!< equivalent to GBRG Bayer pattern
755
756	COLOR_BayerRGGB2BGR = COLOR_BayerBG2BGR,
757	COLOR_BayerGRBG2BGR = COLOR_BayerGB2BGR,
758	COLOR_BayerBGGR2BGR = COLOR_BayerRG2BGR,
759	COLOR_BayerGBRG2BGR = COLOR_BayerGR2BGR,
760
761	COLOR_BayerRGGB2RGB = COLOR_BayerBGGR2BGR,
762	COLOR_BayerGRBG2RGB = COLOR_BayerGBRG2BGR,
763	COLOR_BayerBGGR2RGB = COLOR_BayerRGGB2BGR,
764	COLOR_BayerGBRG2RGB = COLOR_BayerGRBG2BGR,
765
766	COLOR_BayerBG2RGB = COLOR_BayerRG2BGR, //!< equivalent to RGGB Bayer pattern
767	COLOR_BayerGB2RGB = COLOR_BayerGR2BGR, //!< equivalent to GRBG Bayer pattern
768	COLOR_BayerRG2RGB = COLOR_BayerBG2BGR, //!< equivalent to BGGR Bayer pattern
769	COLOR_BayerGR2RGB = COLOR_BayerGB2BGR, //!< equivalent to GBRG Bayer pattern
770
771	COLOR_BayerBG2GRAY = 86, //!< equivalent to RGGB Bayer pattern
772	COLOR_BayerGB2GRAY = 87, //!< equivalent to GRBG Bayer pattern
773	COLOR_BayerRG2GRAY = 88, //!< equivalent to BGGR Bayer pattern
774	COLOR_BayerGR2GRAY = 89, //!< equivalent to GBRG Bayer pattern
775
776	COLOR_BayerRGGB2GRAY = COLOR_BayerBG2GRAY,
777	COLOR_BayerGRBG2GRAY = COLOR_BayerGB2GRAY,
778	COLOR_BayerBGGR2GRAY = COLOR_BayerRG2GRAY,
779	COLOR_BayerGBRG2GRAY = COLOR_BayerGR2GRAY,
780
781	//! Demosaicing using Variable Number of Gradients
782	COLOR_BayerBG2BGR_VNG = 62, //!< equivalent to RGGB Bayer pattern
783	COLOR_BayerGB2BGR_VNG = 63, //!< equivalent to GRBG Bayer pattern
784	COLOR_BayerRG2BGR_VNG = 64, //!< equivalent to BGGR Bayer pattern
785	COLOR_BayerGR2BGR_VNG = 65, //!< equivalent to GBRG Bayer pattern
786
787	COLOR_BayerRGGB2BGR_VNG = COLOR_BayerBG2BGR_VNG,
788	COLOR_BayerGRBG2BGR_VNG = COLOR_BayerGB2BGR_VNG,
789	COLOR_BayerBGGR2BGR_VNG = COLOR_BayerRG2BGR_VNG,
790	COLOR_BayerGBRG2BGR_VNG = COLOR_BayerGR2BGR_VNG,
791
792	COLOR_BayerRGGB2RGB_VNG = COLOR_BayerBGGR2BGR_VNG,
793	COLOR_BayerGRBG2RGB_VNG = COLOR_BayerGBRG2BGR_VNG,
794	COLOR_BayerBGGR2RGB_VNG = COLOR_BayerRGGB2BGR_VNG,
795	COLOR_BayerGBRG2RGB_VNG = COLOR_BayerGRBG2BGR_VNG,
796
797	COLOR_BayerBG2RGB_VNG = COLOR_BayerRG2BGR_VNG, //!< equivalent to RGGB Bayer pattern
798	COLOR_BayerGB2RGB_VNG = COLOR_BayerGR2BGR_VNG, //!< equivalent to GRBG Bayer pattern
799	COLOR_BayerRG2RGB_VNG = COLOR_BayerBG2BGR_VNG, //!< equivalent to BGGR Bayer pattern
800	COLOR_BayerGR2RGB_VNG = COLOR_BayerGB2BGR_VNG, //!< equivalent to GBRG Bayer pattern
801
802	//! Edge-Aware Demosaicing
803	COLOR_BayerBG2BGR_EA = 135, //!< equivalent to RGGB Bayer pattern
804	COLOR_BayerGB2BGR_EA = 136, //!< equivalent to GRBG Bayer pattern
805	COLOR_BayerRG2BGR_EA = 137, //!< equivalent to BGGR Bayer pattern
806	COLOR_BayerGR2BGR_EA = 138, //!< equivalent to GBRG Bayer pattern
807
808	COLOR_BayerRGGB2BGR_EA = COLOR_BayerBG2BGR_EA,
809	COLOR_BayerGRBG2BGR_EA = COLOR_BayerGB2BGR_EA,
810	COLOR_BayerBGGR2BGR_EA = COLOR_BayerRG2BGR_EA,
811	COLOR_BayerGBRG2BGR_EA = COLOR_BayerGR2BGR_EA,
812
813	COLOR_BayerRGGB2RGB_EA = COLOR_BayerBGGR2BGR_EA,
814	COLOR_BayerGRBG2RGB_EA = COLOR_BayerGBRG2BGR_EA,
815	COLOR_BayerBGGR2RGB_EA = COLOR_BayerRGGB2BGR_EA,
816	COLOR_BayerGBRG2RGB_EA = COLOR_BayerGRBG2BGR_EA,
817
818	COLOR_BayerBG2RGB_EA = COLOR_BayerRG2BGR_EA, //!< equivalent to RGGB Bayer pattern
819	COLOR_BayerGB2RGB_EA = COLOR_BayerGR2BGR_EA, //!< equivalent to GRBG Bayer pattern
820	COLOR_BayerRG2RGB_EA = COLOR_BayerBG2BGR_EA, //!< equivalent to BGGR Bayer pattern
821	COLOR_BayerGR2RGB_EA = COLOR_BayerGB2BGR_EA, //!< equivalent to GBRG Bayer pattern
822
823	//! Demosaicing with alpha channel
824	COLOR_BayerBG2BGRA = 139, //!< equivalent to RGGB Bayer pattern
825	COLOR_BayerGB2BGRA = 140, //!< equivalent to GRBG Bayer pattern
826	COLOR_BayerRG2BGRA = 141, //!< equivalent to BGGR Bayer pattern
827	COLOR_BayerGR2BGRA = 142, //!< equivalent to GBRG Bayer pattern
828
829	COLOR_BayerRGGB2BGRA = COLOR_BayerBG2BGRA,
830	COLOR_BayerGRBG2BGRA = COLOR_BayerGB2BGRA,
831	COLOR_BayerBGGR2BGRA = COLOR_BayerRG2BGRA,
832	COLOR_BayerGBRG2BGRA = COLOR_BayerGR2BGRA,
833
834	COLOR_BayerRGGB2RGBA = COLOR_BayerBGGR2BGRA,
835	COLOR_BayerGRBG2RGBA = COLOR_BayerGBRG2BGRA,
836	COLOR_BayerBGGR2RGBA = COLOR_BayerRGGB2BGRA,
837	COLOR_BayerGBRG2RGBA = COLOR_BayerGRBG2BGRA,
838
839	COLOR_BayerBG2RGBA = COLOR_BayerRG2BGRA, //!< equivalent to RGGB Bayer pattern
840	COLOR_BayerGB2RGBA = COLOR_BayerGR2BGRA, //!< equivalent to GRBG Bayer pattern
841	COLOR_BayerRG2RGBA = COLOR_BayerBG2BGRA, //!< equivalent to BGGR Bayer pattern
842	COLOR_BayerGR2RGBA = COLOR_BayerGB2BGRA, //!< equivalent to GBRG Bayer pattern
843
844	COLOR_RGB2YUV_UYVY = 143, //!< 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
845	COLOR_BGR2YUV_UYVY = 144, //!< 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
846	COLOR_RGB2YUV_Y422 = COLOR_RGB2YUV_UYVY, //!< synonym to UYVY
847	COLOR_BGR2YUV_Y422 = COLOR_BGR2YUV_UYVY, //!< synonym to UYVY
848	COLOR_RGB2YUV_UYNV = COLOR_RGB2YUV_UYVY, //!< synonym to UYVY
849	COLOR_BGR2YUV_UYNV = COLOR_BGR2YUV_UYVY, //!< synonym to UYVY
850
851	COLOR_RGBA2YUV_UYVY = 145, //!< 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
852	COLOR_BGRA2YUV_UYVY = 146, //!< 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
853	COLOR_RGBA2YUV_Y422 = COLOR_RGBA2YUV_UYVY, //!< synonym to UYVY
854	COLOR_BGRA2YUV_Y422 = COLOR_BGRA2YUV_UYVY, //!< synonym to UYVY
855	COLOR_RGBA2YUV_UYNV = COLOR_RGBA2YUV_UYVY, //!< synonym to UYVY
856	COLOR_BGRA2YUV_UYNV = COLOR_BGRA2YUV_UYVY, //!< synonym to UYVY
857
858	COLOR_RGB2YUV_YUY2 = 147, //!< 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
859	COLOR_BGR2YUV_YUY2 = 148, //!< 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
860	COLOR_RGB2YUV_YVYU = 149, //!< 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
861	COLOR_BGR2YUV_YVYU = 150, //!< 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
862	COLOR_RGB2YUV_YUYV = COLOR_RGB2YUV_YUY2, //!< synonym to YUY2
863	COLOR_BGR2YUV_YUYV = COLOR_BGR2YUV_YUY2, //!< synonym to YUY2
864	COLOR_RGB2YUV_YUNV = COLOR_RGB2YUV_YUY2, //!< synonym to YUY2
865	COLOR_BGR2YUV_YUNV = COLOR_BGR2YUV_YUY2, //!< synonym to YUY2
866
867	COLOR_RGBA2YUV_YUY2 = 151, //!< 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
868	COLOR_BGRA2YUV_YUY2 = 152, //!< 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
869	COLOR_RGBA2YUV_YVYU = 153, //!< 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
870	COLOR_BGRA2YUV_YVYU = 154, //!< 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
871	COLOR_RGBA2YUV_YUYV = COLOR_RGBA2YUV_YUY2, //!< synonym to YUY2
872	COLOR_BGRA2YUV_YUYV = COLOR_BGRA2YUV_YUY2, //!< synonym to YUY2
873	COLOR_RGBA2YUV_YUNV = COLOR_RGBA2YUV_YUY2, //!< synonym to YUY2
874	COLOR_BGRA2YUV_YUNV = COLOR_BGRA2YUV_YUY2, //!< synonym to YUY2
875
876	COLOR_COLORCVT_MAX = 155
877	};
878
879	//! @addtogroup imgproc_shape
880	//! @{
881
882	//! types of intersection between rectangles
883	enum RectanglesIntersectTypes {
884	INTERSECT_NONE = 0, //!< No intersection
885	INTERSECT_PARTIAL = 1, //!< There is a partial intersection
886	INTERSECT_FULL = 2 //!< One of the rectangle is fully enclosed in the other
887	};
888
889	/** types of line
890	@ingroup imgproc_draw
891	*/
892	enum LineTypes {
893	FILLED = -1,
894	LINE_4 = 4, //!< 4-connected line
895	LINE_8 = 8, //!< 8-connected line
896	LINE_AA = 16 //!< antialiased line
897	};
898
899	/** Only a subset of Hershey fonts <https://en.wikipedia.org/wiki/Hershey_fonts> are supported
900	@ingroup imgproc_draw
901	*/
902	enum HersheyFonts {
903	FONT_HERSHEY_SIMPLEX = 0, //!< normal size sans-serif font
904	FONT_HERSHEY_PLAIN = 1, //!< small size sans-serif font
905	FONT_HERSHEY_DUPLEX = 2, //!< normal size sans-serif font (more complex than FONT_HERSHEY_SIMPLEX)
906	FONT_HERSHEY_COMPLEX = 3, //!< normal size serif font
907	FONT_HERSHEY_TRIPLEX = 4, //!< normal size serif font (more complex than FONT_HERSHEY_COMPLEX)
908	FONT_HERSHEY_COMPLEX_SMALL = 5, //!< smaller version of FONT_HERSHEY_COMPLEX
909	FONT_HERSHEY_SCRIPT_SIMPLEX = 6, //!< hand-writing style font
910	FONT_HERSHEY_SCRIPT_COMPLEX = 7, //!< more complex variant of FONT_HERSHEY_SCRIPT_SIMPLEX
911	FONT_ITALIC = 16 //!< flag for italic font
912	};
913
914	/** Possible set of marker types used for the cv::drawMarker function
915	@ingroup imgproc_draw
916	*/
917	enum MarkerTypes
918	{
919	MARKER_CROSS = 0, //!< A crosshair marker shape
920	MARKER_TILTED_CROSS = 1, //!< A 45 degree tilted crosshair marker shape
921	MARKER_STAR = 2, //!< A star marker shape, combination of cross and tilted cross
922	MARKER_DIAMOND = 3, //!< A diamond marker shape
923	MARKER_SQUARE = 4, //!< A square marker shape
924	MARKER_TRIANGLE_UP = 5, //!< An upwards pointing triangle marker shape
925	MARKER_TRIANGLE_DOWN = 6 //!< A downwards pointing triangle marker shape
926	};
927
928	/** @brief finds arbitrary template in the grayscale image using Generalized Hough Transform
929	*/
930	class CV_EXPORTS_W GeneralizedHough : public Algorithm
931	{
932	public:
933	//! set template to search
934	CV_WRAP virtual void setTemplate(InputArray templ, Point templCenter = Point(-1, -1)) = 0;
935	CV_WRAP virtual void setTemplate(InputArray edges, InputArray dx, InputArray dy, Point templCenter = Point(-1, -1)) = 0;
936
937	//! find template on image
938	CV_WRAP virtual void detect(InputArray image, OutputArray positions, OutputArray votes = noArray()) = 0;
939	CV_WRAP virtual void detect(InputArray edges, InputArray dx, InputArray dy, OutputArray positions, OutputArray votes = noArray()) = 0;
940
941	//! Canny low threshold.
942	CV_WRAP virtual void setCannyLowThresh(int cannyLowThresh) = 0;
943	CV_WRAP virtual int getCannyLowThresh() const = 0;
944
945	//! Canny high threshold.
946	CV_WRAP virtual void setCannyHighThresh(int cannyHighThresh) = 0;
947	CV_WRAP virtual int getCannyHighThresh() const = 0;
948
949	//! Minimum distance between the centers of the detected objects.
950	CV_WRAP virtual void setMinDist(double minDist) = 0;
951	CV_WRAP virtual double getMinDist() const = 0;
952
953	//! Inverse ratio of the accumulator resolution to the image resolution.
954	CV_WRAP virtual void setDp(double dp) = 0;
955	CV_WRAP virtual double getDp() const = 0;
956
957	//! Maximal size of inner buffers.
958	CV_WRAP virtual void setMaxBufferSize(int maxBufferSize) = 0;
959	CV_WRAP virtual int getMaxBufferSize() const = 0;
960	};
961
962	/** @brief finds arbitrary template in the grayscale image using Generalized Hough Transform
963
964	Detects position only without translation and rotation @cite Ballard1981 .
965	*/
966	class CV_EXPORTS_W GeneralizedHoughBallard : public GeneralizedHough
967	{
968	public:
969	//! R-Table levels.
970	CV_WRAP virtual void setLevels(int levels) = 0;
971	CV_WRAP virtual int getLevels() const = 0;
972
973	//! The accumulator threshold for the template centers at the detection stage. The smaller it is, the more false positions may be detected.
974	CV_WRAP virtual void setVotesThreshold(int votesThreshold) = 0;
975	CV_WRAP virtual int getVotesThreshold() const = 0;
976	};
977
978	/** @brief finds arbitrary template in the grayscale image using Generalized Hough Transform
979
980	Detects position, translation and rotation @cite Guil1999 .
981	*/
982	class CV_EXPORTS_W GeneralizedHoughGuil : public GeneralizedHough
983	{
984	public:
985	//! Angle difference in degrees between two points in feature.
986	CV_WRAP virtual void setXi(double xi) = 0;
987	CV_WRAP virtual double getXi() const = 0;
988
989	//! Feature table levels.
990	CV_WRAP virtual void setLevels(int levels) = 0;
991	CV_WRAP virtual int getLevels() const = 0;
992
993	//! Maximal difference between angles that treated as equal.
994	CV_WRAP virtual void setAngleEpsilon(double angleEpsilon) = 0;
995	CV_WRAP virtual double getAngleEpsilon() const = 0;
996
997	//! Minimal rotation angle to detect in degrees.
998	CV_WRAP virtual void setMinAngle(double minAngle) = 0;
999	CV_WRAP virtual double getMinAngle() const = 0;
1000
1001	//! Maximal rotation angle to detect in degrees.
1002	CV_WRAP virtual void setMaxAngle(double maxAngle) = 0;
1003	CV_WRAP virtual double getMaxAngle() const = 0;
1004
1005	//! Angle step in degrees.
1006	CV_WRAP virtual void setAngleStep(double angleStep) = 0;
1007	CV_WRAP virtual double getAngleStep() const = 0;
1008
1009	//! Angle votes threshold.
1010	CV_WRAP virtual void setAngleThresh(int angleThresh) = 0;
1011	CV_WRAP virtual int getAngleThresh() const = 0;
1012
1013	//! Minimal scale to detect.
1014	CV_WRAP virtual void setMinScale(double minScale) = 0;
1015	CV_WRAP virtual double getMinScale() const = 0;
1016
1017	//! Maximal scale to detect.
1018	CV_WRAP virtual void setMaxScale(double maxScale) = 0;
1019	CV_WRAP virtual double getMaxScale() const = 0;
1020
1021	//! Scale step.
1022	CV_WRAP virtual void setScaleStep(double scaleStep) = 0;
1023	CV_WRAP virtual double getScaleStep() const = 0;
1024
1025	//! Scale votes threshold.
1026	CV_WRAP virtual void setScaleThresh(int scaleThresh) = 0;
1027	CV_WRAP virtual int getScaleThresh() const = 0;
1028
1029	//! Position votes threshold.
1030	CV_WRAP virtual void setPosThresh(int posThresh) = 0;
1031	CV_WRAP virtual int getPosThresh() const = 0;
1032	};
1033
1034	//! @} imgproc_shape
1035
1036	//! @addtogroup imgproc_hist
1037	//! @{
1038
1039	/** @brief Base class for Contrast Limited Adaptive Histogram Equalization.
1040	*/
1041	class CV_EXPORTS_W CLAHE : public Algorithm
1042	{
1043	public:
1044	/** @brief Equalizes the histogram of a grayscale image using Contrast Limited Adaptive Histogram Equalization.
1045
1046	@param src Source image of type CV_8UC1 or CV_16UC1.
1047	@param dst Destination image.
1048	*/
1049	CV_WRAP virtual void apply(InputArray src, OutputArray dst) = 0;
1050
1051	/** @brief Sets threshold for contrast limiting.
1052
1053	@param clipLimit threshold value.
1054	*/
1055	CV_WRAP virtual void setClipLimit(double clipLimit) = 0;
1056
1057	//! Returns threshold value for contrast limiting.
1058	CV_WRAP virtual double getClipLimit() const = 0;
1059
1060	/** @brief Sets size of grid for histogram equalization. Input image will be divided into
1061	equally sized rectangular tiles.
1062
1063	@param tileGridSize defines the number of tiles in row and column.
1064	*/
1065	CV_WRAP virtual void setTilesGridSize(Size tileGridSize) = 0;
1066
1067	//!@brief Returns Size defines the number of tiles in row and column.
1068	CV_WRAP virtual Size getTilesGridSize() const = 0;
1069
1070	CV_WRAP virtual void collectGarbage() = 0;
1071	};
1072
1073	//! @} imgproc_hist
1074
1075	//! @addtogroup imgproc_subdiv2d
1076	//! @{
1077
1078	class CV_EXPORTS_W Subdiv2D
1079	{
1080	public:
1081	/** Subdiv2D point location cases */
1082	enum { PTLOC_ERROR = -2, //!< Point location error
1083	PTLOC_OUTSIDE_RECT = -1, //!< Point outside the subdivision bounding rect
1084	PTLOC_INSIDE = 0, //!< Point inside some facet
1085	PTLOC_VERTEX = 1, //!< Point coincides with one of the subdivision vertices
1086	PTLOC_ON_EDGE = 2 //!< Point on some edge
1087	};
1088
1089	/** Subdiv2D edge type navigation (see: getEdge()) */
1090	enum { NEXT_AROUND_ORG = 0x00,
1091	NEXT_AROUND_DST = 0x22,
1092	PREV_AROUND_ORG = 0x11,
1093	PREV_AROUND_DST = 0x33,
1094	NEXT_AROUND_LEFT = 0x13,
1095	NEXT_AROUND_RIGHT = 0x31,
1096	PREV_AROUND_LEFT = 0x20,
1097	PREV_AROUND_RIGHT = 0x02
1098	};
1099
1100	/** creates an empty Subdiv2D object.
1101	To create a new empty Delaunay subdivision you need to use the #initDelaunay function.
1102	*/
1103	CV_WRAP Subdiv2D();
1104
1105	/** @overload
1106
1107	@param rect Rectangle that includes all of the 2D points that are to be added to the subdivision.
1108
1109	The function creates an empty Delaunay subdivision where 2D points can be added using the function
1110	insert() . All of the points to be added must be within the specified rectangle, otherwise a runtime
1111	error is raised.
1112	*/
1113	CV_WRAP Subdiv2D(Rect rect);
1114
1115	/** @brief Creates a new empty Delaunay subdivision
1116
1117	@param rect Rectangle that includes all of the 2D points that are to be added to the subdivision.
1118
1119	*/
1120	CV_WRAP void initDelaunay(Rect rect);
1121
1122	/** @brief Insert a single point into a Delaunay triangulation.
1123
1124	@param pt Point to insert.
1125
1126	The function inserts a single point into a subdivision and modifies the subdivision topology
1127	appropriately. If a point with the same coordinates exists already, no new point is added.
1128	@returns the ID of the point.
1129
1130	@note If the point is outside of the triangulation specified rect a runtime error is raised.
1131	*/
1132	CV_WRAP int insert(Point2f pt);
1133
1134	/** @brief Insert multiple points into a Delaunay triangulation.
1135
1136	@param ptvec Points to insert.
1137
1138	The function inserts a vector of points into a subdivision and modifies the subdivision topology
1139	appropriately.
1140	*/
1141	CV_WRAP void insert(const std::vector<Point2f>& ptvec);
1142
1143	/** @brief Returns the location of a point within a Delaunay triangulation.
1144
1145	@param pt Point to locate.
1146	@param edge Output edge that the point belongs to or is located to the right of it.
1147	@param vertex Optional output vertex the input point coincides with.
1148
1149	The function locates the input point within the subdivision and gives one of the triangle edges
1150	or vertices.
1151
1152	@returns an integer which specify one of the following five cases for point location:
1153	- The point falls into some facet. The function returns #PTLOC_INSIDE and edge will contain one of
1154	edges of the facet.
1155	- The point falls onto the edge. The function returns #PTLOC_ON_EDGE and edge will contain this edge.
1156	- The point coincides with one of the subdivision vertices. The function returns #PTLOC_VERTEX and
1157	vertex will contain a pointer to the vertex.
1158	- The point is outside the subdivision reference rectangle. The function returns #PTLOC_OUTSIDE_RECT
1159	and no pointers are filled.
1160	- One of input arguments is invalid. A runtime error is raised or, if silent or "parent" error
1161	processing mode is selected, #PTLOC_ERROR is returned.
1162	*/
1163	CV_WRAP int locate(Point2f pt, CV_OUT int& edge, CV_OUT int& vertex);
1164
1165	/** @brief Finds the subdivision vertex closest to the given point.
1166
1167	@param pt Input point.
1168	@param nearestPt Output subdivision vertex point.
1169
1170	The function is another function that locates the input point within the subdivision. It finds the
1171	subdivision vertex that is the closest to the input point. It is not necessarily one of vertices
1172	of the facet containing the input point, though the facet (located using locate() ) is used as a
1173	starting point.
1174
1175	@returns vertex ID.
1176	*/
1177	CV_WRAP int findNearest(Point2f pt, CV_OUT Point2f* nearestPt = 0);
1178
1179	/** @brief Returns a list of all edges.
1180
1181	@param edgeList Output vector.
1182
1183	The function gives each edge as a 4 numbers vector, where each two are one of the edge
1184	vertices. i.e. org_x = v[0], org_y = v[1], dst_x = v[2], dst_y = v[3].
1185	*/
1186	CV_WRAP void getEdgeList(CV_OUT std::vector<Vec4f>& edgeList) const;
1187
1188	/** @brief Returns a list of the leading edge ID connected to each triangle.
1189
1190	@param leadingEdgeList Output vector.
1191
1192	The function gives one edge ID for each triangle.
1193	*/
1194	CV_WRAP void getLeadingEdgeList(CV_OUT std::vector<int>& leadingEdgeList) const;
1195
1196	/** @brief Returns a list of all triangles.
1197
1198	@param triangleList Output vector.
1199
1200	The function gives each triangle as a 6 numbers vector, where each two are one of the triangle
1201	vertices. i.e. p1_x = v[0], p1_y = v[1], p2_x = v[2], p2_y = v[3], p3_x = v[4], p3_y = v[5].
1202	*/
1203	CV_WRAP void getTriangleList(CV_OUT std::vector<Vec6f>& triangleList) const;
1204
1205	/** @brief Returns a list of all Voronoi facets.
1206
1207	@param idx Vector of vertices IDs to consider. For all vertices you can pass empty vector.
1208	@param facetList Output vector of the Voronoi facets.
1209	@param facetCenters Output vector of the Voronoi facets center points.
1210
1211	*/
1212	CV_WRAP void getVoronoiFacetList(const std::vector<int>& idx, CV_OUT std::vector<std::vector<Point2f> >& facetList,
1213	CV_OUT std::vector<Point2f>& facetCenters);
1214
1215	/** @brief Returns vertex location from vertex ID.
1216
1217	@param vertex vertex ID.
1218	@param firstEdge Optional. The first edge ID which is connected to the vertex.
1219	@returns vertex (x,y)
1220
1221	*/
1222	CV_WRAP Point2f getVertex(int vertex, CV_OUT int* firstEdge = 0) const;
1223
1224	/** @brief Returns one of the edges related to the given edge.
1225
1226	@param edge Subdivision edge ID.
1227	@param nextEdgeType Parameter specifying which of the related edges to return.
1228	The following values are possible:
1229	- NEXT_AROUND_ORG next around the edge origin ( eOnext on the picture below if e is the input edge)
1230	- NEXT_AROUND_DST next around the edge vertex ( eDnext )
1231	- PREV_AROUND_ORG previous around the edge origin (reversed eRnext )
1232	- PREV_AROUND_DST previous around the edge destination (reversed eLnext )
1233	- NEXT_AROUND_LEFT next around the left facet ( eLnext )
1234	- NEXT_AROUND_RIGHT next around the right facet ( eRnext )
1235	- PREV_AROUND_LEFT previous around the left facet (reversed eOnext )
1236	- PREV_AROUND_RIGHT previous around the right facet (reversed eDnext )
1237
1238	
1239
1240	@returns edge ID related to the input edge.
1241	*/
1242	CV_WRAP int getEdge( int edge, int nextEdgeType ) const;
1243
1244	/** @brief Returns next edge around the edge origin.
1245
1246	@param edge Subdivision edge ID.
1247
1248	@returns an integer which is next edge ID around the edge origin: eOnext on the
1249	picture above if e is the input edge).
1250	*/
1251	CV_WRAP int nextEdge(int edge) const;
1252
1253	/** @brief Returns another edge of the same quad-edge.
1254
1255	@param edge Subdivision edge ID.
1256	@param rotate Parameter specifying which of the edges of the same quad-edge as the input
1257	one to return. The following values are possible:
1258	- 0 - the input edge ( e on the picture below if e is the input edge)
1259	- 1 - the rotated edge ( eRot )
1260	- 2 - the reversed edge (reversed e (in green))
1261	- 3 - the reversed rotated edge (reversed eRot (in green))
1262
1263	@returns one of the edges ID of the same quad-edge as the input edge.
1264	*/
1265	CV_WRAP int rotateEdge(int edge, int rotate) const;
1266	CV_WRAP int symEdge(int edge) const;
1267
1268	/** @brief Returns the edge origin.
1269
1270	@param edge Subdivision edge ID.
1271	@param orgpt Output vertex location.
1272
1273	@returns vertex ID.
1274	*/
1275	CV_WRAP int edgeOrg(int edge, CV_OUT Point2f* orgpt = 0) const;
1276
1277	/** @brief Returns the edge destination.
1278
1279	@param edge Subdivision edge ID.
1280	@param dstpt Output vertex location.
1281
1282	@returns vertex ID.
1283	*/
1284	CV_WRAP int edgeDst(int edge, CV_OUT Point2f* dstpt = 0) const;
1285
1286	protected:
1287	int newEdge();
1288	void deleteEdge(int edge);
1289	int newPoint(Point2f pt, bool isvirtual, int firstEdge = 0);
1290	void deletePoint(int vtx);
1291	void setEdgePoints( int edge, int orgPt, int dstPt );
1292	void splice( int edgeA, int edgeB );
1293	int connectEdges( int edgeA, int edgeB );
1294	void swapEdges( int edge );
1295	int isRightOf(Point2f pt, int edge) const;
1296	void calcVoronoi();
1297	void clearVoronoi();
1298	void checkSubdiv() const;
1299
1300	struct CV_EXPORTS Vertex
1301	{
1302	Vertex();
1303	Vertex(Point2f pt, bool isvirtual, int firstEdge=0);
1304	bool isvirtual() const;
1305	bool isfree() const;
1306
1307	int firstEdge;
1308	int type;
1309	Point2f pt;
1310	};
1311
1312	struct CV_EXPORTS QuadEdge
1313	{
1314	QuadEdge();
1315	QuadEdge(int edgeidx);
1316	bool isfree() const;
1317
1318	int next[4];
1319	int pt[4];
1320	};
1321
1322	//! All of the vertices
1323	std::vector<Vertex> vtx;
1324	//! All of the edges
1325	std::vector<QuadEdge> qedges;
1326	int freeQEdge;
1327	int freePoint;
1328	bool validGeometry;
1329
1330	int recentEdge;
1331	//! Top left corner of the bounding rect
1332	Point2f topLeft;
1333	//! Bottom right corner of the bounding rect
1334	Point2f bottomRight;
1335	};
1336
1337	//! @} imgproc_subdiv2d
1338
1339	//! @addtogroup imgproc_feature
1340	//! @{
1341
1342	/** @example samples/cpp/lsd_lines.cpp
1343	An example using the LineSegmentDetector
1344	\image html building_lsd.png "Sample output image" width=434 height=300
1345	*/
1346
1347	/** @brief Line segment detector class
1348
1349	following the algorithm described at @cite Rafael12 .
1350
1351	@note Implementation has been removed from OpenCV version 3.4.6 to 3.4.15 and version 4.1.0 to 4.5.3 due original code license conflict.
1352	restored again after [Computation of a NFA](https://github.com/rafael-grompone-von-gioi/binomial_nfa) code published under the MIT license.
1353	*/
1354	class CV_EXPORTS_W LineSegmentDetector : public Algorithm
1355	{
1356	public:
1357
1358	/** @brief Finds lines in the input image.
1359
1360	This is the output of the default parameters of the algorithm on the above shown image.
1361
1362	
1363
1364	@param image A grayscale (CV_8UC1) input image. If only a roi needs to be selected, use:
1365	`lsd_ptr-\>detect(image(roi), lines, ...); lines += Scalar(roi.x, roi.y, roi.x, roi.y);`
1366	@param lines A vector of Vec4f elements specifying the beginning and ending point of a line. Where
1367	Vec4f is (x1, y1, x2, y2), point 1 is the start, point 2 - end. Returned lines are strictly
1368	oriented depending on the gradient.
1369	@param width Vector of widths of the regions, where the lines are found. E.g. Width of line.
1370	@param prec Vector of precisions with which the lines are found.
1371	@param nfa Vector containing number of false alarms in the line region, with precision of 10%. The
1372	bigger the value, logarithmically better the detection.
1373	- -1 corresponds to 10 mean false alarms
1374	- 0 corresponds to 1 mean false alarm
1375	- 1 corresponds to 0.1 mean false alarms
1376	This vector will be calculated only when the objects type is #LSD_REFINE_ADV.
1377	*/
1378	CV_WRAP virtual void detect(InputArray image, OutputArray lines,
1379	OutputArray width = noArray(), OutputArray prec = noArray(),
1380	OutputArray nfa = noArray()) = 0;
1381
1382	/** @brief Draws the line segments on a given image.
1383	@param image The image, where the lines will be drawn. Should be bigger or equal to the image,
1384	where the lines were found.
1385	@param lines A vector of the lines that needed to be drawn.
1386	*/
1387	CV_WRAP virtual void drawSegments(InputOutputArray image, InputArray lines) = 0;
1388
1389	/** @brief Draws two groups of lines in blue and red, counting the non overlapping (mismatching) pixels.
1390
1391	@param size The size of the image, where lines1 and lines2 were found.
1392	@param lines1 The first group of lines that needs to be drawn. It is visualized in blue color.
1393	@param lines2 The second group of lines. They visualized in red color.
1394	@param image Optional image, where the lines will be drawn. The image should be color(3-channel)
1395	in order for lines1 and lines2 to be drawn in the above mentioned colors.
1396	*/
1397	CV_WRAP virtual int compareSegments(const Size& size, InputArray lines1, InputArray lines2, InputOutputArray image = noArray()) = 0;
1398
1399	virtual ~LineSegmentDetector() { }
1400	};
1401
1402	/** @brief Creates a smart pointer to a LineSegmentDetector object and initializes it.
1403
1404	The LineSegmentDetector algorithm is defined using the standard values. Only advanced users may want
1405	to edit those, as to tailor it for their own application.
1406
1407	@param refine The way found lines will be refined, see #LineSegmentDetectorModes
1408	@param scale The scale of the image that will be used to find the lines. Range (0..1].
1409	@param sigma_scale Sigma for Gaussian filter. It is computed as sigma = sigma_scale/scale.
1410	@param quant Bound to the quantization error on the gradient norm.
1411	@param ang_th Gradient angle tolerance in degrees.
1412	@param log_eps Detection threshold: -log10(NFA) \> log_eps. Used only when advance refinement is chosen.
1413	@param density_th Minimal density of aligned region points in the enclosing rectangle.
1414	@param n_bins Number of bins in pseudo-ordering of gradient modulus.
1415	*/
1416	CV_EXPORTS_W Ptr<LineSegmentDetector> createLineSegmentDetector(
1417	int refine = LSD_REFINE_STD, double scale = 0.8,
1418	double sigma_scale = 0.6, double quant = 2.0, double ang_th = 22.5,
1419	double log_eps = 0, double density_th = 0.7, int n_bins = 1024);
1420
1421	//! @} imgproc_feature
1422
1423	//! @addtogroup imgproc_filter
1424	//! @{
1425
1426	/** @brief Returns Gaussian filter coefficients.
1427
1428	The function computes and returns the \f$\texttt{ksize} \times 1\f$ matrix of Gaussian filter
1429	coefficients:
1430
1431	\f[G_i= \alpha *e^{-(i-( \texttt{ksize} -1)/2)^2/(2* \texttt{sigma}^2)},\f]
1432
1433	where \f$i=0..\texttt{ksize}-1\f$ and \f$\alpha\f$ is the scale factor chosen so that \f$\sum_i G_i=1\f$.
1434
1435	Two of such generated kernels can be passed to sepFilter2D. Those functions automatically recognize
1436	smoothing kernels (a symmetrical kernel with sum of weights equal to 1) and handle them accordingly.
1437	You may also use the higher-level GaussianBlur.
1438	@param ksize Aperture size. It should be odd ( \f$\texttt{ksize} \mod 2 = 1\f$ ) and positive.
1439	@param sigma Gaussian standard deviation. If it is non-positive, it is computed from ksize as
1440	`sigma = 0.3*((ksize-1)*0.5 - 1) + 0.8`.
1441	@param ktype Type of filter coefficients. It can be CV_32F or CV_64F .
1442	@sa sepFilter2D, getDerivKernels, getStructuringElement, GaussianBlur
1443	*/
1444	CV_EXPORTS_W Mat getGaussianKernel( int ksize, double sigma, int ktype = CV_64F );
1445
1446	/** @brief Returns filter coefficients for computing spatial image derivatives.
1447
1448	The function computes and returns the filter coefficients for spatial image derivatives. When
1449	`ksize=FILTER_SCHARR`, the Scharr \f$3 \times 3\f$ kernels are generated (see #Scharr). Otherwise, Sobel
1450	kernels are generated (see #Sobel). The filters are normally passed to #sepFilter2D or to
1451
1452	@param kx Output matrix of row filter coefficients. It has the type ktype .
1453	@param ky Output matrix of column filter coefficients. It has the type ktype .
1454	@param dx Derivative order in respect of x.
1455	@param dy Derivative order in respect of y.
1456	@param ksize Aperture size. It can be FILTER_SCHARR, 1, 3, 5, or 7.
1457	@param normalize Flag indicating whether to normalize (scale down) the filter coefficients or not.
1458	Theoretically, the coefficients should have the denominator \f$=2^{ksize*2-dx-dy-2}\f$. If you are
1459	going to filter floating-point images, you are likely to use the normalized kernels. But if you
1460	compute derivatives of an 8-bit image, store the results in a 16-bit image, and wish to preserve
1461	all the fractional bits, you may want to set normalize=false .
1462	@param ktype Type of filter coefficients. It can be CV_32f or CV_64F .
1463	*/
1464	CV_EXPORTS_W void getDerivKernels( OutputArray kx, OutputArray ky,
1465	int dx, int dy, int ksize,
1466	bool normalize = false, int ktype = CV_32F );
1467
1468	/** @brief Returns Gabor filter coefficients.
1469
1470	For more details about gabor filter equations and parameters, see: [Gabor
1471	Filter](https://en.wikipedia.org/wiki/Gabor_filter).
1472
1473	@param ksize Size of the filter returned.
1474	@param sigma Standard deviation of the gaussian envelope.
1475	@param theta Orientation of the normal to the parallel stripes of a Gabor function.
1476	@param lambd Wavelength of the sinusoidal factor.
1477	@param gamma Spatial aspect ratio.
1478	@param psi Phase offset.
1479	@param ktype Type of filter coefficients. It can be CV_32F or CV_64F .
1480	*/
1481	CV_EXPORTS_W Mat getGaborKernel( Size ksize, double sigma, double theta, double lambd,
1482	double gamma, double psi = CV_PI*0.5, int ktype = CV_64F );
1483
1484	//! returns "magic" border value for erosion and dilation. It is automatically transformed to Scalar::all(-DBL_MAX) for dilation.
1485	static inline Scalar morphologyDefaultBorderValue() { return Scalar::all(DBL_MAX); }
1486
1487	/** @brief Returns a structuring element of the specified size and shape for morphological operations.
1488
1489	The function constructs and returns the structuring element that can be further passed to #erode,
1490	#dilate or #morphologyEx. But you can also construct an arbitrary binary mask yourself and use it as
1491	the structuring element.
1492
1493	@param shape Element shape that could be one of #MorphShapes
1494	@param ksize Size of the structuring element.
1495	@param anchor Anchor position within the element. The default value \f$(-1, -1)\f$ means that the
1496	anchor is at the center. Note that only the shape of a cross-shaped element depends on the anchor
1497	position. In other cases the anchor just regulates how much the result of the morphological
1498	operation is shifted.
1499	*/
1500	CV_EXPORTS_W Mat getStructuringElement(int shape, Size ksize, Point anchor = Point(-1,-1));
1501
1502	/** @example samples/cpp/tutorial_code/ImgProc/Smoothing/Smoothing.cpp
1503	Sample code for simple filters
1504	
1505	Check @ref tutorial_gausian_median_blur_bilateral_filter "the corresponding tutorial" for more details
1506	*/
1507
1508	/** @brief Blurs an image using the median filter.
1509
1510	The function smoothes an image using the median filter with the \f$\texttt{ksize} \times
1511	\texttt{ksize}\f$ aperture. Each channel of a multi-channel image is processed independently.
1512	In-place operation is supported.
1513
1514	@note The median filter uses #BORDER_REPLICATE internally to cope with border pixels, see #BorderTypes
1515
1516	@param src input 1-, 3-, or 4-channel image; when ksize is 3 or 5, the image depth should be
1517	CV_8U, CV_16U, or CV_32F, for larger aperture sizes, it can only be CV_8U.
1518	@param dst destination array of the same size and type as src.
1519	@param ksize aperture linear size; it must be odd and greater than 1, for example: 3, 5, 7 ...
1520	@sa bilateralFilter, blur, boxFilter, GaussianBlur
1521	*/
1522	CV_EXPORTS_W void medianBlur( InputArray src, OutputArray dst, int ksize );
1523
1524	/** @brief Blurs an image using a Gaussian filter.
1525
1526	The function convolves the source image with the specified Gaussian kernel. In-place filtering is
1527	supported.
1528
1529	@param src input image; the image can have any number of channels, which are processed
1530	independently, but the depth should be CV_8U, CV_16U, CV_16S, CV_32F or CV_64F.
1531	@param dst output image of the same size and type as src.
1532	@param ksize Gaussian kernel size. ksize.width and ksize.height can differ but they both must be
1533	positive and odd. Or, they can be zero's and then they are computed from sigma.
1534	@param sigmaX Gaussian kernel standard deviation in X direction.
1535	@param sigmaY Gaussian kernel standard deviation in Y direction; if sigmaY is zero, it is set to be
1536	equal to sigmaX, if both sigmas are zeros, they are computed from ksize.width and ksize.height,
1537	respectively (see #getGaussianKernel for details); to fully control the result regardless of
1538	possible future modifications of all this semantics, it is recommended to specify all of ksize,
1539	sigmaX, and sigmaY.
1540	@param borderType pixel extrapolation method, see #BorderTypes. #BORDER_WRAP is not supported.
1541	@param hint Implementation modfication flags. See #AlgorithmHint
1542
1543	@sa sepFilter2D, filter2D, blur, boxFilter, bilateralFilter, medianBlur
1544	*/
1545	CV_EXPORTS_W void GaussianBlur( InputArray src, OutputArray dst, Size ksize,
1546	double sigmaX, double sigmaY = 0,
1547	int borderType = BORDER_DEFAULT,
1548	AlgorithmHint hint = cv::ALGO_HINT_DEFAULT );
1549
1550	/** @brief Applies the bilateral filter to an image.
1551
1552	The function applies bilateral filtering to the input image, as described in
1553	https://homepages.inf.ed.ac.uk/rbf/CVonline/LOCAL_COPIES/MANDUCHI1/Bilateral_Filtering.html
1554	bilateralFilter can reduce unwanted noise very well while keeping edges fairly sharp. However, it is
1555	very slow compared to most filters.
1556
1557	_Sigma values_: For simplicity, you can set the 2 sigma values to be the same. If they are small (\<
1558	10), the filter will not have much effect, whereas if they are large (\> 150), they will have a very
1559	strong effect, making the image look "cartoonish".
1560
1561	_Filter size_: Large filters (d \> 5) are very slow, so it is recommended to use d=5 for real-time
1562	applications, and perhaps d=9 for offline applications that need heavy noise filtering.
1563
1564	This filter does not work inplace.
1565	@param src Source 8-bit or floating-point, 1-channel or 3-channel image.
1566	@param dst Destination image of the same size and type as src .
1567	@param d Diameter of each pixel neighborhood that is used during filtering. If it is non-positive,
1568	it is computed from sigmaSpace.
1569	@param sigmaColor Filter sigma in the color space. A larger value of the parameter means that
1570	farther colors within the pixel neighborhood (see sigmaSpace) will be mixed together, resulting
1571	in larger areas of semi-equal color.
1572	@param sigmaSpace Filter sigma in the coordinate space. A larger value of the parameter means that
1573	farther pixels will influence each other as long as their colors are close enough (see sigmaColor
1574	). When d\>0, it specifies the neighborhood size regardless of sigmaSpace. Otherwise, d is
1575	proportional to sigmaSpace.
1576	@param borderType border mode used to extrapolate pixels outside of the image, see #BorderTypes
1577	*/
1578	CV_EXPORTS_W void bilateralFilter( InputArray src, OutputArray dst, int d,
1579	double sigmaColor, double sigmaSpace,
1580	int borderType = BORDER_DEFAULT );
1581
1582	/** @brief Blurs an image using the box filter.
1583
1584	The function smooths an image using the kernel:
1585
1586	\f[\texttt{K} = \alpha \begin{bmatrix} 1 & 1 & 1 & \cdots & 1 & 1 \\ 1 & 1 & 1 & \cdots & 1 & 1 \\ \hdotsfor{6} \\ 1 & 1 & 1 & \cdots & 1 & 1 \end{bmatrix}\f]
1587
1588	where
1589
1590	\f[\alpha = \begin{cases} \frac{1}{\texttt{ksize.width*ksize.height}} & \texttt{when } \texttt{normalize=true} \\1 & \texttt{otherwise}\end{cases}\f]
1591
1592	Unnormalized box filter is useful for computing various integral characteristics over each pixel
1593	neighborhood, such as covariance matrices of image derivatives (used in dense optical flow
1594	algorithms, and so on). If you need to compute pixel sums over variable-size windows, use #integral.
1595
1596	@param src input image.
1597	@param dst output image of the same size and type as src.
1598	@param ddepth the output image depth (-1 to use src.depth()).
1599	@param ksize blurring kernel size.
1600	@param anchor anchor point; default value Point(-1,-1) means that the anchor is at the kernel
1601	center.
1602	@param normalize flag, specifying whether the kernel is normalized by its area or not.
1603	@param borderType border mode used to extrapolate pixels outside of the image, see #BorderTypes. #BORDER_WRAP is not supported.
1604	@sa blur, bilateralFilter, GaussianBlur, medianBlur, integral
1605	*/
1606	CV_EXPORTS_W void boxFilter( InputArray src, OutputArray dst, int ddepth,
1607	Size ksize, Point anchor = Point(-1,-1),
1608	bool normalize = true,
1609	int borderType = BORDER_DEFAULT );
1610
1611	/** @brief Calculates the normalized sum of squares of the pixel values overlapping the filter.
1612
1613	For every pixel \f$ (x, y) \f$ in the source image, the function calculates the sum of squares of those neighboring
1614	pixel values which overlap the filter placed over the pixel \f$ (x, y) \f$.
1615
1616	The unnormalized square box filter can be useful in computing local image statistics such as the local
1617	variance and standard deviation around the neighborhood of a pixel.
1618
1619	@param src input image
1620	@param dst output image of the same size and type as src
1621	@param ddepth the output image depth (-1 to use src.depth())
1622	@param ksize kernel size
1623	@param anchor kernel anchor point. The default value of Point(-1, -1) denotes that the anchor is at the kernel
1624	center.
1625	@param normalize flag, specifying whether the kernel is to be normalized by it's area or not.
1626	@param borderType border mode used to extrapolate pixels outside of the image, see #BorderTypes. #BORDER_WRAP is not supported.
1627	@sa boxFilter
1628	*/
1629	CV_EXPORTS_W void sqrBoxFilter( InputArray src, OutputArray dst, int ddepth,
1630	Size ksize, Point anchor = Point(-1, -1),
1631	bool normalize = true,
1632	int borderType = BORDER_DEFAULT );
1633
1634	/** @brief Blurs an image using the normalized box filter.
1635
1636	The function smooths an image using the kernel:
1637
1638	\f[\texttt{K} = \frac{1}{\texttt{ksize.width*ksize.height}} \begin{bmatrix} 1 & 1 & 1 & \cdots & 1 & 1 \\ 1 & 1 & 1 & \cdots & 1 & 1 \\ \hdotsfor{6} \\ 1 & 1 & 1 & \cdots & 1 & 1 \\ \end{bmatrix}\f]
1639
1640	The call `blur(src, dst, ksize, anchor, borderType)` is equivalent to `boxFilter(src, dst, src.type(), ksize,
1641	anchor, true, borderType)`.
1642
1643	@param src input image; it can have any number of channels, which are processed independently, but
1644	the depth should be CV_8U, CV_16U, CV_16S, CV_32F or CV_64F.
1645	@param dst output image of the same size and type as src.
1646	@param ksize blurring kernel size.
1647	@param anchor anchor point; default value Point(-1,-1) means that the anchor is at the kernel
1648	center.
1649	@param borderType border mode used to extrapolate pixels outside of the image, see #BorderTypes. #BORDER_WRAP is not supported.
1650	@sa boxFilter, bilateralFilter, GaussianBlur, medianBlur
1651	*/
1652	CV_EXPORTS_W void blur( InputArray src, OutputArray dst,
1653	Size ksize, Point anchor = Point(-1,-1),
1654	int borderType = BORDER_DEFAULT );
1655
1656	/** @brief Blurs an image using the stackBlur.
1657
1658	The function applies and stackBlur to an image.
1659	stackBlur can generate similar results as Gaussian blur, and the time consumption does not increase with the increase of kernel size.
1660	It creates a kind of moving stack of colors whilst scanning through the image. Thereby it just has to add one new block of color to the right side
1661	of the stack and remove the leftmost color. The remaining colors on the topmost layer of the stack are either added on or reduced by one,
1662	depending on if they are on the right or on the left side of the stack. The only supported borderType is BORDER_REPLICATE.
1663	Original paper was proposed by Mario Klingemann, which can be found https://underdestruction.com/2004/02/25/stackblur-2004.
1664
1665	@param src input image. The number of channels can be arbitrary, but the depth should be one of
1666	CV_8U, CV_16U, CV_16S or CV_32F.
1667	@param dst output image of the same size and type as src.
1668	@param ksize stack-blurring kernel size. The ksize.width and ksize.height can differ but they both must be
1669	positive and odd.
1670	*/
1671	CV_EXPORTS_W void stackBlur(InputArray src, OutputArray dst, Size ksize);
1672
1673	/** @brief Convolves an image with the kernel.
1674
1675	The function applies an arbitrary linear filter to an image. In-place operation is supported. When
1676	the aperture is partially outside the image, the function interpolates outlier pixel values
1677	according to the specified border mode.
1678
1679	The function does actually compute correlation, not the convolution:
1680
1681	\f[\texttt{dst} (x,y) = \sum _{ \substack{0\leq x' < \texttt{kernel.cols}\\{0\leq y' < \texttt{kernel.rows}}}} \texttt{kernel} (x',y')* \texttt{src} (x+x'- \texttt{anchor.x} ,y+y'- \texttt{anchor.y} )\f]
1682
1683	That is, the kernel is not mirrored around the anchor point. If you need a real convolution, flip
1684	the kernel using #flip and set the new anchor to `(kernel.cols - anchor.x - 1, kernel.rows -
1685	anchor.y - 1)`.
1686
1687	The function uses the DFT-based algorithm in case of sufficiently large kernels (~`11 x 11` or
1688	larger) and the direct algorithm for small kernels.
1689
1690	@param src input image.
1691	@param dst output image of the same size and the same number of channels as src.
1692	@param ddepth desired depth of the destination image, see @ref filter_depths "combinations"
1693	@param kernel convolution kernel (or rather a correlation kernel), a single-channel floating point
1694	matrix; if you want to apply different kernels to different channels, split the image into
1695	separate color planes using split and process them individually.
1696	@param anchor anchor of the kernel that indicates the relative position of a filtered point within
1697	the kernel; the anchor should lie within the kernel; default value (-1,-1) means that the anchor
1698	is at the kernel center.
1699	@param delta optional value added to the filtered pixels before storing them in dst.
1700	@param borderType pixel extrapolation method, see #BorderTypes. #BORDER_WRAP is not supported.
1701	@sa sepFilter2D, dft, matchTemplate
1702	*/
1703	CV_EXPORTS_W void filter2D( InputArray src, OutputArray dst, int ddepth,
1704	InputArray kernel, Point anchor = Point(-1,-1),
1705	double delta = 0, int borderType = BORDER_DEFAULT );
1706
1707	/** @brief Applies a separable linear filter to an image.
1708
1709	The function applies a separable linear filter to the image. That is, first, every row of src is
1710	filtered with the 1D kernel kernelX. Then, every column of the result is filtered with the 1D
1711	kernel kernelY. The final result shifted by delta is stored in dst .
1712
1713	@param src Source image.
1714	@param dst Destination image of the same size and the same number of channels as src .
1715	@param ddepth Destination image depth, see @ref filter_depths "combinations"
1716	@param kernelX Coefficients for filtering each row.
1717	@param kernelY Coefficients for filtering each column.
1718	@param anchor Anchor position within the kernel. The default value \f$(-1,-1)\f$ means that the anchor
1719	is at the kernel center.
1720	@param delta Value added to the filtered results before storing them.
1721	@param borderType Pixel extrapolation method, see #BorderTypes. #BORDER_WRAP is not supported.
1722	@sa filter2D, Sobel, GaussianBlur, boxFilter, blur
1723	*/
1724	CV_EXPORTS_W void sepFilter2D( InputArray src, OutputArray dst, int ddepth,
1725	InputArray kernelX, InputArray kernelY,
1726	Point anchor = Point(-1,-1),
1727	double delta = 0, int borderType = BORDER_DEFAULT );
1728
1729	/** @example samples/cpp/tutorial_code/ImgTrans/Sobel_Demo.cpp
1730	Sample code using Sobel and/or Scharr OpenCV functions to make a simple Edge Detector
1731	
1732	Check @ref tutorial_sobel_derivatives "the corresponding tutorial" for more details
1733	*/
1734
1735	/** @brief Calculates the first, second, third, or mixed image derivatives using an extended Sobel operator.
1736
1737	In all cases except one, the \f$\texttt{ksize} \times \texttt{ksize}\f$ separable kernel is used to
1738	calculate the derivative. When \f$\texttt{ksize = 1}\f$, the \f$3 \times 1\f$ or \f$1 \times 3\f$
1739	kernel is used (that is, no Gaussian smoothing is done). `ksize = 1` can only be used for the first
1740	or the second x- or y- derivatives.
1741
1742	There is also the special value `ksize = #FILTER_SCHARR (-1)` that corresponds to the \f$3\times3\f$ Scharr
1743	filter that may give more accurate results than the \f$3\times3\f$ Sobel. The Scharr aperture is
1744
1745	\f[\vecthreethree{-3}{0}{3}{-10}{0}{10}{-3}{0}{3}\f]
1746
1747	for the x-derivative, or transposed for the y-derivative.
1748
1749	The function calculates an image derivative by convolving the image with the appropriate kernel:
1750
1751	\f[\texttt{dst} = \frac{\partial^{xorder+yorder} \texttt{src}}{\partial x^{xorder} \partial y^{yorder}}\f]
1752
1753	The Sobel operators combine Gaussian smoothing and differentiation, so the result is more or less
1754	resistant to the noise. Most often, the function is called with ( xorder = 1, yorder = 0, ksize = 3)
1755	or ( xorder = 0, yorder = 1, ksize = 3) to calculate the first x- or y- image derivative. The first
1756	case corresponds to a kernel of:
1757
1758	\f[\vecthreethree{-1}{0}{1}{-2}{0}{2}{-1}{0}{1}\f]
1759
1760	The second case corresponds to a kernel of:
1761
1762	\f[\vecthreethree{-1}{-2}{-1}{0}{0}{0}{1}{2}{1}\f]
1763
1764	@param src input image.
1765	@param dst output image of the same size and the same number of channels as src .
1766	@param ddepth output image depth, see @ref filter_depths "combinations"; in the case of
1767	8-bit input images it will result in truncated derivatives.
1768	@param dx order of the derivative x.
1769	@param dy order of the derivative y.
1770	@param ksize size of the extended Sobel kernel; it must be 1, 3, 5, or 7.
1771	@param scale optional scale factor for the computed derivative values; by default, no scaling is
1772	applied (see #getDerivKernels for details).
1773	@param delta optional delta value that is added to the results prior to storing them in dst.
1774	@param borderType pixel extrapolation method, see #BorderTypes. #BORDER_WRAP is not supported.
1775	@sa Scharr, Laplacian, sepFilter2D, filter2D, GaussianBlur, cartToPolar
1776	*/
1777	CV_EXPORTS_W void Sobel( InputArray src, OutputArray dst, int ddepth,
1778	int dx, int dy, int ksize = 3,
1779	double scale = 1, double delta = 0,
1780	int borderType = BORDER_DEFAULT );
1781
1782	/** @brief Calculates the first order image derivative in both x and y using a Sobel operator
1783
1784	Equivalent to calling:
1785
1786	@code
1787	Sobel( src, dx, CV_16SC1, 1, 0, 3 );
1788	Sobel( src, dy, CV_16SC1, 0, 1, 3 );
1789	@endcode
1790
1791	@param src input image.
1792	@param dx output image with first-order derivative in x.
1793	@param dy output image with first-order derivative in y.
1794	@param ksize size of Sobel kernel. It must be 3.
1795	@param borderType pixel extrapolation method, see #BorderTypes.
1796	Only #BORDER_DEFAULT=#BORDER_REFLECT_101 and #BORDER_REPLICATE are supported.
1797
1798	@sa Sobel
1799	*/
1800
1801	CV_EXPORTS_W void spatialGradient( InputArray src, OutputArray dx,
1802	OutputArray dy, int ksize = 3,
1803	int borderType = BORDER_DEFAULT );
1804
1805	/** @brief Calculates the first x- or y- image derivative using Scharr operator.
1806
1807	The function computes the first x- or y- spatial image derivative using the Scharr operator. The
1808	call
1809
1810	\f[\texttt{Scharr(src, dst, ddepth, dx, dy, scale, delta, borderType)}\f]
1811
1812	is equivalent to
1813
1814	\f[\texttt{Sobel(src, dst, ddepth, dx, dy, FILTER_SCHARR, scale, delta, borderType)} .\f]
1815
1816	@param src input image.
1817	@param dst output image of the same size and the same number of channels as src.
1818	@param ddepth output image depth, see @ref filter_depths "combinations"
1819	@param dx order of the derivative x.
1820	@param dy order of the derivative y.
1821	@param scale optional scale factor for the computed derivative values; by default, no scaling is
1822	applied (see #getDerivKernels for details).
1823	@param delta optional delta value that is added to the results prior to storing them in dst.
1824	@param borderType pixel extrapolation method, see #BorderTypes. #BORDER_WRAP is not supported.
1825	@sa cartToPolar
1826	*/
1827	CV_EXPORTS_W void Scharr( InputArray src, OutputArray dst, int ddepth,
1828	int dx, int dy, double scale = 1, double delta = 0,
1829	int borderType = BORDER_DEFAULT );
1830
1831	/** @example samples/cpp/laplace.cpp
1832	An example using Laplace transformations for edge detection
1833	*/
1834
1835	/** @brief Calculates the Laplacian of an image.
1836
1837	The function calculates the Laplacian of the source image by adding up the second x and y
1838	derivatives calculated using the Sobel operator:
1839
1840	\f[\texttt{dst} = \Delta \texttt{src} = \frac{\partial^2 \texttt{src}}{\partial x^2} + \frac{\partial^2 \texttt{src}}{\partial y^2}\f]
1841
1842	This is done when `ksize > 1`. When `ksize == 1`, the Laplacian is computed by filtering the image
1843	with the following \f$3 \times 3\f$ aperture:
1844
1845	\f[\vecthreethree {0}{1}{0}{1}{-4}{1}{0}{1}{0}\f]
1846
1847	@param src Source image.
1848	@param dst Destination image of the same size and the same number of channels as src .
1849	@param ddepth Desired depth of the destination image, see @ref filter_depths "combinations".
1850	@param ksize Aperture size used to compute the second-derivative filters. See #getDerivKernels for
1851	details. The size must be positive and odd.
1852	@param scale Optional scale factor for the computed Laplacian values. By default, no scaling is
1853	applied. See #getDerivKernels for details.
1854	@param delta Optional delta value that is added to the results prior to storing them in dst .
1855	@param borderType Pixel extrapolation method, see #BorderTypes. #BORDER_WRAP is not supported.
1856	@sa Sobel, Scharr
1857	*/
1858	CV_EXPORTS_W void Laplacian( InputArray src, OutputArray dst, int ddepth,
1859	int ksize = 1, double scale = 1, double delta = 0,
1860	int borderType = BORDER_DEFAULT );
1861
1862	//! @} imgproc_filter
1863
1864	//! @addtogroup imgproc_feature
1865	//! @{
1866
1867	/** @example samples/cpp/edge.cpp
1868	This program demonstrates usage of the Canny edge detector
1869
1870	Check @ref tutorial_canny_detector "the corresponding tutorial" for more details
1871	*/
1872
1873	/** @brief Finds edges in an image using the Canny algorithm @cite Canny86 .
1874
1875	The function finds edges in the input image and marks them in the output map edges using the
1876	Canny algorithm. The smallest value between threshold1 and threshold2 is used for edge linking. The
1877	largest value is used to find initial segments of strong edges. See
1878	<https://en.wikipedia.org/wiki/Canny_edge_detector>
1879
1880	@param image 8-bit input image.
1881	@param edges output edge map; single channels 8-bit image, which has the same size as image .
1882	@param threshold1 first threshold for the hysteresis procedure.
1883	@param threshold2 second threshold for the hysteresis procedure.
1884	@param apertureSize aperture size for the Sobel operator.
1885	@param L2gradient a flag, indicating whether a more accurate \f$L_2\f$ norm
1886	\f$=\sqrt{(dI/dx)^2 + (dI/dy)^2}\f$ should be used to calculate the image gradient magnitude (
1887	L2gradient=true ), or whether the default \f$L_1\f$ norm \f$=|dI/dx|+|dI/dy|\f$ is enough (
1888	L2gradient=false ).
1889	*/
1890	CV_EXPORTS_W void Canny( InputArray image, OutputArray edges,
1891	double threshold1, double threshold2,
1892	int apertureSize = 3, bool L2gradient = false );
1893
1894	/** \overload
1895
1896	Finds edges in an image using the Canny algorithm with custom image gradient.
1897
1898	@param dx 16-bit x derivative of input image (CV_16SC1 or CV_16SC3).
1899	@param dy 16-bit y derivative of input image (same type as dx).
1900	@param edges output edge map; single channels 8-bit image, which has the same size as image .
1901	@param threshold1 first threshold for the hysteresis procedure.
1902	@param threshold2 second threshold for the hysteresis procedure.
1903	@param L2gradient a flag, indicating whether a more accurate \f$L_2\f$ norm
1904	\f$=\sqrt{(dI/dx)^2 + (dI/dy)^2}\f$ should be used to calculate the image gradient magnitude (
1905	L2gradient=true ), or whether the default \f$L_1\f$ norm \f$=|dI/dx|+|dI/dy|\f$ is enough (
1906	L2gradient=false ).
1907	*/
1908	CV_EXPORTS_W void Canny( InputArray dx, InputArray dy,
1909	OutputArray edges,
1910	double threshold1, double threshold2,
1911	bool L2gradient = false );
1912
1913	/** @brief Calculates the minimal eigenvalue of gradient matrices for corner detection.
1914
1915	The function is similar to cornerEigenValsAndVecs but it calculates and stores only the minimal
1916	eigenvalue of the covariance matrix of derivatives, that is, \f$\min(\lambda_1, \lambda_2)\f$ in terms
1917	of the formulae in the cornerEigenValsAndVecs description.
1918
1919	@param src Input single-channel 8-bit or floating-point image.
1920	@param dst Image to store the minimal eigenvalues. It has the type CV_32FC1 and the same size as
1921	src .
1922	@param blockSize Neighborhood size (see the details on #cornerEigenValsAndVecs ).
1923	@param ksize Aperture parameter for the Sobel operator.
1924	@param borderType Pixel extrapolation method. See #BorderTypes. #BORDER_WRAP is not supported.
1925	*/
1926	CV_EXPORTS_W void cornerMinEigenVal( InputArray src, OutputArray dst,
1927	int blockSize, int ksize = 3,
1928	int borderType = BORDER_DEFAULT );
1929
1930	/** @brief Harris corner detector.
1931
1932	The function runs the Harris corner detector on the image. Similarly to cornerMinEigenVal and
1933	cornerEigenValsAndVecs , for each pixel \f$(x, y)\f$ it calculates a \f$2\times2\f$ gradient covariance
1934	matrix \f$M^{(x,y)}\f$ over a \f$\texttt{blockSize} \times \texttt{blockSize}\f$ neighborhood. Then, it
1935	computes the following characteristic:
1936
1937	\f[\texttt{dst} (x,y) = \mathrm{det} M^{(x,y)} - k \cdot \left ( \mathrm{tr} M^{(x,y)} \right )^2\f]
1938
1939	Corners in the image can be found as the local maxima of this response map.
1940
1941	@param src Input single-channel 8-bit or floating-point image.
1942	@param dst Image to store the Harris detector responses. It has the type CV_32FC1 and the same
1943	size as src .
1944	@param blockSize Neighborhood size (see the details on #cornerEigenValsAndVecs ).
1945	@param ksize Aperture parameter for the Sobel operator.
1946	@param k Harris detector free parameter. See the formula above.
1947	@param borderType Pixel extrapolation method. See #BorderTypes. #BORDER_WRAP is not supported.
1948	*/
1949	CV_EXPORTS_W void cornerHarris( InputArray src, OutputArray dst, int blockSize,
1950	int ksize, double k,
1951	int borderType = BORDER_DEFAULT );
1952
1953	/** @brief Calculates eigenvalues and eigenvectors of image blocks for corner detection.
1954
1955	For every pixel \f$p\f$ , the function cornerEigenValsAndVecs considers a blockSize \f$\times\f$ blockSize
1956	neighborhood \f$S(p)\f$ . It calculates the covariation matrix of derivatives over the neighborhood as:
1957
1958	\f[M = \begin{bmatrix} \sum _{S(p)}(dI/dx)^2 & \sum _{S(p)}dI/dx dI/dy \\ \sum _{S(p)}dI/dx dI/dy & \sum _{S(p)}(dI/dy)^2 \end{bmatrix}\f]
1959
1960	where the derivatives are computed using the Sobel operator.
1961
1962	After that, it finds eigenvectors and eigenvalues of \f$M\f$ and stores them in the destination image as
1963	\f$(\lambda_1, \lambda_2, x_1, y_1, x_2, y_2)\f$ where
1964
1965	- \f$\lambda_1, \lambda_2\f$ are the non-sorted eigenvalues of \f$M\f$
1966	- \f$x_1, y_1\f$ are the eigenvectors corresponding to \f$\lambda_1\f$
1967	- \f$x_2, y_2\f$ are the eigenvectors corresponding to \f$\lambda_2\f$
1968
1969	The output of the function can be used for robust edge or corner detection.
1970
1971	@param src Input single-channel 8-bit or floating-point image.
1972	@param dst Image to store the results. It has the same size as src and the type CV_32FC(6) .
1973	@param blockSize Neighborhood size (see details below).
1974	@param ksize Aperture parameter for the Sobel operator.
1975	@param borderType Pixel extrapolation method. See #BorderTypes. #BORDER_WRAP is not supported.
1976
1977	@sa cornerMinEigenVal, cornerHarris, preCornerDetect
1978	*/
1979	CV_EXPORTS_W void cornerEigenValsAndVecs( InputArray src, OutputArray dst,
1980	int blockSize, int ksize,
1981	int borderType = BORDER_DEFAULT );
1982
1983	/** @brief Calculates a feature map for corner detection.
1984
1985	The function calculates the complex spatial derivative-based function of the source image
1986
1987	\f[\texttt{dst} = (D_x \texttt{src} )^2 \cdot D_{yy} \texttt{src} + (D_y \texttt{src} )^2 \cdot D_{xx} \texttt{src} - 2 D_x \texttt{src} \cdot D_y \texttt{src} \cdot D_{xy} \texttt{src}\f]
1988
1989	where \f$D_x\f$,\f$D_y\f$ are the first image derivatives, \f$D_{xx}\f$,\f$D_{yy}\f$ are the second image
1990	derivatives, and \f$D_{xy}\f$ is the mixed derivative.
1991
1992	The corners can be found as local maximums of the functions, as shown below:
1993	@code
1994	Mat corners, dilated_corners;
1995	preCornerDetect(image, corners, 3);
1996	// dilation with 3x3 rectangular structuring element
1997	dilate(corners, dilated_corners, Mat(), 1);
1998	Mat corner_mask = corners == dilated_corners;
1999	@endcode
2000
2001	@param src Source single-channel 8-bit of floating-point image.
2002	@param dst Output image that has the type CV_32F and the same size as src .
2003	@param ksize %Aperture size of the Sobel .
2004	@param borderType Pixel extrapolation method. See #BorderTypes. #BORDER_WRAP is not supported.
2005	*/
2006	CV_EXPORTS_W void preCornerDetect( InputArray src, OutputArray dst, int ksize,
2007	int borderType = BORDER_DEFAULT );
2008
2009	/** @brief Refines the corner locations.
2010
2011	The function iterates to find the sub-pixel accurate location of corners or radial saddle
2012	points as described in @cite forstner1987fast, and as shown on the figure below.
2013
2014	
2015
2016	Sub-pixel accurate corner locator is based on the observation that every vector from the center \f$q\f$
2017	to a point \f$p\f$ located within a neighborhood of \f$q\f$ is orthogonal to the image gradient at \f$p\f$
2018	subject to image and measurement noise. Consider the expression:
2019
2020	\f[\epsilon _i = {DI_{p_i}}^T \cdot (q - p_i)\f]
2021
2022	where \f${DI_{p_i}}\f$ is an image gradient at one of the points \f$p_i\f$ in a neighborhood of \f$q\f$ . The
2023	value of \f$q\f$ is to be found so that \f$\epsilon_i\f$ is minimized. A system of equations may be set up
2024	with \f$\epsilon_i\f$ set to zero:
2025
2026	\f[\sum _i(DI_{p_i} \cdot {DI_{p_i}}^T) \cdot q - \sum _i(DI_{p_i} \cdot {DI_{p_i}}^T \cdot p_i)\f]
2027
2028	where the gradients are summed within a neighborhood ("search window") of \f$q\f$ . Calling the first
2029	gradient term \f$G\f$ and the second gradient term \f$b\f$ gives:
2030
2031	\f[q = G^{-1} \cdot b\f]
2032
2033	The algorithm sets the center of the neighborhood window at this new center \f$q\f$ and then iterates
2034	until the center stays within a set threshold.
2035
2036	@param image Input single-channel, 8-bit or float image.
2037	@param corners Initial coordinates of the input corners and refined coordinates provided for
2038	output.
2039	@param winSize Half of the side length of the search window. For example, if winSize=Size(5,5) ,
2040	then a \f$(5*2+1) \times (5*2+1) = 11 \times 11\f$ search window is used.
2041	@param zeroZone Half of the size of the dead region in the middle of the search zone over which
2042	the summation in the formula below is not done. It is used sometimes to avoid possible
2043	singularities of the autocorrelation matrix. The value of (-1,-1) indicates that there is no such
2044	a size.
2045	@param criteria Criteria for termination of the iterative process of corner refinement. That is,
2046	the process of corner position refinement stops either after criteria.maxCount iterations or when
2047	the corner position moves by less than criteria.epsilon on some iteration.
2048	*/
2049	CV_EXPORTS_W void cornerSubPix( InputArray image, InputOutputArray corners,
2050	Size winSize, Size zeroZone,
2051	TermCriteria criteria );
2052
2053	/** @brief Determines strong corners on an image.
2054
2055	The function finds the most prominent corners in the image or in the specified image region, as
2056	described in @cite Shi94
2057
2058	- Function calculates the corner quality measure at every source image pixel using the
2059	#cornerMinEigenVal or #cornerHarris .
2060	- Function performs a non-maximum suppression (the local maximums in *3 x 3* neighborhood are
2061	retained).
2062	- The corners with the minimal eigenvalue less than
2063	\f$\texttt{qualityLevel} \cdot \max_{x,y} qualityMeasureMap(x,y)\f$ are rejected.
2064	- The remaining corners are sorted by the quality measure in the descending order.
2065	- Function throws away each corner for which there is a stronger corner at a distance less than
2066	maxDistance.
2067
2068	The function can be used to initialize a point-based tracker of an object.
2069
2070	@note If the function is called with different values A and B of the parameter qualityLevel , and
2071	A \> B, the vector of returned corners with qualityLevel=A will be the prefix of the output vector
2072	with qualityLevel=B .
2073
2074	@param image Input 8-bit or floating-point 32-bit, single-channel image.
2075	@param corners Output vector of detected corners.
2076	@param maxCorners Maximum number of corners to return. If there are more corners than are found,
2077	the strongest of them is returned. `maxCorners <= 0` implies that no limit on the maximum is set
2078	and all detected corners are returned.
2079	@param qualityLevel Parameter characterizing the minimal accepted quality of image corners. The
2080	parameter value is multiplied by the best corner quality measure, which is the minimal eigenvalue
2081	(see #cornerMinEigenVal ) or the Harris function response (see #cornerHarris ). The corners with the
2082	quality measure less than the product are rejected. For example, if the best corner has the
2083	quality measure = 1500, and the qualityLevel=0.01 , then all the corners with the quality measure
2084	less than 15 are rejected.
2085	@param minDistance Minimum possible Euclidean distance between the returned corners.
2086	@param mask Optional region of interest. If the image is not empty (it needs to have the type
2087	CV_8UC1 and the same size as image ), it specifies the region in which the corners are detected.
2088	@param blockSize Size of an average block for computing a derivative covariation matrix over each
2089	pixel neighborhood. See cornerEigenValsAndVecs .
2090	@param useHarrisDetector Parameter indicating whether to use a Harris detector (see #cornerHarris)
2091	or #cornerMinEigenVal.
2092	@param k Free parameter of the Harris detector.
2093
2094	@sa cornerMinEigenVal, cornerHarris, calcOpticalFlowPyrLK, estimateRigidTransform,
2095	*/
2096
2097	CV_EXPORTS_W void goodFeaturesToTrack( InputArray image, OutputArray corners,
2098	int maxCorners, double qualityLevel, double minDistance,
2099	InputArray mask = noArray(), int blockSize = 3,
2100	bool useHarrisDetector = false, double k = 0.04 );
2101
2102	CV_EXPORTS_W void goodFeaturesToTrack( InputArray image, OutputArray corners,
2103	int maxCorners, double qualityLevel, double minDistance,
2104	InputArray mask, int blockSize,
2105	int gradientSize, bool useHarrisDetector = false,
2106	double k = 0.04 );
2107
2108	/** @brief Same as above, but returns also quality measure of the detected corners.
2109
2110	@param image Input 8-bit or floating-point 32-bit, single-channel image.
2111	@param corners Output vector of detected corners.
2112	@param maxCorners Maximum number of corners to return. If there are more corners than are found,
2113	the strongest of them is returned. `maxCorners <= 0` implies that no limit on the maximum is set
2114	and all detected corners are returned.
2115	@param qualityLevel Parameter characterizing the minimal accepted quality of image corners. The
2116	parameter value is multiplied by the best corner quality measure, which is the minimal eigenvalue
2117	(see #cornerMinEigenVal ) or the Harris function response (see #cornerHarris ). The corners with the
2118	quality measure less than the product are rejected. For example, if the best corner has the
2119	quality measure = 1500, and the qualityLevel=0.01 , then all the corners with the quality measure
2120	less than 15 are rejected.
2121	@param minDistance Minimum possible Euclidean distance between the returned corners.
2122	@param mask Region of interest. If the image is not empty (it needs to have the type
2123	CV_8UC1 and the same size as image ), it specifies the region in which the corners are detected.
2124	@param cornersQuality Output vector of quality measure of the detected corners.
2125	@param blockSize Size of an average block for computing a derivative covariation matrix over each
2126	pixel neighborhood. See cornerEigenValsAndVecs .
2127	@param gradientSize Aperture parameter for the Sobel operator used for derivatives computation.
2128	See cornerEigenValsAndVecs .
2129	@param useHarrisDetector Parameter indicating whether to use a Harris detector (see #cornerHarris)
2130	or #cornerMinEigenVal.
2131	@param k Free parameter of the Harris detector.
2132	*/
2133	CV_EXPORTS CV_WRAP_AS(goodFeaturesToTrackWithQuality) void goodFeaturesToTrack(
2134	InputArray image, OutputArray corners,
2135	int maxCorners, double qualityLevel, double minDistance,
2136	InputArray mask, OutputArray cornersQuality, int blockSize = 3,
2137	int gradientSize = 3, bool useHarrisDetector = false, double k = 0.04);
2138
2139	/** @example samples/cpp/tutorial_code/ImgTrans/houghlines.cpp
2140	An example using the Hough line detector
2141	 
2142	*/
2143
2144	/** @brief Finds lines in a binary image using the standard Hough transform.
2145
2146	The function implements the standard or standard multi-scale Hough transform algorithm for line
2147	detection. See <https://homepages.inf.ed.ac.uk/rbf/HIPR2/hough.htm> for a good explanation of Hough
2148	transform.
2149
2150	@param image 8-bit, single-channel binary source image. The image may be modified by the function.
2151	@param lines Output vector of lines. Each line is represented by a 2 or 3 element vector
2152	\f$(\rho, \theta)\f$ or \f$(\rho, \theta, \textrm{votes})\f$, where \f$\rho\f$ is the distance from
2153	the coordinate origin \f$(0,0)\f$ (top-left corner of the image), \f$\theta\f$ is the line rotation
2154	angle in radians ( \f$0 \sim \textrm{vertical line}, \pi/2 \sim \textrm{horizontal line}\f$ ), and
2155	\f$\textrm{votes}\f$ is the value of accumulator.
2156	@param rho Distance resolution of the accumulator in pixels.
2157	@param theta Angle resolution of the accumulator in radians.
2158	@param threshold %Accumulator threshold parameter. Only those lines are returned that get enough
2159	votes ( \f$>\texttt{threshold}\f$ ).
2160	@param srn For the multi-scale Hough transform, it is a divisor for the distance resolution rho.
2161	The coarse accumulator distance resolution is rho and the accurate accumulator resolution is
2162	rho/srn. If both srn=0 and stn=0, the classical Hough transform is used. Otherwise, both these
2163	parameters should be positive.
2164	@param stn For the multi-scale Hough transform, it is a divisor for the distance resolution theta.
2165	@param min_theta For standard and multi-scale Hough transform, minimum angle to check for lines.
2166	Must fall between 0 and max_theta.
2167	@param max_theta For standard and multi-scale Hough transform, an upper bound for the angle.
2168	Must fall between min_theta and CV_PI. The actual maximum angle in the accumulator may be slightly
2169	less than max_theta, depending on the parameters min_theta and theta.
2170	@param use_edgeval True if you want to use weighted Hough transform.
2171	*/
2172	CV_EXPORTS_W void HoughLines( InputArray image, OutputArray lines,
2173	double rho, double theta, int threshold,
2174	double srn = 0, double stn = 0,
2175	double min_theta = 0, double max_theta = CV_PI,
2176	bool use_edgeval = false );
2177
2178	/** @brief Finds line segments in a binary image using the probabilistic Hough transform.
2179
2180	The function implements the probabilistic Hough transform algorithm for line detection, described
2181	in @cite Matas00
2182
2183	See the line detection example below:
2184	@include snippets/imgproc_HoughLinesP.cpp
2185	This is a sample picture the function parameters have been tuned for:
2186
2187	
2188
2189	And this is the output of the above program in case of the probabilistic Hough transform:
2190
2191	
2192
2193	@param image 8-bit, single-channel binary source image. The image may be modified by the function.
2194	@param lines Output vector of lines. Each line is represented by a 4-element vector
2195	\f$(x_1, y_1, x_2, y_2)\f$ , where \f$(x_1,y_1)\f$ and \f$(x_2, y_2)\f$ are the ending points of each detected
2196	line segment.
2197	@param rho Distance resolution of the accumulator in pixels.
2198	@param theta Angle resolution of the accumulator in radians.
2199	@param threshold %Accumulator threshold parameter. Only those lines are returned that get enough
2200	votes ( \f$>\texttt{threshold}\f$ ).
2201	@param minLineLength Minimum line length. Line segments shorter than that are rejected.
2202	@param maxLineGap Maximum allowed gap between points on the same line to link them.
2203
2204	@sa LineSegmentDetector
2205	*/
2206	CV_EXPORTS_W void HoughLinesP( InputArray image, OutputArray lines,
2207	double rho, double theta, int threshold,
2208	double minLineLength = 0, double maxLineGap = 0 );
2209
2210	/** @brief Finds lines in a set of points using the standard Hough transform.
2211
2212	The function finds lines in a set of points using a modification of the Hough transform.
2213	@include snippets/imgproc_HoughLinesPointSet.cpp
2214	@param point Input vector of points. Each vector must be encoded as a Point vector \f$(x,y)\f$. Type must be CV_32FC2 or CV_32SC2.
2215	@param lines Output vector of found lines. Each vector is encoded as a vector<Vec3d> \f$(votes, rho, theta)\f$.
2216	The larger the value of 'votes', the higher the reliability of the Hough line.
2217	@param lines_max Max count of Hough lines.
2218	@param threshold %Accumulator threshold parameter. Only those lines are returned that get enough
2219	votes ( \f$>\texttt{threshold}\f$ ).
2220	@param min_rho Minimum value for \f$\rho\f$ for the accumulator (Note: \f$\rho\f$ can be negative. The absolute value \f$|\rho|\f$ is the distance of a line to the origin.).
2221	@param max_rho Maximum value for \f$\rho\f$ for the accumulator.
2222	@param rho_step Distance resolution of the accumulator.
2223	@param min_theta Minimum angle value of the accumulator in radians.
2224	@param max_theta Upper bound for the angle value of the accumulator in radians. The actual maximum
2225	angle may be slightly less than max_theta, depending on the parameters min_theta and theta_step.
2226	@param theta_step Angle resolution of the accumulator in radians.
2227	*/
2228	CV_EXPORTS_W void HoughLinesPointSet( InputArray point, OutputArray lines, int lines_max, int threshold,
2229	double min_rho, double max_rho, double rho_step,
2230	double min_theta, double max_theta, double theta_step );
2231
2232	/** @example samples/cpp/tutorial_code/ImgTrans/houghcircles.cpp
2233	An example using the Hough circle detector
2234	*/
2235
2236	/** @brief Finds circles in a grayscale image using the Hough transform.
2237
2238	The function finds circles in a grayscale image using a modification of the Hough transform.
2239
2240	Example: :
2241	@include snippets/imgproc_HoughLinesCircles.cpp
2242
2243	@note Usually the function detects the centers of circles well. However, it may fail to find correct
2244	radii. You can assist to the function by specifying the radius range ( minRadius and maxRadius ) if
2245	you know it. Or, in the case of #HOUGH_GRADIENT method you may set maxRadius to a negative number
2246	to return centers only without radius search, and find the correct radius using an additional procedure.
2247
2248	It also helps to smooth image a bit unless it's already soft. For example,
2249	GaussianBlur() with 7x7 kernel and 1.5x1.5 sigma or similar blurring may help.
2250
2251	@param image 8-bit, single-channel, grayscale input image.
2252	@param circles Output vector of found circles. Each vector is encoded as 3 or 4 element
2253	floating-point vector \f$(x, y, radius)\f$ or \f$(x, y, radius, votes)\f$ .
2254	@param method Detection method, see #HoughModes. The available methods are #HOUGH_GRADIENT and #HOUGH_GRADIENT_ALT.
2255	@param dp Inverse ratio of the accumulator resolution to the image resolution. For example, if
2256	dp=1 , the accumulator has the same resolution as the input image. If dp=2 , the accumulator has
2257	half as big width and height. For #HOUGH_GRADIENT_ALT the recommended value is dp=1.5,
2258	unless some small very circles need to be detected.
2259	@param minDist Minimum distance between the centers of the detected circles. If the parameter is
2260	too small, multiple neighbor circles may be falsely detected in addition to a true one. If it is
2261	too large, some circles may be missed.
2262	@param param1 First method-specific parameter. In case of #HOUGH_GRADIENT and #HOUGH_GRADIENT_ALT,
2263	it is the higher threshold of the two passed to the Canny edge detector (the lower one is twice smaller).
2264	Note that #HOUGH_GRADIENT_ALT uses #Scharr algorithm to compute image derivatives, so the threshold value
2265	should normally be higher, such as 300 or normally exposed and contrasty images.
2266	@param param2 Second method-specific parameter. In case of #HOUGH_GRADIENT, it is the
2267	accumulator threshold for the circle centers at the detection stage. The smaller it is, the more
2268	false circles may be detected. Circles, corresponding to the larger accumulator values, will be
2269	returned first. In the case of #HOUGH_GRADIENT_ALT algorithm, this is the circle "perfectness" measure.
2270	The closer it to 1, the better shaped circles algorithm selects. In most cases 0.9 should be fine.
2271	If you want get better detection of small circles, you may decrease it to 0.85, 0.8 or even less.
2272	But then also try to limit the search range [minRadius, maxRadius] to avoid many false circles.
2273	@param minRadius Minimum circle radius.
2274	@param maxRadius Maximum circle radius. If <= 0, uses the maximum image dimension. If < 0, #HOUGH_GRADIENT returns
2275	centers without finding the radius. #HOUGH_GRADIENT_ALT always computes circle radiuses.
2276
2277	@sa fitEllipse, minEnclosingCircle
2278	*/
2279	CV_EXPORTS_W void HoughCircles( InputArray image, OutputArray circles,
2280	int method, double dp, double minDist,
2281	double param1 = 100, double param2 = 100,
2282	int minRadius = 0, int maxRadius = 0 );
2283
2284	//! @} imgproc_feature
2285
2286	//! @addtogroup imgproc_filter
2287	//! @{
2288
2289	/** @example samples/cpp/tutorial_code/ImgProc/Morphology_2.cpp
2290	Advanced morphology Transformations sample code
2291	
2292	Check @ref tutorial_opening_closing_hats "the corresponding tutorial" for more details
2293	*/
2294
2295	/** @brief Erodes an image by using a specific structuring element.
2296
2297	The function erodes the source image using the specified structuring element that determines the
2298	shape of a pixel neighborhood over which the minimum is taken:
2299
2300	\f[\texttt{dst} (x,y) = \min _{(x',y'): \, \texttt{element} (x',y') \ne0 } \texttt{src} (x+x',y+y')\f]
2301
2302	The function supports the in-place mode. Erosion can be applied several ( iterations ) times. In
2303	case of multi-channel images, each channel is processed independently.
2304
2305	@param src input image; the number of channels can be arbitrary, but the depth should be one of
2306	CV_8U, CV_16U, CV_16S, CV_32F or CV_64F.
2307	@param dst output image of the same size and type as src.
2308	@param kernel structuring element used for erosion; if `element=Mat()`, a `3 x 3` rectangular
2309	structuring element is used. Kernel can be created using #getStructuringElement.
2310	@param anchor position of the anchor within the element; default value (-1, -1) means that the
2311	anchor is at the element center.
2312	@param iterations number of times erosion is applied.
2313	@param borderType pixel extrapolation method, see #BorderTypes. #BORDER_WRAP is not supported.
2314	@param borderValue border value in case of a constant border
2315	@sa dilate, morphologyEx, getStructuringElement
2316	*/
2317	CV_EXPORTS_W void erode( InputArray src, OutputArray dst, InputArray kernel,
2318	Point anchor = Point(-1,-1), int iterations = 1,
2319	int borderType = BORDER_CONSTANT,
2320	const Scalar& borderValue = morphologyDefaultBorderValue() );
2321
2322	/** @example samples/cpp/tutorial_code/ImgProc/Morphology_1.cpp
2323	Erosion and Dilation sample code
2324	
2325	Check @ref tutorial_erosion_dilatation "the corresponding tutorial" for more details
2326	*/
2327
2328	/** @brief Dilates an image by using a specific structuring element.
2329
2330	The function dilates the source image using the specified structuring element that determines the
2331	shape of a pixel neighborhood over which the maximum is taken:
2332	\f[\texttt{dst} (x,y) = \max _{(x',y'): \, \texttt{element} (x',y') \ne0 } \texttt{src} (x+x',y+y')\f]
2333
2334	The function supports the in-place mode. Dilation can be applied several ( iterations ) times. In
2335	case of multi-channel images, each channel is processed independently.
2336
2337	@param src input image; the number of channels can be arbitrary, but the depth should be one of
2338	CV_8U, CV_16U, CV_16S, CV_32F or CV_64F.
2339	@param dst output image of the same size and type as src.
2340	@param kernel structuring element used for dilation; if element=Mat(), a 3 x 3 rectangular
2341	structuring element is used. Kernel can be created using #getStructuringElement
2342	@param anchor position of the anchor within the element; default value (-1, -1) means that the
2343	anchor is at the element center.
2344	@param iterations number of times dilation is applied.
2345	@param borderType pixel extrapolation method, see #BorderTypes. #BORDER_WRAP is not suported.
2346	@param borderValue border value in case of a constant border
2347	@sa erode, morphologyEx, getStructuringElement
2348	*/
2349	CV_EXPORTS_W void dilate( InputArray src, OutputArray dst, InputArray kernel,
2350	Point anchor = Point(-1,-1), int iterations = 1,
2351	int borderType = BORDER_CONSTANT,
2352	const Scalar& borderValue = morphologyDefaultBorderValue() );
2353
2354	/** @brief Performs advanced morphological transformations.
2355
2356	The function cv::morphologyEx can perform advanced morphological transformations using an erosion and dilation as
2357	basic operations.
2358
2359	Any of the operations can be done in-place. In case of multi-channel images, each channel is
2360	processed independently.
2361
2362	@param src Source image. The number of channels can be arbitrary. The depth should be one of
2363	CV_8U, CV_16U, CV_16S, CV_32F or CV_64F.
2364	@param dst Destination image of the same size and type as source image.
2365	@param op Type of a morphological operation, see #MorphTypes
2366	@param kernel Structuring element. It can be created using #getStructuringElement.
2367	@param anchor Anchor position with the kernel. Negative values mean that the anchor is at the
2368	kernel center.
2369	@param iterations Number of times erosion and dilation are applied.
2370	@param borderType Pixel extrapolation method, see #BorderTypes. #BORDER_WRAP is not supported.
2371	@param borderValue Border value in case of a constant border. The default value has a special
2372	meaning.
2373	@sa dilate, erode, getStructuringElement
2374	@note The number of iterations is the number of times erosion or dilatation operation will be applied.
2375	For instance, an opening operation (#MORPH_OPEN) with two iterations is equivalent to apply
2376	successively: erode -> erode -> dilate -> dilate (and not erode -> dilate -> erode -> dilate).
2377	*/
2378	CV_EXPORTS_W void morphologyEx( InputArray src, OutputArray dst,
2379	int op, InputArray kernel,
2380	Point anchor = Point(-1,-1), int iterations = 1,
2381	int borderType = BORDER_CONSTANT,
2382	const Scalar& borderValue = morphologyDefaultBorderValue() );
2383
2384	//! @} imgproc_filter
2385
2386	//! @addtogroup imgproc_transform
2387	//! @{
2388
2389	/** @brief Resizes an image.
2390
2391	The function resize resizes the image src down to or up to the specified size. Note that the
2392	initial dst type or size are not taken into account. Instead, the size and type are derived from
2393	the `src`,`dsize`,`fx`, and `fy`. If you want to resize src so that it fits the pre-created dst,
2394	you may call the function as follows:
2395	@code
2396	// explicitly specify dsize=dst.size(); fx and fy will be computed from that.
2397	resize(src, dst, dst.size(), 0, 0, interpolation);
2398	@endcode
2399	If you want to decimate the image by factor of 2 in each direction, you can call the function this
2400	way:
2401	@code
2402	// specify fx and fy and let the function compute the destination image size.
2403	resize(src, dst, Size(), 0.5, 0.5, interpolation);
2404	@endcode
2405	To shrink an image, it will generally look best with #INTER_AREA interpolation, whereas to
2406	enlarge an image, it will generally look best with #INTER_CUBIC (slow) or #INTER_LINEAR
2407	(faster but still looks OK).
2408
2409	@param src input image.
2410	@param dst output image; it has the size dsize (when it is non-zero) or the size computed from
2411	src.size(), fx, and fy; the type of dst is the same as of src.
2412	@param dsize output image size; if it equals zero (`None` in Python), it is computed as:
2413	\f[\texttt{dsize = Size(round(fx*src.cols), round(fy*src.rows))}\f]
2414	Either dsize or both fx and fy must be non-zero.
2415	@param fx scale factor along the horizontal axis; when it equals 0, it is computed as
2416	\f[\texttt{(double)dsize.width/src.cols}\f]
2417	@param fy scale factor along the vertical axis; when it equals 0, it is computed as
2418	\f[\texttt{(double)dsize.height/src.rows}\f]
2419	@param interpolation interpolation method, see #InterpolationFlags
2420
2421	@sa warpAffine, warpPerspective, remap
2422	*/
2423	CV_EXPORTS_W void resize( InputArray src, OutputArray dst,
2424	Size dsize, double fx = 0, double fy = 0,
2425	int interpolation = INTER_LINEAR );
2426
2427	/** @brief Applies an affine transformation to an image.
2428
2429	The function warpAffine transforms the source image using the specified matrix:
2430
2431	\f[\texttt{dst} (x,y) = \texttt{src} ( \texttt{M} _{11} x + \texttt{M} _{12} y + \texttt{M} _{13}, \texttt{M} _{21} x + \texttt{M} _{22} y + \texttt{M} _{23})\f]
2432
2433	when the flag #WARP_INVERSE_MAP is set. Otherwise, the transformation is first inverted
2434	with #invertAffineTransform and then put in the formula above instead of M. The function cannot
2435	operate in-place.
2436
2437	@param src input image.
2438	@param dst output image that has the size dsize and the same type as src .
2439	@param M \f$2\times 3\f$ transformation matrix.
2440	@param dsize size of the output image.
2441	@param flags combination of interpolation methods (see #InterpolationFlags) and the optional
2442	flag #WARP_INVERSE_MAP that means that M is the inverse transformation (
2443	\f$\texttt{dst}\rightarrow\texttt{src}\f$ ).
2444	@param borderMode pixel extrapolation method (see #BorderTypes); when
2445	borderMode=#BORDER_TRANSPARENT, it means that the pixels in the destination image corresponding to
2446	the "outliers" in the source image are not modified by the function.
2447	@param borderValue value used in case of a constant border; by default, it is 0.
2448
2449	@sa warpPerspective, resize, remap, getRectSubPix, transform
2450	*/
2451	CV_EXPORTS_W void warpAffine( InputArray src, OutputArray dst,
2452	InputArray M, Size dsize,
2453	int flags = INTER_LINEAR,
2454	int borderMode = BORDER_CONSTANT,
2455	const Scalar& borderValue = Scalar());
2456
2457	/** @example samples/cpp/warpPerspective_demo.cpp
2458	An example program shows using cv::getPerspectiveTransform and cv::warpPerspective for image warping
2459	*/
2460
2461	/** @brief Applies a perspective transformation to an image.
2462
2463	The function warpPerspective transforms the source image using the specified matrix:
2464
2465	\f[\texttt{dst} (x,y) = \texttt{src} \left ( \frac{M_{11} x + M_{12} y + M_{13}}{M_{31} x + M_{32} y + M_{33}} ,
2466	\frac{M_{21} x + M_{22} y + M_{23}}{M_{31} x + M_{32} y + M_{33}} \right )\f]
2467
2468	when the flag #WARP_INVERSE_MAP is set. Otherwise, the transformation is first inverted with invert
2469	and then put in the formula above instead of M. The function cannot operate in-place.
2470
2471	@param src input image.
2472	@param dst output image that has the size dsize and the same type as src .
2473	@param M \f$3\times 3\f$ transformation matrix.
2474	@param dsize size of the output image.
2475	@param flags combination of interpolation methods (#INTER_LINEAR or #INTER_NEAREST) and the
2476	optional flag #WARP_INVERSE_MAP, that sets M as the inverse transformation (
2477	\f$\texttt{dst}\rightarrow\texttt{src}\f$ ).
2478	@param borderMode pixel extrapolation method (#BORDER_CONSTANT or #BORDER_REPLICATE).
2479	@param borderValue value used in case of a constant border; by default, it equals 0.
2480
2481	@sa warpAffine, resize, remap, getRectSubPix, perspectiveTransform
2482	*/
2483	CV_EXPORTS_W void warpPerspective( InputArray src, OutputArray dst,
2484	InputArray M, Size dsize,
2485	int flags = INTER_LINEAR,
2486	int borderMode = BORDER_CONSTANT,
2487	const Scalar& borderValue = Scalar());
2488
2489	/** @brief Applies a generic geometrical transformation to an image.
2490
2491	The function remap transforms the source image using the specified map:
2492
2493	\f[\texttt{dst} (x,y) = \texttt{src} (map_x(x,y),map_y(x,y))\f]
2494
2495	with the WARP_RELATIVE_MAP flag :
2496
2497	\f[\texttt{dst} (x,y) = \texttt{src} (x+map_x(x,y),y+map_y(x,y))\f]
2498
2499	where values of pixels with non-integer coordinates are computed using one of available
2500	interpolation methods. \f$map_x\f$ and \f$map_y\f$ can be encoded as separate floating-point maps
2501	in \f$map_1\f$ and \f$map_2\f$ respectively, or interleaved floating-point maps of \f$(x,y)\f$ in
2502	\f$map_1\f$, or fixed-point maps created by using #convertMaps. The reason you might want to
2503	convert from floating to fixed-point representations of a map is that they can yield much faster
2504	(\~2x) remapping operations. In the converted case, \f$map_1\f$ contains pairs (cvFloor(x),
2505	cvFloor(y)) and \f$map_2\f$ contains indices in a table of interpolation coefficients.
2506
2507	This function cannot operate in-place.
2508
2509	@param src Source image.
2510	@param dst Destination image. It has the same size as map1 and the same type as src .
2511	@param map1 The first map of either (x,y) points or just x values having the type CV_16SC2 ,
2512	CV_32FC1, or CV_32FC2. See #convertMaps for details on converting a floating point
2513	representation to fixed-point for speed.
2514	@param map2 The second map of y values having the type CV_16UC1, CV_32FC1, or none (empty map
2515	if map1 is (x,y) points), respectively.
2516	@param interpolation Interpolation method (see #InterpolationFlags). The methods #INTER_AREA
2517	#INTER_LINEAR_EXACT and #INTER_NEAREST_EXACT are not supported by this function.
2518	The extra flag WARP_RELATIVE_MAP can be ORed to the interpolation method
2519	(e.g. INTER_LINEAR | WARP_RELATIVE_MAP)
2520	@param borderMode Pixel extrapolation method (see #BorderTypes). When
2521	borderMode=#BORDER_TRANSPARENT, it means that the pixels in the destination image that
2522	corresponds to the "outliers" in the source image are not modified by the function.
2523	@param borderValue Value used in case of a constant border. By default, it is 0.
2524	@note
2525	Due to current implementation limitations the size of an input and output images should be less than 32767x32767.
2526	*/
2527	CV_EXPORTS_W void remap( InputArray src, OutputArray dst,
2528	InputArray map1, InputArray map2,
2529	int interpolation, int borderMode = BORDER_CONSTANT,
2530	const Scalar& borderValue = Scalar());
2531
2532	/** @brief Converts image transformation maps from one representation to another.
2533
2534	The function converts a pair of maps for remap from one representation to another. The following
2535	options ( (map1.type(), map2.type()) \f$\rightarrow\f$ (dstmap1.type(), dstmap2.type()) ) are
2536	supported:
2537
2538	- \f$\texttt{(CV_32FC1, CV_32FC1)} \rightarrow \texttt{(CV_16SC2, CV_16UC1)}\f$. This is the
2539	most frequently used conversion operation, in which the original floating-point maps (see #remap)
2540	are converted to a more compact and much faster fixed-point representation. The first output array
2541	contains the rounded coordinates and the second array (created only when nninterpolation=false )
2542	contains indices in the interpolation tables.
2543
2544	- \f$\texttt{(CV_32FC2)} \rightarrow \texttt{(CV_16SC2, CV_16UC1)}\f$. The same as above but
2545	the original maps are stored in one 2-channel matrix.
2546
2547	- Reverse conversion. Obviously, the reconstructed floating-point maps will not be exactly the same
2548	as the originals.
2549
2550	@param map1 The first input map of type CV_16SC2, CV_32FC1, or CV_32FC2 .
2551	@param map2 The second input map of type CV_16UC1, CV_32FC1, or none (empty matrix),
2552	respectively.
2553	@param dstmap1 The first output map that has the type dstmap1type and the same size as src .
2554	@param dstmap2 The second output map.
2555	@param dstmap1type Type of the first output map that should be CV_16SC2, CV_32FC1, or
2556	CV_32FC2 .
2557	@param nninterpolation Flag indicating whether the fixed-point maps are used for the
2558	nearest-neighbor or for a more complex interpolation.
2559
2560	@sa remap, undistort, initUndistortRectifyMap
2561	*/
2562	CV_EXPORTS_W void convertMaps( InputArray map1, InputArray map2,
2563	OutputArray dstmap1, OutputArray dstmap2,
2564	int dstmap1type, bool nninterpolation = false );
2565
2566	/** @brief Calculates an affine matrix of 2D rotation.
2567
2568	The function calculates the following matrix:
2569
2570	\f[\begin{bmatrix} \alpha & \beta & (1- \alpha ) \cdot \texttt{center.x} - \beta \cdot \texttt{center.y} \\ - \beta & \alpha & \beta \cdot \texttt{center.x} + (1- \alpha ) \cdot \texttt{center.y} \end{bmatrix}\f]
2571
2572	where
2573
2574	\f[\begin{array}{l} \alpha = \texttt{scale} \cdot \cos \texttt{angle} , \\ \beta = \texttt{scale} \cdot \sin \texttt{angle} \end{array}\f]
2575
2576	The transformation maps the rotation center to itself. If this is not the target, adjust the shift.
2577
2578	@param center Center of the rotation in the source image.
2579	@param angle Rotation angle in degrees. Positive values mean counter-clockwise rotation (the
2580	coordinate origin is assumed to be the top-left corner).
2581	@param scale Isotropic scale factor.
2582
2583	@sa getAffineTransform, warpAffine, transform
2584	*/
2585	CV_EXPORTS_W Mat getRotationMatrix2D(Point2f center, double angle, double scale);
2586
2587	/** @sa getRotationMatrix2D */
2588	CV_EXPORTS Matx23d getRotationMatrix2D_(Point2f center, double angle, double scale);
2589
2590	inline
2591	Mat getRotationMatrix2D(Point2f center, double angle, double scale)
2592	{
2593	return Mat(getRotationMatrix2D_(center, angle, scale), true);
2594	}
2595
2596	/** @brief Calculates an affine transform from three pairs of the corresponding points.
2597
2598	The function calculates the \f$2 \times 3\f$ matrix of an affine transform so that:
2599
2600	\f[\begin{bmatrix} x'_i \\ y'_i \end{bmatrix} = \texttt{map_matrix} \cdot \begin{bmatrix} x_i \\ y_i \\ 1 \end{bmatrix}\f]
2601
2602	where
2603
2604	\f[dst(i)=(x'_i,y'_i), src(i)=(x_i, y_i), i=0,1,2\f]
2605
2606	@param src Coordinates of triangle vertices in the source image.
2607	@param dst Coordinates of the corresponding triangle vertices in the destination image.
2608
2609	@sa warpAffine, transform
2610	*/
2611	CV_EXPORTS Mat getAffineTransform( const Point2f src[], const Point2f dst[] );
2612
2613	/** @brief Inverts an affine transformation.
2614
2615	The function computes an inverse affine transformation represented by \f$2 \times 3\f$ matrix M:
2616
2617	\f[\begin{bmatrix} a_{11} & a_{12} & b_1 \\ a_{21} & a_{22} & b_2 \end{bmatrix}\f]
2618
2619	The result is also a \f$2 \times 3\f$ matrix of the same type as M.
2620
2621	@param M Original affine transformation.
2622	@param iM Output reverse affine transformation.
2623	*/
2624	CV_EXPORTS_W void invertAffineTransform( InputArray M, OutputArray iM );
2625
2626	/** @brief Calculates a perspective transform from four pairs of the corresponding points.
2627
2628	The function calculates the \f$3 \times 3\f$ matrix of a perspective transform so that:
2629
2630	\f[\begin{bmatrix} t_i x'_i \\ t_i y'_i \\ t_i \end{bmatrix} = \texttt{map_matrix} \cdot \begin{bmatrix} x_i \\ y_i \\ 1 \end{bmatrix}\f]
2631
2632	where
2633
2634	\f[dst(i)=(x'_i,y'_i), src(i)=(x_i, y_i), i=0,1,2,3\f]
2635
2636	@param src Coordinates of quadrangle vertices in the source image.
2637	@param dst Coordinates of the corresponding quadrangle vertices in the destination image.
2638	@param solveMethod method passed to cv::solve (#DecompTypes)
2639
2640	@sa findHomography, warpPerspective, perspectiveTransform
2641	*/
2642	CV_EXPORTS_W Mat getPerspectiveTransform(InputArray src, InputArray dst, int solveMethod = DECOMP_LU);
2643
2644	/** @overload */
2645	CV_EXPORTS Mat getPerspectiveTransform(const Point2f src[], const Point2f dst[], int solveMethod = DECOMP_LU);
2646
2647
2648	CV_EXPORTS_W Mat getAffineTransform( InputArray src, InputArray dst );
2649
2650	/** @brief Retrieves a pixel rectangle from an image with sub-pixel accuracy.
2651
2652	The function getRectSubPix extracts pixels from src:
2653
2654	\f[patch(x, y) = src(x + \texttt{center.x} - ( \texttt{dst.cols} -1)*0.5, y + \texttt{center.y} - ( \texttt{dst.rows} -1)*0.5)\f]
2655
2656	where the values of the pixels at non-integer coordinates are retrieved using bilinear
2657	interpolation. Every channel of multi-channel images is processed independently. Also
2658	the image should be a single channel or three channel image. While the center of the
2659	rectangle must be inside the image, parts of the rectangle may be outside.
2660
2661	@param image Source image.
2662	@param patchSize Size of the extracted patch.
2663	@param center Floating point coordinates of the center of the extracted rectangle within the
2664	source image. The center must be inside the image.
2665	@param patch Extracted patch that has the size patchSize and the same number of channels as src .
2666	@param patchType Depth of the extracted pixels. By default, they have the same depth as src .
2667
2668	@sa warpAffine, warpPerspective
2669	*/
2670	CV_EXPORTS_W void getRectSubPix( InputArray image, Size patchSize,
2671	Point2f center, OutputArray patch, int patchType = -1 );
2672
2673	/** @example samples/cpp/polar_transforms.cpp
2674	An example using the cv::linearPolar and cv::logPolar operations
2675	*/
2676
2677	/** @brief Remaps an image to semilog-polar coordinates space.
2678
2679	@deprecated This function produces same result as cv::warpPolar(src, dst, src.size(), center, maxRadius, flags+WARP_POLAR_LOG);
2680
2681	@internal
2682	Transform the source image using the following transformation (See @ref polar_remaps_reference_image "Polar remaps reference image d)"):
2683	\f[\begin{array}{l}
2684	dst( \rho , \phi ) = src(x,y) \\
2685	dst.size() \leftarrow src.size()
2686	\end{array}\f]
2687
2688	where
2689	\f[\begin{array}{l}
2690	I = (dx,dy) = (x - center.x,y - center.y) \\
2691	\rho = M \cdot log_e(\texttt{magnitude} (I)) ,\\
2692	\phi = Kangle \cdot \texttt{angle} (I) \\
2693	\end{array}\f]
2694
2695	and
2696	\f[\begin{array}{l}
2697	M = src.cols / log_e(maxRadius) \\
2698	Kangle = src.rows / 2\Pi \\
2699	\end{array}\f]
2700
2701	The function emulates the human "foveal" vision and can be used for fast scale and
2702	rotation-invariant template matching, for object tracking and so forth.
2703	@param src Source image
2704	@param dst Destination image. It will have same size and type as src.
2705	@param center The transformation center; where the output precision is maximal
2706	@param M Magnitude scale parameter. It determines the radius of the bounding circle to transform too.
2707	@param flags A combination of interpolation methods, see #InterpolationFlags
2708
2709	@note
2710	- The function can not operate in-place.
2711	- To calculate magnitude and angle in degrees #cartToPolar is used internally thus angles are measured from 0 to 360 with accuracy about 0.3 degrees.
2712
2713	@sa cv::linearPolar
2714	@endinternal
2715	*/
2716	CV_EXPORTS_W void logPolar( InputArray src, OutputArray dst,
2717	Point2f center, double M, int flags );
2718
2719	/** @brief Remaps an image to polar coordinates space.
2720
2721	@deprecated This function produces same result as cv::warpPolar(src, dst, src.size(), center, maxRadius, flags)
2722
2723	@internal
2724	Transform the source image using the following transformation (See @ref polar_remaps_reference_image "Polar remaps reference image c)"):
2725	\f[\begin{array}{l}
2726	dst( \rho , \phi ) = src(x,y) \\
2727	dst.size() \leftarrow src.size()
2728	\end{array}\f]
2729
2730	where
2731	\f[\begin{array}{l}
2732	I = (dx,dy) = (x - center.x,y - center.y) \\
2733	\rho = Kmag \cdot \texttt{magnitude} (I) ,\\
2734	\phi = angle \cdot \texttt{angle} (I)
2735	\end{array}\f]
2736
2737	and
2738	\f[\begin{array}{l}
2739	Kx = src.cols / maxRadius \\
2740	Ky = src.rows / 2\Pi
2741	\end{array}\f]
2742
2743
2744	@param src Source image
2745	@param dst Destination image. It will have same size and type as src.
2746	@param center The transformation center;
2747	@param maxRadius The radius of the bounding circle to transform. It determines the inverse magnitude scale parameter too.
2748	@param flags A combination of interpolation methods, see #InterpolationFlags
2749
2750	@note
2751	- The function can not operate in-place.
2752	- To calculate magnitude and angle in degrees #cartToPolar is used internally thus angles are measured from 0 to 360 with accuracy about 0.3 degrees.
2753
2754	@sa cv::logPolar
2755	@endinternal
2756	*/
2757	CV_EXPORTS_W void linearPolar( InputArray src, OutputArray dst,
2758	Point2f center, double maxRadius, int flags );
2759
2760
2761	/** \brief Remaps an image to polar or semilog-polar coordinates space
2762
2763	@anchor polar_remaps_reference_image
2764	
2765
2766	Transform the source image using the following transformation:
2767	\f[
2768	dst(\rho , \phi ) = src(x,y)
2769	\f]
2770
2771	where
2772	\f[
2773	\begin{array}{l}
2774	\vec{I} = (x - center.x, \;y - center.y) \\
2775	\phi = Kangle \cdot \texttt{angle} (\vec{I}) \\
2776	\rho = \left\{\begin{matrix}
2777	Klin \cdot \texttt{magnitude} (\vec{I}) & default \\
2778	Klog \cdot log_e(\texttt{magnitude} (\vec{I})) & if \; semilog \\
2779	\end{matrix}\right.
2780	\end{array}
2781	\f]
2782
2783	and
2784	\f[
2785	\begin{array}{l}
2786	Kangle = dsize.height / 2\Pi \\
2787	Klin = dsize.width / maxRadius \\
2788	Klog = dsize.width / log_e(maxRadius) \\
2789	\end{array}
2790	\f]
2791
2792
2793	\par Linear vs semilog mapping
2794
2795	Polar mapping can be linear or semi-log. Add one of #WarpPolarMode to `flags` to specify the polar mapping mode.
2796
2797	Linear is the default mode.
2798
2799	The semilog mapping emulates the human "foveal" vision that permit very high acuity on the line of sight (central vision)
2800	in contrast to peripheral vision where acuity is minor.
2801
2802	\par Option on `dsize`:
2803
2804	- if both values in `dsize <=0 ` (default),
2805	the destination image will have (almost) same area of source bounding circle:
2806	\f[\begin{array}{l}
2807	dsize.area \leftarrow (maxRadius^2 \cdot \Pi) \\
2808	dsize.width = \texttt{cvRound}(maxRadius) \\
2809	dsize.height = \texttt{cvRound}(maxRadius \cdot \Pi) \\
2810	\end{array}\f]
2811
2812
2813	- if only `dsize.height <= 0`,
2814	the destination image area will be proportional to the bounding circle area but scaled by `Kx * Kx`:
2815	\f[\begin{array}{l}
2816	dsize.height = \texttt{cvRound}(dsize.width \cdot \Pi) \\
2817	\end{array}
2818	\f]
2819
2820	- if both values in `dsize > 0 `,
2821	the destination image will have the given size therefore the area of the bounding circle will be scaled to `dsize`.
2822
2823
2824	\par Reverse mapping
2825
2826	You can get reverse mapping adding #WARP_INVERSE_MAP to `flags`
2827	\snippet polar_transforms.cpp InverseMap
2828
2829	In addiction, to calculate the original coordinate from a polar mapped coordinate \f$(rho, phi)->(x, y)\f$:
2830	\snippet polar_transforms.cpp InverseCoordinate
2831
2832	@param src Source image.
2833	@param dst Destination image. It will have same type as src.
2834	@param dsize The destination image size (see description for valid options).
2835	@param center The transformation center.
2836	@param maxRadius The radius of the bounding circle to transform. It determines the inverse magnitude scale parameter too.
2837	@param flags A combination of interpolation methods, #InterpolationFlags + #WarpPolarMode.
2838	- Add #WARP_POLAR_LINEAR to select linear polar mapping (default)
2839	- Add #WARP_POLAR_LOG to select semilog polar mapping
2840	- Add #WARP_INVERSE_MAP for reverse mapping.
2841	@note
2842	- The function can not operate in-place.
2843	- To calculate magnitude and angle in degrees #cartToPolar is used internally thus angles are measured from 0 to 360 with accuracy about 0.3 degrees.
2844	- This function uses #remap. Due to current implementation limitations the size of an input and output images should be less than 32767x32767.
2845
2846	@sa cv::remap
2847	*/
2848	CV_EXPORTS_W void warpPolar(InputArray src, OutputArray dst, Size dsize,
2849	Point2f center, double maxRadius, int flags);
2850
2851
2852	//! @} imgproc_transform
2853
2854	//! @addtogroup imgproc_misc
2855	//! @{
2856
2857	/** @brief Calculates the integral of an image.
2858
2859	The function calculates one or more integral images for the source image as follows:
2860
2861	\f[\texttt{sum} (X,Y) = \sum _{x<X,y<Y} \texttt{image} (x,y)\f]
2862
2863	\f[\texttt{sqsum} (X,Y) = \sum _{x<X,y<Y} \texttt{image} (x,y)^2\f]
2864
2865	\f[\texttt{tilted} (X,Y) = \sum _{y<Y,abs(x-X+1) \leq Y-y-1} \texttt{image} (x,y)\f]
2866
2867	Using these integral images, you can calculate sum, mean, and standard deviation over a specific
2868	up-right or rotated rectangular region of the image in a constant time, for example:
2869
2870	\f[\sum _{x_1 \leq x < x_2, \, y_1 \leq y < y_2} \texttt{image} (x,y) = \texttt{sum} (x_2,y_2)- \texttt{sum} (x_1,y_2)- \texttt{sum} (x_2,y_1)+ \texttt{sum} (x_1,y_1)\f]
2871
2872	It makes possible to do a fast blurring or fast block correlation with a variable window size, for
2873	example. In case of multi-channel images, sums for each channel are accumulated independently.
2874
2875	As a practical example, the next figure shows the calculation of the integral of a straight
2876	rectangle Rect(4,4,3,2) and of a tilted rectangle Rect(5,1,2,3) . The selected pixels in the
2877	original image are shown, as well as the relative pixels in the integral images sum and tilted .
2878
2879	
2880
2881	@param src input image as \f$W \times H\f$, 8-bit or floating-point (32f or 64f).
2882	@param sum integral image as \f$(W+1)\times (H+1)\f$ , 32-bit integer or floating-point (32f or 64f).
2883	@param sqsum integral image for squared pixel values; it is \f$(W+1)\times (H+1)\f$, double-precision
2884	floating-point (64f) array.
2885	@param tilted integral for the image rotated by 45 degrees; it is \f$(W+1)\times (H+1)\f$ array with
2886	the same data type as sum.
2887	@param sdepth desired depth of the integral and the tilted integral images, CV_32S, CV_32F, or
2888	CV_64F.
2889	@param sqdepth desired depth of the integral image of squared pixel values, CV_32F or CV_64F.
2890	*/
2891	CV_EXPORTS_AS(integral3) void integral( InputArray src, OutputArray sum,
2892	OutputArray sqsum, OutputArray tilted,
2893	int sdepth = -1, int sqdepth = -1 );
2894
2895	/** @overload */
2896	CV_EXPORTS_W void integral( InputArray src, OutputArray sum, int sdepth = -1 );
2897
2898	/** @overload */
2899	CV_EXPORTS_AS(integral2) void integral( InputArray src, OutputArray sum,
2900	OutputArray sqsum, int sdepth = -1, int sqdepth = -1 );
2901
2902	//! @} imgproc_misc
2903
2904	//! @addtogroup imgproc_motion
2905	//! @{
2906
2907	/** @brief Adds an image to the accumulator image.
2908
2909	The function adds src or some of its elements to dst :
2910
2911	\f[\texttt{dst} (x,y) \leftarrow \texttt{dst} (x,y) + \texttt{src} (x,y) \quad \text{if} \quad \texttt{mask} (x,y) \ne 0\f]
2912
2913	The function supports multi-channel images. Each channel is processed independently.
2914
2915	The function cv::accumulate can be used, for example, to collect statistics of a scene background
2916	viewed by a still camera and for the further foreground-background segmentation.
2917
2918	@param src Input image of type CV_8UC(n), CV_16UC(n), CV_32FC(n) or CV_64FC(n), where n is a positive integer.
2919	@param dst %Accumulator image with the same number of channels as input image, and a depth of CV_32F or CV_64F.
2920	@param mask Optional operation mask.
2921
2922	@sa accumulateSquare, accumulateProduct, accumulateWeighted
2923	*/
2924	CV_EXPORTS_W void accumulate( InputArray src, InputOutputArray dst,
2925	InputArray mask = noArray() );
2926
2927	/** @brief Adds the square of a source image to the accumulator image.
2928
2929	The function adds the input image src or its selected region, raised to a power of 2, to the
2930	accumulator dst :
2931
2932	\f[\texttt{dst} (x,y) \leftarrow \texttt{dst} (x,y) + \texttt{src} (x,y)^2 \quad \text{if} \quad \texttt{mask} (x,y) \ne 0\f]
2933
2934	The function supports multi-channel images. Each channel is processed independently.
2935
2936	@param src Input image as 1- or 3-channel, 8-bit or 32-bit floating point.
2937	@param dst %Accumulator image with the same number of channels as input image, 32-bit or 64-bit
2938	floating-point.
2939	@param mask Optional operation mask.
2940
2941	@sa accumulateSquare, accumulateProduct, accumulateWeighted
2942	*/
2943	CV_EXPORTS_W void accumulateSquare( InputArray src, InputOutputArray dst,
2944	InputArray mask = noArray() );
2945
2946	/** @brief Adds the per-element product of two input images to the accumulator image.
2947
2948	The function adds the product of two images or their selected regions to the accumulator dst :
2949
2950	\f[\texttt{dst} (x,y) \leftarrow \texttt{dst} (x,y) + \texttt{src1} (x,y) \cdot \texttt{src2} (x,y) \quad \text{if} \quad \texttt{mask} (x,y) \ne 0\f]
2951
2952	The function supports multi-channel images. Each channel is processed independently.
2953
2954	@param src1 First input image, 1- or 3-channel, 8-bit or 32-bit floating point.
2955	@param src2 Second input image of the same type and the same size as src1 .
2956	@param dst %Accumulator image with the same number of channels as input images, 32-bit or 64-bit
2957	floating-point.
2958	@param mask Optional operation mask.
2959
2960	@sa accumulate, accumulateSquare, accumulateWeighted
2961	*/
2962	CV_EXPORTS_W void accumulateProduct( InputArray src1, InputArray src2,
2963	InputOutputArray dst, InputArray mask=noArray() );
2964
2965	/** @brief Updates a running average.
2966
2967	The function calculates the weighted sum of the input image src and the accumulator dst so that dst
2968	becomes a running average of a frame sequence:
2969
2970	\f[\texttt{dst} (x,y) \leftarrow (1- \texttt{alpha} ) \cdot \texttt{dst} (x,y) + \texttt{alpha} \cdot \texttt{src} (x,y) \quad \text{if} \quad \texttt{mask} (x,y) \ne 0\f]
2971
2972	That is, alpha regulates the update speed (how fast the accumulator "forgets" about earlier images).
2973	The function supports multi-channel images. Each channel is processed independently.
2974
2975	@param src Input image as 1- or 3-channel, 8-bit or 32-bit floating point.
2976	@param dst %Accumulator image with the same number of channels as input image, 32-bit or 64-bit
2977	floating-point.
2978	@param alpha Weight of the input image.
2979	@param mask Optional operation mask.
2980
2981	@sa accumulate, accumulateSquare, accumulateProduct
2982	*/
2983	CV_EXPORTS_W void accumulateWeighted( InputArray src, InputOutputArray dst,
2984	double alpha, InputArray mask = noArray() );
2985
2986	/** @brief The function is used to detect translational shifts that occur between two images.
2987
2988	The operation takes advantage of the Fourier shift theorem for detecting the translational shift in
2989	the frequency domain. It can be used for fast image registration as well as motion estimation. For
2990	more information please see <https://en.wikipedia.org/wiki/Phase_correlation>
2991
2992	Calculates the cross-power spectrum of two supplied source arrays. The arrays are padded if needed
2993	with getOptimalDFTSize.
2994
2995	The function performs the following equations:
2996	- First it applies a Hanning window to each image to remove possible edge effects, if it's provided
2997	by user. See @ref createHanningWindow and <https://en.wikipedia.org/wiki/Hann_function>. This window may
2998	be cached until the array size changes to speed up processing time.
2999	- Next it computes the forward DFTs of each source array:
3000	\f[\mathbf{G}_a = \mathcal{F}\{src_1\}, \; \mathbf{G}_b = \mathcal{F}\{src_2\}\f]
3001	where \f$\mathcal{F}\f$ is the forward DFT.
3002	- It then computes the cross-power spectrum of each frequency domain array:
3003	\f[R = \frac{ \mathbf{G}_a \mathbf{G}_b^*}{|\mathbf{G}_a \mathbf{G}_b^*|}\f]
3004	- Next the cross-correlation is converted back into the time domain via the inverse DFT:
3005	\f[r = \mathcal{F}^{-1}\{R\}\f]
3006	- Finally, it computes the peak location and computes a 5x5 weighted centroid around the peak to
3007	achieve sub-pixel accuracy.
3008	\f[(\Delta x, \Delta y) = \texttt{weightedCentroid} \{\arg \max_{(x, y)}\{r\}\}\f]
3009	- If non-zero, the response parameter is computed as the sum of the elements of r within the 5x5
3010	centroid around the peak location. It is normalized to a maximum of 1 (meaning there is a single
3011	peak) and will be smaller when there are multiple peaks.
3012
3013	@param src1 Source floating point array (CV_32FC1 or CV_64FC1)
3014	@param src2 Source floating point array (CV_32FC1 or CV_64FC1)
3015	@param window Floating point array with windowing coefficients to reduce edge effects (optional).
3016	@param response Signal power within the 5x5 centroid around the peak, between 0 and 1 (optional).
3017	@returns detected phase shift (sub-pixel) between the two arrays.
3018
3019	@sa dft, getOptimalDFTSize, idft, mulSpectrums createHanningWindow
3020	*/
3021	CV_EXPORTS_W Point2d phaseCorrelate(InputArray src1, InputArray src2,
3022	InputArray window = noArray(), CV_OUT double* response = 0);
3023
3024	/** @brief This function computes a Hanning window coefficients in two dimensions.
3025
3026	See (https://en.wikipedia.org/wiki/Hann_function) and (https://en.wikipedia.org/wiki/Window_function)
3027	for more information.
3028
3029	An example is shown below:
3030	@code
3031	// create hanning window of size 100x100 and type CV_32F
3032	Mat hann;
3033	createHanningWindow(hann, Size(100, 100), CV_32F);
3034	@endcode
3035	@param dst Destination array to place Hann coefficients in
3036	@param winSize The window size specifications (both width and height must be > 1)
3037	@param type Created array type
3038	*/
3039	CV_EXPORTS_W void createHanningWindow(OutputArray dst, Size winSize, int type);
3040
3041	/** @brief Performs the per-element division of the first Fourier spectrum by the second Fourier spectrum.
3042
3043	The function cv::divSpectrums performs the per-element division of the first array by the second array.
3044	The arrays are CCS-packed or complex matrices that are results of a real or complex Fourier transform.
3045
3046	@param a first input array.
3047	@param b second input array of the same size and type as src1 .
3048	@param c output array of the same size and type as src1 .
3049	@param flags operation flags; currently, the only supported flag is cv::DFT_ROWS, which indicates that
3050	each row of src1 and src2 is an independent 1D Fourier spectrum. If you do not want to use this flag, then simply add a `0` as value.
3051	@param conjB optional flag that conjugates the second input array before the multiplication (true)
3052	or not (false).
3053	*/
3054	CV_EXPORTS_W void divSpectrums(InputArray a, InputArray b, OutputArray c,
3055	int flags, bool conjB = false);
3056
3057	//! @} imgproc_motion
3058
3059	//! @addtogroup imgproc_misc
3060	//! @{
3061
3062	/** @brief Applies a fixed-level threshold to each array element.
3063
3064	The function applies fixed-level thresholding to a multiple-channel array. The function is typically
3065	used to get a bi-level (binary) image out of a grayscale image ( #compare could be also used for
3066	this purpose) or for removing a noise, that is, filtering out pixels with too small or too large
3067	values. There are several types of thresholding supported by the function. They are determined by
3068	type parameter.
3069
3070	Also, the special values #THRESH_OTSU or #THRESH_TRIANGLE may be combined with one of the
3071	above values. In these cases, the function determines the optimal threshold value using the Otsu's
3072	or Triangle algorithm and uses it instead of the specified thresh.
3073
3074	@note Currently, the Otsu's method is implemented only for CV_8UC1 and CV_16UC1 images,
3075	and the Triangle's method is implemented only for CV_8UC1 images.
3076
3077	@param src input array (multiple-channel, CV_8U, CV_16S, CV_16U, CV_32F or CV_64F).
3078	@param dst output array of the same size and type and the same number of channels as src.
3079	@param thresh threshold value.
3080	@param maxval maximum value to use with the #THRESH_BINARY and #THRESH_BINARY_INV thresholding
3081	types.
3082	@param type thresholding type (see #ThresholdTypes).
3083	@return the computed threshold value if Otsu's or Triangle methods used.
3084
3085	@sa thresholdWithMask, adaptiveThreshold, findContours, compare, min, max
3086	*/
3087	CV_EXPORTS_W double threshold( InputArray src, OutputArray dst,
3088	double thresh, double maxval, int type );
3089
3090	/** @brief Same as #threshold, but with an optional mask
3091
3092	@note If the mask is empty, #thresholdWithMask is equivalent to #threshold.
3093	If the mask is not empty, dst *must* be of the same size and type as src, so that
3094	outliers pixels are left as-is
3095
3096	@param src input array (multiple-channel, 8-bit or 32-bit floating point).
3097	@param dst output array of the same size and type and the same number of channels as src.
3098	@param mask optional mask (same size as src, 8-bit).
3099	@param thresh threshold value.
3100	@param maxval maximum value to use with the #THRESH_BINARY and #THRESH_BINARY_INV thresholding
3101	types.
3102	@param type thresholding type (see #ThresholdTypes).
3103	@return the computed threshold value if Otsu's or Triangle methods used.
3104
3105	@sa threshold, adaptiveThreshold, findContours, compare, min, max
3106	*/
3107	CV_EXPORTS_W double thresholdWithMask( InputArray src, InputOutputArray dst, InputArray mask,
3108	double thresh, double maxval, int type );
3109
3110	/** @brief Applies an adaptive threshold to an array.
3111
3112	The function transforms a grayscale image to a binary image according to the formulae:
3113	- **THRESH_BINARY**
3114	\f[dst(x,y) = \fork{\texttt{maxValue}}{if \(src(x,y) > T(x,y)\)}{0}{otherwise}\f]
3115	- **THRESH_BINARY_INV**
3116	\f[dst(x,y) = \fork{0}{if \(src(x,y) > T(x,y)\)}{\texttt{maxValue}}{otherwise}\f]
3117	where \f$T(x,y)\f$ is a threshold calculated individually for each pixel (see adaptiveMethod parameter).
3118
3119	The function can process the image in-place.
3120
3121	@param src Source 8-bit single-channel image.
3122	@param dst Destination image of the same size and the same type as src.
3123	@param maxValue Non-zero value assigned to the pixels for which the condition is satisfied
3124	@param adaptiveMethod Adaptive thresholding algorithm to use, see #AdaptiveThresholdTypes.
3125	The #BORDER_REPLICATE | #BORDER_ISOLATED is used to process boundaries.
3126	@param thresholdType Thresholding type that must be either #THRESH_BINARY or #THRESH_BINARY_INV,
3127	see #ThresholdTypes.
3128	@param blockSize Size of a pixel neighborhood that is used to calculate a threshold value for the
3129	pixel: 3, 5, 7, and so on.
3130	@param C Constant subtracted from the mean or weighted mean (see the details below). Normally, it
3131	is positive but may be zero or negative as well.
3132
3133	@sa threshold, blur, GaussianBlur
3134	*/
3135	CV_EXPORTS_W void adaptiveThreshold( InputArray src, OutputArray dst,
3136	double maxValue, int adaptiveMethod,
3137	int thresholdType, int blockSize, double C );
3138
3139	//! @} imgproc_misc
3140
3141	//! @addtogroup imgproc_filter
3142	//! @{
3143
3144	/** @example samples/cpp/tutorial_code/ImgProc/Pyramids/Pyramids.cpp
3145	An example using pyrDown and pyrUp functions
3146	*/
3147
3148	/** @brief Blurs an image and downsamples it.
3149
3150	By default, size of the output image is computed as `Size((src.cols+1)/2, (src.rows+1)/2)`, but in
3151	any case, the following conditions should be satisfied:
3152
3153	\f[\begin{array}{l} | \texttt{dstsize.width} *2-src.cols| \leq 2 \\ | \texttt{dstsize.height} *2-src.rows| \leq 2 \end{array}\f]
3154
3155	The function performs the downsampling step of the Gaussian pyramid construction. First, it
3156	convolves the source image with the kernel:
3157
3158	\f[\frac{1}{256} \begin{bmatrix} 1 & 4 & 6 & 4 & 1 \\ 4 & 16 & 24 & 16 & 4 \\ 6 & 24 & 36 & 24 & 6 \\ 4 & 16 & 24 & 16 & 4 \\ 1 & 4 & 6 & 4 & 1 \end{bmatrix}\f]
3159
3160	Then, it downsamples the image by rejecting even rows and columns.
3161
3162	@param src input image.
3163	@param dst output image; it has the specified size and the same type as src.
3164	@param dstsize size of the output image.
3165	@param borderType Pixel extrapolation method, see #BorderTypes (#BORDER_CONSTANT isn't supported)
3166	*/
3167	CV_EXPORTS_W void pyrDown( InputArray src, OutputArray dst,
3168	const Size& dstsize = Size(), int borderType = BORDER_DEFAULT );
3169
3170	/** @brief Upsamples an image and then blurs it.
3171
3172	By default, size of the output image is computed as `Size(src.cols\*2, (src.rows\*2)`, but in any
3173	case, the following conditions should be satisfied:
3174
3175	\f[\begin{array}{l} | \texttt{dstsize.width} -src.cols*2| \leq ( \texttt{dstsize.width} \mod 2) \\ | \texttt{dstsize.height} -src.rows*2| \leq ( \texttt{dstsize.height} \mod 2) \end{array}\f]
3176
3177	The function performs the upsampling step of the Gaussian pyramid construction, though it can
3178	actually be used to construct the Laplacian pyramid. First, it upsamples the source image by
3179	injecting even zero rows and columns and then convolves the result with the same kernel as in
3180	pyrDown multiplied by 4.
3181
3182	@param src input image.
3183	@param dst output image. It has the specified size and the same type as src .
3184	@param dstsize size of the output image.
3185	@param borderType Pixel extrapolation method, see #BorderTypes (only #BORDER_DEFAULT is supported)
3186	*/
3187	CV_EXPORTS_W void pyrUp( InputArray src, OutputArray dst,
3188	const Size& dstsize = Size(), int borderType = BORDER_DEFAULT );
3189
3190	/** @brief Constructs the Gaussian pyramid for an image.
3191
3192	The function constructs a vector of images and builds the Gaussian pyramid by recursively applying
3193	pyrDown to the previously built pyramid layers, starting from `dst[0]==src`.
3194
3195	@param src Source image. Check pyrDown for the list of supported types.
3196	@param dst Destination vector of maxlevel+1 images of the same type as src. dst[0] will be the
3197	same as src. dst[1] is the next pyramid layer, a smoothed and down-sized src, and so on.
3198	@param maxlevel 0-based index of the last (the smallest) pyramid layer. It must be non-negative.
3199	@param borderType Pixel extrapolation method, see #BorderTypes (#BORDER_CONSTANT isn't supported)
3200	*/
3201	CV_EXPORTS void buildPyramid( InputArray src, OutputArrayOfArrays dst,
3202	int maxlevel, int borderType = BORDER_DEFAULT );
3203
3204	//! @} imgproc_filter
3205
3206	//! @addtogroup imgproc_hist
3207	//! @{
3208
3209	/** @example samples/cpp/demhist.cpp
3210	An example for creating histograms of an image
3211	*/
3212
3213	/** @brief Calculates a histogram of a set of arrays.
3214
3215	The function cv::calcHist calculates the histogram of one or more arrays. The elements of a tuple used
3216	to increment a histogram bin are taken from the corresponding input arrays at the same location. The
3217	sample below shows how to compute a 2D Hue-Saturation histogram for a color image. :
3218	@include snippets/imgproc_calcHist.cpp
3219
3220	@param images Source arrays. They all should have the same depth, CV_8U, CV_16U or CV_32F , and the same
3221	size. Each of them can have an arbitrary number of channels.
3222	@param nimages Number of source images.
3223	@param channels List of the dims channels used to compute the histogram. The first array channels
3224	are numerated from 0 to images[0].channels()-1 , the second array channels are counted from
3225	images[0].channels() to images[0].channels() + images[1].channels()-1, and so on.
3226	@param mask Optional mask. If the matrix is not empty, it must be an 8-bit array of the same size
3227	as images[i] . The non-zero mask elements mark the array elements counted in the histogram.
3228	@param hist Output histogram, which is a dense or sparse dims -dimensional array.
3229	@param dims Histogram dimensionality that must be positive and not greater than CV_MAX_DIMS
3230	(equal to 32 in the current OpenCV version).
3231	@param histSize Array of histogram sizes in each dimension.
3232	@param ranges Array of the dims arrays of the histogram bin boundaries in each dimension. When the
3233	histogram is uniform ( uniform =true), then for each dimension i it is enough to specify the lower
3234	(inclusive) boundary \f$L_0\f$ of the 0-th histogram bin and the upper (exclusive) boundary
3235	\f$U_{\texttt{histSize}[i]-1}\f$ for the last histogram bin histSize[i]-1 . That is, in case of a
3236	uniform histogram each of ranges[i] is an array of 2 elements. When the histogram is not uniform (
3237	uniform=false ), then each of ranges[i] contains histSize[i]+1 elements:
3238	\f$L_0, U_0=L_1, U_1=L_2, ..., U_{\texttt{histSize[i]}-2}=L_{\texttt{histSize[i]}-1}, U_{\texttt{histSize[i]}-1}\f$
3239	. The array elements, that are not between \f$L_0\f$ and \f$U_{\texttt{histSize[i]}-1}\f$ , are not
3240	counted in the histogram.
3241	@param uniform Flag indicating whether the histogram is uniform or not (see above).
3242	@param accumulate Accumulation flag. If it is set, the histogram is not cleared in the beginning
3243	when it is allocated. This feature enables you to compute a single histogram from several sets of
3244	arrays, or to update the histogram in time.
3245	*/
3246	CV_EXPORTS void calcHist( const Mat* images, int nimages,
3247	const int* channels, InputArray mask,
3248	OutputArray hist, int dims, const int* histSize,
3249	const float** ranges, bool uniform = true, bool accumulate = false );
3250
3251	/** @overload
3252
3253	this variant uses %SparseMat for output
3254	*/
3255	CV_EXPORTS void calcHist( const Mat* images, int nimages,
3256	const int* channels, InputArray mask,
3257	SparseMat& hist, int dims,
3258	const int* histSize, const float** ranges,
3259	bool uniform = true, bool accumulate = false );
3260
3261	/** @overload
3262
3263	this variant supports only uniform histograms.
3264
3265	ranges argument is either empty vector or a flattened vector of histSize.size()*2 elements
3266	(histSize.size() element pairs). The first and second elements of each pair specify the lower and
3267	upper boundaries.
3268	*/
3269	CV_EXPORTS_W void calcHist( InputArrayOfArrays images,
3270	const std::vector<int>& channels,
3271	InputArray mask, OutputArray hist,
3272	const std::vector<int>& histSize,
3273	const std::vector<float>& ranges,
3274	bool accumulate = false );
3275
3276	/** @brief Calculates the back projection of a histogram.
3277
3278	The function cv::calcBackProject calculates the back project of the histogram. That is, similarly to
3279	#calcHist , at each location (x, y) the function collects the values from the selected channels
3280	in the input images and finds the corresponding histogram bin. But instead of incrementing it, the
3281	function reads the bin value, scales it by scale , and stores in backProject(x,y) . In terms of
3282	statistics, the function computes probability of each element value in respect with the empirical
3283	probability distribution represented by the histogram. See how, for example, you can find and track
3284	a bright-colored object in a scene:
3285
3286	- Before tracking, show the object to the camera so that it covers almost the whole frame.
3287	Calculate a hue histogram. The histogram may have strong maximums, corresponding to the dominant
3288	colors in the object.
3289
3290	- When tracking, calculate a back projection of a hue plane of each input video frame using that
3291	pre-computed histogram. Threshold the back projection to suppress weak colors. It may also make
3292	sense to suppress pixels with non-sufficient color saturation and too dark or too bright pixels.
3293
3294	- Find connected components in the resulting picture and choose, for example, the largest
3295	component.
3296
3297	This is an approximate algorithm of the CamShift color object tracker.
3298
3299	@param images Source arrays. They all should have the same depth, CV_8U, CV_16U or CV_32F , and the same
3300	size. Each of them can have an arbitrary number of channels.
3301	@param nimages Number of source images.
3302	@param channels The list of channels used to compute the back projection. The number of channels
3303	must match the histogram dimensionality. The first array channels are numerated from 0 to
3304	images[0].channels()-1 , the second array channels are counted from images[0].channels() to
3305	images[0].channels() + images[1].channels()-1, and so on.
3306	@param hist Input histogram that can be dense or sparse.
3307	@param backProject Destination back projection array that is a single-channel array of the same
3308	size and depth as images[0] .
3309	@param ranges Array of arrays of the histogram bin boundaries in each dimension. See #calcHist .
3310	@param scale Optional scale factor for the output back projection.
3311	@param uniform Flag indicating whether the histogram is uniform or not (see #calcHist).
3312
3313	@sa calcHist, compareHist
3314	*/
3315	CV_EXPORTS void calcBackProject( const Mat* images, int nimages,
3316	const int* channels, InputArray hist,
3317	OutputArray backProject, const float** ranges,
3318	double scale = 1, bool uniform = true );
3319
3320	/** @overload */
3321	CV_EXPORTS void calcBackProject( const Mat* images, int nimages,
3322	const int* channels, const SparseMat& hist,
3323	OutputArray backProject, const float** ranges,
3324	double scale = 1, bool uniform = true );
3325
3326	/** @overload */
3327	CV_EXPORTS_W void calcBackProject( InputArrayOfArrays images, const std::vector<int>& channels,
3328	InputArray hist, OutputArray dst,
3329	const std::vector<float>& ranges,
3330	double scale );
3331
3332	/** @brief Compares two histograms.
3333
3334	The function cv::compareHist compares two dense or two sparse histograms using the specified method.
3335
3336	The function returns \f$d(H_1, H_2)\f$ .
3337
3338	While the function works well with 1-, 2-, 3-dimensional dense histograms, it may not be suitable
3339	for high-dimensional sparse histograms. In such histograms, because of aliasing and sampling
3340	problems, the coordinates of non-zero histogram bins can slightly shift. To compare such histograms
3341	or more general sparse configurations of weighted points, consider using the #EMD function.
3342
3343	@param H1 First compared histogram.
3344	@param H2 Second compared histogram of the same size as H1 .
3345	@param method Comparison method, see #HistCompMethods
3346	*/
3347	CV_EXPORTS_W double compareHist( InputArray H1, InputArray H2, int method );
3348
3349	/** @overload */
3350	CV_EXPORTS double compareHist( const SparseMat& H1, const SparseMat& H2, int method );
3351
3352	/** @brief Equalizes the histogram of a grayscale image.
3353
3354	The function equalizes the histogram of the input image using the following algorithm:
3355
3356	- Calculate the histogram \f$H\f$ for src .
3357	- Normalize the histogram so that the sum of histogram bins is 255.
3358	- Compute the integral of the histogram:
3359	\f[H'_i = \sum _{0 \le j < i} H(j)\f]
3360	- Transform the image using \f$H'\f$ as a look-up table: \f$\texttt{dst}(x,y) = H'(\texttt{src}(x,y))\f$
3361
3362	The algorithm normalizes the brightness and increases the contrast of the image.
3363
3364	@param src Source 8-bit single channel image.
3365	@param dst Destination image of the same size and type as src .
3366	*/
3367	CV_EXPORTS_W void equalizeHist( InputArray src, OutputArray dst );
3368
3369	/** @brief Creates a smart pointer to a cv::CLAHE class and initializes it.
3370
3371	@param clipLimit Threshold for contrast limiting.
3372	@param tileGridSize Size of grid for histogram equalization. Input image will be divided into
3373	equally sized rectangular tiles. tileGridSize defines the number of tiles in row and column.
3374	*/
3375	CV_EXPORTS_W Ptr<CLAHE> createCLAHE(double clipLimit = 40.0, Size tileGridSize = Size(8, 8));
3376
3377	/** @brief Computes the "minimal work" distance between two weighted point configurations.
3378
3379	The function computes the earth mover distance and/or a lower boundary of the distance between the
3380	two weighted point configurations. One of the applications described in @cite RubnerSept98,
3381	@cite Rubner2000 is multi-dimensional histogram comparison for image retrieval. EMD is a transportation
3382	problem that is solved using some modification of a simplex algorithm, thus the complexity is
3383	exponential in the worst case, though, on average it is much faster. In the case of a real metric
3384	the lower boundary can be calculated even faster (using linear-time algorithm) and it can be used
3385	to determine roughly whether the two signatures are far enough so that they cannot relate to the
3386	same object.
3387
3388	@param signature1 First signature, a \f$\texttt{size1}\times \texttt{dims}+1\f$ floating-point matrix.
3389	Each row stores the point weight followed by the point coordinates. The matrix is allowed to have
3390	a single column (weights only) if the user-defined cost matrix is used. The weights must be
3391	non-negative and have at least one non-zero value.
3392	@param signature2 Second signature of the same format as signature1 , though the number of rows
3393	may be different. The total weights may be different. In this case an extra "dummy" point is added
3394	to either signature1 or signature2. The weights must be non-negative and have at least one non-zero
3395	value.
3396	@param distType Used metric. See #DistanceTypes.
3397	@param cost User-defined \f$\texttt{size1}\times \texttt{size2}\f$ cost matrix. Also, if a cost matrix
3398	is used, lower boundary lowerBound cannot be calculated because it needs a metric function.
3399	@param lowerBound Optional input/output parameter: lower boundary of a distance between the two
3400	signatures that is a distance between mass centers. The lower boundary may not be calculated if
3401	the user-defined cost matrix is used, the total weights of point configurations are not equal, or
3402	if the signatures consist of weights only (the signature matrices have a single column). You
3403	**must** initialize \*lowerBound . If the calculated distance between mass centers is greater or
3404	equal to \*lowerBound (it means that the signatures are far enough), the function does not
3405	calculate EMD. In any case \*lowerBound is set to the calculated distance between mass centers on
3406	return. Thus, if you want to calculate both distance between mass centers and EMD, \*lowerBound
3407	should be set to 0.
3408	@param flow Resultant \f$\texttt{size1} \times \texttt{size2}\f$ flow matrix: \f$\texttt{flow}_{i,j}\f$ is
3409	a flow from \f$i\f$ -th point of signature1 to \f$j\f$ -th point of signature2 .
3410	*/
3411	CV_EXPORTS float EMD( InputArray signature1, InputArray signature2,
3412	int distType, InputArray cost=noArray(),
3413	float* lowerBound = 0, OutputArray flow = noArray() );
3414
3415	CV_EXPORTS_AS(EMD) float wrapperEMD( InputArray signature1, InputArray signature2,
3416	int distType, InputArray cost=noArray(),
3417	CV_IN_OUT Ptr<float> lowerBound = Ptr<float>(), OutputArray flow = noArray() );
3418
3419	//! @} imgproc_hist
3420
3421	//! @addtogroup imgproc_segmentation
3422	//! @{
3423
3424	/** @example samples/cpp/watershed.cpp
3425	An example using the watershed algorithm
3426	*/
3427
3428	/** @brief Performs a marker-based image segmentation using the watershed algorithm.
3429
3430	The function implements one of the variants of watershed, non-parametric marker-based segmentation
3431	algorithm, described in @cite Meyer92 .
3432
3433	Before passing the image to the function, you have to roughly outline the desired regions in the
3434	image markers with positive (\>0) indices. So, every region is represented as one or more connected
3435	components with the pixel values 1, 2, 3, and so on. Such markers can be retrieved from a binary
3436	mask using #findContours and #drawContours (see the watershed.cpp demo). The markers are "seeds" of
3437	the future image regions. All the other pixels in markers , whose relation to the outlined regions
3438	is not known and should be defined by the algorithm, should be set to 0's. In the function output,
3439	each pixel in markers is set to a value of the "seed" components or to -1 at boundaries between the
3440	regions.
3441
3442	@note Any two neighbor connected components are not necessarily separated by a watershed boundary
3443	(-1's pixels); for example, they can touch each other in the initial marker image passed to the
3444	function.
3445
3446	@param image Input 8-bit 3-channel image.
3447	@param markers Input/output 32-bit single-channel image (map) of markers. It should have the same
3448	size as image .
3449
3450	@sa findContours
3451	*/
3452	CV_EXPORTS_W void watershed( InputArray image, InputOutputArray markers );
3453
3454	//! @} imgproc_segmentation
3455
3456	//! @addtogroup imgproc_filter
3457	//! @{
3458
3459	/** @brief Performs initial step of meanshift segmentation of an image.
3460
3461	The function implements the filtering stage of meanshift segmentation, that is, the output of the
3462	function is the filtered "posterized" image with color gradients and fine-grain texture flattened.
3463	At every pixel (X,Y) of the input image (or down-sized input image, see below) the function executes
3464	meanshift iterations, that is, the pixel (X,Y) neighborhood in the joint space-color hyperspace is
3465	considered:
3466
3467	\f[(x,y): X- \texttt{sp} \le x \le X+ \texttt{sp} , Y- \texttt{sp} \le y \le Y+ \texttt{sp} , ||(R,G,B)-(r,g,b)|| \le \texttt{sr}\f]
3468
3469	where (R,G,B) and (r,g,b) are the vectors of color components at (X,Y) and (x,y), respectively
3470	(though, the algorithm does not depend on the color space used, so any 3-component color space can
3471	be used instead). Over the neighborhood the average spatial value (X',Y') and average color vector
3472	(R',G',B') are found and they act as the neighborhood center on the next iteration:
3473
3474	\f[(X,Y)~(X',Y'), (R,G,B)~(R',G',B').\f]
3475
3476	After the iterations over, the color components of the initial pixel (that is, the pixel from where
3477	the iterations started) are set to the final value (average color at the last iteration):
3478
3479	\f[I(X,Y) <- (R*,G*,B*)\f]
3480
3481	When maxLevel \> 0, the gaussian pyramid of maxLevel+1 levels is built, and the above procedure is
3482	run on the smallest layer first. After that, the results are propagated to the larger layer and the
3483	iterations are run again only on those pixels where the layer colors differ by more than sr from the
3484	lower-resolution layer of the pyramid. That makes boundaries of color regions sharper. Note that the
3485	results will be actually different from the ones obtained by running the meanshift procedure on the
3486	whole original image (i.e. when maxLevel==0).
3487
3488	@param src The source 8-bit, 3-channel image.
3489	@param dst The destination image of the same format and the same size as the source.
3490	@param sp The spatial window radius.
3491	@param sr The color window radius.
3492	@param maxLevel Maximum level of the pyramid for the segmentation.
3493	@param termcrit Termination criteria: when to stop meanshift iterations.
3494	*/
3495	CV_EXPORTS_W void pyrMeanShiftFiltering( InputArray src, OutputArray dst,
3496	double sp, double sr, int maxLevel = 1,
3497	TermCriteria termcrit=TermCriteria(TermCriteria::MAX_ITER+TermCriteria::EPS,5,1) );
3498
3499	//! @}
3500
3501	//! @addtogroup imgproc_segmentation
3502	//! @{
3503
3504	/** @example samples/cpp/grabcut.cpp
3505	An example using the GrabCut algorithm
3506	
3507	*/
3508
3509	/** @brief Runs the GrabCut algorithm.
3510
3511	The function implements the [GrabCut image segmentation algorithm](https://en.wikipedia.org/wiki/GrabCut).
3512
3513	@param img Input 8-bit 3-channel image.
3514	@param mask Input/output 8-bit single-channel mask. The mask is initialized by the function when
3515	mode is set to #GC_INIT_WITH_RECT. Its elements may have one of the #GrabCutClasses.
3516	@param rect ROI containing a segmented object. The pixels outside of the ROI are marked as
3517	"obvious background". The parameter is only used when mode==#GC_INIT_WITH_RECT .
3518	@param bgdModel Temporary array for the background model. Do not modify it while you are
3519	processing the same image.
3520	@param fgdModel Temporary arrays for the foreground model. Do not modify it while you are
3521	processing the same image.
3522	@param iterCount Number of iterations the algorithm should make before returning the result. Note
3523	that the result can be refined with further calls with mode==#GC_INIT_WITH_MASK or
3524	mode==GC_EVAL .
3525	@param mode Operation mode that could be one of the #GrabCutModes
3526	*/
3527	CV_EXPORTS_W void grabCut( InputArray img, InputOutputArray mask, Rect rect,
3528	InputOutputArray bgdModel, InputOutputArray fgdModel,
3529	int iterCount, int mode = GC_EVAL );
3530
3531	//! @} imgproc_segmentation
3532
3533	//! @addtogroup imgproc_misc
3534	//! @{
3535
3536	/** @example samples/cpp/distrans.cpp
3537	An example on using the distance transform
3538	*/
3539
3540	/** @brief Calculates the distance to the closest zero pixel for each pixel of the source image.
3541
3542	The function cv::distanceTransform calculates the approximate or precise distance from every binary
3543	image pixel to the nearest zero pixel. For zero image pixels, the distance will obviously be zero.
3544
3545	When maskSize == #DIST_MASK_PRECISE and distanceType == #DIST_L2 , the function runs the
3546	algorithm described in @cite Felzenszwalb04 . This algorithm is parallelized with the TBB library.
3547
3548	In other cases, the algorithm @cite Borgefors86 is used. This means that for a pixel the function
3549	finds the shortest path to the nearest zero pixel consisting of basic shifts: horizontal, vertical,
3550	diagonal, or knight's move (the latest is available for a \f$5\times 5\f$ mask). The overall
3551	distance is calculated as a sum of these basic distances. Since the distance function should be
3552	symmetric, all of the horizontal and vertical shifts must have the same cost (denoted as a ), all
3553	the diagonal shifts must have the same cost (denoted as `b`), and all knight's moves must have the
3554	same cost (denoted as `c`). For the #DIST_C and #DIST_L1 types, the distance is calculated
3555	precisely, whereas for #DIST_L2 (Euclidean distance) the distance can be calculated only with a
3556	relative error (a \f$5\times 5\f$ mask gives more accurate results). For `a`,`b`, and `c`, OpenCV
3557	uses the values suggested in the original paper:
3558	- DIST_L1: `a = 1, b = 2`
3559	- DIST_L2:
3560	- `3 x 3`: `a=0.955, b=1.3693`
3561	- `5 x 5`: `a=1, b=1.4, c=2.1969`
3562	- DIST_C: `a = 1, b = 1`
3563
3564	Typically, for a fast, coarse distance estimation #DIST_L2, a \f$3\times 3\f$ mask is used. For a
3565	more accurate distance estimation #DIST_L2, a \f$5\times 5\f$ mask or the precise algorithm is used.
3566	Note that both the precise and the approximate algorithms are linear on the number of pixels.
3567
3568	This variant of the function does not only compute the minimum distance for each pixel \f$(x, y)\f$
3569	but also identifies the nearest connected component consisting of zero pixels
3570	(labelType==#DIST_LABEL_CCOMP) or the nearest zero pixel (labelType==#DIST_LABEL_PIXEL). Index of the
3571	component/pixel is stored in `labels(x, y)`. When labelType==#DIST_LABEL_CCOMP, the function
3572	automatically finds connected components of zero pixels in the input image and marks them with
3573	distinct labels. When labelType==#DIST_LABEL_PIXEL, the function scans through the input image and
3574	marks all the zero pixels with distinct labels.
3575
3576	In this mode, the complexity is still linear. That is, the function provides a very fast way to
3577	compute the Voronoi diagram for a binary image. Currently, the second variant can use only the
3578	approximate distance transform algorithm, i.e. maskSize=#DIST_MASK_PRECISE is not supported
3579	yet.
3580
3581	@param src 8-bit, single-channel (binary) source image.
3582	@param dst Output image with calculated distances. It is a 8-bit or 32-bit floating-point,
3583	single-channel image of the same size as src.
3584	@param labels Output 2D array of labels (the discrete Voronoi diagram). It has the type
3585	CV_32SC1 and the same size as src.
3586	@param distanceType Type of distance, see #DistanceTypes
3587	@param maskSize Size of the distance transform mask, see #DistanceTransformMasks.
3588	#DIST_MASK_PRECISE is not supported by this variant. In case of the #DIST_L1 or #DIST_C distance type,
3589	the parameter is forced to 3 because a \f$3\times 3\f$ mask gives the same result as \f$5\times
3590	5\f$ or any larger aperture.
3591	@param labelType Type of the label array to build, see #DistanceTransformLabelTypes.
3592	*/
3593	CV_EXPORTS_AS(distanceTransformWithLabels) void distanceTransform( InputArray src, OutputArray dst,
3594	OutputArray labels, int distanceType, int maskSize,
3595	int labelType = DIST_LABEL_CCOMP );
3596
3597	/** @overload
3598	@param src 8-bit, single-channel (binary) source image.
3599	@param dst Output image with calculated distances. It is a 8-bit or 32-bit floating-point,
3600	single-channel image of the same size as src .
3601	@param distanceType Type of distance, see #DistanceTypes
3602	@param maskSize Size of the distance transform mask, see #DistanceTransformMasks. In case of the
3603	#DIST_L1 or #DIST_C distance type, the parameter is forced to 3 because a \f$3\times 3\f$ mask gives
3604	the same result as \f$5\times 5\f$ or any larger aperture.
3605	@param dstType Type of output image. It can be CV_8U or CV_32F. Type CV_8U can be used only for
3606	the first variant of the function and distanceType == #DIST_L1.
3607	*/
3608	CV_EXPORTS_W void distanceTransform( InputArray src, OutputArray dst,
3609	int distanceType, int maskSize, int dstType=CV_32F);
3610
3611	/** @brief Fills a connected component with the given color.
3612
3613	The function cv::floodFill fills a connected component starting from the seed point with the specified
3614	color. The connectivity is determined by the color/brightness closeness of the neighbor pixels. The
3615	pixel at \f$(x,y)\f$ is considered to belong to the repainted domain if:
3616
3617	- in case of a grayscale image and floating range
3618	\f[\texttt{src} (x',y')- \texttt{loDiff} \leq \texttt{src} (x,y) \leq \texttt{src} (x',y')+ \texttt{upDiff}\f]
3619
3620
3621	- in case of a grayscale image and fixed range
3622	\f[\texttt{src} ( \texttt{seedPoint} .x, \texttt{seedPoint} .y)- \texttt{loDiff} \leq \texttt{src} (x,y) \leq \texttt{src} ( \texttt{seedPoint} .x, \texttt{seedPoint} .y)+ \texttt{upDiff}\f]
3623
3624
3625	- in case of a color image and floating range
3626	\f[\texttt{src} (x',y')_r- \texttt{loDiff} _r \leq \texttt{src} (x,y)_r \leq \texttt{src} (x',y')_r+ \texttt{upDiff} _r,\f]
3627	\f[\texttt{src} (x',y')_g- \texttt{loDiff} _g \leq \texttt{src} (x,y)_g \leq \texttt{src} (x',y')_g+ \texttt{upDiff} _g\f]
3628	and
3629	\f[\texttt{src} (x',y')_b- \texttt{loDiff} _b \leq \texttt{src} (x,y)_b \leq \texttt{src} (x',y')_b+ \texttt{upDiff} _b\f]
3630
3631
3632	- in case of a color image and fixed range
3633	\f[\texttt{src} ( \texttt{seedPoint} .x, \texttt{seedPoint} .y)_r- \texttt{loDiff} _r \leq \texttt{src} (x,y)_r \leq \texttt{src} ( \texttt{seedPoint} .x, \texttt{seedPoint} .y)_r+ \texttt{upDiff} _r,\f]
3634	\f[\texttt{src} ( \texttt{seedPoint} .x, \texttt{seedPoint} .y)_g- \texttt{loDiff} _g \leq \texttt{src} (x,y)_g \leq \texttt{src} ( \texttt{seedPoint} .x, \texttt{seedPoint} .y)_g+ \texttt{upDiff} _g\f]
3635	and
3636	\f[\texttt{src} ( \texttt{seedPoint} .x, \texttt{seedPoint} .y)_b- \texttt{loDiff} _b \leq \texttt{src} (x,y)_b \leq \texttt{src} ( \texttt{seedPoint} .x, \texttt{seedPoint} .y)_b+ \texttt{upDiff} _b\f]
3637
3638
3639	where \f$src(x',y')\f$ is the value of one of pixel neighbors that is already known to belong to the
3640	component. That is, to be added to the connected component, a color/brightness of the pixel should
3641	be close enough to:
3642	- Color/brightness of one of its neighbors that already belong to the connected component in case
3643	of a floating range.
3644	- Color/brightness of the seed point in case of a fixed range.
3645
3646	Use these functions to either mark a connected component with the specified color in-place, or build
3647	a mask and then extract the contour, or copy the region to another image, and so on.
3648
3649	@param image Input/output 1- or 3-channel, 8-bit, or floating-point image. It is modified by the
3650	function unless the #FLOODFILL_MASK_ONLY flag is set in the second variant of the function. See
3651	the details below.
3652	@param mask Operation mask that should be a single-channel 8-bit image, 2 pixels wider and 2 pixels
3653	taller than image. If an empty Mat is passed it will be created automatically. Since this is both an
3654	input and output parameter, you must take responsibility of initializing it.
3655	Flood-filling cannot go across non-zero pixels in the input mask. For example,
3656	an edge detector output can be used as a mask to stop filling at edges. On output, pixels in the
3657	mask corresponding to filled pixels in the image are set to 1 or to the specified value in flags
3658	as described below. Additionally, the function fills the border of the mask with ones to simplify
3659	internal processing. It is therefore possible to use the same mask in multiple calls to the function
3660	to make sure the filled areas do not overlap.
3661	@param seedPoint Starting point.
3662	@param newVal New value of the repainted domain pixels.
3663	@param loDiff Maximal lower brightness/color difference between the currently observed pixel and
3664	one of its neighbors belonging to the component, or a seed pixel being added to the component.
3665	@param upDiff Maximal upper brightness/color difference between the currently observed pixel and
3666	one of its neighbors belonging to the component, or a seed pixel being added to the component.
3667	@param rect Optional output parameter set by the function to the minimum bounding rectangle of the
3668	repainted domain.
3669	@param flags Operation flags. The first 8 bits contain a connectivity value. The default value of
3670	4 means that only the four nearest neighbor pixels (those that share an edge) are considered. A
3671	connectivity value of 8 means that the eight nearest neighbor pixels (those that share a corner)
3672	will be considered. The next 8 bits (8-16) contain a value between 1 and 255 with which to fill
3673	the mask (the default value is 1). For example, 4 | ( 255 \<\< 8 ) will consider 4 nearest
3674	neighbours and fill the mask with a value of 255. The following additional options occupy higher
3675	bits and therefore may be further combined with the connectivity and mask fill values using
3676	bit-wise or (|), see #FloodFillFlags.
3677
3678	@note Since the mask is larger than the filled image, a pixel \f$(x, y)\f$ in image corresponds to the
3679	pixel \f$(x+1, y+1)\f$ in the mask .
3680
3681	@sa findContours
3682	*/
3683	CV_EXPORTS_W int floodFill( InputOutputArray image, InputOutputArray mask,
3684	Point seedPoint, Scalar newVal, CV_OUT Rect* rect=0,
3685	Scalar loDiff = Scalar(), Scalar upDiff = Scalar(),
3686	int flags = 4 );
3687
3688	/** @example samples/cpp/ffilldemo.cpp
3689	An example using the FloodFill technique
3690	*/
3691
3692	/** @overload
3693
3694	variant without `mask` parameter
3695	*/
3696	CV_EXPORTS int floodFill( InputOutputArray image,
3697	Point seedPoint, Scalar newVal, CV_OUT Rect* rect = 0,
3698	Scalar loDiff = Scalar(), Scalar upDiff = Scalar(),
3699	int flags = 4 );
3700
3701	//! Performs linear blending of two images:
3702	//! \f[ \texttt{dst}(i,j) = \texttt{weights1}(i,j)*\texttt{src1}(i,j) + \texttt{weights2}(i,j)*\texttt{src2}(i,j) \f]
3703	//! @param src1 It has a type of CV_8UC(n) or CV_32FC(n), where n is a positive integer.
3704	//! @param src2 It has the same type and size as src1.
3705	//! @param weights1 It has a type of CV_32FC1 and the same size with src1.
3706	//! @param weights2 It has a type of CV_32FC1 and the same size with src1.
3707	//! @param dst It is created if it does not have the same size and type with src1.
3708	CV_EXPORTS_W void blendLinear(InputArray src1, InputArray src2, InputArray weights1, InputArray weights2, OutputArray dst);
3709
3710	//! @} imgproc_misc
3711
3712	//! @addtogroup imgproc_color_conversions
3713	//! @{
3714
3715	/** @brief Converts an image from one color space to another.
3716
3717	The function converts an input image from one color space to another. In case of a transformation
3718	to-from RGB color space, the order of the channels should be specified explicitly (RGB or BGR). Note
3719	that the default color format in OpenCV is often referred to as RGB but it is actually BGR (the
3720	bytes are reversed). So the first byte in a standard (24-bit) color image will be an 8-bit Blue
3721	component, the second byte will be Green, and the third byte will be Red. The fourth, fifth, and
3722	sixth bytes would then be the second pixel (Blue, then Green, then Red), and so on.
3723
3724	The conventional ranges for R, G, and B channel values are:
3725	- 0 to 255 for CV_8U images
3726	- 0 to 65535 for CV_16U images
3727	- 0 to 1 for CV_32F images
3728
3729	In case of linear transformations, the range does not matter. But in case of a non-linear
3730	transformation, an input RGB image should be normalized to the proper value range to get the correct
3731	results, for example, for RGB \f$\rightarrow\f$ L\*u\*v\* transformation. For example, if you have a
3732	32-bit floating-point image directly converted from an 8-bit image without any scaling, then it will
3733	have the 0..255 value range instead of 0..1 assumed by the function. So, before calling #cvtColor ,
3734	you need first to scale the image down:
3735	@code
3736	img *= 1./255;
3737	cvtColor(img, img, COLOR_BGR2Luv);
3738	@endcode
3739	If you use #cvtColor with 8-bit images, the conversion will have some information lost. For many
3740	applications, this will not be noticeable but it is recommended to use 32-bit images in applications
3741	that need the full range of colors or that convert an image before an operation and then convert
3742	back.
3743
3744	If conversion adds the alpha channel, its value will set to the maximum of corresponding channel
3745	range: 255 for CV_8U, 65535 for CV_16U, 1 for CV_32F.
3746
3747	@param src input image: 8-bit unsigned, 16-bit unsigned ( CV_16UC... ), or single-precision
3748	floating-point.
3749	@param dst output image of the same size and depth as src.
3750	@param code color space conversion code (see #ColorConversionCodes).
3751	@param dstCn number of channels in the destination image; if the parameter is 0, the number of the
3752	channels is derived automatically from src and code.
3753	@param hint Implementation modfication flags. See #AlgorithmHint
3754
3755	@see @ref imgproc_color_conversions
3756	*/
3757	CV_EXPORTS_W void cvtColor( InputArray src, OutputArray dst, int code, int dstCn = 0, AlgorithmHint hint = cv::ALGO_HINT_DEFAULT );
3758
3759	/** @brief Converts an image from one color space to another where the source image is
3760	stored in two planes.
3761
3762	This function only supports YUV420 to RGB conversion as of now.
3763
3764	@param src1 8-bit image (#CV_8U) of the Y plane.
3765	@param src2 image containing interleaved U/V plane.
3766	@param dst output image.
3767	@param code Specifies the type of conversion. It can take any of the following values:
3768	- #COLOR_YUV2BGR_NV12
3769	- #COLOR_YUV2RGB_NV12
3770	- #COLOR_YUV2BGRA_NV12
3771	- #COLOR_YUV2RGBA_NV12
3772	- #COLOR_YUV2BGR_NV21
3773	- #COLOR_YUV2RGB_NV21
3774	- #COLOR_YUV2BGRA_NV21
3775	- #COLOR_YUV2RGBA_NV21
3776	@param hint Implementation modfication flags. See #AlgorithmHint
3777	*/
3778	CV_EXPORTS_W void cvtColorTwoPlane( InputArray src1, InputArray src2, OutputArray dst, int code, AlgorithmHint hint = cv::ALGO_HINT_DEFAULT );
3779
3780	/** @brief main function for all demosaicing processes
3781
3782	@param src input image: 8-bit unsigned or 16-bit unsigned.
3783	@param dst output image of the same size and depth as src.
3784	@param code Color space conversion code (see the description below).
3785	@param dstCn number of channels in the destination image; if the parameter is 0, the number of the
3786	channels is derived automatically from src and code.
3787
3788	The function can do the following transformations:
3789
3790	- Demosaicing using bilinear interpolation
3791
3792	#COLOR_BayerBG2BGR , #COLOR_BayerGB2BGR , #COLOR_BayerRG2BGR , #COLOR_BayerGR2BGR
3793
3794	#COLOR_BayerBG2GRAY , #COLOR_BayerGB2GRAY , #COLOR_BayerRG2GRAY , #COLOR_BayerGR2GRAY
3795
3796	- Demosaicing using Variable Number of Gradients.
3797
3798	#COLOR_BayerBG2BGR_VNG , #COLOR_BayerGB2BGR_VNG , #COLOR_BayerRG2BGR_VNG , #COLOR_BayerGR2BGR_VNG
3799
3800	- Edge-Aware Demosaicing.
3801
3802	#COLOR_BayerBG2BGR_EA , #COLOR_BayerGB2BGR_EA , #COLOR_BayerRG2BGR_EA , #COLOR_BayerGR2BGR_EA
3803
3804	- Demosaicing with alpha channel
3805
3806	#COLOR_BayerBG2BGRA , #COLOR_BayerGB2BGRA , #COLOR_BayerRG2BGRA , #COLOR_BayerGR2BGRA
3807
3808	@sa cvtColor
3809	*/
3810	CV_EXPORTS_W void demosaicing(InputArray src, OutputArray dst, int code, int dstCn = 0);
3811
3812	//! @} imgproc_color_conversions
3813
3814	//! @addtogroup imgproc_shape
3815	//! @{
3816
3817	/** @brief Calculates all of the moments up to the third order of a polygon or rasterized shape.
3818
3819	The function computes moments, up to the 3rd order, of a vector shape or a rasterized shape. The
3820	results are returned in the structure cv::Moments.
3821
3822	@param array Single chanel raster image (CV_8U, CV_16U, CV_16S, CV_32F, CV_64F) or an array (
3823	\f$1 \times N\f$ or \f$N \times 1\f$ ) of 2D points (Point or Point2f).
3824	@param binaryImage If it is true, all non-zero image pixels are treated as 1's. The parameter is
3825	used for images only.
3826	@returns moments.
3827
3828	@note Only applicable to contour moments calculations from Python bindings: Note that the numpy
3829	type for the input array should be either np.int32 or np.float32.
3830
3831	@sa contourArea, arcLength
3832	*/
3833	CV_EXPORTS_W Moments moments( InputArray array, bool binaryImage = false );
3834
3835	/** @brief Calculates seven Hu invariants.
3836
3837	The function calculates seven Hu invariants (introduced in @cite Hu62; see also
3838	<https://en.wikipedia.org/wiki/Image_moment>) defined as:
3839
3840	\f[\begin{array}{l} hu[0]= \eta _{20}+ \eta _{02} \\ hu[1]=( \eta _{20}- \eta _{02})^{2}+4 \eta _{11}^{2} \\ hu[2]=( \eta _{30}-3 \eta _{12})^{2}+ (3 \eta _{21}- \eta _{03})^{2} \\ hu[3]=( \eta _{30}+ \eta _{12})^{2}+ ( \eta _{21}+ \eta _{03})^{2} \\ hu[4]=( \eta _{30}-3 \eta _{12})( \eta _{30}+ \eta _{12})[( \eta _{30}+ \eta _{12})^{2}-3( \eta _{21}+ \eta _{03})^{2}]+(3 \eta _{21}- \eta _{03})( \eta _{21}+ \eta _{03})[3( \eta _{30}+ \eta _{12})^{2}-( \eta _{21}+ \eta _{03})^{2}] \\ hu[5]=( \eta _{20}- \eta _{02})[( \eta _{30}+ \eta _{12})^{2}- ( \eta _{21}+ \eta _{03})^{2}]+4 \eta _{11}( \eta _{30}+ \eta _{12})( \eta _{21}+ \eta _{03}) \\ hu[6]=(3 \eta _{21}- \eta _{03})( \eta _{21}+ \eta _{03})[3( \eta _{30}+ \eta _{12})^{2}-( \eta _{21}+ \eta _{03})^{2}]-( \eta _{30}-3 \eta _{12})( \eta _{21}+ \eta _{03})[3( \eta _{30}+ \eta _{12})^{2}-( \eta _{21}+ \eta _{03})^{2}] \\ \end{array}\f]
3841
3842	where \f$\eta_{ji}\f$ stands for \f$\texttt{Moments::nu}_{ji}\f$ .
3843
3844	These values are proved to be invariants to the image scale, rotation, and reflection except the
3845	seventh one, whose sign is changed by reflection. This invariance is proved with the assumption of
3846	infinite image resolution. In case of raster images, the computed Hu invariants for the original and
3847	transformed images are a bit different.
3848
3849	@param moments Input moments computed with moments .
3850	@param hu Output Hu invariants.
3851
3852	@sa matchShapes
3853	*/
3854	CV_EXPORTS void HuMoments( const Moments& moments, double hu[7] );
3855
3856	/** @overload */
3857	CV_EXPORTS_W void HuMoments( const Moments& m, OutputArray hu );
3858
3859	//! @} imgproc_shape
3860
3861	//! @addtogroup imgproc_object
3862	//! @{
3863
3864	//! type of the template matching operation
3865	enum TemplateMatchModes {
3866	TM_SQDIFF = 0, /*!< \f[R(x,y)= \sum _{x',y'} (T(x',y')-I(x+x',y+y'))^2\f]
3867	with mask:
3868	\f[R(x,y)= \sum _{x',y'} \left( (T(x',y')-I(x+x',y+y')) \cdot
3869	M(x',y') \right)^2\f] */
3870	TM_SQDIFF_NORMED = 1, /*!< \f[R(x,y)= \frac{\sum_{x',y'} (T(x',y')-I(x+x',y+y'))^2}{\sqrt{\sum_{
3871	x',y'}T(x',y')^2 \cdot \sum_{x',y'} I(x+x',y+y')^2}}\f]
3872	with mask:
3873	\f[R(x,y)= \frac{\sum _{x',y'} \left( (T(x',y')-I(x+x',y+y')) \cdot
3874	M(x',y') \right)^2}{\sqrt{\sum_{x',y'} \left( T(x',y') \cdot
3875	M(x',y') \right)^2 \cdot \sum_{x',y'} \left( I(x+x',y+y') \cdot
3876	M(x',y') \right)^2}}\f] */
3877	TM_CCORR = 2, /*!< \f[R(x,y)= \sum _{x',y'} (T(x',y') \cdot I(x+x',y+y'))\f]
3878	with mask:
3879	\f[R(x,y)= \sum _{x',y'} (T(x',y') \cdot I(x+x',y+y') \cdot M(x',y')
3880	^2)\f] */
3881	TM_CCORR_NORMED = 3, /*!< \f[R(x,y)= \frac{\sum_{x',y'} (T(x',y') \cdot I(x+x',y+y'))}{\sqrt{
3882	\sum_{x',y'}T(x',y')^2 \cdot \sum_{x',y'} I(x+x',y+y')^2}}\f]
3883	with mask:
3884	\f[R(x,y)= \frac{\sum_{x',y'} (T(x',y') \cdot I(x+x',y+y') \cdot
3885	M(x',y')^2)}{\sqrt{\sum_{x',y'} \left( T(x',y') \cdot M(x',y')
3886	\right)^2 \cdot \sum_{x',y'} \left( I(x+x',y+y') \cdot M(x',y')
3887	\right)^2}}\f] */
3888	TM_CCOEFF = 4, /*!< \f[R(x,y)= \sum _{x',y'} (T'(x',y') \cdot I'(x+x',y+y'))\f]
3889	where
3890	\f[\begin{array}{l} T'(x',y')=T(x',y') - 1/(w \cdot h) \cdot \sum _{
3891	x'',y''} T(x'',y'') \\ I'(x+x',y+y')=I(x+x',y+y') - 1/(w \cdot h)
3892	\cdot \sum _{x'',y''} I(x+x'',y+y'') \end{array}\f]
3893	with mask:
3894	\f[\begin{array}{l} T'(x',y')=M(x',y') \cdot \left( T(x',y') -
3895	\frac{1}{\sum _{x'',y''} M(x'',y'')} \cdot \sum _{x'',y''}
3896	(T(x'',y'') \cdot M(x'',y'')) \right) \\ I'(x+x',y+y')=M(x',y')
3897	\cdot \left( I(x+x',y+y') - \frac{1}{\sum _{x'',y''} M(x'',y'')}
3898	\cdot \sum _{x'',y''} (I(x+x'',y+y'') \cdot M(x'',y'')) \right)
3899	\end{array} \f] */
3900	TM_CCOEFF_NORMED = 5 /*!< \f[R(x,y)= \frac{ \sum_{x',y'} (T'(x',y') \cdot I'(x+x',y+y')) }{
3901	\sqrt{\sum_{x',y'}T'(x',y')^2 \cdot \sum_{x',y'} I'(x+x',y+y')^2}
3902	}\f] */
3903	};
3904
3905	/** @example samples/cpp/tutorial_code/Histograms_Matching/MatchTemplate_Demo.cpp
3906	An example using Template Matching algorithm
3907	*/
3908
3909	/** @brief Compares a template against overlapped image regions.
3910
3911	The function slides through image , compares the overlapped patches of size \f$w \times h\f$ against
3912	templ using the specified method and stores the comparison results in result . #TemplateMatchModes
3913	describes the formulae for the available comparison methods ( \f$I\f$ denotes image, \f$T\f$
3914	template, \f$R\f$ result, \f$M\f$ the optional mask ). The summation is done over template and/or
3915	the image patch: \f$x' = 0...w-1, y' = 0...h-1\f$
3916
3917	After the function finishes the comparison, the best matches can be found as global minimums (when
3918	#TM_SQDIFF was used) or maximums (when #TM_CCORR or #TM_CCOEFF was used) using the
3919	#minMaxLoc function. In case of a color image, template summation in the numerator and each sum in
3920	the denominator is done over all of the channels and separate mean values are used for each channel.
3921	That is, the function can take a color template and a color image. The result will still be a
3922	single-channel image, which is easier to analyze.
3923
3924	@param image Image where the search is running. It must be 8-bit or 32-bit floating-point.
3925	@param templ Searched template. It must be not greater than the source image and have the same
3926	data type.
3927	@param result Map of comparison results. It must be single-channel 32-bit floating-point. If image
3928	is \f$W \times H\f$ and templ is \f$w \times h\f$ , then result is \f$(W-w+1) \times (H-h+1)\f$ .
3929	@param method Parameter specifying the comparison method, see #TemplateMatchModes
3930	@param mask Optional mask. It must have the same size as templ. It must either have the same number
3931	of channels as template or only one channel, which is then used for all template and
3932	image channels. If the data type is #CV_8U, the mask is interpreted as a binary mask,
3933	meaning only elements where mask is nonzero are used and are kept unchanged independent
3934	of the actual mask value (weight equals 1). For data type #CV_32F, the mask values are
3935	used as weights. The exact formulas are documented in #TemplateMatchModes.
3936	*/
3937	CV_EXPORTS_W void matchTemplate( InputArray image, InputArray templ,
3938	OutputArray result, int method, InputArray mask = noArray() );
3939
3940	//! @}
3941
3942	//! @addtogroup imgproc_shape
3943	//! @{
3944
3945	/** @example samples/cpp/connected_components.cpp
3946	This program demonstrates connected components and use of the trackbar
3947	*/
3948
3949	/** @brief computes the connected components labeled image of boolean image
3950
3951	image with 4 or 8 way connectivity - returns N, the total number of labels [0, N-1] where 0
3952	represents the background label. ltype specifies the output label image type, an important
3953	consideration based on the total number of labels or alternatively the total number of pixels in
3954	the source image. ccltype specifies the connected components labeling algorithm to use, currently
3955	Bolelli (Spaghetti) @cite Bolelli2019, Grana (BBDT) @cite Grana2010 and Wu's (SAUF) @cite Wu2009 algorithms
3956	are supported, see the #ConnectedComponentsAlgorithmsTypes for details. Note that SAUF algorithm forces
3957	a row major ordering of labels while Spaghetti and BBDT do not.
3958	This function uses parallel version of the algorithms if at least one allowed
3959	parallel framework is enabled and if the rows of the image are at least twice the number returned by #getNumberOfCPUs.
3960
3961	@param image the 8-bit single-channel image to be labeled
3962	@param labels destination labeled image
3963	@param connectivity 8 or 4 for 8-way or 4-way connectivity respectively
3964	@param ltype output image label type. Currently CV_32S and CV_16U are supported.
3965	@param ccltype connected components algorithm type (see the #ConnectedComponentsAlgorithmsTypes).
3966	*/
3967	CV_EXPORTS_AS(connectedComponentsWithAlgorithm) int connectedComponents(InputArray image, OutputArray labels,
3968	int connectivity, int ltype, int ccltype);
3969
3970
3971	/** @overload
3972
3973	@param image the 8-bit single-channel image to be labeled
3974	@param labels destination labeled image
3975	@param connectivity 8 or 4 for 8-way or 4-way connectivity respectively
3976	@param ltype output image label type. Currently CV_32S and CV_16U are supported.
3977	*/
3978	CV_EXPORTS_W int connectedComponents(InputArray image, OutputArray labels,
3979	int connectivity = 8, int ltype = CV_32S);
3980
3981
3982	/** @brief computes the connected components labeled image of boolean image and also produces a statistics output for each label
3983
3984	image with 4 or 8 way connectivity - returns N, the total number of labels [0, N-1] where 0
3985	represents the background label. ltype specifies the output label image type, an important
3986	consideration based on the total number of labels or alternatively the total number of pixels in
3987	the source image. ccltype specifies the connected components labeling algorithm to use, currently
3988	Bolelli (Spaghetti) @cite Bolelli2019, Grana (BBDT) @cite Grana2010 and Wu's (SAUF) @cite Wu2009 algorithms
3989	are supported, see the #ConnectedComponentsAlgorithmsTypes for details. Note that SAUF algorithm forces
3990	a row major ordering of labels while Spaghetti and BBDT do not.
3991	This function uses parallel version of the algorithms (statistics included) if at least one allowed
3992	parallel framework is enabled and if the rows of the image are at least twice the number returned by #getNumberOfCPUs.
3993
3994	@param image the 8-bit single-channel image to be labeled
3995	@param labels destination labeled image
3996	@param stats statistics output for each label, including the background label.
3997	Statistics are accessed via stats(label, COLUMN) where COLUMN is one of
3998	#ConnectedComponentsTypes, selecting the statistic. The data type is CV_32S.
3999	@param centroids centroid output for each label, including the background label. Centroids are
4000	accessed via centroids(label, 0) for x and centroids(label, 1) for y. The data type CV_64F.
4001	@param connectivity 8 or 4 for 8-way or 4-way connectivity respectively
4002	@param ltype output image label type. Currently CV_32S and CV_16U are supported.
4003	@param ccltype connected components algorithm type (see #ConnectedComponentsAlgorithmsTypes).
4004	*/
4005	CV_EXPORTS_AS(connectedComponentsWithStatsWithAlgorithm) int connectedComponentsWithStats(InputArray image, OutputArray labels,
4006	OutputArray stats, OutputArray centroids,
4007	int connectivity, int ltype, int ccltype);
4008
4009	/** @overload
4010	@param image the 8-bit single-channel image to be labeled
4011	@param labels destination labeled image
4012	@param stats statistics output for each label, including the background label.
4013	Statistics are accessed via stats(label, COLUMN) where COLUMN is one of
4014	#ConnectedComponentsTypes, selecting the statistic. The data type is CV_32S.
4015	@param centroids centroid output for each label, including the background label. Centroids are
4016	accessed via centroids(label, 0) for x and centroids(label, 1) for y. The data type CV_64F.
4017	@param connectivity 8 or 4 for 8-way or 4-way connectivity respectively
4018	@param ltype output image label type. Currently CV_32S and CV_16U are supported.
4019	*/
4020	CV_EXPORTS_W int connectedComponentsWithStats(InputArray image, OutputArray labels,
4021	OutputArray stats, OutputArray centroids,
4022	int connectivity = 8, int ltype = CV_32S);
4023
4024
4025	/** @brief Finds contours in a binary image.
4026
4027	The function retrieves contours from the binary image using the algorithm @cite Suzuki85 . The contours
4028	are a useful tool for shape analysis and object detection and recognition. See squares.cpp in the
4029	OpenCV sample directory.
4030	@note Since opencv 3.2 source image is not modified by this function.
4031
4032	@param image Source, an 8-bit single-channel image. Non-zero pixels are treated as 1's. Zero
4033	pixels remain 0's, so the image is treated as binary . You can use #compare, #inRange, #threshold ,
4034	#adaptiveThreshold, #Canny, and others to create a binary image out of a grayscale or color one.
4035	If mode equals to #RETR_CCOMP or #RETR_FLOODFILL, the input can also be a 32-bit integer image of labels (CV_32SC1).
4036	@param contours Detected contours. Each contour is stored as a vector of points (e.g.
4037	std::vector<std::vector<cv::Point> >).
4038	@param hierarchy Optional output vector (e.g. std::vector<cv::Vec4i>), containing information about the image topology. It has
4039	as many elements as the number of contours. For each i-th contour contours[i], the elements
4040	hierarchy[i][0] , hierarchy[i][1] , hierarchy[i][2] , and hierarchy[i][3] are set to 0-based indices
4041	in contours of the next and previous contours at the same hierarchical level, the first child
4042	contour and the parent contour, respectively. If for the contour i there are no next, previous,
4043	parent, or nested contours, the corresponding elements of hierarchy[i] will be negative.
4044	@note In Python, hierarchy is nested inside a top level array. Use hierarchy[0][i] to access hierarchical elements of i-th contour.
4045	@param mode Contour retrieval mode, see #RetrievalModes
4046	@param method Contour approximation method, see #ContourApproximationModes
4047	@param offset Optional offset by which every contour point is shifted. This is useful if the
4048	contours are extracted from the image ROI and then they should be analyzed in the whole image
4049	context.
4050	*/
4051	CV_EXPORTS_W void findContours( InputArray image, OutputArrayOfArrays contours,
4052	OutputArray hierarchy, int mode,
4053	int method, Point offset = Point());
4054
4055	/** @overload */
4056	CV_EXPORTS void findContours( InputArray image, OutputArrayOfArrays contours,
4057	int mode, int method, Point offset = Point());
4058
4059	//! @brief Find contours using link runs algorithm
4060	//!
4061	//! This function implements an algorithm different from cv::findContours:
4062	//! - doesn't allocate temporary image internally, thus it has reduced memory consumption
4063	//! - supports CV_8UC1 images only
4064	//! - outputs 2-level hierarhy only (RETR_CCOMP mode)
4065	//! - doesn't support approximation change other than CHAIN_APPROX_SIMPLE
4066	//! In all other aspects this function is compatible with cv::findContours.
4067	CV_EXPORTS_W void findContoursLinkRuns(InputArray image, OutputArrayOfArrays contours, OutputArray hierarchy);
4068
4069	//! @overload
4070	CV_EXPORTS_W void findContoursLinkRuns(InputArray image, OutputArrayOfArrays contours);
4071
4072	/** @brief Approximates a polygonal curve(s) with the specified precision.
4073
4074	The function cv::approxPolyDP approximates a curve or a polygon with another curve/polygon with less
4075	vertices so that the distance between them is less or equal to the specified precision. It uses the
4076	Douglas-Peucker algorithm <https://en.wikipedia.org/wiki/Ramer-Douglas-Peucker_algorithm>
4077
4078	@param curve Input vector of a 2D point stored in std::vector or Mat
4079	@param approxCurve Result of the approximation. The type should match the type of the input curve.
4080	@param epsilon Parameter specifying the approximation accuracy. This is the maximum distance
4081	between the original curve and its approximation.
4082	@param closed If true, the approximated curve is closed (its first and last vertices are
4083	connected). Otherwise, it is not closed.
4084	*/
4085	CV_EXPORTS_W void approxPolyDP( InputArray curve,
4086	OutputArray approxCurve,
4087	double epsilon, bool closed );
4088
4089	/** @brief Approximates a polygon with a convex hull with a specified accuracy and number of sides.
4090
4091	The cv::approxPolyN function approximates a polygon with a convex hull
4092	so that the difference between the contour area of the original contour and the new polygon is minimal.
4093	It uses a greedy algorithm for contracting two vertices into one in such a way that the additional area is minimal.
4094	Straight lines formed by each edge of the convex contour are drawn and the areas of the resulting triangles are considered.
4095	Each vertex will lie either on the original contour or outside it.
4096
4097	The algorithm based on the paper @cite LowIlie2003 .
4098
4099	@param curve Input vector of a 2D points stored in std::vector or Mat, points must be float or integer.
4100	@param approxCurve Result of the approximation. The type is vector of a 2D point (Point2f or Point) in std::vector or Mat.
4101	@param nsides The parameter defines the number of sides of the result polygon.
4102	@param epsilon_percentage defines the percentage of the maximum of additional area.
4103	If it equals -1, it is not used. Otherwise algorighm stops if additional area is greater than contourArea(_curve) * percentage.
4104	If additional area exceeds the limit, algorithm returns as many vertices as there were at the moment the limit was exceeded.
4105	@param ensure_convex If it is true, algorithm creates a convex hull of input contour. Otherwise input vector should be convex.
4106	*/
4107	CV_EXPORTS_W void approxPolyN(InputArray curve, OutputArray approxCurve,
4108	int nsides, float epsilon_percentage = -1.0,
4109	bool ensure_convex = true);
4110
4111	/** @brief Calculates a contour perimeter or a curve length.
4112
4113	The function computes a curve length or a closed contour perimeter.
4114
4115	@param curve Input vector of 2D points, stored in std::vector or Mat.
4116	@param closed Flag indicating whether the curve is closed or not.
4117	*/
4118	CV_EXPORTS_W double arcLength( InputArray curve, bool closed );
4119
4120	/** @brief Calculates the up-right bounding rectangle of a point set or non-zero pixels of gray-scale image.
4121
4122	The function calculates and returns the minimal up-right bounding rectangle for the specified point set or
4123	non-zero pixels of gray-scale image.
4124
4125	@param array Input gray-scale image or 2D point set, stored in std::vector or Mat.
4126	*/
4127	CV_EXPORTS_W Rect boundingRect( InputArray array );
4128
4129	/** @brief Calculates a contour area.
4130
4131	The function computes a contour area. Similarly to moments , the area is computed using the Green
4132	formula. Thus, the returned area and the number of non-zero pixels, if you draw the contour using
4133	#drawContours or #fillPoly , can be different. Also, the function will most certainly give a wrong
4134	results for contours with self-intersections.
4135
4136	Example:
4137	@code
4138	vector<Point> contour;
4139	contour.push_back(Point2f(0, 0));
4140	contour.push_back(Point2f(10, 0));
4141	contour.push_back(Point2f(10, 10));
4142	contour.push_back(Point2f(5, 4));
4143
4144	double area0 = contourArea(contour);
4145	vector<Point> approx;
4146	approxPolyDP(contour, approx, 5, true);
4147	double area1 = contourArea(approx);
4148
4149	cout << "area0 =" << area0 << endl <<
4150	"area1 =" << area1 << endl <<
4151	"approx poly vertices" << approx.size() << endl;
4152	@endcode
4153	@param contour Input vector of 2D points (contour vertices), stored in std::vector or Mat.
4154	@param oriented Oriented area flag. If it is true, the function returns a signed area value,
4155	depending on the contour orientation (clockwise or counter-clockwise). Using this feature you can
4156	determine orientation of a contour by taking the sign of an area. By default, the parameter is
4157	false, which means that the absolute value is returned.
4158	*/
4159	CV_EXPORTS_W double contourArea( InputArray contour, bool oriented = false );
4160
4161	/** @brief Finds a rotated rectangle of the minimum area enclosing the input 2D point set.
4162
4163	The function calculates and returns the minimum-area bounding rectangle (possibly rotated) for a
4164	specified point set. The angle of rotation represents the angle between the line connecting the starting
4165	and ending points (based on the clockwise order with greatest index for the corner with greatest \f$y\f$)
4166	and the horizontal axis. This angle always falls between \f$[-90, 0)\f$ because, if the object
4167	rotates more than a rect angle, the next edge is used to measure the angle. The starting and ending points change
4168	as the object rotates.Developer should keep in mind that the returned RotatedRect can contain negative
4169	indices when data is close to the containing Mat element boundary.
4170
4171	@param points Input vector of 2D points, stored in std::vector\<\> or Mat
4172	*/
4173	CV_EXPORTS_W RotatedRect minAreaRect( InputArray points );
4174
4175	/** @brief Finds the four vertices of a rotated rect. Useful to draw the rotated rectangle.
4176
4177	The function finds the four vertices of a rotated rectangle. The four vertices are returned
4178	in clockwise order starting from the point with greatest \f$y\f$. If two points have the
4179	same \f$y\f$ coordinate the rightmost is the starting point. This function is useful to draw the
4180	rectangle. In C++, instead of using this function, you can directly use RotatedRect::points method. Please
4181	visit the @ref tutorial_bounding_rotated_ellipses "tutorial on Creating Bounding rotated boxes and ellipses for contours" for more information.
4182
4183	@param box The input rotated rectangle. It may be the output of @ref minAreaRect.
4184	@param points The output array of four vertices of rectangles.
4185	*/
4186	CV_EXPORTS_W void boxPoints(RotatedRect box, OutputArray points);
4187
4188	/** @brief Finds a circle of the minimum area enclosing a 2D point set.
4189
4190	The function finds the minimal enclosing circle of a 2D point set using an iterative algorithm.
4191
4192	@param points Input vector of 2D points, stored in std::vector\<\> or Mat
4193	@param center Output center of the circle.
4194	@param radius Output radius of the circle.
4195	*/
4196	CV_EXPORTS_W void minEnclosingCircle( InputArray points,
4197	CV_OUT Point2f& center, CV_OUT float& radius );
4198
4199	/** @example samples/cpp/minarea.cpp
4200	*/
4201
4202	/** @brief Finds a triangle of minimum area enclosing a 2D point set and returns its area.
4203
4204	The function finds a triangle of minimum area enclosing the given set of 2D points and returns its
4205	area. The output for a given 2D point set is shown in the image below. 2D points are depicted in
4206	*red* and the enclosing triangle in *yellow*.
4207
4208	
4209
4210	The implementation of the algorithm is based on O'Rourke's @cite ORourke86 and Klee and Laskowski's
4211	@cite KleeLaskowski85 papers. O'Rourke provides a \f$\theta(n)\f$ algorithm for finding the minimal
4212	enclosing triangle of a 2D convex polygon with n vertices. Since the #minEnclosingTriangle function
4213	takes a 2D point set as input an additional preprocessing step of computing the convex hull of the
4214	2D point set is required. The complexity of the #convexHull function is \f$O(n log(n))\f$ which is higher
4215	than \f$\theta(n)\f$. Thus the overall complexity of the function is \f$O(n log(n))\f$.
4216
4217	@param points Input vector of 2D points with depth CV_32S or CV_32F, stored in std::vector\<\> or Mat
4218	@param triangle Output vector of three 2D points defining the vertices of the triangle. The depth
4219	of the OutputArray must be CV_32F.
4220	*/
4221	CV_EXPORTS_W double minEnclosingTriangle( InputArray points, CV_OUT OutputArray triangle );
4222
4223	/** @brief Compares two shapes.
4224
4225	The function compares two shapes. All three implemented methods use the Hu invariants (see #HuMoments)
4226
4227	@param contour1 First contour or grayscale image.
4228	@param contour2 Second contour or grayscale image.
4229	@param method Comparison method, see #ShapeMatchModes
4230	@param parameter Method-specific parameter (not supported now).
4231	*/
4232	CV_EXPORTS_W double matchShapes( InputArray contour1, InputArray contour2,
4233	int method, double parameter );
4234
4235	/** @example samples/cpp/convexhull.cpp
4236	An example using the convexHull functionality
4237	*/
4238
4239	/** @brief Finds the convex hull of a point set.
4240
4241	The function cv::convexHull finds the convex hull of a 2D point set using the Sklansky's algorithm @cite Sklansky82
4242	that has *O(N logN)* complexity in the current implementation.
4243
4244	@param points Input 2D point set, stored in std::vector or Mat.
4245	@param hull Output convex hull. It is either an integer vector of indices or vector of points. In
4246	the first case, the hull elements are 0-based indices of the convex hull points in the original
4247	array (since the set of convex hull points is a subset of the original point set). In the second
4248	case, hull elements are the convex hull points themselves.
4249	@param clockwise Orientation flag. If it is true, the output convex hull is oriented clockwise.
4250	Otherwise, it is oriented counter-clockwise. The assumed coordinate system has its X axis pointing
4251	to the right, and its Y axis pointing upwards.
4252	@param returnPoints Operation flag. In case of a matrix, when the flag is true, the function
4253	returns convex hull points. Otherwise, it returns indices of the convex hull points. When the
4254	output array is std::vector, the flag is ignored, and the output depends on the type of the
4255	vector: std::vector\<int\> implies returnPoints=false, std::vector\<Point\> implies
4256	returnPoints=true.
4257
4258	@note `points` and `hull` should be different arrays, inplace processing isn't supported.
4259
4260	Check @ref tutorial_hull "the corresponding tutorial" for more details.
4261
4262	useful links:
4263
4264	https://www.learnopencv.com/convex-hull-using-opencv-in-python-and-c/
4265	*/
4266	CV_EXPORTS_W void convexHull( InputArray points, OutputArray hull,
4267	bool clockwise = false, bool returnPoints = true );
4268
4269	/** @brief Finds the convexity defects of a contour.
4270
4271	The figure below displays convexity defects of a hand contour:
4272
4273	
4274
4275	@param contour Input contour.
4276	@param convexhull Convex hull obtained using convexHull that should contain indices of the contour
4277	points that make the hull.
4278	@param convexityDefects The output vector of convexity defects. In C++ and the new Python/Java
4279	interface each convexity defect is represented as 4-element integer vector (a.k.a. #Vec4i):
4280	(start_index, end_index, farthest_pt_index, fixpt_depth), where indices are 0-based indices
4281	in the original contour of the convexity defect beginning, end and the farthest point, and
4282	fixpt_depth is fixed-point approximation (with 8 fractional bits) of the distance between the
4283	farthest contour point and the hull. That is, to get the floating-point value of the depth will be
4284	fixpt_depth/256.0.
4285	*/
4286	CV_EXPORTS_W void convexityDefects( InputArray contour, InputArray convexhull, OutputArray convexityDefects );
4287
4288	/** @brief Tests a contour convexity.
4289
4290	The function tests whether the input contour is convex or not. The contour must be simple, that is,
4291	without self-intersections. Otherwise, the function output is undefined.
4292
4293	@param contour Input vector of 2D points, stored in std::vector\<\> or Mat
4294	*/
4295	CV_EXPORTS_W bool isContourConvex( InputArray contour );
4296
4297	/** @example samples/cpp/intersectExample.cpp
4298	Examples of how intersectConvexConvex works
4299	*/
4300
4301	/** @brief Finds intersection of two convex polygons
4302
4303	@param p1 First polygon
4304	@param p2 Second polygon
4305	@param p12 Output polygon describing the intersecting area
4306	@param handleNested When true, an intersection is found if one of the polygons is fully enclosed in the other.
4307	When false, no intersection is found. If the polygons share a side or the vertex of one polygon lies on an edge
4308	of the other, they are not considered nested and an intersection will be found regardless of the value of handleNested.
4309
4310	@returns Area of intersecting polygon. May be negative, if algorithm has not converged, e.g. non-convex input.
4311
4312	@note intersectConvexConvex doesn't confirm that both polygons are convex and will return invalid results if they aren't.
4313	*/
4314	CV_EXPORTS_W float intersectConvexConvex( InputArray p1, InputArray p2,
4315	OutputArray p12, bool handleNested = true );
4316
4317	/** @example samples/cpp/fitellipse.cpp
4318	An example using the fitEllipse technique
4319	*/
4320
4321	/** @brief Fits an ellipse around a set of 2D points.
4322
4323	The function calculates the ellipse that fits (in a least-squares sense) a set of 2D points best of
4324	all. It returns the rotated rectangle in which the ellipse is inscribed. The first algorithm described by @cite Fitzgibbon95
4325	is used. Developer should keep in mind that it is possible that the returned
4326	ellipse/rotatedRect data contains negative indices, due to the data points being close to the
4327	border of the containing Mat element.
4328
4329	@param points Input 2D point set, stored in std::vector\<\> or Mat
4330
4331	@note Input point types are @ref Point2i or @ref Point2f and at least 5 points are required.
4332	@note @ref getClosestEllipsePoints function can be used to compute the ellipse fitting error.
4333	*/
4334	CV_EXPORTS_W RotatedRect fitEllipse( InputArray points );
4335
4336	/** @brief Fits an ellipse around a set of 2D points.
4337
4338	The function calculates the ellipse that fits a set of 2D points.
4339	It returns the rotated rectangle in which the ellipse is inscribed.
4340	The Approximate Mean Square (AMS) proposed by @cite Taubin1991 is used.
4341
4342	For an ellipse, this basis set is \f$ \chi= \left(x^2, x y, y^2, x, y, 1\right) \f$,
4343	which is a set of six free coefficients \f$ A^T=\left\{A_{\text{xx}},A_{\text{xy}},A_{\text{yy}},A_x,A_y,A_0\right\} \f$.
4344	However, to specify an ellipse, all that is needed is five numbers; the major and minor axes lengths \f$ (a,b) \f$,
4345	the position \f$ (x_0,y_0) \f$, and the orientation \f$ \theta \f$. This is because the basis set includes lines,
4346	quadratics, parabolic and hyperbolic functions as well as elliptical functions as possible fits.
4347	If the fit is found to be a parabolic or hyperbolic function then the standard #fitEllipse method is used.
4348	The AMS method restricts the fit to parabolic, hyperbolic and elliptical curves
4349	by imposing the condition that \f$ A^T ( D_x^T D_x + D_y^T D_y) A = 1 \f$ where
4350	the matrices \f$ Dx \f$ and \f$ Dy \f$ are the partial derivatives of the design matrix \f$ D \f$ with
4351	respect to x and y. The matrices are formed row by row applying the following to
4352	each of the points in the set:
4353	\f{align*}{
4354	D(i,:)&=\left\{x_i^2, x_i y_i, y_i^2, x_i, y_i, 1\right\} &
4355	D_x(i,:)&=\left\{2 x_i,y_i,0,1,0,0\right\} &
4356	D_y(i,:)&=\left\{0,x_i,2 y_i,0,1,0\right\}
4357	\f}
4358	The AMS method minimizes the cost function
4359	\f{equation*}{
4360	\epsilon ^2=\frac{ A^T D^T D A }{ A^T (D_x^T D_x + D_y^T D_y) A^T }
4361	\f}
4362
4363	The minimum cost is found by solving the generalized eigenvalue problem.
4364
4365	\f{equation*}{
4366	D^T D A = \lambda \left( D_x^T D_x + D_y^T D_y\right) A
4367	\f}
4368
4369	@param points Input 2D point set, stored in std::vector\<\> or Mat
4370
4371	@note Input point types are @ref Point2i or @ref Point2f and at least 5 points are required.
4372	@note @ref getClosestEllipsePoints function can be used to compute the ellipse fitting error.
4373	*/
4374	CV_EXPORTS_W RotatedRect fitEllipseAMS( InputArray points );
4375
4376
4377	/** @brief Fits an ellipse around a set of 2D points.
4378
4379	The function calculates the ellipse that fits a set of 2D points.
4380	It returns the rotated rectangle in which the ellipse is inscribed.
4381	The Direct least square (Direct) method by @cite oy1998NumericallySD is used.
4382
4383	For an ellipse, this basis set is \f$ \chi= \left(x^2, x y, y^2, x, y, 1\right) \f$,
4384	which is a set of six free coefficients \f$ A^T=\left\{A_{\text{xx}},A_{\text{xy}},A_{\text{yy}},A_x,A_y,A_0\right\} \f$.
4385	However, to specify an ellipse, all that is needed is five numbers; the major and minor axes lengths \f$ (a,b) \f$,
4386	the position \f$ (x_0,y_0) \f$, and the orientation \f$ \theta \f$. This is because the basis set includes lines,
4387	quadratics, parabolic and hyperbolic functions as well as elliptical functions as possible fits.
4388	The Direct method confines the fit to ellipses by ensuring that \f$ 4 A_{xx} A_{yy}- A_{xy}^2 > 0 \f$.
4389	The condition imposed is that \f$ 4 A_{xx} A_{yy}- A_{xy}^2=1 \f$ which satisfies the inequality
4390	and as the coefficients can be arbitrarily scaled is not overly restrictive.
4391
4392	\f{equation*}{
4393	\epsilon ^2= A^T D^T D A \quad \text{with} \quad A^T C A =1 \quad \text{and} \quad C=\left(\begin{matrix}
4394	0 & 0 & 2 & 0 & 0 & 0 \\
4395	0 & -1 & 0 & 0 & 0 & 0 \\
4396	2 & 0 & 0 & 0 & 0 & 0 \\
4397	0 & 0 & 0 & 0 & 0 & 0 \\
4398	0 & 0 & 0 & 0 & 0 & 0 \\
4399	0 & 0 & 0 & 0 & 0 & 0
4400	\end{matrix} \right)
4401	\f}
4402
4403	The minimum cost is found by solving the generalized eigenvalue problem.
4404
4405	\f{equation*}{
4406	D^T D A = \lambda \left( C\right) A
4407	\f}
4408
4409	The system produces only one positive eigenvalue \f$ \lambda\f$ which is chosen as the solution
4410	with its eigenvector \f$\mathbf{u}\f$. These are used to find the coefficients
4411
4412	\f{equation*}{
4413	A = \sqrt{\frac{1}{\mathbf{u}^T C \mathbf{u}}} \mathbf{u}
4414	\f}
4415	The scaling factor guarantees that \f$A^T C A =1\f$.
4416
4417	@param points Input 2D point set, stored in std::vector\<\> or Mat
4418
4419	@note Input point types are @ref Point2i or @ref Point2f and at least 5 points are required.
4420	@note @ref getClosestEllipsePoints function can be used to compute the ellipse fitting error.
4421	*/
4422	CV_EXPORTS_W RotatedRect fitEllipseDirect( InputArray points );
4423
4424	/** @brief Compute for each 2d point the nearest 2d point located on a given ellipse.
4425
4426	The function computes the nearest 2d location on a given ellipse for a vector of 2d points and is based on @cite Chatfield2017 code.
4427	This function can be used to compute for instance the ellipse fitting error.
4428
4429	@param ellipse_params Ellipse parameters
4430	@param points Input 2d points
4431	@param closest_pts For each 2d point, their corresponding closest 2d point located on a given ellipse
4432
4433	@note Input point types are @ref Point2i or @ref Point2f
4434	@see fitEllipse, fitEllipseAMS, fitEllipseDirect
4435	*/
4436	CV_EXPORTS_W void getClosestEllipsePoints( const RotatedRect& ellipse_params, InputArray points, OutputArray closest_pts );
4437
4438	/** @brief Fits a line to a 2D or 3D point set.
4439
4440	The function fitLine fits a line to a 2D or 3D point set by minimizing \f$\sum_i \rho(r_i)\f$ where
4441	\f$r_i\f$ is a distance between the \f$i^{th}\f$ point, the line and \f$\rho(r)\f$ is a distance function, one
4442	of the following:
4443	- DIST_L2
4444	\f[\rho (r) = r^2/2 \quad \text{(the simplest and the fastest least-squares method)}\f]
4445	- DIST_L1
4446	\f[\rho (r) = r\f]
4447	- DIST_L12
4448	\f[\rho (r) = 2 \cdot ( \sqrt{1 + \frac{r^2}{2}} - 1)\f]
4449	- DIST_FAIR
4450	\f[\rho \left (r \right ) = C^2 \cdot \left ( \frac{r}{C} - \log{\left(1 + \frac{r}{C}\right)} \right ) \quad \text{where} \quad C=1.3998\f]
4451	- DIST_WELSCH
4452	\f[\rho \left (r \right ) = \frac{C^2}{2} \cdot \left ( 1 - \exp{\left(-\left(\frac{r}{C}\right)^2\right)} \right ) \quad \text{where} \quad C=2.9846\f]
4453	- DIST_HUBER
4454	\f[\rho (r) = \fork{r^2/2}{if \(r < C\)}{C \cdot (r-C/2)}{otherwise} \quad \text{where} \quad C=1.345\f]
4455
4456	The algorithm is based on the M-estimator ( <https://en.wikipedia.org/wiki/M-estimator> ) technique
4457	that iteratively fits the line using the weighted least-squares algorithm. After each iteration the
4458	weights \f$w_i\f$ are adjusted to be inversely proportional to \f$\rho(r_i)\f$ .
4459
4460	@param points Input vector of 2D or 3D points, stored in std::vector\<\> or Mat.
4461	@param line Output line parameters. In case of 2D fitting, it should be a vector of 4 elements
4462	(like Vec4f) - (vx, vy, x0, y0), where (vx, vy) is a normalized vector collinear to the line and
4463	(x0, y0) is a point on the line. In case of 3D fitting, it should be a vector of 6 elements (like
4464	Vec6f) - (vx, vy, vz, x0, y0, z0), where (vx, vy, vz) is a normalized vector collinear to the line
4465	and (x0, y0, z0) is a point on the line.
4466	@param distType Distance used by the M-estimator, see #DistanceTypes
4467	@param param Numerical parameter ( C ) for some types of distances. If it is 0, an optimal value
4468	is chosen.
4469	@param reps Sufficient accuracy for the radius (distance between the coordinate origin and the line).
4470	@param aeps Sufficient accuracy for the angle. 0.01 would be a good default value for reps and aeps.
4471	*/
4472	CV_EXPORTS_W void fitLine( InputArray points, OutputArray line, int distType,
4473	double param, double reps, double aeps );
4474
4475	/** @brief Performs a point-in-contour test.
4476
4477	The function determines whether the point is inside a contour, outside, or lies on an edge (or
4478	coincides with a vertex). It returns positive (inside), negative (outside), or zero (on an edge)
4479	value, correspondingly. When measureDist=false , the return value is +1, -1, and 0, respectively.
4480	Otherwise, the return value is a signed distance between the point and the nearest contour edge.
4481
4482	See below a sample output of the function where each image pixel is tested against the contour:
4483
4484	
4485
4486	@param contour Input contour.
4487	@param pt Point tested against the contour.
4488	@param measureDist If true, the function estimates the signed distance from the point to the
4489	nearest contour edge. Otherwise, the function only checks if the point is inside a contour or not.
4490	*/
4491	CV_EXPORTS_W double pointPolygonTest( InputArray contour, Point2f pt, bool measureDist );
4492
4493	/** @brief Finds out if there is any intersection between two rotated rectangles.
4494
4495	If there is then the vertices of the intersecting region are returned as well.
4496
4497	Below are some examples of intersection configurations. The hatched pattern indicates the
4498	intersecting region and the red vertices are returned by the function.
4499
4500	
4501
4502	@param rect1 First rectangle
4503	@param rect2 Second rectangle
4504	@param intersectingRegion The output array of the vertices of the intersecting region. It returns
4505	at most 8 vertices. Stored as std::vector\<cv::Point2f\> or cv::Mat as Mx1 of type CV_32FC2.
4506	@returns One of #RectanglesIntersectTypes
4507	*/
4508	CV_EXPORTS_W int rotatedRectangleIntersection( const RotatedRect& rect1, const RotatedRect& rect2, OutputArray intersectingRegion );
4509
4510	/** @brief Creates a smart pointer to a cv::GeneralizedHoughBallard class and initializes it.
4511	*/
4512	CV_EXPORTS_W Ptr<GeneralizedHoughBallard> createGeneralizedHoughBallard();
4513
4514	/** @brief Creates a smart pointer to a cv::GeneralizedHoughGuil class and initializes it.
4515	*/
4516	CV_EXPORTS_W Ptr<GeneralizedHoughGuil> createGeneralizedHoughGuil();
4517
4518	//! @} imgproc_shape
4519
4520	//! @addtogroup imgproc_colormap
4521	//! @{
4522
4523	//! GNU Octave/MATLAB equivalent colormaps
4524	enum ColormapTypes
4525	{
4526	COLORMAP_AUTUMN = 0, //!< 
4527	COLORMAP_BONE = 1, //!< 
4528	COLORMAP_JET = 2, //!< 
4529	COLORMAP_WINTER = 3, //!< 
4530	COLORMAP_RAINBOW = 4, //!< 
4531	COLORMAP_OCEAN = 5, //!< 
4532	COLORMAP_SUMMER = 6, //!< 
4533	COLORMAP_SPRING = 7, //!< 
4534	COLORMAP_COOL = 8, //!< 
4535	COLORMAP_HSV = 9, //!< 
4536	COLORMAP_PINK = 10, //!< 
4537	COLORMAP_HOT = 11, //!< 
4538	COLORMAP_PARULA = 12, //!< 
4539	COLORMAP_MAGMA = 13, //!< 
4540	COLORMAP_INFERNO = 14, //!< 
4541	COLORMAP_PLASMA = 15, //!< 
4542	COLORMAP_VIRIDIS = 16, //!< 
4543	COLORMAP_CIVIDIS = 17, //!< 
4544	COLORMAP_TWILIGHT = 18, //!< 
4545	COLORMAP_TWILIGHT_SHIFTED = 19, //!< 
4546	COLORMAP_TURBO = 20, //!< 
4547	COLORMAP_DEEPGREEN = 21 //!< 
4548	};
4549
4550	/** @example samples/cpp/falsecolor.cpp
4551	An example using applyColorMap function
4552	*/
4553
4554	/** @brief Applies a GNU Octave/MATLAB equivalent colormap on a given image.
4555
4556	@param src The source image, grayscale or colored of type CV_8UC1 or CV_8UC3. If CV_8UC3, then the CV_8UC1 image is generated internally using cv::COLOR_BGR2GRAY.
4557	@param dst The result is the colormapped source image. Note: Mat::create is called on dst.
4558	@param colormap The colormap to apply, see #ColormapTypes
4559	*/
4560	CV_EXPORTS_W void applyColorMap(InputArray src, OutputArray dst, int colormap);
4561
4562	/** @brief Applies a user colormap on a given image.
4563
4564	@param src The source image, grayscale or colored of type CV_8UC1 or CV_8UC3. If CV_8UC3, then the CV_8UC1 image is generated internally using cv::COLOR_BGR2GRAY.
4565	@param dst The result is the colormapped source image of the same number of channels as userColor. Note: Mat::create is called on dst.
4566	@param userColor The colormap to apply of type CV_8UC1 or CV_8UC3 and size 256
4567	*/
4568	CV_EXPORTS_W void applyColorMap(InputArray src, OutputArray dst, InputArray userColor);
4569
4570	//! @} imgproc_colormap
4571
4572	//! @addtogroup imgproc_draw
4573	//! @{
4574
4575
4576	/** OpenCV color channel order is BGR[A] */
4577	#define CV_RGB(r, g, b) cv::Scalar((b), (g), (r), 0)
4578
4579	/** @brief Draws a line segment connecting two points.
4580
4581	The function line draws the line segment between pt1 and pt2 points in the image. The line is
4582	clipped by the image boundaries. For non-antialiased lines with integer coordinates, the 8-connected
4583	or 4-connected Bresenham algorithm is used. Thick lines are drawn with rounding endings. Antialiased
4584	lines are drawn using Gaussian filtering.
4585
4586	@param img Image.
4587	@param pt1 First point of the line segment.
4588	@param pt2 Second point of the line segment.
4589	@param color Line color.
4590	@param thickness Line thickness.
4591	@param lineType Type of the line. See #LineTypes.
4592	@param shift Number of fractional bits in the point coordinates.
4593	*/
4594	CV_EXPORTS_W void line(InputOutputArray img, Point pt1, Point pt2, const Scalar& color,
4595	int thickness = 1, int lineType = LINE_8, int shift = 0);
4596
4597	/** @brief Draws an arrow segment pointing from the first point to the second one.
4598
4599	The function cv::arrowedLine draws an arrow between pt1 and pt2 points in the image. See also #line.
4600
4601	@param img Image.
4602	@param pt1 The point the arrow starts from.
4603	@param pt2 The point the arrow points to.
4604	@param color Line color.
4605	@param thickness Line thickness.
4606	@param line_type Type of the line. See #LineTypes
4607	@param shift Number of fractional bits in the point coordinates.
4608	@param tipLength The length of the arrow tip in relation to the arrow length
4609	*/
4610	CV_EXPORTS_W void arrowedLine(InputOutputArray img, Point pt1, Point pt2, const Scalar& color,
4611	int thickness=1, int line_type=8, int shift=0, double tipLength=0.1);
4612
4613	/** @brief Draws a simple, thick, or filled up-right rectangle.
4614
4615	The function cv::rectangle draws a rectangle outline or a filled rectangle whose two opposite corners
4616	are pt1 and pt2.
4617
4618	@param img Image.
4619	@param pt1 Vertex of the rectangle.
4620	@param pt2 Vertex of the rectangle opposite to pt1 .
4621	@param color Rectangle color or brightness (grayscale image).
4622	@param thickness Thickness of lines that make up the rectangle. Negative values, like #FILLED,
4623	mean that the function has to draw a filled rectangle.
4624	@param lineType Type of the line. See #LineTypes
4625	@param shift Number of fractional bits in the point coordinates.
4626	*/
4627	CV_EXPORTS_W void rectangle(InputOutputArray img, Point pt1, Point pt2,
4628	const Scalar& color, int thickness = 1,
4629	int lineType = LINE_8, int shift = 0);
4630
4631	/** @overload
4632
4633	use `rec` parameter as alternative specification of the drawn rectangle: `r.tl() and
4634	r.br()-Point(1,1)` are opposite corners
4635	*/
4636	CV_EXPORTS_W void rectangle(InputOutputArray img, Rect rec,
4637	const Scalar& color, int thickness = 1,
4638	int lineType = LINE_8, int shift = 0);
4639
4640	/** @example samples/cpp/tutorial_code/ImgProc/basic_drawing/Drawing_2.cpp
4641	An example using drawing functions
4642	*/
4643
4644	/** @brief Draws a circle.
4645
4646	The function cv::circle draws a simple or filled circle with a given center and radius.
4647	@param img Image where the circle is drawn.
4648	@param center Center of the circle.
4649	@param radius Radius of the circle.
4650	@param color Circle color.
4651	@param thickness Thickness of the circle outline, if positive. Negative values, like #FILLED,
4652	mean that a filled circle is to be drawn.
4653	@param lineType Type of the circle boundary. See #LineTypes
4654	@param shift Number of fractional bits in the coordinates of the center and in the radius value.
4655	*/
4656	CV_EXPORTS_W void circle(InputOutputArray img, Point center, int radius,
4657	const Scalar& color, int thickness = 1,
4658	int lineType = LINE_8, int shift = 0);
4659
4660	/** @brief Draws a simple or thick elliptic arc or fills an ellipse sector.
4661
4662	The function cv::ellipse with more parameters draws an ellipse outline, a filled ellipse, an elliptic
4663	arc, or a filled ellipse sector. The drawing code uses general parametric form.
4664	A piecewise-linear curve is used to approximate the elliptic arc
4665	boundary. If you need more control of the ellipse rendering, you can retrieve the curve using
4666	#ellipse2Poly and then render it with #polylines or fill it with #fillPoly. If you use the first
4667	variant of the function and want to draw the whole ellipse, not an arc, pass `startAngle=0` and
4668	`endAngle=360`. If `startAngle` is greater than `endAngle`, they are swapped. The figure below explains
4669	the meaning of the parameters to draw the blue arc.
4670
4671	
4672
4673	@param img Image.
4674	@param center Center of the ellipse.
4675	@param axes Half of the size of the ellipse main axes.
4676	@param angle Ellipse rotation angle in degrees.
4677	@param startAngle Starting angle of the elliptic arc in degrees.
4678	@param endAngle Ending angle of the elliptic arc in degrees.
4679	@param color Ellipse color.
4680	@param thickness Thickness of the ellipse arc outline, if positive. Otherwise, this indicates that
4681	a filled ellipse sector is to be drawn.
4682	@param lineType Type of the ellipse boundary. See #LineTypes
4683	@param shift Number of fractional bits in the coordinates of the center and values of axes.
4684	*/
4685	CV_EXPORTS_W void ellipse(InputOutputArray img, Point center, Size axes,
4686	double angle, double startAngle, double endAngle,
4687	const Scalar& color, int thickness = 1,
4688	int lineType = LINE_8, int shift = 0);
4689
4690	/** @overload
4691	@param img Image.
4692	@param box Alternative ellipse representation via RotatedRect. This means that the function draws
4693	an ellipse inscribed in the rotated rectangle.
4694	@param color Ellipse color.
4695	@param thickness Thickness of the ellipse arc outline, if positive. Otherwise, this indicates that
4696	a filled ellipse sector is to be drawn.
4697	@param lineType Type of the ellipse boundary. See #LineTypes
4698	*/
4699	CV_EXPORTS_W void ellipse(InputOutputArray img, const RotatedRect& box, const Scalar& color,
4700	int thickness = 1, int lineType = LINE_8);
4701
4702	/* ----------------------------------------------------------------------------------------- */
4703	/* ADDING A SET OF PREDEFINED MARKERS WHICH COULD BE USED TO HIGHLIGHT POSITIONS IN AN IMAGE */
4704	/* ----------------------------------------------------------------------------------------- */
4705
4706	/** @brief Draws a marker on a predefined position in an image.
4707
4708	The function cv::drawMarker draws a marker on a given position in the image. For the moment several
4709	marker types are supported, see #MarkerTypes for more information.
4710
4711	@param img Image.
4712	@param position The point where the crosshair is positioned.
4713	@param color Line color.
4714	@param markerType The specific type of marker you want to use, see #MarkerTypes
4715	@param thickness Line thickness.
4716	@param line_type Type of the line, See #LineTypes
4717	@param markerSize The length of the marker axis [default = 20 pixels]
4718	*/
4719	CV_EXPORTS_W void drawMarker(InputOutputArray img, Point position, const Scalar& color,
4720	int markerType = MARKER_CROSS, int markerSize=20, int thickness=1,
4721	int line_type=8);
4722
4723	/* ----------------------------------------------------------------------------------------- */
4724	/* END OF MARKER SECTION */
4725	/* ----------------------------------------------------------------------------------------- */
4726
4727	/** @brief Fills a convex polygon.
4728
4729	The function cv::fillConvexPoly draws a filled convex polygon. This function is much faster than the
4730	function #fillPoly . It can fill not only convex polygons but any monotonic polygon without
4731	self-intersections, that is, a polygon whose contour intersects every horizontal line (scan line)
4732	twice at the most (though, its top-most and/or the bottom edge could be horizontal).
4733
4734	@param img Image.
4735	@param points Polygon vertices.
4736	@param color Polygon color.
4737	@param lineType Type of the polygon boundaries. See #LineTypes
4738	@param shift Number of fractional bits in the vertex coordinates.
4739	*/
4740	CV_EXPORTS_W void fillConvexPoly(InputOutputArray img, InputArray points,
4741	const Scalar& color, int lineType = LINE_8,
4742	int shift = 0);
4743
4744	/** @overload */
4745	CV_EXPORTS void fillConvexPoly(InputOutputArray img, const Point* pts, int npts,
4746	const Scalar& color, int lineType = LINE_8,
4747	int shift = 0);
4748
4749	/** @example samples/cpp/tutorial_code/ImgProc/basic_drawing/Drawing_1.cpp
4750	An example using drawing functions
4751	Check @ref tutorial_random_generator_and_text "the corresponding tutorial" for more details
4752	*/
4753
4754	/** @brief Fills the area bounded by one or more polygons.
4755
4756	The function cv::fillPoly fills an area bounded by several polygonal contours. The function can fill
4757	complex areas, for example, areas with holes, contours with self-intersections (some of their
4758	parts), and so forth.
4759
4760	@param img Image.
4761	@param pts Array of polygons where each polygon is represented as an array of points.
4762	@param color Polygon color.
4763	@param lineType Type of the polygon boundaries. See #LineTypes
4764	@param shift Number of fractional bits in the vertex coordinates.
4765	@param offset Optional offset of all points of the contours.
4766	*/
4767	CV_EXPORTS_W void fillPoly(InputOutputArray img, InputArrayOfArrays pts,
4768	const Scalar& color, int lineType = LINE_8, int shift = 0,
4769	Point offset = Point() );
4770
4771	/** @overload */
4772	CV_EXPORTS void fillPoly(InputOutputArray img, const Point** pts,
4773	const int* npts, int ncontours,
4774	const Scalar& color, int lineType = LINE_8, int shift = 0,
4775	Point offset = Point() );
4776
4777	/** @brief Draws several polygonal curves.
4778
4779	@param img Image.
4780	@param pts Array of polygonal curves.
4781	@param isClosed Flag indicating whether the drawn polylines are closed or not. If they are closed,
4782	the function draws a line from the last vertex of each curve to its first vertex.
4783	@param color Polyline color.
4784	@param thickness Thickness of the polyline edges.
4785	@param lineType Type of the line segments. See #LineTypes
4786	@param shift Number of fractional bits in the vertex coordinates.
4787
4788	The function cv::polylines draws one or more polygonal curves.
4789	*/
4790	CV_EXPORTS_W void polylines(InputOutputArray img, InputArrayOfArrays pts,
4791	bool isClosed, const Scalar& color,
4792	int thickness = 1, int lineType = LINE_8, int shift = 0 );
4793
4794	/** @overload */
4795	CV_EXPORTS void polylines(InputOutputArray img, const Point* const* pts, const int* npts,
4796	int ncontours, bool isClosed, const Scalar& color,
4797	int thickness = 1, int lineType = LINE_8, int shift = 0 );
4798
4799	/** @example samples/cpp/contours2.cpp
4800	An example program illustrates the use of cv::findContours and cv::drawContours
4801	\image html WindowsQtContoursOutput.png "Screenshot of the program"
4802	*/
4803
4804	/** @example samples/cpp/segment_objects.cpp
4805	An example using drawContours to clean up a background segmentation result
4806	*/
4807
4808	/** @brief Draws contours outlines or filled contours.
4809
4810	The function draws contour outlines in the image if \f$\texttt{thickness} \ge 0\f$ or fills the area
4811	bounded by the contours if \f$\texttt{thickness}<0\f$ . The example below shows how to retrieve
4812	connected components from the binary image and label them: :
4813	@include snippets/imgproc_drawContours.cpp
4814
4815	@param image Destination image.
4816	@param contours All the input contours. Each contour is stored as a point vector.
4817	@param contourIdx Parameter indicating a contour to draw. If it is negative, all the contours are drawn.
4818	@param color Color of the contours.
4819	@param thickness Thickness of lines the contours are drawn with. If it is negative (for example,
4820	thickness=#FILLED ), the contour interiors are drawn.
4821	@param lineType Line connectivity. See #LineTypes
4822	@param hierarchy Optional information about hierarchy. It is only needed if you want to draw only
4823	some of the contours (see maxLevel ).
4824	@param maxLevel Maximal level for drawn contours. If it is 0, only the specified contour is drawn.
4825	If it is 1, the function draws the contour(s) and all the nested contours. If it is 2, the function
4826	draws the contours, all the nested contours, all the nested-to-nested contours, and so on. This
4827	parameter is only taken into account when there is hierarchy available.
4828	@param offset Optional contour shift parameter. Shift all the drawn contours by the specified
4829	\f$\texttt{offset}=(dx,dy)\f$ .
4830	@note When thickness=#FILLED, the function is designed to handle connected components with holes correctly
4831	even when no hierarchy data is provided. This is done by analyzing all the outlines together
4832	using even-odd rule. This may give incorrect results if you have a joint collection of separately retrieved
4833	contours. In order to solve this problem, you need to call #drawContours separately for each sub-group
4834	of contours, or iterate over the collection using contourIdx parameter.
4835	*/
4836	CV_EXPORTS_W void drawContours( InputOutputArray image, InputArrayOfArrays contours,
4837	int contourIdx, const Scalar& color,
4838	int thickness = 1, int lineType = LINE_8,
4839	InputArray hierarchy = noArray(),
4840	int maxLevel = INT_MAX, Point offset = Point() );
4841
4842	/** @brief Clips the line against the image rectangle.
4843
4844	The function cv::clipLine calculates a part of the line segment that is entirely within the specified
4845	rectangle. It returns false if the line segment is completely outside the rectangle. Otherwise,
4846	it returns true .
4847	@param imgSize Image size. The image rectangle is Rect(0, 0, imgSize.width, imgSize.height) .
4848	@param pt1 First line point.
4849	@param pt2 Second line point.
4850	*/
4851	CV_EXPORTS bool clipLine(Size imgSize, CV_IN_OUT Point& pt1, CV_IN_OUT Point& pt2);
4852
4853	/** @overload
4854	@param imgSize Image size. The image rectangle is Rect(0, 0, imgSize.width, imgSize.height) .
4855	@param pt1 First line point.
4856	@param pt2 Second line point.
4857	*/
4858	CV_EXPORTS bool clipLine(Size2l imgSize, CV_IN_OUT Point2l& pt1, CV_IN_OUT Point2l& pt2);
4859
4860	/** @overload
4861	@param imgRect Image rectangle.
4862	@param pt1 First line point.
4863	@param pt2 Second line point.
4864	*/
4865	CV_EXPORTS_W bool clipLine(Rect imgRect, CV_OUT CV_IN_OUT Point& pt1, CV_OUT CV_IN_OUT Point& pt2);
4866
4867	/** @brief Approximates an elliptic arc with a polyline.
4868
4869	The function ellipse2Poly computes the vertices of a polyline that approximates the specified
4870	elliptic arc. It is used by #ellipse. If `arcStart` is greater than `arcEnd`, they are swapped.
4871
4872	@param center Center of the arc.
4873	@param axes Half of the size of the ellipse main axes. See #ellipse for details.
4874	@param angle Rotation angle of the ellipse in degrees. See #ellipse for details.
4875	@param arcStart Starting angle of the elliptic arc in degrees.
4876	@param arcEnd Ending angle of the elliptic arc in degrees.
4877	@param delta Angle between the subsequent polyline vertices. It defines the approximation
4878	accuracy.
4879	@param pts Output vector of polyline vertices.
4880	*/
4881	CV_EXPORTS_W void ellipse2Poly( Point center, Size axes, int angle,
4882	int arcStart, int arcEnd, int delta,
4883	CV_OUT std::vector<Point>& pts );
4884
4885	/** @overload
4886	@param center Center of the arc.
4887	@param axes Half of the size of the ellipse main axes. See #ellipse for details.
4888	@param angle Rotation angle of the ellipse in degrees. See #ellipse for details.
4889	@param arcStart Starting angle of the elliptic arc in degrees.
4890	@param arcEnd Ending angle of the elliptic arc in degrees.
4891	@param delta Angle between the subsequent polyline vertices. It defines the approximation accuracy.
4892	@param pts Output vector of polyline vertices.
4893	*/
4894	CV_EXPORTS void ellipse2Poly(Point2d center, Size2d axes, int angle,
4895	int arcStart, int arcEnd, int delta,
4896	CV_OUT std::vector<Point2d>& pts);
4897
4898	/** @brief Draws a text string.
4899
4900	The function cv::putText renders the specified text string in the image. Symbols that cannot be rendered
4901	using the specified font are replaced by question marks. See #getTextSize for a text rendering code
4902	example.
4903
4904	The `fontScale` parameter is a scale factor that is multiplied by the base font size:
4905	- When scale > 1, the text is magnified.
4906	- When 0 < scale < 1, the text is minimized.
4907	- When scale < 0, the text is mirrored or reversed.
4908
4909	@param img Image.
4910	@param text Text string to be drawn.
4911	@param org Bottom-left corner of the text string in the image.
4912	@param fontFace Font type, see #HersheyFonts.
4913	@param fontScale Font scale factor that is multiplied by the font-specific base size.
4914	@param color Text color.
4915	@param thickness Thickness of the lines used to draw a text.
4916	@param lineType Line type. See #LineTypes
4917	@param bottomLeftOrigin When true, the image data origin is at the bottom-left corner. Otherwise,
4918	it is at the top-left corner.
4919	*/
4920	CV_EXPORTS_W void putText( InputOutputArray img, const String& text, Point org,
4921	int fontFace, double fontScale, Scalar color,
4922	int thickness = 1, int lineType = LINE_8,
4923	bool bottomLeftOrigin = false );
4924
4925	/** @brief Calculates the width and height of a text string.
4926
4927	The function cv::getTextSize calculates and returns the size of a box that contains the specified text.
4928	That is, the following code renders some text, the tight box surrounding it, and the baseline: :
4929	@code
4930	String text = "Funny text inside the box";
4931	int fontFace = FONT_HERSHEY_SCRIPT_SIMPLEX;
4932	double fontScale = 2;
4933	int thickness = 3;
4934
4935	Mat img(600, 800, CV_8UC3, Scalar::all(0));
4936
4937	int baseline=0;
4938	Size textSize = getTextSize(text, fontFace,
4939	fontScale, thickness, &baseline);
4940	baseline += thickness;
4941
4942	// center the text
4943	Point textOrg((img.cols - textSize.width)/2,
4944	(img.rows + textSize.height)/2);
4945
4946	// draw the box
4947	rectangle(img, textOrg + Point(0, baseline),
4948	textOrg + Point(textSize.width, -textSize.height),
4949	Scalar(0,0,255));
4950	// ... and the baseline first
4951	line(img, textOrg + Point(0, thickness),
4952	textOrg + Point(textSize.width, thickness),
4953	Scalar(0, 0, 255));
4954
4955	// then put the text itself
4956	putText(img, text, textOrg, fontFace, fontScale,
4957	Scalar::all(255), thickness, 8);
4958	@endcode
4959
4960	@param text Input text string.
4961	@param fontFace Font to use, see #HersheyFonts.
4962	@param fontScale Font scale factor that is multiplied by the font-specific base size.
4963	@param thickness Thickness of lines used to render the text. See #putText for details.
4964	@param[out] baseLine y-coordinate of the baseline relative to the bottom-most text
4965	point.
4966	@return The size of a box that contains the specified text.
4967
4968	@see putText
4969	*/
4970	CV_EXPORTS_W Size getTextSize(const String& text, int fontFace,
4971	double fontScale, int thickness,
4972	CV_OUT int* baseLine);
4973
4974
4975	/** @brief Calculates the font-specific size to use to achieve a given height in pixels.
4976
4977	@param fontFace Font to use, see cv::HersheyFonts.
4978	@param pixelHeight Pixel height to compute the fontScale for
4979	@param thickness Thickness of lines used to render the text.See putText for details.
4980	@return The fontSize to use for cv::putText
4981
4982	@see cv::putText
4983	*/
4984	CV_EXPORTS_W double getFontScaleFromHeight(const int fontFace,
4985	const int pixelHeight,
4986	const int thickness = 1);
4987
4988	/** @brief Class for iterating over all pixels on a raster line segment.
4989
4990	The class LineIterator is used to get each pixel of a raster line connecting
4991	two specified points.
4992	It can be treated as a versatile implementation of the Bresenham algorithm
4993	where you can stop at each pixel and do some extra processing, for
4994	example, grab pixel values along the line or draw a line with an effect
4995	(for example, with XOR operation).
4996
4997	The number of pixels along the line is stored in LineIterator::count.
4998	The method LineIterator::pos returns the current position in the image:
4999
5000	@code{.cpp}
5001	// grabs pixels along the line (pt1, pt2)
5002	// from 8-bit 3-channel image to the buffer
5003	LineIterator it(img, pt1, pt2, 8);
5004	LineIterator it2 = it;
5005	vector<Vec3b> buf(it.count);
5006
5007	for(int i = 0; i < it.count; i++, ++it)
5008	buf[i] = *(const Vec3b*)*it;
5009
5010	// alternative way of iterating through the line
5011	for(int i = 0; i < it2.count; i++, ++it2)
5012	{
5013	Vec3b val = img.at<Vec3b>(it2.pos());
5014	CV_Assert(buf[i] == val);
5015	}
5016	@endcode
5017	*/
5018	class CV_EXPORTS LineIterator
5019	{
5020	public:
5021	/** @brief Initializes iterator object for the given line and image.
5022
5023	The returned iterator can be used to traverse all pixels on a line that
5024	connects the given two points.
5025	The line will be clipped on the image boundaries.
5026
5027	@param img Underlying image.
5028	@param pt1 First endpoint of the line.
5029	@param pt2 The other endpoint of the line.
5030	@param connectivity Pixel connectivity of the iterator. Valid values are 4 (iterator can move
5031	up, down, left and right) and 8 (iterator can also move diagonally).
5032	@param leftToRight If true, the line is traversed from the leftmost endpoint to the rightmost
5033	endpoint. Otherwise, the line is traversed from \p pt1 to \p pt2.
5034	*/
5035	LineIterator( const Mat& img, Point pt1, Point pt2,
5036	int connectivity = 8, bool leftToRight = false )
5037	{
5038	init(img: &img, boundingAreaRect: Rect(0, 0, img.cols, img.rows), pt1, pt2, connectivity, leftToRight);
5039	ptmode = false;
5040	}
5041	LineIterator( Point pt1, Point pt2,
5042	int connectivity = 8, bool leftToRight = false )
5043	{
5044	init(img: 0, boundingAreaRect: Rect(std::min(a: pt1.x, b: pt2.x),
5045	std::min(a: pt1.y, b: pt2.y),
5046	std::max(a: pt1.x, b: pt2.x) - std::min(a: pt1.x, b: pt2.x) + 1,
5047	std::max(a: pt1.y, b: pt2.y) - std::min(a: pt1.y, b: pt2.y) + 1),
5048	pt1, pt2, connectivity, leftToRight);
5049	ptmode = true;
5050	}
5051	LineIterator( Size boundingAreaSize, Point pt1, Point pt2,
5052	int connectivity = 8, bool leftToRight = false )
5053	{
5054	init(img: 0, boundingAreaRect: Rect(0, 0, boundingAreaSize.width, boundingAreaSize.height),
5055	pt1, pt2, connectivity, leftToRight);
5056	ptmode = true;
5057	}
5058	LineIterator( Rect boundingAreaRect, Point pt1, Point pt2,
5059	int connectivity = 8, bool leftToRight = false )
5060	{
5061	init(img: 0, boundingAreaRect, pt1, pt2, connectivity, leftToRight);
5062	ptmode = true;
5063	}
5064	void init(const Mat* img, Rect boundingAreaRect, Point pt1, Point pt2, int connectivity, bool leftToRight);
5065
5066	/** @brief Returns pointer to the current pixel.
5067	*/
5068	uchar* operator *();
5069
5070	/** @brief Moves iterator to the next pixel on the line.
5071
5072	This is the prefix version (++it).
5073	*/
5074	LineIterator& operator ++();
5075
5076	/** @brief Moves iterator to the next pixel on the line.
5077
5078	This is the postfix version (it++).
5079	*/
5080	LineIterator operator ++(int);
5081
5082	/** @brief Returns coordinates of the current pixel.
5083	*/
5084	Point pos() const;
5085
5086	uchar* ptr;
5087	const uchar* ptr0;
5088	int step, elemSize;
5089	int err, count;
5090	int minusDelta, plusDelta;
5091	int minusStep, plusStep;
5092	int minusShift, plusShift;
5093	Point p;
5094	bool ptmode;
5095	};
5096
5097	//! @cond IGNORED
5098
5099	// === LineIterator implementation ===
5100
5101	inline
5102	uchar* LineIterator::operator *()
5103	{
5104	return ptmode ? 0 : ptr;
5105	}
5106
5107	inline
5108	LineIterator& LineIterator::operator ++()
5109	{
5110	int mask = err < 0 ? -1 : 0;
5111	err += minusDelta + (plusDelta & mask);
5112	if(!ptmode)
5113	{
5114	ptr += minusStep + (plusStep & mask);
5115	}
5116	else
5117	{
5118	p.x += minusShift + (plusShift & mask);
5119	p.y += minusStep + (plusStep & mask);
5120	}
5121	return *this;
5122	}
5123
5124	inline
5125	LineIterator LineIterator::operator ++(int)
5126	{
5127	LineIterator it = *this;
5128	++(*this);
5129	return it;
5130	}
5131
5132	inline
5133	Point LineIterator::pos() const
5134	{
5135	if(!ptmode)
5136	{
5137	size_t offset = (size_t)(ptr - ptr0);
5138	int y = (int)(offset/step);
5139	int x = (int)((offset - (size_t)y*step)/elemSize);
5140	return Point(x, y);
5141	}
5142	return p;
5143	}
5144
5145	//! @endcond
5146
5147	//! @} imgproc_draw
5148
5149	//! @} imgproc
5150
5151	} // cv
5152
5153
5154	#include "./imgproc/segmentation.hpp"
5155
5156
5157	#endif
5158