You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1210 lines
51 KiB
1210 lines
51 KiB
/*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 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_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 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
|
|
|