diff options
Diffstat (limited to 'thirdparty1/linux/include/opencv2/imgproc/imgproc_c.h')
| -rw-r--r-- | thirdparty1/linux/include/opencv2/imgproc/imgproc_c.h | 1210 |
1 files changed, 1210 insertions, 0 deletions
diff --git a/thirdparty1/linux/include/opencv2/imgproc/imgproc_c.h b/thirdparty1/linux/include/opencv2/imgproc/imgproc_c.h new file mode 100644 index 0000000..d11db4b --- /dev/null +++ b/thirdparty1/linux/include/opencv2/imgproc/imgproc_c.h @@ -0,0 +1,1210 @@ +/*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::logPolar +*/ +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::linearPolar +*/ +CVAPI(void) cvLinearPolar( const CvArr* src, CvArr* dst, + CvPoint2D32f center, double maxRadius, + int flags CV_DEFAULT(CV_INTER_LINEAR+CV_WARP_FILL_OUTLIERS)); + +/** @brief Transforms the input image to compensate lens distortion +@see cv::undistort +*/ +CVAPI(void) cvUndistort2( const CvArr* src, CvArr* dst, + const CvMat* camera_matrix, + const CvMat* distortion_coeffs, + const CvMat* new_camera_matrix CV_DEFAULT(0) ); + +/** @brief Computes transformation map from intrinsic camera parameters + that can used by cvRemap +*/ +CVAPI(void) cvInitUndistortMap( const CvMat* camera_matrix, + const CvMat* distortion_coeffs, + CvArr* mapx, CvArr* mapy ); + +/** @brief Computes undistortion+rectification map for a head of stereo camera +@see cv::initUndistortRectifyMap +*/ +CVAPI(void) cvInitUndistortRectifyMap( const CvMat* camera_matrix, + const CvMat* dist_coeffs, + const CvMat *R, const CvMat* new_camera_matrix, + CvArr* mapx, CvArr* mapy ); + +/** @brief Computes the original (undistorted) feature coordinates + from the observed (distorted) coordinates +@see cv::undistortPoints +*/ +CVAPI(void) cvUndistortPoints( const CvMat* src, CvMat* dst, + const CvMat* camera_matrix, + const CvMat* dist_coeffs, + const CvMat* R CV_DEFAULT(0), + const CvMat* P CV_DEFAULT(0)); + +/** @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: + + + +@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_RGB( r, g, b ) cvScalar( (b), (g), (r), 0 ) +#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; + axes.width = cvRound(box.size.width*0.5); + axes.height = 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 spcifying 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 |