/*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/core/core_c.h"
#include "opencv2/imgproc/types_c.h"
#ifdef __cplusplus
extern "C" {
#endif
/*********************** Background statistics accumulation *****************************/
/* Adds image to accumulator */
CVAPI(void) cvAcc( const CvArr* image, CvArr* sum,
const CvArr* mask CV_DEFAULT(NULL) );
/* Adds squared image to accumulator */
CVAPI(void) cvSquareAcc( const CvArr* image, CvArr* sqsum,
const CvArr* mask CV_DEFAULT(NULL) );
/* Adds a product of two images to accumulator */
CVAPI(void) cvMultiplyAcc( const CvArr* image1, const CvArr* image2, CvArr* acc,
const CvArr* mask CV_DEFAULT(NULL) );
/* Adds image to accumulator with weights: acc = acc*(1-alpha) + image*alpha */
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)));
/* Smoothes array (removes noise) */
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));
/* Convolves the image with the kernel */
CVAPI(void) cvFilter2D( const CvArr* src, CvArr* dst, const CvMat* kernel,
CvPoint anchor CV_DEFAULT(cvPoint(-1,-1)));
/* Finds integral image: SUM(X,Y) = sum(x<X,y<Y)I(x,y) */
CVAPI(void) cvIntegral( const CvArr* image, CvArr* sum,
CvArr* sqsum CV_DEFAULT(NULL),
CvArr* tilted_sum CV_DEFAULT(NULL));
/*
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]
*/
CVAPI(void) cvPyrDown( const CvArr* src, CvArr* dst,
int filter CV_DEFAULT(CV_GAUSSIAN_5x5) );
/*
Up-samples image and smoothes the result with gaussian kernel.
dst_width = src_width*2,
dst_height = src_height*2
*/
CVAPI(void) cvPyrUp( const CvArr* src, CvArr* dst,
int filter CV_DEFAULT(CV_GAUSSIAN_5x5) );
/* Builds pyramid for an image */
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) );
/* Releases pyramid */
CVAPI(void) cvReleasePyramid( CvMat*** pyramid, int extra_layers );
/* Filters image using meanshift algorithm */
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)));
/* Segments image using seed "markers" */
CVAPI(void) cvWatershed( const CvArr* image, CvArr* markers );
/* 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 */
CVAPI(void) cvSobel( const CvArr* src, CvArr* dst,
int xorder, int yorder,
int aperture_size CV_DEFAULT(3));
/* Calculates the image Laplacian: (d2/dx + d2/dy)I */
CVAPI(void) cvLaplace( const CvArr* src, CvArr* dst,
int aperture_size CV_DEFAULT(3) );
/* Converts input array pixels from one color space to another */
CVAPI(void) cvCvtColor( const CvArr* src, CvArr* dst, int code );
/* Resizes image (input array is resized to fit the destination array) */
CVAPI(void) cvResize( const CvArr* src, CvArr* dst,
int interpolation CV_DEFAULT( CV_INTER_LINEAR ));
/* Warps image with affine transform */
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)) );
/* Computes affine transform matrix for mapping src[i] to dst[i] (i=0,1,2) */
CVAPI(CvMat*) cvGetAffineTransform( const CvPoint2D32f * src,
const CvPoint2D32f * dst,
CvMat * map_matrix );
/* Computes rotation_matrix matrix */
CVAPI(CvMat*) cv2DRotationMatrix( CvPoint2D32f center, double angle,
double scale, CvMat* map_matrix );
/* Warps image with perspective (projective) transform */
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)) );
/* Computes perspective transform matrix for mapping src[i] to dst[i] (i=0,1,2,3) */
CVAPI(CvMat*) cvGetPerspectiveTransform( const CvPoint2D32f* src,
const CvPoint2D32f* dst,
CvMat* map_matrix );
/* Performs generic geometric transformation using the specified coordinate maps */
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)) );
/* Converts mapx & mapy from floating-point to integer formats for cvRemap */
CVAPI(void) cvConvertMaps( const CvArr* mapx, const CvArr* mapy,
CvArr* mapxy, CvArr* mapalpha );
/* Performs forward or inverse log-polar image transform */
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 */
CVAPI(void) cvLinearPolar( const CvArr* src, CvArr* dst,
CvPoint2D32f center, double maxRadius,
int flags CV_DEFAULT(CV_INTER_LINEAR+CV_WARP_FILL_OUTLIERS));
/* Transforms the input image to compensate lens distortion */
CVAPI(void) cvUndistort2( const CvArr* src, CvArr* dst,
const CvMat* camera_matrix,
const CvMat* distortion_coeffs,
const CvMat* new_camera_matrix CV_DEFAULT(0) );
/* 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 );
/* Computes undistortion+rectification map for a head of stereo camera */
CVAPI(void) cvInitUndistortRectifyMap( const CvMat* camera_matrix,
const CvMat* dist_coeffs,
const CvMat *R, const CvMat* new_camera_matrix,
CvArr* mapx, CvArr* mapy );
/* Computes the original (undistorted) feature coordinates
from the observed (distorted) coordinates */
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));
/* creates structuring element used for morphological operations */
CVAPI(IplConvKernel*) cvCreateStructuringElementEx(
int cols, int rows, int anchor_x, int anchor_y,
int shape, int* values CV_DEFAULT(NULL) );
/* releases structuring element */
CVAPI(void) cvReleaseStructuringElement( IplConvKernel** element );
/* erodes input image (applies minimum filter) one or more times.
If element pointer is NULL, 3x3 rectangular element is used */
CVAPI(void) cvErode( const CvArr* src, CvArr* dst,
IplConvKernel* element CV_DEFAULT(NULL),
int iterations CV_DEFAULT(1) );
/* dilates input image (applies maximum filter) one or more times.
If element pointer is NULL, 3x3 rectangular element is used */
CVAPI(void) cvDilate( const CvArr* src, CvArr* dst,
IplConvKernel* element CV_DEFAULT(NULL),
int iterations CV_DEFAULT(1) );
/* Performs complex morphological transformation */
CVAPI(void) cvMorphologyEx( const CvArr* src, CvArr* dst,
CvArr* temp, IplConvKernel* element,
int operation, int iterations CV_DEFAULT(1) );
/* Calculates all spatial and central moments up to the 3rd order */
CVAPI(void) cvMoments( const CvArr* arr, CvMoments* moments, int binary CV_DEFAULT(0));
/* Retrieve particular spatial, central or normalized central moments */
CVAPI(double) cvGetSpatialMoment( CvMoments* moments, int x_order, int y_order );
CVAPI(double) cvGetCentralMoment( CvMoments* moments, int x_order, int y_order );
CVAPI(double) cvGetNormalizedCentralMoment( CvMoments* moments,
int x_order, int y_order );
/* Calculates 7 Hu's invariants from precalculated spatial and central moments */
CVAPI(void) cvGetHuMoments( CvMoments* moments, CvHuMoments* hu_moments );
/*********************************** data sampling **************************************/
/* Fetches pixels that belong to the specified line segment and stores them to the buffer.
Returns the number of retrieved points. */
CVAPI(int) cvSampleLine( const CvArr* image, CvPoint pt1, CvPoint pt2, void* buffer,
int connectivity CV_DEFAULT(8));
/* 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*/
CVAPI(void) cvGetRectSubPix( const CvArr* src, CvArr* dst, CvPoint2D32f center );
/* 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)
*/
CVAPI(void) cvGetQuadrangleSubPix( const CvArr* src, CvArr* dst,
const CvMat* map_matrix );
/* Measures similarity between template and overlapped windows in the source image
and fills the resultant image with the measurements */
CVAPI(void) cvMatchTemplate( const CvArr* image, const CvArr* templ,
CvArr* result, int method );
/* Computes earth mover distance between
two weighted point sets (called signatures) */
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 *
\****************************************************************************************/
/* Retrieves outer and optionally inner boundaries of white (non-zero) connected
components in the black (zero) background */
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)));
/* Initalizes contour retrieving process.
Calls cvStartFindContours.
Calls cvFindNextContour until null pointer is returned
or some other condition becomes true.
Calls cvEndFindContours at the end. */
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)));
/* Retrieves next contour */
CVAPI(CvSeq*) cvFindNextContour( CvContourScanner scanner );
/* Substitutes the last retrieved contour with the new one
(if the substitutor is null, the last retrieved contour is removed from the tree) */
CVAPI(void) cvSubstituteContour( CvContourScanner scanner, CvSeq* new_contour );
/* Releases contour scanner and returns pointer to the first outer contour */
CVAPI(CvSeq*) cvEndFindContours( CvContourScanner* scanner );
/* Approximates a single Freeman chain or a tree of chains to polygonal curves */
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));
/* Initalizes 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 */
CVAPI(void) cvStartReadChainPoints( CvChain* chain, CvChainPtReader* reader );
/* Retrieves the next chain point */
CVAPI(CvPoint) cvReadChainPoint( CvChainPtReader* reader );
/****************************************************************************************\
* Contour Processing and Shape Analysis *
\****************************************************************************************/
/* Approximates a single polygonal curve (contour) or
a tree of polygonal curves (contours) */
CVAPI(CvSeq*) cvApproxPoly( const void* src_seq,
int header_size, CvMemStorage* storage,
int method, double eps,
int recursive CV_DEFAULT(0));
/* Calculates perimeter of a contour or length of a part of contour */
CVAPI(double) cvArcLength( const void* curve,
CvSlice slice CV_DEFAULT(CV_WHOLE_SEQ),
int is_closed CV_DEFAULT(-1));
CV_INLINE double cvContourPerimeter( const void* contour )
{
return cvArcLength( contour, CV_WHOLE_SEQ, 1 );
}
/* Calculates contour bounding rectangle (update=1) or
just retrieves pre-calculated rectangle (update=0) */
CVAPI(CvRect) cvBoundingRect( CvArr* points, int update CV_DEFAULT(0) );
/* Calculates area of a contour or contour segment */
CVAPI(double) cvContourArea( const CvArr* contour,
CvSlice slice CV_DEFAULT(CV_WHOLE_SEQ),
int oriented CV_DEFAULT(0));
/* Finds minimum area rotated rectangle bounding a set of points */
CVAPI(CvBox2D) cvMinAreaRect2( const CvArr* points,
CvMemStorage* storage CV_DEFAULT(NULL));
/* Finds minimum enclosing circle for a set of points */
CVAPI(int) cvMinEnclosingCircle( const CvArr* points,
CvPoint2D32f* center, float* radius );
/* Compares two contours by matching their moments */
CVAPI(double) cvMatchShapes( const void* object1, const void* object2,
int method, double parameter CV_DEFAULT(0));
/* Calculates exact convex hull of 2d point set */
CVAPI(CvSeq*) cvConvexHull2( const CvArr* input,
void* hull_storage CV_DEFAULT(NULL),
int orientation CV_DEFAULT(CV_CLOCKWISE),
int return_points CV_DEFAULT(0));
/* Checks whether the contour is convex or not (returns 1 if convex, 0 if not) */
CVAPI(int) cvCheckContourConvexity( const CvArr* contour );
/* Finds convexity defects for the contour */
CVAPI(CvSeq*) cvConvexityDefects( const CvArr* contour, const CvArr* convexhull,
CvMemStorage* storage CV_DEFAULT(NULL));
/* Fits ellipse into a set of 2d points */
CVAPI(CvBox2D) cvFitEllipse2( const CvArr* points );
/* Finds minimum rectangle containing two given rectangles */
CVAPI(CvRect) cvMaxRect( const CvRect* rect1, const CvRect* rect2 );
/* Finds coordinates of the box vertices */
CVAPI(void) cvBoxPoints( CvBox2D box, CvPoint2D32f pt[4] );
/* 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 );
/* 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) */
CVAPI(double) cvPointPolygonTest( const CvArr* contour,
CvPoint2D32f pt, int measure_dist );
/****************************************************************************************\
* Histogram functions *
\****************************************************************************************/
/* Creates new histogram */
CVAPI(CvHistogram*) cvCreateHist( int dims, int* sizes, int type,
float** ranges CV_DEFAULT(NULL),
int uniform CV_DEFAULT(1));
/* Assignes histogram bin ranges */
CVAPI(void) cvSetHistBinRanges( CvHistogram* hist, float** ranges,
int uniform CV_DEFAULT(1));
/* Creates histogram header for array */
CVAPI(CvHistogram*) cvMakeHistHeaderForArray(
int dims, int* sizes, CvHistogram* hist,
float* data, float** ranges CV_DEFAULT(NULL),
int uniform CV_DEFAULT(1));
/* Releases histogram */
CVAPI(void) cvReleaseHist( CvHistogram** hist );
/* Clears all the histogram bins */
CVAPI(void) cvClearHist( CvHistogram* hist );
/* Finds indices and values of minimum and maximum histogram bins */
CVAPI(void) cvGetMinMaxHistValue( const CvHistogram* hist,
float* min_value, float* max_value,
int* min_idx CV_DEFAULT(NULL),
int* max_idx CV_DEFAULT(NULL));
/* Normalizes histogram by dividing all bins by sum of the bins, multiplied by <factor>.
After that sum of histogram bins is equal to <factor> */
CVAPI(void) cvNormalizeHist( CvHistogram* hist, double factor );
/* Clear all histogram bins that are below the threshold */
CVAPI(void) cvThreshHist( CvHistogram* hist, double threshold );
/* Compares two histogram */
CVAPI(double) cvCompareHist( const CvHistogram* hist1,
const CvHistogram* hist2,
int method);
/* Copies one histogram to another. Destination histogram is created if
the destination pointer is NULL */
CVAPI(void) cvCopyHist( const CvHistogram* src, CvHistogram** dst );
/* Calculates bayesian probabilistic histograms
(each or src and dst is an array of <number> histograms */
CVAPI(void) cvCalcBayesianProb( CvHistogram** src, int number,
CvHistogram** dst);
/* Calculates array histogram */
CVAPI(void) cvCalcArrHist( CvArr** arr, CvHistogram* hist,
int accumulate CV_DEFAULT(0),
const CvArr* mask CV_DEFAULT(NULL) );
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 );
}
/* Calculates back project */
CVAPI(void) cvCalcArrBackProject( CvArr** image, CvArr* dst,
const CvHistogram* hist );
#define cvCalcBackProject(image, dst, hist) cvCalcArrBackProject((CvArr**)image, dst, hist)
/* Does some sort of template matching but compares histograms of
template and each window location */
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 )
/* calculates probabilistic density (divides one histogram by another) */
CVAPI(void) cvCalcProbDensity( const CvHistogram* hist1, const CvHistogram* hist2,
CvHistogram* dst_hist, double scale CV_DEFAULT(255) );
/* equalizes histogram of 8-bit single-channel image */
CVAPI(void) cvEqualizeHist( const CvArr* src, CvArr* dst );
/* Applies distance transform to binary image */
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));
/* Applies fixed-level threshold to grayscale image.
This is a basic operation applied before retrieving contours */
CVAPI(double) cvThreshold( const CvArr* src, CvArr* dst,
double threshold, double max_value,
int threshold_type );
/* 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,...) */
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));
/* Fills the connected component until the color difference gets large enough */
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 *
\****************************************************************************************/
/* Runs canny edge detector */
CVAPI(void) cvCanny( const CvArr* image, CvArr* edges, double threshold1,
double threshold2, int aperture_size CV_DEFAULT(3) );
/* 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 */
CVAPI(void) cvPreCornerDetect( const CvArr* image, CvArr* corners,
int aperture_size CV_DEFAULT(3) );
/* Calculates eigen values and vectors of 2x2
gradient covariation matrix at every image pixel */
CVAPI(void) cvCornerEigenValsAndVecs( const CvArr* image, CvArr* eigenvv,
int block_size, int aperture_size CV_DEFAULT(3) );
/* Calculates minimal eigenvalue for 2x2 gradient covariation matrix at
every image pixel */
CVAPI(void) cvCornerMinEigenVal( const CvArr* image, CvArr* eigenval,
int block_size, int aperture_size CV_DEFAULT(3) );
/* Harris corner detector:
Calculates det(M) - k*(trace(M)^2), where M is 2x2 gradient covariation matrix for each pixel */
CVAPI(void) cvCornerHarris( const CvArr* image, CvArr* harris_responce,
int block_size, int aperture_size CV_DEFAULT(3),
double k CV_DEFAULT(0.04) );
/* Adjust corner position using some sort of gradient search */
CVAPI(void) cvFindCornerSubPix( const CvArr* image, CvPoint2D32f* corners,
int count, CvSize win, CvSize zero_zone,
CvTermCriteria criteria );
/* Finds a sparse set of points within the selected region
that seem to be easy to track */
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) );
/* 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 */
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));
/* Finds circles in the image */
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));
/* Fits a line into set of 2d or 3d points in a robust way (M-estimator technique) */
CVAPI(void) cvFitLine( const CvArr* points, int dist_type, double param,
double reps, double aeps, float* line );
#ifdef __cplusplus
}
#endif
#endif
Submit an article or tip