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