OpenCV学习笔记四：ImgProc模块
一，简介
这个模块包含一系列的常用图像处理算法。
二，分析
此模块包含的文件如下图：
其导出算法包括如下：
/*********************** 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 boundning 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 );
------------------------------------------------------------------------------------------------------
头文件：
types_c.h ， 定义了连通区域结构CvConnectedComp，平滑算法ID，颜色空间转换ID，像素插值算法ID，形状类型ID（RECT,CROSS等），形态学算法ID，中心矩/空间矩结构CvMoments，CvHuMoments，模板匹配类型ID，轮廓，形状匹配算法ID，直方图比较算法ID，二值化算法ID，泛洪算法类型，边缘检测，hough变换算法ID；
imgporc_c.h ，C/C++兼容头文件，其定义见上述函数列表；
imgproc.hpp，C++ only头文件，其定义参考imgproc_c.h
------------------------------------------------------------------------------------------------------
实现文件：
实现文件内容与文件名匹配，诸多算法均在其中一一有实现，目前不做具体分析。
------------------------------------------------------------------------------------------------------
三，总结
opencv包含常见的颜色空间转换，图像缩放，形态学操作等基本图像处理算法；也包含二值化，边缘检测，模板匹配，轮廓检测，直方图，泛洪，hough变换等高级主题。可在需要时研究相关实现，或者向其中添加所需算法。作为一个图像处理包，经过优化测试之后可应用于实际工业环境中。