node-native-win-utils 1.4.0 → 2.1.1

package/include/opencv2/imgproc/imgproc_c.h

@@ -1,1177 +0,0 @@
-/*M///////////////////////////////////////////////////////////////////////////////////////
-//
-//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
-//
-//  By downloading, copying, installing or using the software you agree to this license.
-//  If you do not agree to this license, do not download, install,
-//  copy or use the software.
-//
-//
-//                           License Agreement
-//                For Open Source Computer Vision Library
-//
-// Copyright (C) 2000-2008, Intel Corporation, all rights reserved.
-// Copyright (C) 2009, Willow Garage Inc., all rights reserved.
-// Third party copyrights are property of their respective owners.
-//
-// Redistribution and use in source and binary forms, with or without modification,
-// are permitted provided that the following conditions are met:
-//
-//   * Redistribution's of source code must retain the above copyright notice,
-//     this list of conditions and the following disclaimer.
-//
-//   * Redistribution's in binary form must reproduce the above copyright notice,
-//     this list of conditions and the following disclaimer in the documentation
-//     and/or other materials provided with the distribution.
-//
-//   * The name of the copyright holders may not be used to endorse or promote products
-//     derived from this software without specific prior written permission.
-//
-// This software is provided by the copyright holders and contributors "as is" and
-// any express or implied warranties, including, but not limited to, the implied
-// warranties of merchantability and fitness for a particular purpose are disclaimed.
-// In no event shall the Intel Corporation or contributors be liable for any direct,
-// indirect, incidental, special, exemplary, or consequential damages
-// (including, but not limited to, procurement of substitute goods or services;
-// loss of use, data, or profits; or business interruption) however caused
-// and on any theory of liability, whether in contract, strict liability,
-// or tort (including negligence or otherwise) arising in any way out of
-// the use of this software, even if advised of the possibility of such damage.
-//
-//M*/
-
-#ifndef OPENCV_IMGPROC_IMGPROC_C_H
-#define OPENCV_IMGPROC_IMGPROC_C_H
-
-#include "opencv2/imgproc/types_c.h"
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-/** @addtogroup imgproc_c
-@{
-*/
-
-/*********************** Background statistics accumulation *****************************/
-
-/** @brief Adds image to accumulator
-@see cv::accumulate
-*/
-CVAPI(void)  cvAcc( const CvArr* image, CvArr* sum,
-                   const CvArr* mask CV_DEFAULT(NULL) );
-
-/** @brief Adds squared image to accumulator
-@see cv::accumulateSquare
-*/
-CVAPI(void)  cvSquareAcc( const CvArr* image, CvArr* sqsum,
-                         const CvArr* mask CV_DEFAULT(NULL) );
-
-/** @brief Adds a product of two images to accumulator
-@see cv::accumulateProduct
-*/
-CVAPI(void)  cvMultiplyAcc( const CvArr* image1, const CvArr* image2, CvArr* acc,
-                           const CvArr* mask CV_DEFAULT(NULL) );
-
-/** @brief Adds image to accumulator with weights: acc = acc*(1-alpha) + image*alpha
-@see cv::accumulateWeighted
-*/
-CVAPI(void)  cvRunningAvg( const CvArr* image, CvArr* acc, double alpha,
-                          const CvArr* mask CV_DEFAULT(NULL) );
-
-/****************************************************************************************\
-*                                    Image Processing                                    *
-\****************************************************************************************/
-
-/** Copies source 2D array inside of the larger destination array and
-   makes a border of the specified type (IPL_BORDER_*) around the copied area. */
-CVAPI(void) cvCopyMakeBorder( const CvArr* src, CvArr* dst, CvPoint offset,
-                              int bordertype, CvScalar value CV_DEFAULT(cvScalarAll(0)));
-
-/** @brief Smooths the image in one of several ways.
-
-@param src The source image
-@param dst The destination image
-@param smoothtype Type of the smoothing, see SmoothMethod_c
-@param size1 The first parameter of the smoothing operation, the aperture width. Must be a
-positive odd number (1, 3, 5, ...)
-@param size2 The second parameter of the smoothing operation, the aperture height. Ignored by
-CV_MEDIAN and CV_BILATERAL methods. In the case of simple scaled/non-scaled and Gaussian blur if
-size2 is zero, it is set to size1. Otherwise it must be a positive odd number.
-@param sigma1 In the case of a Gaussian parameter this parameter may specify Gaussian \f$\sigma\f$
-(standard deviation). If it is zero, it is calculated from the kernel size:
-\f[\sigma  = 0.3 (n/2 - 1) + 0.8  \quad   \text{where}   \quad  n= \begin{array}{l l} \mbox{\texttt{size1} for horizontal kernel} \\ \mbox{\texttt{size2} for vertical kernel} \end{array}\f]
-Using standard sigma for small kernels ( \f$3\times 3\f$ to \f$7\times 7\f$ ) gives better speed. If
-sigma1 is not zero, while size1 and size2 are zeros, the kernel size is calculated from the
-sigma (to provide accurate enough operation).
-@param sigma2 additional parameter for bilateral filtering
-
-@see cv::GaussianBlur, cv::blur, cv::medianBlur, cv::bilateralFilter.
- */
-CVAPI(void) cvSmooth( const CvArr* src, CvArr* dst,
-                      int smoothtype CV_DEFAULT(CV_GAUSSIAN),
-                      int size1 CV_DEFAULT(3),
-                      int size2 CV_DEFAULT(0),
-                      double sigma1 CV_DEFAULT(0),
-                      double sigma2 CV_DEFAULT(0));
-
-/** @brief Convolves an image with the kernel.
-
-@param src input image.
-@param dst output image of the same size and the same number of channels as src.
-@param kernel convolution kernel (or rather a correlation kernel), a single-channel floating point
-matrix; if you want to apply different kernels to different channels, split the image into
-separate color planes using split and process them individually.
-@param anchor anchor of the kernel that indicates the relative position of a filtered point within
-the kernel; the anchor should lie within the kernel; default value (-1,-1) means that the anchor
-is at the kernel center.
-
-@see cv::filter2D
- */
-CVAPI(void) cvFilter2D( const CvArr* src, CvArr* dst, const CvMat* kernel,
-                        CvPoint anchor CV_DEFAULT(cvPoint(-1,-1)));
-
-/** @brief Finds integral image: SUM(X,Y) = sum(x<X,y<Y)I(x,y)
-@see cv::integral
-*/
-CVAPI(void) cvIntegral( const CvArr* image, CvArr* sum,
-                       CvArr* sqsum CV_DEFAULT(NULL),
-                       CvArr* tilted_sum CV_DEFAULT(NULL));
-
-/** @brief Smoothes the input image with gaussian kernel and then down-samples it.
-
-   dst_width = floor(src_width/2)[+1],
-   dst_height = floor(src_height/2)[+1]
-   @see cv::pyrDown
-*/
-CVAPI(void)  cvPyrDown( const CvArr* src, CvArr* dst,
-                        int filter CV_DEFAULT(CV_GAUSSIAN_5x5) );
-
-/** @brief Up-samples image and smoothes the result with gaussian kernel.
-
-   dst_width = src_width*2,
-   dst_height = src_height*2
-   @see cv::pyrUp
-*/
-CVAPI(void)  cvPyrUp( const CvArr* src, CvArr* dst,
-                      int filter CV_DEFAULT(CV_GAUSSIAN_5x5) );
-
-/** @brief Builds pyramid for an image
-@see buildPyramid
-*/
-CVAPI(CvMat**) cvCreatePyramid( const CvArr* img, int extra_layers, double rate,
-                                const CvSize* layer_sizes CV_DEFAULT(0),
-                                CvArr* bufarr CV_DEFAULT(0),
-                                int calc CV_DEFAULT(1),
-                                int filter CV_DEFAULT(CV_GAUSSIAN_5x5) );
-
-/** @brief Releases pyramid */
-CVAPI(void)  cvReleasePyramid( CvMat*** pyramid, int extra_layers );
-
-
-/** @brief Filters image using meanshift algorithm
-@see cv::pyrMeanShiftFiltering
-*/
-CVAPI(void) cvPyrMeanShiftFiltering( const CvArr* src, CvArr* dst,
-    double sp, double sr, int max_level CV_DEFAULT(1),
-    CvTermCriteria termcrit CV_DEFAULT(cvTermCriteria(CV_TERMCRIT_ITER+CV_TERMCRIT_EPS,5,1)));
-
-/** @brief Segments image using seed "markers"
-@see cv::watershed
-*/
-CVAPI(void) cvWatershed( const CvArr* image, CvArr* markers );
-
-/** @brief Calculates an image derivative using generalized Sobel
-
-   (aperture_size = 1,3,5,7) or Scharr (aperture_size = -1) operator.
-   Scharr can be used only for the first dx or dy derivative
-@see cv::Sobel
-*/
-CVAPI(void) cvSobel( const CvArr* src, CvArr* dst,
-                    int xorder, int yorder,
-                    int aperture_size CV_DEFAULT(3));
-
-/** @brief Calculates the image Laplacian: (d2/dx + d2/dy)I
-@see cv::Laplacian
-*/
-CVAPI(void) cvLaplace( const CvArr* src, CvArr* dst,
-                      int aperture_size CV_DEFAULT(3) );
-
-/** @brief Converts input array pixels from one color space to another
-@see cv::cvtColor
-*/
-CVAPI(void)  cvCvtColor( const CvArr* src, CvArr* dst, int code );
-
-
-/** @brief Resizes image (input array is resized to fit the destination array)
-@see cv::resize
-*/
-CVAPI(void)  cvResize( const CvArr* src, CvArr* dst,
-                       int interpolation CV_DEFAULT( CV_INTER_LINEAR ));
-
-/** @brief Warps image with affine transform
-@note ::cvGetQuadrangleSubPix is similar to ::cvWarpAffine, but the outliers are extrapolated using
-replication border mode.
-@see cv::warpAffine
-*/
-CVAPI(void)  cvWarpAffine( const CvArr* src, CvArr* dst, const CvMat* map_matrix,
-                           int flags CV_DEFAULT(CV_INTER_LINEAR+CV_WARP_FILL_OUTLIERS),
-                           CvScalar fillval CV_DEFAULT(cvScalarAll(0)) );
-
-/** @brief Computes affine transform matrix for mapping src[i] to dst[i] (i=0,1,2)
-@see cv::getAffineTransform
-*/
-CVAPI(CvMat*) cvGetAffineTransform( const CvPoint2D32f * src,
-                                    const CvPoint2D32f * dst,
-                                    CvMat * map_matrix );
-
-/** @brief Computes rotation_matrix matrix
-@see cv::getRotationMatrix2D
-*/
-CVAPI(CvMat*)  cv2DRotationMatrix( CvPoint2D32f center, double angle,
-                                   double scale, CvMat* map_matrix );
-
-/** @brief Warps image with perspective (projective) transform
-@see cv::warpPerspective
-*/
-CVAPI(void)  cvWarpPerspective( const CvArr* src, CvArr* dst, const CvMat* map_matrix,
-                                int flags CV_DEFAULT(CV_INTER_LINEAR+CV_WARP_FILL_OUTLIERS),
-                                CvScalar fillval CV_DEFAULT(cvScalarAll(0)) );
-
-/** @brief Computes perspective transform matrix for mapping src[i] to dst[i] (i=0,1,2,3)
-@see cv::getPerspectiveTransform
-*/
-CVAPI(CvMat*) cvGetPerspectiveTransform( const CvPoint2D32f* src,
-                                         const CvPoint2D32f* dst,
-                                         CvMat* map_matrix );
-
-/** @brief Performs generic geometric transformation using the specified coordinate maps
-@see cv::remap
-*/
-CVAPI(void)  cvRemap( const CvArr* src, CvArr* dst,
-                      const CvArr* mapx, const CvArr* mapy,
-                      int flags CV_DEFAULT(CV_INTER_LINEAR+CV_WARP_FILL_OUTLIERS),
-                      CvScalar fillval CV_DEFAULT(cvScalarAll(0)) );
-
-/** @brief Converts mapx & mapy from floating-point to integer formats for cvRemap
-@see cv::convertMaps
-*/
-CVAPI(void)  cvConvertMaps( const CvArr* mapx, const CvArr* mapy,
-                            CvArr* mapxy, CvArr* mapalpha );
-
-/** @brief Performs forward or inverse log-polar image transform
-@see cv::warpPolar
-*/
-CVAPI(void)  cvLogPolar( const CvArr* src, CvArr* dst,
-                         CvPoint2D32f center, double M,
-                         int flags CV_DEFAULT(CV_INTER_LINEAR+CV_WARP_FILL_OUTLIERS));
-
-/** Performs forward or inverse linear-polar image transform
-@see cv::warpPolar
-*/
-CVAPI(void)  cvLinearPolar( const CvArr* src, CvArr* dst,
-                         CvPoint2D32f center, double maxRadius,
-                         int flags CV_DEFAULT(CV_INTER_LINEAR+CV_WARP_FILL_OUTLIERS));
-
-/** @brief Returns a structuring element of the specified size and shape for morphological operations.
-
-@note the created structuring element IplConvKernel\* element must be released in the end using
-`cvReleaseStructuringElement(&element)`.
-
-@param cols Width of the structuring element
-@param rows Height of the structuring element
-@param anchor_x x-coordinate of the anchor
-@param anchor_y y-coordinate of the anchor
-@param shape element shape that could be one of the cv::MorphShapes_c
-@param values integer array of cols*rows elements that specifies the custom shape of the
-structuring element, when shape=CV_SHAPE_CUSTOM.
-
-@see cv::getStructuringElement
- */
- CVAPI(IplConvKernel*)  cvCreateStructuringElementEx(
-            int cols, int  rows, int  anchor_x, int  anchor_y,
-            int shape, int* values CV_DEFAULT(NULL) );
-
-/** @brief releases structuring element
-@see cvCreateStructuringElementEx
-*/
-CVAPI(void)  cvReleaseStructuringElement( IplConvKernel** element );
-
-/** @brief erodes input image (applies minimum filter) one or more times.
-   If element pointer is NULL, 3x3 rectangular element is used
-@see cv::erode
-*/
-CVAPI(void)  cvErode( const CvArr* src, CvArr* dst,
-                      IplConvKernel* element CV_DEFAULT(NULL),
-                      int iterations CV_DEFAULT(1) );
-
-/** @brief dilates input image (applies maximum filter) one or more times.
-
-   If element pointer is NULL, 3x3 rectangular element is used
-@see cv::dilate
-*/
-CVAPI(void)  cvDilate( const CvArr* src, CvArr* dst,
-                       IplConvKernel* element CV_DEFAULT(NULL),
-                       int iterations CV_DEFAULT(1) );
-
-/** @brief Performs complex morphological transformation
-@see cv::morphologyEx
-*/
-CVAPI(void)  cvMorphologyEx( const CvArr* src, CvArr* dst,
-                             CvArr* temp, IplConvKernel* element,
-                             int operation, int iterations CV_DEFAULT(1) );
-
-/** @brief Calculates all spatial and central moments up to the 3rd order
-@see cv::moments
-*/
-CVAPI(void) cvMoments( const CvArr* arr, CvMoments* moments, int binary CV_DEFAULT(0));
-
-/** @brief Retrieve spatial moments */
-CVAPI(double)  cvGetSpatialMoment( CvMoments* moments, int x_order, int y_order );
-/** @brief Retrieve central moments */
-CVAPI(double)  cvGetCentralMoment( CvMoments* moments, int x_order, int y_order );
-/** @brief Retrieve normalized central moments */
-CVAPI(double)  cvGetNormalizedCentralMoment( CvMoments* moments,
-                                             int x_order, int y_order );
-
-/** @brief Calculates 7 Hu's invariants from precalculated spatial and central moments
-@see cv::HuMoments
-*/
-CVAPI(void) cvGetHuMoments( CvMoments*  moments, CvHuMoments*  hu_moments );
-
-/*********************************** data sampling **************************************/
-
-/** @brief Fetches pixels that belong to the specified line segment and stores them to the buffer.
-
-   Returns the number of retrieved points.
-@see cv::LineSegmentDetector
-*/
-CVAPI(int)  cvSampleLine( const CvArr* image, CvPoint pt1, CvPoint pt2, void* buffer,
-                          int connectivity CV_DEFAULT(8));
-
-/** @brief Retrieves the rectangular image region with specified center from the input array.
-
- dst(x,y) <- src(x + center.x - dst_width/2, y + center.y - dst_height/2).
- Values of pixels with fractional coordinates are retrieved using bilinear interpolation
-@see cv::getRectSubPix
-*/
-CVAPI(void)  cvGetRectSubPix( const CvArr* src, CvArr* dst, CvPoint2D32f center );
-
-
-/** @brief Retrieves quadrangle from the input array.
-
-    matrixarr = ( a11  a12 | b1 )   dst(x,y) <- src(A[x y]' + b)
-                ( a21  a22 | b2 )   (bilinear interpolation is used to retrieve pixels
-                                     with fractional coordinates)
-@see cvWarpAffine
-*/
-CVAPI(void)  cvGetQuadrangleSubPix( const CvArr* src, CvArr* dst,
-                                    const CvMat* map_matrix );
-
-/** @brief Measures similarity between template and overlapped windows in the source image
-   and fills the resultant image with the measurements
-@see cv::matchTemplate
-*/
-CVAPI(void)  cvMatchTemplate( const CvArr* image, const CvArr* templ,
-                              CvArr* result, int method );
-
-/** @brief Computes earth mover distance between
-   two weighted point sets (called signatures)
-@see cv::EMD
-*/
-CVAPI(float)  cvCalcEMD2( const CvArr* signature1,
-                          const CvArr* signature2,
-                          int distance_type,
-                          CvDistanceFunction distance_func CV_DEFAULT(NULL),
-                          const CvArr* cost_matrix CV_DEFAULT(NULL),
-                          CvArr* flow CV_DEFAULT(NULL),
-                          float* lower_bound CV_DEFAULT(NULL),
-                          void* userdata CV_DEFAULT(NULL));
-
-/****************************************************************************************\
-*                              Contours retrieving                                       *
-\****************************************************************************************/
-
-/** @brief Retrieves outer and optionally inner boundaries of white (non-zero) connected
-   components in the black (zero) background
-@see cv::findContours, cvStartFindContours, cvFindNextContour, cvSubstituteContour, cvEndFindContours
-*/
-CVAPI(int)  cvFindContours( CvArr* image, CvMemStorage* storage, CvSeq** first_contour,
-                            int header_size CV_DEFAULT(sizeof(CvContour)),
-                            int mode CV_DEFAULT(CV_RETR_LIST),
-                            int method CV_DEFAULT(CV_CHAIN_APPROX_SIMPLE),
-                            CvPoint offset CV_DEFAULT(cvPoint(0,0)));
-
-/** @brief Initializes contour retrieving process.
-
-   Calls cvStartFindContours.
-   Calls cvFindNextContour until null pointer is returned
-   or some other condition becomes true.
-   Calls cvEndFindContours at the end.
-@see cvFindContours
-*/
-CVAPI(CvContourScanner)  cvStartFindContours( CvArr* image, CvMemStorage* storage,
-                            int header_size CV_DEFAULT(sizeof(CvContour)),
-                            int mode CV_DEFAULT(CV_RETR_LIST),
-                            int method CV_DEFAULT(CV_CHAIN_APPROX_SIMPLE),
-                            CvPoint offset CV_DEFAULT(cvPoint(0,0)));
-
-/** @brief Retrieves next contour
-@see cvFindContours
-*/
-CVAPI(CvSeq*)  cvFindNextContour( CvContourScanner scanner );
-
-
-/** @brief Substitutes the last retrieved contour with the new one
-
-   (if the substitutor is null, the last retrieved contour is removed from the tree)
-@see cvFindContours
-*/
-CVAPI(void)   cvSubstituteContour( CvContourScanner scanner, CvSeq* new_contour );
-
-
-/** @brief Releases contour scanner and returns pointer to the first outer contour
-@see cvFindContours
-*/
-CVAPI(CvSeq*)  cvEndFindContours( CvContourScanner* scanner );
-
-/** @brief Approximates Freeman chain(s) with a polygonal curve.
-
-This is a standalone contour approximation routine, not represented in the new interface. When
-cvFindContours retrieves contours as Freeman chains, it calls the function to get approximated
-contours, represented as polygons.
-
-@param src_seq Pointer to the approximated Freeman chain that can refer to other chains.
-@param storage Storage location for the resulting polylines.
-@param method Approximation method (see the description of the function :ocvFindContours ).
-@param parameter Method parameter (not used now).
-@param minimal_perimeter Approximates only those contours whose perimeters are not less than
-minimal_perimeter . Other chains are removed from the resulting structure.
-@param recursive Recursion flag. If it is non-zero, the function approximates all chains that can
-be obtained from chain by using the h_next or v_next links. Otherwise, the single input chain is
-approximated.
-@see cvStartReadChainPoints, cvReadChainPoint
- */
-CVAPI(CvSeq*) cvApproxChains( CvSeq* src_seq, CvMemStorage* storage,
-                            int method CV_DEFAULT(CV_CHAIN_APPROX_SIMPLE),
-                            double parameter CV_DEFAULT(0),
-                            int  minimal_perimeter CV_DEFAULT(0),
-                            int  recursive CV_DEFAULT(0));
-
-/** @brief Initializes Freeman chain reader.
-
-   The reader is used to iteratively get coordinates of all the chain points.
-   If the Freeman codes should be read as is, a simple sequence reader should be used
-@see cvApproxChains
-*/
-CVAPI(void) cvStartReadChainPoints( CvChain* chain, CvChainPtReader* reader );
-
-/** @brief Retrieves the next chain point
-@see cvApproxChains
-*/
-CVAPI(CvPoint) cvReadChainPoint( CvChainPtReader* reader );
-
-
-/****************************************************************************************\
-*                            Contour Processing and Shape Analysis                       *
-\****************************************************************************************/
-
-/** @brief Approximates a single polygonal curve (contour) or
-   a tree of polygonal curves (contours)
-@see cv::approxPolyDP
-*/
-CVAPI(CvSeq*)  cvApproxPoly( const void* src_seq,
-                             int header_size, CvMemStorage* storage,
-                             int method, double eps,
-                             int recursive CV_DEFAULT(0));
-
-/** @brief Calculates perimeter of a contour or length of a part of contour
-@see cv::arcLength
-*/
-CVAPI(double)  cvArcLength( const void* curve,
-                            CvSlice slice CV_DEFAULT(CV_WHOLE_SEQ),
-                            int is_closed CV_DEFAULT(-1));
-
-/** same as cvArcLength for closed contour
-*/
-CV_INLINE double cvContourPerimeter( const void* contour )
-{
-    return cvArcLength( contour, CV_WHOLE_SEQ, 1 );
-}
-
-
-/** @brief Calculates contour bounding rectangle (update=1) or
-   just retrieves pre-calculated rectangle (update=0)
-@see cv::boundingRect
-*/
-CVAPI(CvRect)  cvBoundingRect( CvArr* points, int update CV_DEFAULT(0) );
-
-/** @brief Calculates area of a contour or contour segment
-@see cv::contourArea
-*/
-CVAPI(double)  cvContourArea( const CvArr* contour,
-                              CvSlice slice CV_DEFAULT(CV_WHOLE_SEQ),
-                              int oriented CV_DEFAULT(0));
-
-/** @brief Finds minimum area rotated rectangle bounding a set of points
-@see cv::minAreaRect
-*/
-CVAPI(CvBox2D)  cvMinAreaRect2( const CvArr* points,
-                                CvMemStorage* storage CV_DEFAULT(NULL));
-
-/** @brief Finds minimum enclosing circle for a set of points
-@see cv::minEnclosingCircle
-*/
-CVAPI(int)  cvMinEnclosingCircle( const CvArr* points,
-                                  CvPoint2D32f* center, float* radius );
-
-/** @brief Compares two contours by matching their moments
-@see cv::matchShapes
-*/
-CVAPI(double)  cvMatchShapes( const void* object1, const void* object2,
-                              int method, double parameter CV_DEFAULT(0));
-
-/** @brief Calculates exact convex hull of 2d point set
-@see cv::convexHull
-*/
-CVAPI(CvSeq*) cvConvexHull2( const CvArr* input,
-                             void* hull_storage CV_DEFAULT(NULL),
-                             int orientation CV_DEFAULT(CV_CLOCKWISE),
-                             int return_points CV_DEFAULT(0));
-
-/** @brief Checks whether the contour is convex or not (returns 1 if convex, 0 if not)
-@see cv::isContourConvex
-*/
-CVAPI(int)  cvCheckContourConvexity( const CvArr* contour );
-
-
-/** @brief Finds convexity defects for the contour
-@see cv::convexityDefects
-*/
-CVAPI(CvSeq*)  cvConvexityDefects( const CvArr* contour, const CvArr* convexhull,
-                                   CvMemStorage* storage CV_DEFAULT(NULL));
-
-/** @brief Fits ellipse into a set of 2d points
-@see cv::fitEllipse
-*/
-CVAPI(CvBox2D) cvFitEllipse2( const CvArr* points );
-
-/** @brief Finds minimum rectangle containing two given rectangles */
-CVAPI(CvRect)  cvMaxRect( const CvRect* rect1, const CvRect* rect2 );
-
-/** @brief Finds coordinates of the box vertices */
-CVAPI(void) cvBoxPoints( CvBox2D box, CvPoint2D32f pt[4] );
-
-/** @brief Initializes sequence header for a matrix (column or row vector) of points
-
-   a wrapper for cvMakeSeqHeaderForArray (it does not initialize bounding rectangle!!!) */
-CVAPI(CvSeq*) cvPointSeqFromMat( int seq_kind, const CvArr* mat,
-                                 CvContour* contour_header,
-                                 CvSeqBlock* block );
-
-/** @brief Checks whether the point is inside polygon, outside, on an edge (at a vertex).
-
-   Returns positive, negative or zero value, correspondingly.
-   Optionally, measures a signed distance between
-   the point and the nearest polygon edge (measure_dist=1)
-@see cv::pointPolygonTest
-*/
-CVAPI(double) cvPointPolygonTest( const CvArr* contour,
-                                  CvPoint2D32f pt, int measure_dist );
-
-/****************************************************************************************\
-*                                  Histogram functions                                   *
-\****************************************************************************************/
-
-/** @brief Creates a histogram.
-
-The function creates a histogram of the specified size and returns a pointer to the created
-histogram. If the array ranges is 0, the histogram bin ranges must be specified later via the
-function cvSetHistBinRanges. Though cvCalcHist and cvCalcBackProject may process 8-bit images
-without setting bin ranges, they assume they are equally spaced in 0 to 255 bins.
-
-@param dims Number of histogram dimensions.
-@param sizes Array of the histogram dimension sizes.
-@param type Histogram representation format. CV_HIST_ARRAY means that the histogram data is
-represented as a multi-dimensional dense array CvMatND. CV_HIST_SPARSE means that histogram data
-is represented as a multi-dimensional sparse array CvSparseMat.
-@param ranges Array of ranges for the histogram bins. Its meaning depends on the uniform parameter
-value. The ranges are used when the histogram is calculated or backprojected to determine which
-histogram bin corresponds to which value/tuple of values from the input image(s).
-@param uniform Uniformity flag. If not zero, the histogram has evenly spaced bins and for every
-\f$0<=i<cDims\f$ ranges[i] is an array of two numbers: lower and upper boundaries for the i-th
-histogram dimension. The whole range [lower,upper] is then split into dims[i] equal parts to
-determine the i-th input tuple value ranges for every histogram bin. And if uniform=0 , then the
-i-th element of the ranges array contains dims[i]+1 elements: \f$\texttt{lower}_0,
-\texttt{upper}_0, \texttt{lower}_1, \texttt{upper}_1 = \texttt{lower}_2,
-...
-\texttt{upper}_{dims[i]-1}\f$ where \f$\texttt{lower}_j\f$ and \f$\texttt{upper}_j\f$ are lower
-and upper boundaries of the i-th input tuple value for the j-th bin, respectively. In either
-case, the input values that are beyond the specified range for a histogram bin are not counted
-by cvCalcHist and filled with 0 by cvCalcBackProject.
- */
-CVAPI(CvHistogram*)  cvCreateHist( int dims, int* sizes, int type,
-                                   float** ranges CV_DEFAULT(NULL),
-                                   int uniform CV_DEFAULT(1));
-
-/** @brief Sets the bounds of the histogram bins.
-
-This is a standalone function for setting bin ranges in the histogram. For a more detailed
-description of the parameters ranges and uniform, see the :ocvCalcHist function that can initialize
-the ranges as well. Ranges for the histogram bins must be set before the histogram is calculated or
-the backproject of the histogram is calculated.
-
-@param hist Histogram.
-@param ranges Array of bin ranges arrays. See :ocvCreateHist for details.
-@param uniform Uniformity flag. See :ocvCreateHist for details.
- */
-CVAPI(void)  cvSetHistBinRanges( CvHistogram* hist, float** ranges,
-                                int uniform CV_DEFAULT(1));
-
-/** @brief Makes a histogram out of an array.
-
-The function initializes the histogram, whose header and bins are allocated by the user.
-cvReleaseHist does not need to be called afterwards. Only dense histograms can be initialized this
-way. The function returns hist.
-
-@param dims Number of the histogram dimensions.
-@param sizes Array of the histogram dimension sizes.
-@param hist Histogram header initialized by the function.
-@param data Array used to store histogram bins.
-@param ranges Histogram bin ranges. See cvCreateHist for details.
-@param uniform Uniformity flag. See cvCreateHist for details.
- */
-CVAPI(CvHistogram*)  cvMakeHistHeaderForArray(
-                            int  dims, int* sizes, CvHistogram* hist,
-                            float* data, float** ranges CV_DEFAULT(NULL),
-                            int uniform CV_DEFAULT(1));
-
-/** @brief Releases the histogram.
-
-The function releases the histogram (header and the data). The pointer to the histogram is cleared
-by the function. If \*hist pointer is already NULL, the function does nothing.
-
-@param hist Double pointer to the released histogram.
- */
-CVAPI(void)  cvReleaseHist( CvHistogram** hist );
-
-/** @brief Clears the histogram.
-
-The function sets all of the histogram bins to 0 in case of a dense histogram and removes all
-histogram bins in case of a sparse array.
-
-@param hist Histogram.
- */
-CVAPI(void)  cvClearHist( CvHistogram* hist );
-
-/** @brief Finds the minimum and maximum histogram bins.
-
-The function finds the minimum and maximum histogram bins and their positions. All of output
-arguments are optional. Among several extremas with the same value the ones with the minimum index
-(in the lexicographical order) are returned. In case of several maximums or minimums, the earliest
-in the lexicographical order (extrema locations) is returned.
-
-@param hist Histogram.
-@param min_value Pointer to the minimum value of the histogram.
-@param max_value Pointer to the maximum value of the histogram.
-@param min_idx Pointer to the array of coordinates for the minimum.
-@param max_idx Pointer to the array of coordinates for the maximum.
- */
-CVAPI(void)  cvGetMinMaxHistValue( const CvHistogram* hist,
-                                   float* min_value, float* max_value,
-                                   int* min_idx CV_DEFAULT(NULL),
-                                   int* max_idx CV_DEFAULT(NULL));
-
-
-/** @brief Normalizes the histogram.
-
-The function normalizes the histogram bins by scaling them so that the sum of the bins becomes equal
-to factor.
-
-@param hist Pointer to the histogram.
-@param factor Normalization factor.
- */
-CVAPI(void)  cvNormalizeHist( CvHistogram* hist, double factor );
-
-
-/** @brief Thresholds the histogram.
-
-The function clears histogram bins that are below the specified threshold.
-
-@param hist Pointer to the histogram.
-@param threshold Threshold level.
- */
-CVAPI(void)  cvThreshHist( CvHistogram* hist, double threshold );
-
-
-/** Compares two histogram */
-CVAPI(double)  cvCompareHist( const CvHistogram* hist1,
-                              const CvHistogram* hist2,
-                              int method);
-
-/** @brief Copies a histogram.
-
-The function makes a copy of the histogram. If the second histogram pointer \*dst is NULL, a new
-histogram of the same size as src is created. Otherwise, both histograms must have equal types and
-sizes. Then the function copies the bin values of the source histogram to the destination histogram
-and sets the same bin value ranges as in src.
-
-@param src Source histogram.
-@param dst Pointer to the destination histogram.
- */
-CVAPI(void)  cvCopyHist( const CvHistogram* src, CvHistogram** dst );
-
-
-/** @brief Calculates bayesian probabilistic histograms
-   (each or src and dst is an array of _number_ histograms */
-CVAPI(void)  cvCalcBayesianProb( CvHistogram** src, int number,
-                                CvHistogram** dst);
-
-/** @brief Calculates array histogram
-@see cv::calcHist
-*/
-CVAPI(void)  cvCalcArrHist( CvArr** arr, CvHistogram* hist,
-                            int accumulate CV_DEFAULT(0),
-                            const CvArr* mask CV_DEFAULT(NULL) );
-
-/** @overload */
-CV_INLINE  void  cvCalcHist( IplImage** image, CvHistogram* hist,
-                             int accumulate CV_DEFAULT(0),
-                             const CvArr* mask CV_DEFAULT(NULL) )
-{
-    cvCalcArrHist( (CvArr**)image, hist, accumulate, mask );
-}
-
-/** @brief Calculates back project
-@see cvCalcBackProject, cv::calcBackProject
-*/
-CVAPI(void)  cvCalcArrBackProject( CvArr** image, CvArr* dst,
-                                   const CvHistogram* hist );
-
-#define  cvCalcBackProject(image, dst, hist) cvCalcArrBackProject((CvArr**)image, dst, hist)
-
-
-/** @brief Locates a template within an image by using a histogram comparison.
-
-The function calculates the back projection by comparing histograms of the source image patches with
-the given histogram. The function is similar to matchTemplate, but instead of comparing the raster
-patch with all its possible positions within the search window, the function CalcBackProjectPatch
-compares histograms. See the algorithm diagram below:
-
-![image](pics/backprojectpatch.png)
-
-@param image Source images (though, you may pass CvMat\*\* as well).
-@param dst Destination image.
-@param range
-@param hist Histogram.
-@param method Comparison method passed to cvCompareHist (see the function description).
-@param factor Normalization factor for histograms that affects the normalization scale of the
-destination image. Pass 1 if not sure.
-
-@see cvCalcBackProjectPatch
- */
-CVAPI(void)  cvCalcArrBackProjectPatch( CvArr** image, CvArr* dst, CvSize range,
-                                        CvHistogram* hist, int method,
-                                        double factor );
-
-#define  cvCalcBackProjectPatch( image, dst, range, hist, method, factor ) \
-     cvCalcArrBackProjectPatch( (CvArr**)image, dst, range, hist, method, factor )
-
-
-/** @brief Divides one histogram by another.
-
-The function calculates the object probability density from two histograms as:
-
-\f[\texttt{disthist} (I)= \forkthree{0}{if \(\texttt{hist1}(I)=0\)}{\texttt{scale}}{if \(\texttt{hist1}(I) \ne 0\) and \(\texttt{hist2}(I) > \texttt{hist1}(I)\)}{\frac{\texttt{hist2}(I) \cdot \texttt{scale}}{\texttt{hist1}(I)}}{if \(\texttt{hist1}(I) \ne 0\) and \(\texttt{hist2}(I) \le \texttt{hist1}(I)\)}\f]
-
-@param hist1 First histogram (the divisor).
-@param hist2 Second histogram.
-@param dst_hist Destination histogram.
-@param scale Scale factor for the destination histogram.
- */
-CVAPI(void)  cvCalcProbDensity( const CvHistogram* hist1, const CvHistogram* hist2,
-                                CvHistogram* dst_hist, double scale CV_DEFAULT(255) );
-
-/** @brief equalizes histogram of 8-bit single-channel image
-@see cv::equalizeHist
-*/
-CVAPI(void)  cvEqualizeHist( const CvArr* src, CvArr* dst );
-
-
-/** @brief Applies distance transform to binary image
-@see cv::distanceTransform
-*/
-CVAPI(void)  cvDistTransform( const CvArr* src, CvArr* dst,
-                              int distance_type CV_DEFAULT(CV_DIST_L2),
-                              int mask_size CV_DEFAULT(3),
-                              const float* mask CV_DEFAULT(NULL),
-                              CvArr* labels CV_DEFAULT(NULL),
-                              int labelType CV_DEFAULT(CV_DIST_LABEL_CCOMP));
-
-
-/** @brief Applies fixed-level threshold to grayscale image.
-
-   This is a basic operation applied before retrieving contours
-@see cv::threshold
-*/
-CVAPI(double)  cvThreshold( const CvArr*  src, CvArr*  dst,
-                            double  threshold, double  max_value,
-                            int threshold_type );
-
-/** @brief Applies adaptive threshold to grayscale image.
-
-   The two parameters for methods CV_ADAPTIVE_THRESH_MEAN_C and
-   CV_ADAPTIVE_THRESH_GAUSSIAN_C are:
-   neighborhood size (3, 5, 7 etc.),
-   and a constant subtracted from mean (...,-3,-2,-1,0,1,2,3,...)
-@see cv::adaptiveThreshold
-*/
-CVAPI(void)  cvAdaptiveThreshold( const CvArr* src, CvArr* dst, double max_value,
-                                  int adaptive_method CV_DEFAULT(CV_ADAPTIVE_THRESH_MEAN_C),
-                                  int threshold_type CV_DEFAULT(CV_THRESH_BINARY),
-                                  int block_size CV_DEFAULT(3),
-                                  double param1 CV_DEFAULT(5));
-
-/** @brief Fills the connected component until the color difference gets large enough
-@see cv::floodFill
-*/
-CVAPI(void)  cvFloodFill( CvArr* image, CvPoint seed_point,
-                          CvScalar new_val, CvScalar lo_diff CV_DEFAULT(cvScalarAll(0)),
-                          CvScalar up_diff CV_DEFAULT(cvScalarAll(0)),
-                          CvConnectedComp* comp CV_DEFAULT(NULL),
-                          int flags CV_DEFAULT(4),
-                          CvArr* mask CV_DEFAULT(NULL));
-
-/****************************************************************************************\
-*                                  Feature detection                                     *
-\****************************************************************************************/
-
-/** @brief Runs canny edge detector
-@see cv::Canny
-*/
-CVAPI(void)  cvCanny( const CvArr* image, CvArr* edges, double threshold1,
-                      double threshold2, int  aperture_size CV_DEFAULT(3) );
-
-/** @brief Calculates constraint image for corner detection
-
-   Dx^2 * Dyy + Dxx * Dy^2 - 2 * Dx * Dy * Dxy.
-   Applying threshold to the result gives coordinates of corners
-@see cv::preCornerDetect
-*/
-CVAPI(void) cvPreCornerDetect( const CvArr* image, CvArr* corners,
-                               int aperture_size CV_DEFAULT(3) );
-
-/** @brief Calculates eigen values and vectors of 2x2
-   gradient covariation matrix at every image pixel
-@see cv::cornerEigenValsAndVecs
-*/
-CVAPI(void)  cvCornerEigenValsAndVecs( const CvArr* image, CvArr* eigenvv,
-                                       int block_size, int aperture_size CV_DEFAULT(3) );
-
-/** @brief Calculates minimal eigenvalue for 2x2 gradient covariation matrix at
-   every image pixel
-@see cv::cornerMinEigenVal
-*/
-CVAPI(void)  cvCornerMinEigenVal( const CvArr* image, CvArr* eigenval,
-                                  int block_size, int aperture_size CV_DEFAULT(3) );
-
-/** @brief Harris corner detector:
-
-   Calculates det(M) - k*(trace(M)^2), where M is 2x2 gradient covariation matrix for each pixel
-@see cv::cornerHarris
-*/
-CVAPI(void)  cvCornerHarris( const CvArr* image, CvArr* harris_response,
-                             int block_size, int aperture_size CV_DEFAULT(3),
-                             double k CV_DEFAULT(0.04) );
-
-/** @brief Adjust corner position using some sort of gradient search
-@see cv::cornerSubPix
-*/
-CVAPI(void)  cvFindCornerSubPix( const CvArr* image, CvPoint2D32f* corners,
-                                 int count, CvSize win, CvSize zero_zone,
-                                 CvTermCriteria  criteria );
-
-/** @brief Finds a sparse set of points within the selected region
-   that seem to be easy to track
-@see cv::goodFeaturesToTrack
-*/
-CVAPI(void)  cvGoodFeaturesToTrack( const CvArr* image, CvArr* eig_image,
-                                    CvArr* temp_image, CvPoint2D32f* corners,
-                                    int* corner_count, double  quality_level,
-                                    double  min_distance,
-                                    const CvArr* mask CV_DEFAULT(NULL),
-                                    int block_size CV_DEFAULT(3),
-                                    int use_harris CV_DEFAULT(0),
-                                    double k CV_DEFAULT(0.04) );
-
-/** @brief Finds lines on binary image using one of several methods.
-
-   line_storage is either memory storage or 1 x _max number of lines_ CvMat, its
-   number of columns is changed by the function.
-   method is one of CV_HOUGH_*;
-   rho, theta and threshold are used for each of those methods;
-   param1 ~ line length, param2 ~ line gap - for probabilistic,
-   param1 ~ srn, param2 ~ stn - for multi-scale
-@see cv::HoughLines
-*/
-CVAPI(CvSeq*)  cvHoughLines2( CvArr* image, void* line_storage, int method,
-                              double rho, double theta, int threshold,
-                              double param1 CV_DEFAULT(0), double param2 CV_DEFAULT(0),
-                              double min_theta CV_DEFAULT(0), double max_theta CV_DEFAULT(CV_PI));
-
-/** @brief Finds circles in the image
-@see cv::HoughCircles
-*/
-CVAPI(CvSeq*) cvHoughCircles( CvArr* image, void* circle_storage,
-                              int method, double dp, double min_dist,
-                              double param1 CV_DEFAULT(100),
-                              double param2 CV_DEFAULT(100),
-                              int min_radius CV_DEFAULT(0),
-                              int max_radius CV_DEFAULT(0));
-
-/** @brief Fits a line into set of 2d or 3d points in a robust way (M-estimator technique)
-@see cv::fitLine
-*/
-CVAPI(void)  cvFitLine( const CvArr* points, int dist_type, double param,
-                        double reps, double aeps, float* line );
-
-/****************************************************************************************\
-*                                     Drawing                                            *
-\****************************************************************************************/
-
-/****************************************************************************************\
-*       Drawing functions work with images/matrices of arbitrary type.                   *
-*       For color images the channel order is BGR[A]                                     *
-*       Antialiasing is supported only for 8-bit image now.                              *
-*       All the functions include parameter color that means rgb value (that may be      *
-*       constructed with CV_RGB macro) for color images and brightness                   *
-*       for grayscale images.                                                            *
-*       If a drawn figure is partially or completely outside of the image, it is clipped.*
-\****************************************************************************************/
-
-#define CV_FILLED -1
-
-#define CV_AA 16
-
-/** @brief Draws 4-connected, 8-connected or antialiased line segment connecting two points
-@see cv::line
-*/
-CVAPI(void)  cvLine( CvArr* img, CvPoint pt1, CvPoint pt2,
-                     CvScalar color, int thickness CV_DEFAULT(1),
-                     int line_type CV_DEFAULT(8), int shift CV_DEFAULT(0) );
-
-/** @brief Draws a rectangle given two opposite corners of the rectangle (pt1 & pt2)
-
-   if thickness<0 (e.g. thickness == CV_FILLED), the filled box is drawn
-@see cv::rectangle
-*/
-CVAPI(void)  cvRectangle( CvArr* img, CvPoint pt1, CvPoint pt2,
-                          CvScalar color, int thickness CV_DEFAULT(1),
-                          int line_type CV_DEFAULT(8),
-                          int shift CV_DEFAULT(0));
-
-/** @brief Draws a rectangle specified by a CvRect structure
-@see cv::rectangle
-*/
-CVAPI(void)  cvRectangleR( CvArr* img, CvRect r,
-                           CvScalar color, int thickness CV_DEFAULT(1),
-                           int line_type CV_DEFAULT(8),
-                           int shift CV_DEFAULT(0));
-
-
-/** @brief Draws a circle with specified center and radius.
-
-   Thickness works in the same way as with cvRectangle
-@see cv::circle
-*/
-CVAPI(void)  cvCircle( CvArr* img, CvPoint center, int radius,
-                       CvScalar color, int thickness CV_DEFAULT(1),
-                       int line_type CV_DEFAULT(8), int shift CV_DEFAULT(0));
-
-/** @brief Draws ellipse outline, filled ellipse, elliptic arc or filled elliptic sector
-
-   depending on _thickness_, _start_angle_ and _end_angle_ parameters. The resultant figure
-   is rotated by _angle_. All the angles are in degrees
-@see cv::ellipse
-*/
-CVAPI(void)  cvEllipse( CvArr* img, CvPoint center, CvSize axes,
-                        double angle, double start_angle, double end_angle,
-                        CvScalar color, int thickness CV_DEFAULT(1),
-                        int line_type CV_DEFAULT(8), int shift CV_DEFAULT(0));
-
-CV_INLINE  void  cvEllipseBox( CvArr* img, CvBox2D box, CvScalar color,
-                               int thickness CV_DEFAULT(1),
-                               int line_type CV_DEFAULT(8), int shift CV_DEFAULT(0) )
-{
-    CvSize axes = cvSize(
-        cvRound(box.size.width*0.5),
-        cvRound(box.size.height*0.5)
-    );
-
-    cvEllipse( img, cvPointFrom32f( box.center ), axes, box.angle,
-               0, 360, color, thickness, line_type, shift );
-}
-
-/** @brief Fills convex or monotonous polygon.
-@see cv::fillConvexPoly
-*/
-CVAPI(void)  cvFillConvexPoly( CvArr* img, const CvPoint* pts, int npts, CvScalar color,
-                               int line_type CV_DEFAULT(8), int shift CV_DEFAULT(0));
-
-/** @brief Fills an area bounded by one or more arbitrary polygons
-@see cv::fillPoly
-*/
-CVAPI(void)  cvFillPoly( CvArr* img, CvPoint** pts, const int* npts,
-                         int contours, CvScalar color,
-                         int line_type CV_DEFAULT(8), int shift CV_DEFAULT(0) );
-
-/** @brief Draws one or more polygonal curves
-@see cv::polylines
-*/
-CVAPI(void)  cvPolyLine( CvArr* img, CvPoint** pts, const int* npts, int contours,
-                         int is_closed, CvScalar color, int thickness CV_DEFAULT(1),
-                         int line_type CV_DEFAULT(8), int shift CV_DEFAULT(0) );
-
-#define cvDrawRect cvRectangle
-#define cvDrawLine cvLine
-#define cvDrawCircle cvCircle
-#define cvDrawEllipse cvEllipse
-#define cvDrawPolyLine cvPolyLine
-
-/** @brief Clips the line segment connecting *pt1 and *pt2
-   by the rectangular window
-
-   (0<=x<img_size.width, 0<=y<img_size.height).
-@see cv::clipLine
-*/
-CVAPI(int) cvClipLine( CvSize img_size, CvPoint* pt1, CvPoint* pt2 );
-
-/** @brief Initializes line iterator.
-
-Initially, line_iterator->ptr will point to pt1 (or pt2, see left_to_right description) location in
-the image. Returns the number of pixels on the line between the ending points.
-@see cv::LineIterator
-*/
-CVAPI(int)  cvInitLineIterator( const CvArr* image, CvPoint pt1, CvPoint pt2,
-                                CvLineIterator* line_iterator,
-                                int connectivity CV_DEFAULT(8),
-                                int left_to_right CV_DEFAULT(0));
-
-#define CV_NEXT_LINE_POINT( line_iterator )                     \
-{                                                               \
-    int _line_iterator_mask = (line_iterator).err < 0 ? -1 : 0; \
-    (line_iterator).err += (line_iterator).minus_delta +        \
-        ((line_iterator).plus_delta & _line_iterator_mask);     \
-    (line_iterator).ptr += (line_iterator).minus_step +         \
-        ((line_iterator).plus_step & _line_iterator_mask);      \
-}
-
-
-#define CV_FONT_HERSHEY_SIMPLEX         0
-#define CV_FONT_HERSHEY_PLAIN           1
-#define CV_FONT_HERSHEY_DUPLEX          2
-#define CV_FONT_HERSHEY_COMPLEX         3
-#define CV_FONT_HERSHEY_TRIPLEX         4
-#define CV_FONT_HERSHEY_COMPLEX_SMALL   5
-#define CV_FONT_HERSHEY_SCRIPT_SIMPLEX  6
-#define CV_FONT_HERSHEY_SCRIPT_COMPLEX  7
-
-#define CV_FONT_ITALIC                 16
-
-#define CV_FONT_VECTOR0    CV_FONT_HERSHEY_SIMPLEX
-
-
-/** Font structure */
-typedef struct CvFont
-{
-  const char* nameFont;   //Qt:nameFont
-  CvScalar color;       //Qt:ColorFont -> cvScalar(blue_component, green_component, red_component[, alpha_component])
-    int         font_face;    //Qt: bool italic         /** =CV_FONT_* */
-    const int*  ascii;      //!< font data and metrics
-    const int*  greek;
-    const int*  cyrillic;
-    float       hscale, vscale;
-    float       shear;      //!< slope coefficient: 0 - normal, >0 - italic
-    int         thickness;    //!< Qt: weight               /** letters thickness */
-    float       dx;       //!< horizontal interval between letters
-    int         line_type;    //!< Qt: PointSize
-}
-CvFont;
-
-/** @brief Initializes font structure (OpenCV 1.x API).
-
-The function initializes the font structure that can be passed to text rendering functions.
-
-@param font Pointer to the font structure initialized by the function
-@param font_face Font name identifier. See cv::HersheyFonts and corresponding old CV_* identifiers.
-@param hscale Horizontal scale. If equal to 1.0f , the characters have the original width
-depending on the font type. If equal to 0.5f , the characters are of half the original width.
-@param vscale Vertical scale. If equal to 1.0f , the characters have the original height depending
-on the font type. If equal to 0.5f , the characters are of half the original height.
-@param shear Approximate tangent of the character slope relative to the vertical line. A zero
-value means a non-italic font, 1.0f means about a 45 degree slope, etc.
-@param thickness Thickness of the text strokes
-@param line_type Type of the strokes, see line description
-
-@sa cvPutText
- */
-CVAPI(void)  cvInitFont( CvFont* font, int font_face,
-                         double hscale, double vscale,
-                         double shear CV_DEFAULT(0),
-                         int thickness CV_DEFAULT(1),
-                         int line_type CV_DEFAULT(8));
-
-CV_INLINE CvFont cvFont( double scale, int thickness CV_DEFAULT(1) )
-{
-    CvFont font;
-    cvInitFont( &font, CV_FONT_HERSHEY_PLAIN, scale, scale, 0, thickness, CV_AA );
-    return font;
-}
-
-/** @brief Renders text stroke with specified font and color at specified location.
-   CvFont should be initialized with cvInitFont
-@see cvInitFont, cvGetTextSize, cvFont, cv::putText
-*/
-CVAPI(void)  cvPutText( CvArr* img, const char* text, CvPoint org,
-                        const CvFont* font, CvScalar color );
-
-/** @brief Calculates bounding box of text stroke (useful for alignment)
-@see cv::getTextSize
-*/
-CVAPI(void)  cvGetTextSize( const char* text_string, const CvFont* font,
-                            CvSize* text_size, int* baseline );
-
-/** @brief Unpacks color value
-
-if arrtype is CV_8UC?, _color_ is treated as packed color value, otherwise the first channels
-(depending on arrtype) of destination scalar are set to the same value = _color_
-*/
-CVAPI(CvScalar)  cvColorToScalar( double packed_color, int arrtype );
-
-/** @brief Returns the polygon points which make up the given ellipse.
-
-The ellipse is define by the box of size 'axes' rotated 'angle' around the 'center'. A partial
-sweep of the ellipse arc can be done by specifying arc_start and arc_end to be something other than
-0 and 360, respectively. The input array 'pts' must be large enough to hold the result. The total
-number of points stored into 'pts' is returned by this function.
-@see cv::ellipse2Poly
-*/
-CVAPI(int) cvEllipse2Poly( CvPoint center, CvSize axes,
-                 int angle, int arc_start, int arc_end, CvPoint * pts, int delta );
-
-/** @brief Draws contour outlines or filled interiors on the image
-@see cv::drawContours
-*/
-CVAPI(void)  cvDrawContours( CvArr *img, CvSeq* contour,
-                             CvScalar external_color, CvScalar hole_color,
-                             int max_level, int thickness CV_DEFAULT(1),
-                             int line_type CV_DEFAULT(8),
-                             CvPoint offset CV_DEFAULT(cvPoint(0,0)));
-
-/** @} */
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif