- Main Page
- Related Pages
- Namespaces
- Classes
- Files

- File List
- File Members

# /usr/obj/OpenCV-2.2.0/OpenCV-2.2.0/modules/imgproc/include/opencv2/imgproc/imgproc_c.h

Go to the documentation of this file.

    00001 /*M///////////////////////////////////////////////////////////////////////////////////////
    00002 //
    00003 //  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
    00004 //
    00005 //  By downloading, copying, installing or using the software you agree to this license.
    00006 //  If you do not agree to this license, do not download, install,
    00007 //  copy or use the software.
    00008 //
    00009 //
    00010 //                           License Agreement
    00011 //                For Open Source Computer Vision Library
    00012 //
    00013 // Copyright (C) 2000-2008, Intel Corporation, all rights reserved.
    00014 // Copyright (C) 2009, Willow Garage Inc., all rights reserved.
    00015 // Third party copyrights are property of their respective owners.
    00016 //
    00017 // Redistribution and use in source and binary forms, with or without modification,
    00018 // are permitted provided that the following conditions are met:
    00019 //
    00020 //   * Redistribution's of source code must retain the above copyright notice,
    00021 //     this list of conditions and the following disclaimer.
    00022 //
    00023 //   * Redistribution's in binary form must reproduce the above copyright notice,
    00024 //     this list of conditions and the following disclaimer in the documentation
    00025 //     and/or other materials provided with the distribution.
    00026 //
    00027 //   * The name of the copyright holders may not be used to endorse or promote products
    00028 //     derived from this software without specific prior written permission.
    00029 //
    00030 // This software is provided by the copyright holders and contributors "as is" and
    00031 // any express or implied warranties, including, but not limited to, the implied
    00032 // warranties of merchantability and fitness for a particular purpose are disclaimed.
    00033 // In no event shall the Intel Corporation or contributors be liable for any direct,
    00034 // indirect, incidental, special, exemplary, or consequential damages
    00035 // (including, but not limited to, procurement of substitute goods or services;
    00036 // loss of use, data, or profits; or business interruption) however caused
    00037 // and on any theory of liability, whether in contract, strict liability,
    00038 // or tort (including negligence or otherwise) arising in any way out of
    00039 // the use of this software, even if advised of the possibility of such damage.
    00040 //
    00041 //M*/
    00042
    00043 #ifndef __OPENCV_IMGPROC_IMGPROC_C_H__
    00044 #define __OPENCV_IMGPROC_IMGPROC_C_H__
    00045
    00046 #include "opencv2/core/core_c.h"
    00047 #include "opencv2/imgproc/types_c.h"
    00048
    00049 #ifdef __cplusplus
    00050 extern "C" {
    00051 #endif
    00052
    00053 /*********************** Background statistics accumulation *****************************/
    00054
    00055 /* Adds image to accumulator */
    00056 CVAPI(void)  cvAcc( const CvArr* image, CvArr* sum,
    00057                    const CvArr* mask CV_DEFAULT(NULL) );
    00058
    00059 /* Adds squared image to accumulator */
    00060 CVAPI(void)  cvSquareAcc( const CvArr* image, CvArr* sqsum,
    00061                          const CvArr* mask CV_DEFAULT(NULL) );
    00062
    00063 /* Adds a product of two images to accumulator */
    00064 CVAPI(void)  cvMultiplyAcc( const CvArr* image1, const CvArr* image2, CvArr* acc,
    00065                            const CvArr* mask CV_DEFAULT(NULL) );
    00066
    00067 /* Adds image to accumulator with weights: acc = acc*(1-alpha) + image*alpha */
    00068 CVAPI(void)  cvRunningAvg( const CvArr* image, CvArr* acc, double alpha,
    00069                           const CvArr* mask CV_DEFAULT(NULL) );
    00070
    00071 /****************************************************************************************\
    00072 *                                    Image Processing                                    *
    00073 \****************************************************************************************/
    00074
    00075 /* Copies source 2D array inside of the larger destination array and
    00076    makes a border of the specified type (IPL_BORDER_*) around the copied area. */
    00077 CVAPI(void) cvCopyMakeBorder( const CvArr* src, CvArr* dst, CvPoint offset,
    00078                               int bordertype, CvScalar value CV_DEFAULT(cvScalarAll(0)));
    00079
    00080 /* Smoothes array (removes noise) */
    00081 CVAPI(void) cvSmooth( const CvArr* src, CvArr* dst,
    00082                       int smoothtype CV_DEFAULT(CV_GAUSSIAN),
    00083                       int size1 CV_DEFAULT(3),
    00084                       int size2 CV_DEFAULT(0),
    00085                       double sigma1 CV_DEFAULT(0),
    00086                       double sigma2 CV_DEFAULT(0));
    00087
    00088 /* Convolves the image with the kernel */
    00089 CVAPI(void) cvFilter2D( const CvArr* src, CvArr* dst, const CvMat* kernel,
    00090                         CvPoint anchor CV_DEFAULT(cvPoint(-1,-1)));
    00091
    00092 /* Finds integral image: SUM(X,Y) = sum(x<X,y<Y)I(x,y) */
    00093 CVAPI(void) cvIntegral( const CvArr* image, CvArr* sum,
    00094                        CvArr* sqsum CV_DEFAULT(NULL),
    00095                        CvArr* tilted_sum CV_DEFAULT(NULL));
    00096
    00097 /*
    00098    Smoothes the input image with gaussian kernel and then down-samples it.
    00099    dst_width = floor(src_width/2)[+1],
    00100    dst_height = floor(src_height/2)[+1]
    00101 */
    00102 CVAPI(void)  cvPyrDown( const CvArr* src, CvArr* dst,
    00103                         int filter CV_DEFAULT(CV_GAUSSIAN_5x5) );
    00104
    00105 /*
    00106    Up-samples image and smoothes the result with gaussian kernel.
    00107    dst_width = src_width*2,
    00108    dst_height = src_height*2
    00109 */
    00110 CVAPI(void)  cvPyrUp( const CvArr* src, CvArr* dst,
    00111                       int filter CV_DEFAULT(CV_GAUSSIAN_5x5) );
    00112
    00113 /* Builds pyramid for an image */
    00114 CVAPI(CvMat**) cvCreatePyramid( const CvArr* img, int extra_layers, double rate,
    00115                                 const CvSize* layer_sizes CV_DEFAULT(0),
    00116                                 CvArr* bufarr CV_DEFAULT(0),
    00117                                 int calc CV_DEFAULT(1),
    00118                                 int filter CV_DEFAULT(CV_GAUSSIAN_5x5) );
    00119
    00120 /* Releases pyramid */
    00121 CVAPI(void)  cvReleasePyramid( CvMat*** pyramid, int extra_layers );
    00122
    00123
    00124 /* Splits color or grayscale image into multiple connected components
    00125    of nearly the same color/brightness using modification of Burt algorithm.
    00126    comp with contain a pointer to sequence (CvSeq)
    00127    of connected components (CvConnectedComp) */
    00128 CVAPI(void) cvPyrSegmentation( IplImage* src, IplImage* dst,
    00129                               CvMemStorage* storage, CvSeq** comp,
    00130                               int level, double threshold1,
    00131                               double threshold2 );
    00132
    00133 /* Filters image using meanshift algorithm */
    00134 CVAPI(void) cvPyrMeanShiftFiltering( const CvArr* src, CvArr* dst,
    00135     double sp, double sr, int max_level CV_DEFAULT(1),
    00136     CvTermCriteria termcrit CV_DEFAULT(cvTermCriteria(CV_TERMCRIT_ITER+CV_TERMCRIT_EPS,5,1)));
    00137
    00138 /* Segments image using seed "markers" */
    00139 CVAPI(void) cvWatershed( const CvArr* image, CvArr* markers );
    00140
    00141 /* Inpaints the selected region in the image */
    00142 CVAPI(void) cvInpaint( const CvArr* src, const CvArr* inpaint_mask,
    00143                        CvArr* dst, double inpaintRange, int flags );
    00144
    00145 /* Calculates an image derivative using generalized Sobel
    00146    (aperture_size = 1,3,5,7) or Scharr (aperture_size = -1) operator.
    00147    Scharr can be used only for the first dx or dy derivative */
    00148 CVAPI(void) cvSobel( const CvArr* src, CvArr* dst,
    00149                     int xorder, int yorder,
    00150                     int aperture_size CV_DEFAULT(3));
    00151
    00152 /* Calculates the image Laplacian: (d2/dx + d2/dy)I */
    00153 CVAPI(void) cvLaplace( const CvArr* src, CvArr* dst,
    00154                       int aperture_size CV_DEFAULT(3) );
    00155
    00156 /* Converts input array pixels from one color space to another */
    00157 CVAPI(void)  cvCvtColor( const CvArr* src, CvArr* dst, int code );
    00158
    00159
    00160 /* Resizes image (input array is resized to fit the destination array) */
    00161 CVAPI(void)  cvResize( const CvArr* src, CvArr* dst,
    00162                        int interpolation CV_DEFAULT( CV_INTER_LINEAR ));
    00163
    00164 /* Warps image with affine transform */
    00165 CVAPI(void)  cvWarpAffine( const CvArr* src, CvArr* dst, const CvMat* map_matrix,
    00166                            int flags CV_DEFAULT(CV_INTER_LINEAR+CV_WARP_FILL_OUTLIERS),
    00167                            CvScalar fillval CV_DEFAULT(cvScalarAll(0)) );
    00168
    00169 /* Computes affine transform matrix for mapping src[i] to dst[i] (i=0,1,2) */
    00170 CVAPI(CvMat*) cvGetAffineTransform( const CvPoint2D32f * src,
    00171                                     const CvPoint2D32f * dst,
    00172                                     CvMat * map_matrix );
    00173
    00174 /* Computes rotation_matrix matrix */
    00175 CVAPI(CvMat*)  cv2DRotationMatrix( CvPoint2D32f center, double angle,
    00176                                    double scale, CvMat* map_matrix );
    00177
    00178 /* Warps image with perspective (projective) transform */
    00179 CVAPI(void)  cvWarpPerspective( const CvArr* src, CvArr* dst, const CvMat* map_matrix,
    00180                                 int flags CV_DEFAULT(CV_INTER_LINEAR+CV_WARP_FILL_OUTLIERS),
    00181                                 CvScalar fillval CV_DEFAULT(cvScalarAll(0)) );
    00182
    00183 /* Computes perspective transform matrix for mapping src[i] to dst[i] (i=0,1,2,3) */
    00184 CVAPI(CvMat*) cvGetPerspectiveTransform( const CvPoint2D32f* src,
    00185                                          const CvPoint2D32f* dst,
    00186                                          CvMat* map_matrix );
    00187
    00188 /* Performs generic geometric transformation using the specified coordinate maps */
    00189 CVAPI(void)  cvRemap( const CvArr* src, CvArr* dst,
    00190                       const CvArr* mapx, const CvArr* mapy,
    00191                       int flags CV_DEFAULT(CV_INTER_LINEAR+CV_WARP_FILL_OUTLIERS),
    00192                       CvScalar fillval CV_DEFAULT(cvScalarAll(0)) );
    00193
    00194 /* Converts mapx & mapy from floating-point to integer formats for cvRemap */
    00195 CVAPI(void)  cvConvertMaps( const CvArr* mapx, const CvArr* mapy,
    00196                             CvArr* mapxy, CvArr* mapalpha );
    00197
    00198 /* Performs forward or inverse log-polar image transform */
    00199 CVAPI(void)  cvLogPolar( const CvArr* src, CvArr* dst,
    00200                          CvPoint2D32f center, double M,
    00201                          int flags CV_DEFAULT(CV_INTER_LINEAR+CV_WARP_FILL_OUTLIERS));
    00202
    00203 /* Performs forward or inverse linear-polar image transform */
    00204 CVAPI(void)  cvLinearPolar( const CvArr* src, CvArr* dst,
    00205                          CvPoint2D32f center, double maxRadius,
    00206                          int flags CV_DEFAULT(CV_INTER_LINEAR+CV_WARP_FILL_OUTLIERS));
    00207
    00208 /* Transforms the input image to compensate lens distortion */
    00209 CVAPI(void) cvUndistort2( const CvArr* src, CvArr* dst,
    00210                           const CvMat* camera_matrix,
    00211                           const CvMat* distortion_coeffs,
    00212                           const CvMat* new_camera_matrix CV_DEFAULT(0) );
    00213
    00214 /* Computes transformation map from intrinsic camera parameters
    00215    that can used by cvRemap */
    00216 CVAPI(void) cvInitUndistortMap( const CvMat* camera_matrix,
    00217                                 const CvMat* distortion_coeffs,
    00218                                 CvArr* mapx, CvArr* mapy );
    00219
    00220 /* Computes undistortion+rectification map for a head of stereo camera */
    00221 CVAPI(void) cvInitUndistortRectifyMap( const CvMat* camera_matrix,
    00222                                        const CvMat* dist_coeffs,
    00223                                        const CvMat *R, const CvMat* new_camera_matrix,
    00224                                        CvArr* mapx, CvArr* mapy );
    00225
    00226 /* Computes the original (undistorted) feature coordinates
    00227    from the observed (distorted) coordinates */
    00228 CVAPI(void) cvUndistortPoints( const CvMat* src, CvMat* dst,
    00229                                const CvMat* camera_matrix,
    00230                                const CvMat* dist_coeffs,
    00231                                const CvMat* R CV_DEFAULT(0),
    00232                                const CvMat* P CV_DEFAULT(0));
    00233
    00234 /* creates structuring element used for morphological operations */
    00235 CVAPI(IplConvKernel*)  cvCreateStructuringElementEx(
    00236             int cols, int  rows, int  anchor_x, int  anchor_y,
    00237             int shape, int* values CV_DEFAULT(NULL) );
    00238
    00239 /* releases structuring element */
    00240 CVAPI(void)  cvReleaseStructuringElement( IplConvKernel** element );
    00241
    00242 /* erodes input image (applies minimum filter) one or more times.
    00243    If element pointer is NULL, 3x3 rectangular element is used */
    00244 CVAPI(void)  cvErode( const CvArr* src, CvArr* dst,
    00245                       IplConvKernel* element CV_DEFAULT(NULL),
    00246                       int iterations CV_DEFAULT(1) );
    00247
    00248 /* dilates input image (applies maximum filter) one or more times.
    00249    If element pointer is NULL, 3x3 rectangular element is used */
    00250 CVAPI(void)  cvDilate( const CvArr* src, CvArr* dst,
    00251                        IplConvKernel* element CV_DEFAULT(NULL),
    00252                        int iterations CV_DEFAULT(1) );
    00253
    00254 /* Performs complex morphological transformation */
    00255 CVAPI(void)  cvMorphologyEx( const CvArr* src, CvArr* dst,
    00256                              CvArr* temp, IplConvKernel* element,
    00257                              int operation, int iterations CV_DEFAULT(1) );
    00258
    00259 /* Calculates all spatial and central moments up to the 3rd order */
    00260 CVAPI(void) cvMoments( const CvArr* arr, CvMoments* moments, int binary CV_DEFAULT(0));
    00261
    00262 /* Retrieve particular spatial, central or normalized central moments */
    00263 CVAPI(double)  cvGetSpatialMoment( CvMoments* moments, int x_order, int y_order );
    00264 CVAPI(double)  cvGetCentralMoment( CvMoments* moments, int x_order, int y_order );
    00265 CVAPI(double)  cvGetNormalizedCentralMoment( CvMoments* moments,
    00266                                              int x_order, int y_order );
    00267
    00268 /* Calculates 7 Hu's invariants from precalculated spatial and central moments */
    00269 CVAPI(void) cvGetHuMoments( CvMoments*  moments, CvHuMoments*  hu_moments );
    00270
    00271 /*********************************** data sampling **************************************/
    00272
    00273 /* Fetches pixels that belong to the specified line segment and stores them to the buffer.
    00274    Returns the number of retrieved points. */
    00275 CVAPI(int)  cvSampleLine( const CvArr* image, CvPoint pt1, CvPoint pt2, void* buffer,
    00276                           int connectivity CV_DEFAULT(8));
    00277
    00278 /* Retrieves the rectangular image region with specified center from the input array.
    00279  dst(x,y) <- src(x + center.x - dst_width/2, y + center.y - dst_height/2).
    00280  Values of pixels with fractional coordinates are retrieved using bilinear interpolation*/
    00281 CVAPI(void)  cvGetRectSubPix( const CvArr* src, CvArr* dst, CvPoint2D32f center );
    00282
    00283
    00284 /* Retrieves quadrangle from the input array.
    00285     matrixarr = ( a11  a12 | b1 )   dst(x,y) <- src(A[x y]' + b)
    00286                 ( a21  a22 | b2 )   (bilinear interpolation is used to retrieve pixels
    00287                                      with fractional coordinates)
    00288 */
    00289 CVAPI(void)  cvGetQuadrangleSubPix( const CvArr* src, CvArr* dst,
    00290                                     const CvMat* map_matrix );
    00291
    00292 /* Measures similarity between template and overlapped windows in the source image
    00293    and fills the resultant image with the measurements */
    00294 CVAPI(void)  cvMatchTemplate( const CvArr* image, const CvArr* templ,
    00295                               CvArr* result, int method );
    00296
    00297 /* Computes earth mover distance between
    00298    two weighted point sets (called signatures) */
    00299 CVAPI(float)  cvCalcEMD2( const CvArr* signature1,
    00300                           const CvArr* signature2,
    00301                           int distance_type,
    00302                           CvDistanceFunction distance_func CV_DEFAULT(NULL),
    00303                           const CvArr* cost_matrix CV_DEFAULT(NULL),
    00304                           CvArr* flow CV_DEFAULT(NULL),
    00305                           float* lower_bound CV_DEFAULT(NULL),
    00306                           void* userdata CV_DEFAULT(NULL));
    00307
    00308 /****************************************************************************************\
    00309 *                              Contours retrieving                                       *
    00310 \****************************************************************************************/
    00311
    00312 /* Retrieves outer and optionally inner boundaries of white (non-zero) connected
    00313    components in the black (zero) background */
    00314 CVAPI(int)  cvFindContours( CvArr* image, CvMemStorage* storage, CvSeq** first_contour,
    00315                             int header_size CV_DEFAULT(sizeof(CvContour)),
    00316                             int mode CV_DEFAULT(CV_RETR_LIST),
    00317                             int method CV_DEFAULT(CV_CHAIN_APPROX_SIMPLE),
    00318                             CvPoint offset CV_DEFAULT(cvPoint(0,0)));
    00319
    00320 /* Initalizes contour retrieving process.
    00321    Calls cvStartFindContours.
    00322    Calls cvFindNextContour until null pointer is returned
    00323    or some other condition becomes true.
    00324    Calls cvEndFindContours at the end. */
    00325 CVAPI(CvContourScanner)  cvStartFindContours( CvArr* image, CvMemStorage* storage,
    00326                             int header_size CV_DEFAULT(sizeof(CvContour)),
    00327                             int mode CV_DEFAULT(CV_RETR_LIST),
    00328                             int method CV_DEFAULT(CV_CHAIN_APPROX_SIMPLE),
    00329                             CvPoint offset CV_DEFAULT(cvPoint(0,0)));
    00330
    00331 /* Retrieves next contour */
    00332 CVAPI(CvSeq*)  cvFindNextContour( CvContourScanner scanner );
    00333
    00334
    00335 /* Substitutes the last retrieved contour with the new one
    00336    (if the substitutor is null, the last retrieved contour is removed from the tree) */
    00337 CVAPI(void)   cvSubstituteContour( CvContourScanner scanner, CvSeq* new_contour );
    00338
    00339
    00340 /* Releases contour scanner and returns pointer to the first outer contour */
    00341 CVAPI(CvSeq*)  cvEndFindContours( CvContourScanner* scanner );
    00342
    00343 /* Approximates a single Freeman chain or a tree of chains to polygonal curves */
    00344 CVAPI(CvSeq*) cvApproxChains( CvSeq* src_seq, CvMemStorage* storage,
    00345                             int method CV_DEFAULT(CV_CHAIN_APPROX_SIMPLE),
    00346                             double parameter CV_DEFAULT(0),
    00347                             int  minimal_perimeter CV_DEFAULT(0),
    00348                             int  recursive CV_DEFAULT(0));
    00349
    00350 /* Initalizes Freeman chain reader.
    00351    The reader is used to iteratively get coordinates of all the chain points.
    00352    If the Freeman codes should be read as is, a simple sequence reader should be used */
    00353 CVAPI(void) cvStartReadChainPoints( CvChain* chain, CvChainPtReader* reader );
    00354
    00355 /* Retrieves the next chain point */
    00356 CVAPI(CvPoint) cvReadChainPoint( CvChainPtReader* reader );
    00357
    00358 /****************************************************************************************\
    00359 *                              Planar subdivisions                                       *
    00360 \****************************************************************************************/
    00361
    00362 /* Initializes Delaunay triangulation */
    00363 CVAPI(void)  cvInitSubdivDelaunay2D( CvSubdiv2D* subdiv, CvRect rect );
    00364
    00365 /* Creates new subdivision */
    00366 CVAPI(CvSubdiv2D*)  cvCreateSubdiv2D( int subdiv_type, int header_size,
    00367                                       int vtx_size, int quadedge_size,
    00368                                       CvMemStorage* storage );
    00369
    00370 /************************* high-level subdivision functions ***************************/
    00371
    00372 /* Simplified Delaunay diagram creation */
    00373 CV_INLINE  CvSubdiv2D* cvCreateSubdivDelaunay2D( CvRect rect, CvMemStorage* storage )
    00374 {
    00375     CvSubdiv2D* subdiv = cvCreateSubdiv2D( CV_SEQ_KIND_SUBDIV2D, sizeof(*subdiv),
    00376                          sizeof(CvSubdiv2DPoint), sizeof(CvQuadEdge2D), storage );
    00377
    00378     cvInitSubdivDelaunay2D( subdiv, rect );
    00379     return subdiv;
    00380 }
    00381
    00382
    00383 /* Inserts new point to the Delaunay triangulation */
    00384 CVAPI(CvSubdiv2DPoint*)  cvSubdivDelaunay2DInsert( CvSubdiv2D* subdiv, CvPoint2D32f pt);
    00385
    00386 /* Locates a point within the Delaunay triangulation (finds the edge
    00387    the point is left to or belongs to, or the triangulation point the given
    00388    point coinsides with */
    00389 CVAPI(CvSubdiv2DPointLocation)  cvSubdiv2DLocate(
    00390                                CvSubdiv2D* subdiv, CvPoint2D32f pt,
    00391                                CvSubdiv2DEdge* edge,
    00392                                CvSubdiv2DPoint** vertex CV_DEFAULT(NULL) );
    00393
    00394 /* Calculates Voronoi tesselation (i.e. coordinates of Voronoi points) */
    00395 CVAPI(void)  cvCalcSubdivVoronoi2D( CvSubdiv2D* subdiv );
    00396
    00397
    00398 /* Removes all Voronoi points from the tesselation */
    00399 CVAPI(void)  cvClearSubdivVoronoi2D( CvSubdiv2D* subdiv );
    00400
    00401
    00402 /* Finds the nearest to the given point vertex in subdivision. */
    00403 CVAPI(CvSubdiv2DPoint*) cvFindNearestPoint2D( CvSubdiv2D* subdiv, CvPoint2D32f pt );
    00404
    00405
    00406 /************ Basic quad-edge navigation and operations ************/
    00407
    00408 CV_INLINE  CvSubdiv2DEdge  cvSubdiv2DNextEdge( CvSubdiv2DEdge edge )
    00409 {
    00410     return  CV_SUBDIV2D_NEXT_EDGE(edge);
    00411 }
    00412
    00413
    00414 CV_INLINE  CvSubdiv2DEdge  cvSubdiv2DRotateEdge( CvSubdiv2DEdge edge, int rotate )
    00415 {
    00416     return  (edge & ~3) + ((edge + rotate) & 3);
    00417 }
    00418
    00419 CV_INLINE  CvSubdiv2DEdge  cvSubdiv2DSymEdge( CvSubdiv2DEdge edge )
    00420 {
    00421     return edge ^ 2;
    00422 }
    00423
    00424 CV_INLINE  CvSubdiv2DEdge  cvSubdiv2DGetEdge( CvSubdiv2DEdge edge, CvNextEdgeType type )
    00425 {
    00426     CvQuadEdge2D* e = (CvQuadEdge2D*)(edge & ~3);
    00427     edge = e->next[(edge + (int)type) & 3];
    00428     return  (edge & ~3) + ((edge + ((int)type >> 4)) & 3);
    00429 }
    00430
    00431
    00432 CV_INLINE  CvSubdiv2DPoint*  cvSubdiv2DEdgeOrg( CvSubdiv2DEdge edge )
    00433 {
    00434     CvQuadEdge2D* e = (CvQuadEdge2D*)(edge & ~3);
    00435     return (CvSubdiv2DPoint*)e->pt[edge & 3];
    00436 }
    00437
    00438
    00439 CV_INLINE  CvSubdiv2DPoint*  cvSubdiv2DEdgeDst( CvSubdiv2DEdge edge )
    00440 {
    00441     CvQuadEdge2D* e = (CvQuadEdge2D*)(edge & ~3);
    00442     return (CvSubdiv2DPoint*)e->pt[(edge + 2) & 3];
    00443 }
    00444
    00445
    00446 CV_INLINE  double  cvTriangleArea( CvPoint2D32f a, CvPoint2D32f b, CvPoint2D32f c )
    00447 {
    00448     return ((double)b.x - a.x) * ((double)c.y - a.y) - ((double)b.y - a.y) * ((double)c.x - a.x);
    00449 }
    00450
    00451
    00452 /****************************************************************************************\
    00453 *                            Contour Processing and Shape Analysis                       *
    00454 \****************************************************************************************/
    00455
    00456 /* Approximates a single polygonal curve (contour) or
    00457    a tree of polygonal curves (contours) */
    00458 CVAPI(CvSeq*)  cvApproxPoly( const void* src_seq,
    00459                              int header_size, CvMemStorage* storage,
    00460                              int method, double parameter,
    00461                              int parameter2 CV_DEFAULT(0));
    00462
    00463 /* Calculates perimeter of a contour or length of a part of contour */
    00464 CVAPI(double)  cvArcLength( const void* curve,
    00465                             CvSlice slice CV_DEFAULT(CV_WHOLE_SEQ),
    00466                             int is_closed CV_DEFAULT(-1));
    00467
    00468 CV_INLINE double cvContourPerimeter( const void* contour )
    00469 {
    00470     return cvArcLength( contour, CV_WHOLE_SEQ, 1 );
    00471 }
    00472
    00473
    00474 /* Calculates contour boundning rectangle (update=1) or
    00475    just retrieves pre-calculated rectangle (update=0) */
    00476 CVAPI(CvRect)  cvBoundingRect( CvArr* points, int update CV_DEFAULT(0) );
    00477
    00478 /* Calculates area of a contour or contour segment */
    00479 CVAPI(double)  cvContourArea( const CvArr* contour,
    00480                               CvSlice slice CV_DEFAULT(CV_WHOLE_SEQ),
    00481                               int oriented CV_DEFAULT(0));
    00482
    00483 /* Finds minimum area rotated rectangle bounding a set of points */
    00484 CVAPI(CvBox2D)  cvMinAreaRect2( const CvArr* points,
    00485                                 CvMemStorage* storage CV_DEFAULT(NULL));
    00486
    00487 /* Finds minimum enclosing circle for a set of points */
    00488 CVAPI(int)  cvMinEnclosingCircle( const CvArr* points,
    00489                                   CvPoint2D32f* center, float* radius );
    00490
    00491 /* Compares two contours by matching their moments */
    00492 CVAPI(double)  cvMatchShapes( const void* object1, const void* object2,
    00493                               int method, double parameter CV_DEFAULT(0));
    00494
    00495 /* Calculates exact convex hull of 2d point set */
    00496 CVAPI(CvSeq*) cvConvexHull2( const CvArr* input,
    00497                              void* hull_storage CV_DEFAULT(NULL),
    00498                              int orientation CV_DEFAULT(CV_CLOCKWISE),
    00499                              int return_points CV_DEFAULT(0));
    00500
    00501 /* Checks whether the contour is convex or not (returns 1 if convex, 0 if not) */
    00502 CVAPI(int)  cvCheckContourConvexity( const CvArr* contour );
    00503
    00504
    00505 /* Finds convexity defects for the contour */
    00506 CVAPI(CvSeq*)  cvConvexityDefects( const CvArr* contour, const CvArr* convexhull,
    00507                                    CvMemStorage* storage CV_DEFAULT(NULL));
    00508
    00509 /* Fits ellipse into a set of 2d points */
    00510 CVAPI(CvBox2D) cvFitEllipse2( const CvArr* points );
    00511
    00512 /* Finds minimum rectangle containing two given rectangles */
    00513 CVAPI(CvRect)  cvMaxRect( const CvRect* rect1, const CvRect* rect2 );
    00514
    00515 /* Finds coordinates of the box vertices */
    00516 CVAPI(void) cvBoxPoints( CvBox2D box, CvPoint2D32f pt[4] );
    00517
    00518 /* Initializes sequence header for a matrix (column or row vector) of points -
    00519    a wrapper for cvMakeSeqHeaderForArray (it does not initialize bounding rectangle!!!) */
    00520 CVAPI(CvSeq*) cvPointSeqFromMat( int seq_kind, const CvArr* mat,
    00521                                  CvContour* contour_header,
    00522                                  CvSeqBlock* block );
    00523
    00524 /* Checks whether the point is inside polygon, outside, on an edge (at a vertex).
    00525    Returns positive, negative or zero value, correspondingly.
    00526    Optionally, measures a signed distance between
    00527    the point and the nearest polygon edge (measure_dist=1) */
    00528 CVAPI(double) cvPointPolygonTest( const CvArr* contour,
    00529                                   CvPoint2D32f pt, int measure_dist );
    00530
    00531 /****************************************************************************************\
    00532 *                                  Histogram functions                                   *
    00533 \****************************************************************************************/
    00534
    00535 /* Creates new histogram */
    00536 CVAPI(CvHistogram*)  cvCreateHist( int dims, int* sizes, int type,
    00537                                    float** ranges CV_DEFAULT(NULL),
    00538                                    int uniform CV_DEFAULT(1));
    00539
    00540 /* Assignes histogram bin ranges */
    00541 CVAPI(void)  cvSetHistBinRanges( CvHistogram* hist, float** ranges,
    00542                                 int uniform CV_DEFAULT(1));
    00543
    00544 /* Creates histogram header for array */
    00545 CVAPI(CvHistogram*)  cvMakeHistHeaderForArray(
    00546                             int  dims, int* sizes, CvHistogram* hist,
    00547                             float* data, float** ranges CV_DEFAULT(NULL),
    00548                             int uniform CV_DEFAULT(1));
    00549
    00550 /* Releases histogram */
    00551 CVAPI(void)  cvReleaseHist( CvHistogram** hist );
    00552
    00553 /* Clears all the histogram bins */
    00554 CVAPI(void)  cvClearHist( CvHistogram* hist );
    00555
    00556 /* Finds indices and values of minimum and maximum histogram bins */
    00557 CVAPI(void)  cvGetMinMaxHistValue( const CvHistogram* hist,
    00558                                    float* min_value, float* max_value,
    00559                                    int* min_idx CV_DEFAULT(NULL),
    00560                                    int* max_idx CV_DEFAULT(NULL));
    00561
    00562
    00563 /* Normalizes histogram by dividing all bins by sum of the bins, multiplied by <factor>.
    00564    After that sum of histogram bins is equal to <factor> */
    00565 CVAPI(void)  cvNormalizeHist( CvHistogram* hist, double factor );
    00566
    00567
    00568 /* Clear all histogram bins that are below the threshold */
    00569 CVAPI(void)  cvThreshHist( CvHistogram* hist, double threshold );
    00570
    00571
    00572 /* Compares two histogram */
    00573 CVAPI(double)  cvCompareHist( const CvHistogram* hist1,
    00574                               const CvHistogram* hist2,
    00575                               int method);
    00576
    00577 /* Copies one histogram to another. Destination histogram is created if
    00578    the destination pointer is NULL */
    00579 CVAPI(void)  cvCopyHist( const CvHistogram* src, CvHistogram** dst );
    00580
    00581
    00582 /* Calculates bayesian probabilistic histograms
    00583    (each or src and dst is an array of <number> histograms */
    00584 CVAPI(void)  cvCalcBayesianProb( CvHistogram** src, int number,
    00585                                 CvHistogram** dst);
    00586
    00587 /* Calculates array histogram */
    00588 CVAPI(void)  cvCalcArrHist( CvArr** arr, CvHistogram* hist,
    00589                             int accumulate CV_DEFAULT(0),
    00590                             const CvArr* mask CV_DEFAULT(NULL) );
    00591
    00592 CV_INLINE  void  cvCalcHist( IplImage** image, CvHistogram* hist,
    00593                              int accumulate CV_DEFAULT(0),
    00594                              const CvArr* mask CV_DEFAULT(NULL) )
    00595 {
    00596     cvCalcArrHist( (CvArr**)image, hist, accumulate, mask );
    00597 }
    00598
    00599 /* Calculates back project */
    00600 CVAPI(void)  cvCalcArrBackProject( CvArr** image, CvArr* dst,
    00601                                    const CvHistogram* hist );
    00602 #define  cvCalcBackProject(image, dst, hist) cvCalcArrBackProject((CvArr**)image, dst, hist)
    00603
    00604
    00605 /* Does some sort of template matching but compares histograms of
    00606    template and each window location */
    00607 CVAPI(void)  cvCalcArrBackProjectPatch( CvArr** image, CvArr* dst, CvSize range,
    00608                                         CvHistogram* hist, int method,
    00609                                         double factor );
    00610 #define  cvCalcBackProjectPatch( image, dst, range, hist, method, factor ) \
    00611      cvCalcArrBackProjectPatch( (CvArr**)image, dst, range, hist, method, factor )
    00612
    00613
    00614 /* calculates probabilistic density (divides one histogram by another) */
    00615 CVAPI(void)  cvCalcProbDensity( const CvHistogram* hist1, const CvHistogram* hist2,
    00616                                 CvHistogram* dst_hist, double scale CV_DEFAULT(255) );
    00617
    00618 /* equalizes histogram of 8-bit single-channel image */
    00619 CVAPI(void)  cvEqualizeHist( const CvArr* src, CvArr* dst );
    00620
    00621
    00622 /* Applies distance transform to binary image */
    00623 CVAPI(void)  cvDistTransform( const CvArr* src, CvArr* dst,
    00624                               int distance_type CV_DEFAULT(CV_DIST_L2),
    00625                               int mask_size CV_DEFAULT(3),
    00626                               const float* mask CV_DEFAULT(NULL),
    00627                               CvArr* labels CV_DEFAULT(NULL));
    00628
    00629
    00630 /* Applies fixed-level threshold to grayscale image.
    00631    This is a basic operation applied before retrieving contours */
    00632 CVAPI(double)  cvThreshold( const CvArr*  src, CvArr*  dst,
    00633                             double  threshold, double  max_value,
    00634                             int threshold_type );
    00635
    00636 /* Applies adaptive threshold to grayscale image.
    00637    The two parameters for methods CV_ADAPTIVE_THRESH_MEAN_C and
    00638    CV_ADAPTIVE_THRESH_GAUSSIAN_C are:
    00639    neighborhood size (3, 5, 7 etc.),
    00640    and a constant subtracted from mean (...,-3,-2,-1,0,1,2,3,...) */
    00641 CVAPI(void)  cvAdaptiveThreshold( const CvArr* src, CvArr* dst, double max_value,
    00642                                   int adaptive_method CV_DEFAULT(CV_ADAPTIVE_THRESH_MEAN_C),
    00643                                   int threshold_type CV_DEFAULT(CV_THRESH_BINARY),
    00644                                   int block_size CV_DEFAULT(3),
    00645                                   double param1 CV_DEFAULT(5));
    00646
    00647 /* Fills the connected component until the color difference gets large enough */
    00648 CVAPI(void)  cvFloodFill( CvArr* image, CvPoint seed_point,
    00649                           CvScalar new_val, CvScalar lo_diff CV_DEFAULT(cvScalarAll(0)),
    00650                           CvScalar up_diff CV_DEFAULT(cvScalarAll(0)),
    00651                           CvConnectedComp* comp CV_DEFAULT(NULL),
    00652                           int flags CV_DEFAULT(4),
    00653                           CvArr* mask CV_DEFAULT(NULL));
    00654
    00655 /****************************************************************************************\
    00656 *                                  Feature detection                                     *
    00657 \****************************************************************************************/
    00658
    00659 /* Runs canny edge detector */
    00660 CVAPI(void)  cvCanny( const CvArr* image, CvArr* edges, double threshold1,
    00661                       double threshold2, int  aperture_size CV_DEFAULT(3) );
    00662
    00663 /* Calculates constraint image for corner detection
    00664    Dx^2 * Dyy + Dxx * Dy^2 - 2 * Dx * Dy * Dxy.
    00665    Applying threshold to the result gives coordinates of corners */
    00666 CVAPI(void) cvPreCornerDetect( const CvArr* image, CvArr* corners,
    00667                                int aperture_size CV_DEFAULT(3) );
    00668
    00669 /* Calculates eigen values and vectors of 2x2
    00670    gradient covariation matrix at every image pixel */
    00671 CVAPI(void)  cvCornerEigenValsAndVecs( const CvArr* image, CvArr* eigenvv,
    00672                                        int block_size, int aperture_size CV_DEFAULT(3) );
    00673
    00674 /* Calculates minimal eigenvalue for 2x2 gradient covariation matrix at
    00675    every image pixel */
    00676 CVAPI(void)  cvCornerMinEigenVal( const CvArr* image, CvArr* eigenval,
    00677                                   int block_size, int aperture_size CV_DEFAULT(3) );
    00678
    00679 /* Harris corner detector:
    00680    Calculates det(M) - k*(trace(M)^2), where M is 2x2 gradient covariation matrix for each pixel */
    00681 CVAPI(void)  cvCornerHarris( const CvArr* image, CvArr* harris_responce,
    00682                              int block_size, int aperture_size CV_DEFAULT(3),
    00683                              double k CV_DEFAULT(0.04) );
    00684
    00685 /* Adjust corner position using some sort of gradient search */
    00686 CVAPI(void)  cvFindCornerSubPix( const CvArr* image, CvPoint2D32f* corners,
    00687                                  int count, CvSize win, CvSize zero_zone,
    00688                                  CvTermCriteria  criteria );
    00689
    00690 /* Finds a sparse set of points within the selected region
    00691    that seem to be easy to track */
    00692 CVAPI(void)  cvGoodFeaturesToTrack( const CvArr* image, CvArr* eig_image,
    00693                                     CvArr* temp_image, CvPoint2D32f* corners,
    00694                                     int* corner_count, double  quality_level,
    00695                                     double  min_distance,
    00696                                     const CvArr* mask CV_DEFAULT(NULL),
    00697                                     int block_size CV_DEFAULT(3),
    00698                                     int use_harris CV_DEFAULT(0),
    00699                                     double k CV_DEFAULT(0.04) );
    00700
    00701 /* Finds lines on binary image using one of several methods.
    00702    line_storage is either memory storage or 1 x <max number of lines> CvMat, its
    00703    number of columns is changed by the function.
    00704    method is one of CV_HOUGH_*;
    00705    rho, theta and threshold are used for each of those methods;
    00706    param1 ~ line length, param2 ~ line gap - for probabilistic,
    00707    param1 ~ srn, param2 ~ stn - for multi-scale */
    00708 CVAPI(CvSeq*)  cvHoughLines2( CvArr* image, void* line_storage, int method,
    00709                               double rho, double theta, int threshold,
    00710                               double param1 CV_DEFAULT(0), double param2 CV_DEFAULT(0));
    00711
    00712 /* Finds circles in the image */
    00713 CVAPI(CvSeq*) cvHoughCircles( CvArr* image, void* circle_storage,
    00714                               int method, double dp, double min_dist,
    00715                               double param1 CV_DEFAULT(100),
    00716                               double param2 CV_DEFAULT(100),
    00717                               int min_radius CV_DEFAULT(0),
    00718                               int max_radius CV_DEFAULT(0));
    00719
    00720 /* Fits a line into set of 2d or 3d points in a robust way (M-estimator technique) */
    00721 CVAPI(void)  cvFitLine( const CvArr* points, int dist_type, double param,
    00722                         double reps, double aeps, float* line );
    00723
    00724
    00725 /* Constructs kd-tree from set of feature descriptors */
    00726 CVAPI(struct CvFeatureTree*) cvCreateKDTree(CvMat* desc);
    00727
    00728 /* Constructs spill-tree from set of feature descriptors */
    00729 CVAPI(struct CvFeatureTree*) cvCreateSpillTree( const CvMat* raw_data,
    00730                                     const int naive CV_DEFAULT(50),
    00731                                     const double rho CV_DEFAULT(.7),
    00732                                     const double tau CV_DEFAULT(.1) );
    00733
    00734 /* Release feature tree */
    00735 CVAPI(void) cvReleaseFeatureTree(struct CvFeatureTree* tr);
    00736
    00737 /* Searches feature tree for k nearest neighbors of given reference points,
    00738    searching (in case of kd-tree/bbf) at most emax leaves. */
    00739 CVAPI(void) cvFindFeatures(struct CvFeatureTree* tr, const CvMat* query_points,
    00740                            CvMat* indices, CvMat* dist, int k, int emax CV_DEFAULT(20));
    00741
    00742 /* Search feature tree for all points that are inlier to given rect region.
    00743    Only implemented for kd trees */
    00744 CVAPI(int) cvFindFeaturesBoxed(struct CvFeatureTree* tr,
    00745                                CvMat* bounds_min, CvMat* bounds_max,
    00746                                CvMat* out_indices);
    00747
    00748
    00749 /* Construct a Locality Sensitive Hash (LSH) table, for indexing d-dimensional vectors of
    00750    given type. Vectors will be hashed L times with k-dimensional p-stable (p=2) functions. */
    00751 CVAPI(struct CvLSH*) cvCreateLSH(struct CvLSHOperations* ops, int d,
    00752                                  int L CV_DEFAULT(10), int k CV_DEFAULT(10),
    00753                                  int type CV_DEFAULT(CV_64FC1), double r CV_DEFAULT(4),
    00754                                  int64 seed CV_DEFAULT(-1));
    00755
    00756 /* Construct in-memory LSH table, with n bins. */
    00757 CVAPI(struct CvLSH*) cvCreateMemoryLSH(int d, int n, int L CV_DEFAULT(10), int k CV_DEFAULT(10),
    00758                                        int type CV_DEFAULT(CV_64FC1), double r CV_DEFAULT(4),
    00759                                        int64 seed CV_DEFAULT(-1));
    00760
    00761 /* Free the given LSH structure. */
    00762 CVAPI(void) cvReleaseLSH(struct CvLSH** lsh);
    00763
    00764 /* Return the number of vectors in the LSH. */
    00765 CVAPI(unsigned int) LSHSize(struct CvLSH* lsh);
    00766
    00767 /* Add vectors to the LSH structure, optionally returning indices. */
    00768 CVAPI(void) cvLSHAdd(struct CvLSH* lsh, const CvMat* data, CvMat* indices CV_DEFAULT(0));
    00769
    00770 /* Remove vectors from LSH, as addressed by given indices. */
    00771 CVAPI(void) cvLSHRemove(struct CvLSH* lsh, const CvMat* indices);
    00772
    00773 /* Query the LSH n times for at most k nearest points; data is n x d,
    00774    indices and dist are n x k. At most emax stored points will be accessed. */
    00775 CVAPI(void) cvLSHQuery(struct CvLSH* lsh, const CvMat* query_points,
    00776                        CvMat* indices, CvMat* dist, int k, int emax);
    00777
    00778
    00779 #ifdef __cplusplus
    00780 }
    00781 #endif
    00782
    00783 #endif

All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Defines