X-Git-Url: https://vcs.maemo.org/git/?a=blobdiff_plain;f=cv%2Finclude%2Fcv.h;fp=cv%2Finclude%2Fcv.h;h=0000000000000000000000000000000000000000;hb=e4c14cdbdf2fe805e79cd96ded236f57e7b89060;hp=28a7952f2fa365bf80c36bbd15bac8e45d20db94;hpb=454138ff8a20f6edb9b65a910101403d8b520643;p=opencv diff --git a/cv/include/cv.h b/cv/include/cv.h deleted file mode 100644 index 28a7952..0000000 --- a/cv/include/cv.h +++ /dev/null @@ -1,1268 +0,0 @@ -/*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. -// -// -// Intel License Agreement -// For Open Source Computer Vision Library -// -// Copyright (C) 2000, Intel Corporation, 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 Intel Corporation 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 _CV_H_ -#define _CV_H_ - -#ifdef __IPL_H__ -#define HAVE_IPL -#endif - -#ifndef SKIP_INCLUDES - #if defined(_CH_) - #pragma package - #include - LOAD_CHDL(cv) - #endif -#endif - -#include "cxcore.h" -#include "cvtypes.h" - -#ifdef __cplusplus -extern "C" { -#endif - -/****************************************************************************************\ -* 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))); - -#define CV_BLUR_NO_SCALE 0 -#define CV_BLUR 1 -#define CV_GAUSSIAN 2 -#define CV_MEDIAN 3 -#define CV_BILATERAL 4 - -/* 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(xnext[(edge + (int)type) & 3]; - return (edge & ~3) + ((edge + ((int)type >> 4)) & 3); -} - - -CV_INLINE CvSubdiv2DPoint* cvSubdiv2DEdgeOrg( CvSubdiv2DEdge edge ) -{ - CvQuadEdge2D* e = (CvQuadEdge2D*)(edge & ~3); - return (CvSubdiv2DPoint*)e->pt[edge & 3]; -} - - -CV_INLINE CvSubdiv2DPoint* cvSubdiv2DEdgeDst( CvSubdiv2DEdge edge ) -{ - CvQuadEdge2D* e = (CvQuadEdge2D*)(edge & ~3); - return (CvSubdiv2DPoint*)e->pt[(edge + 2) & 3]; -} - - -CV_INLINE double cvTriangleArea( CvPoint2D32f a, CvPoint2D32f b, CvPoint2D32f c ) -{ - return (b.x - a.x) * (c.y - a.y) - (b.y - a.y) * (c.x - a.x); -} - - -/****************************************************************************************\ -* Contour Processing and Shape Analysis * -\****************************************************************************************/ - -#define CV_POLY_APPROX_DP 0 - -/* 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 parameter, - int parameter2 CV_DEFAULT(0)); - -#define CV_DOMINANT_IPAN 1 - -/* Finds high-curvature points of the contour */ -CVAPI(CvSeq*) cvFindDominantPoints( CvSeq* contour, CvMemStorage* storage, - int method CV_DEFAULT(CV_DOMINANT_IPAN), - double parameter1 CV_DEFAULT(0), - double parameter2 CV_DEFAULT(0), - double parameter3 CV_DEFAULT(0), - double parameter4 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)); -#define cvContourPerimeter( contour ) 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)); - -/* 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 ); - -#define CV_CONTOURS_MATCH_I1 1 -#define CV_CONTOURS_MATCH_I2 2 -#define CV_CONTOURS_MATCH_I3 3 - -/* Compares two contours by matching their moments */ -CVAPI(double) cvMatchShapes( const void* object1, const void* object2, - int method, double parameter CV_DEFAULT(0)); - -/* Builds hierarhical representation of a contour */ -CVAPI(CvContourTree*) cvCreateContourTree( const CvSeq* contour, - CvMemStorage* storage, - double threshold ); - -/* Reconstruct (completelly or partially) contour a from contour tree */ -CVAPI(CvSeq*) cvContourFromContourTree( const CvContourTree* tree, - CvMemStorage* storage, - CvTermCriteria criteria ); - -/* Compares two contour trees */ -#define CV_CONTOUR_TREES_MATCH_I1 1 - -CVAPI(double) cvMatchContourTrees( const CvContourTree* tree1, - const CvContourTree* tree2, - int method, double threshold ); - -/* Calculates histogram of a contour */ -CVAPI(void) cvCalcPGH( const CvSeq* contour, CvHistogram* hist ); - -#define CV_CLOCKWISE 1 -#define CV_COUNTER_CLOCKWISE 2 - -/* 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 . - After that sum of histogram bins is equal to */ -CVAPI(void) cvNormalizeHist( CvHistogram* hist, double factor ); - - -/* Clear all histogram bins that are below the threshold */ -CVAPI(void) cvThreshHist( CvHistogram* hist, double threshold ); - -#define CV_COMP_CORREL 0 -#define CV_COMP_CHISQR 1 -#define CV_COMP_INTERSECT 2 -#define CV_COMP_BHATTACHARYYA 3 - -/* 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 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 ); - - -#define CV_VALUE 1 -#define CV_ARRAY 2 -/* Updates active contour in order to minimize its cummulative - (internal and external) energy. */ -CVAPI(void) cvSnakeImage( const IplImage* image, CvPoint* points, - int length, float* alpha, - float* beta, float* gamma, - int coeff_usage, CvSize win, - CvTermCriteria criteria, int calc_gradient CV_DEFAULT(1)); - -/* Calculates the cooficients of the homography matrix */ -CVAPI(void) cvCalcImageHomography( float* line, CvPoint3D32f* center, - float* intrinsic, float* homography ); - -#define CV_DIST_MASK_3 3 -#define CV_DIST_MASK_5 5 -#define CV_DIST_MASK_PRECISE 0 - -/* 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)); - - -/* Types of thresholding */ -#define CV_THRESH_BINARY 0 /* value = value > threshold ? max_value : 0 */ -#define CV_THRESH_BINARY_INV 1 /* value = value > threshold ? 0 : max_value */ -#define CV_THRESH_TRUNC 2 /* value = value > threshold ? threshold : value */ -#define CV_THRESH_TOZERO 3 /* value = value > threshold ? value : 0 */ -#define CV_THRESH_TOZERO_INV 4 /* value = value > threshold ? 0 : value */ -#define CV_THRESH_MASK 7 - -#define CV_THRESH_OTSU 8 /* use Otsu algorithm to choose the optimal threshold value; - combine the flag with one of the above CV_THRESH_* values */ - -/* 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 ); - -#define CV_ADAPTIVE_THRESH_MEAN_C 0 -#define CV_ADAPTIVE_THRESH_GAUSSIAN_C 1 - -/* 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)); - -#define CV_FLOODFILL_FIXED_RANGE (1 << 16) -#define CV_FLOODFILL_MASK_ONLY (1 << 17) - -/* 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 * -\****************************************************************************************/ - -#define CV_CANNY_L2_GRADIENT (1 << 31) - -/* 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) ); - -#define CV_HOUGH_STANDARD 0 -#define CV_HOUGH_PROBABILISTIC 1 -#define CV_HOUGH_MULTI_SCALE 2 -#define CV_HOUGH_GRADIENT 3 - -/* Finds lines on binary image using one of several methods. - line_storage is either memory storage or 1 x 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 ); - - - -struct CvFeatureTree; - -/* Constructs kd-tree from set of feature descriptors */ -CVAPI(CvFeatureTree*) cvCreateFeatureTree(CvMat* desc); - -/* Release kd-tree */ -CVAPI(void) cvReleaseFeatureTree(CvFeatureTree* tr); - -/* Searches kd-tree for k nearest neighbors of given reference points, - searching at most emax leaves. */ -CVAPI(void) cvFindFeatures(CvFeatureTree* tr, CvMat* desc, - CvMat* results, CvMat* dist, int k = 2, int emax = 20); - -/* Search kd-tree for all points that are inlier to given rect region. */ -CVAPI(int) cvFindFeaturesBoxed(CvFeatureTree* tr, - CvMat* bounds_min, CvMat* bounds_max, - CvMat* results); - - -/****************************************************************************************\ -* Haar-like Object Detection functions * -\****************************************************************************************/ - -/* Loads haar classifier cascade from a directory. - It is obsolete: convert your cascade to xml and use cvLoad instead */ -CVAPI(CvHaarClassifierCascade*) cvLoadHaarClassifierCascade( - const char* directory, CvSize orig_window_size); - -CVAPI(void) cvReleaseHaarClassifierCascade( CvHaarClassifierCascade** cascade ); - -#define CV_HAAR_DO_CANNY_PRUNING 1 -#define CV_HAAR_SCALE_IMAGE 2 -#define CV_HAAR_FIND_BIGGEST_OBJECT 4 -#define CV_HAAR_DO_ROUGH_SEARCH 8 - -CVAPI(CvSeq*) cvHaarDetectObjects( const CvArr* image, - CvHaarClassifierCascade* cascade, - CvMemStorage* storage, double scale_factor CV_DEFAULT(1.1), - int min_neighbors CV_DEFAULT(3), int flags CV_DEFAULT(0), - CvSize min_size CV_DEFAULT(cvSize(0,0))); - -/* sets images for haar classifier cascade */ -CVAPI(void) cvSetImagesForHaarClassifierCascade( CvHaarClassifierCascade* cascade, - const CvArr* sum, const CvArr* sqsum, - const CvArr* tilted_sum, double scale ); - -/* runs the cascade on the specified window */ -CVAPI(int) cvRunHaarClassifierCascade( CvHaarClassifierCascade* cascade, - CvPoint pt, int start_stage CV_DEFAULT(0)); - -/****************************************************************************************\ -* Camera Calibration and Rectification functions * -\****************************************************************************************/ - -/* transforms the input image to compensate lens distortion */ -CVAPI(void) cvUndistort2( const CvArr* src, CvArr* dst, - const CvMat* intrinsic_matrix, - const CvMat* distortion_coeffs ); - -/* computes transformation map from intrinsic camera parameters - that can used by cvRemap */ -CVAPI(void) cvInitUndistortMap( const CvMat* intrinsic_matrix, - const CvMat* distortion_coeffs, - CvArr* mapx, CvArr* mapy ); - -/* converts rotation vector to rotation matrix or vice versa */ -CVAPI(int) cvRodrigues2( const CvMat* src, CvMat* dst, - CvMat* jacobian CV_DEFAULT(0) ); - -/* finds perspective transformation between the object plane and image (view) plane */ -CVAPI(void) cvFindHomography( const CvMat* src_points, - const CvMat* dst_points, - CvMat* homography ); - -/* Computes RQ decomposition for 3x3 matrices */ -CVAPI(void) cvRQDecomp3x3( const CvMat *matrixM, CvMat *matrixR, CvMat *matrixQ, - CvMat *matrixQx CV_DEFAULT(NULL), - CvMat *matrixQy CV_DEFAULT(NULL), - CvMat *matrixQz CV_DEFAULT(NULL), - CvPoint3D64f *eulerAngles CV_DEFAULT(NULL)); - -/* Computes projection matrix decomposition */ -CVAPI(void) cvDecomposeProjectionMatrix( const CvMat *projMatr, CvMat *calibMatr, - CvMat *rotMatr, CvMat *posVect, - CvMat *rotMatrX CV_DEFAULT(NULL), - CvMat *rotMatrY CV_DEFAULT(NULL), - CvMat *rotMatrZ CV_DEFAULT(NULL), - CvPoint3D64f *eulerAngles CV_DEFAULT(NULL)); - -/* projects object points to the view plane using - the specified extrinsic and intrinsic camera parameters */ -CVAPI(void) cvProjectPoints2( const CvMat* object_points, const CvMat* rotation_vector, - const CvMat* translation_vector, const CvMat* intrinsic_matrix, - const CvMat* distortion_coeffs, CvMat* image_points, - CvMat* dpdrot CV_DEFAULT(NULL), CvMat* dpdt CV_DEFAULT(NULL), - CvMat* dpdf CV_DEFAULT(NULL), CvMat* dpdc CV_DEFAULT(NULL), - CvMat* dpddist CV_DEFAULT(NULL) ); - -/* finds extrinsic camera parameters from - a few known corresponding point pairs and intrinsic parameters */ -CVAPI(void) cvFindExtrinsicCameraParams2( const CvMat* object_points, - const CvMat* image_points, - const CvMat* intrinsic_matrix, - const CvMat* distortion_coeffs, - CvMat* rotation_vector, - CvMat* translation_vector ); - -#define CV_CALIB_USE_INTRINSIC_GUESS 1 -#define CV_CALIB_FIX_ASPECT_RATIO 2 -#define CV_CALIB_FIX_PRINCIPAL_POINT 4 -#define CV_CALIB_ZERO_TANGENT_DIST 8 - -/* finds intrinsic and extrinsic camera parameters - from a few views of known calibration pattern */ -CVAPI(void) cvCalibrateCamera2( const CvMat* object_points, - const CvMat* image_points, - const CvMat* point_counts, - CvSize image_size, - CvMat* intrinsic_matrix, - CvMat* distortion_coeffs, - CvMat* rotation_vectors CV_DEFAULT(NULL), - CvMat* translation_vectors CV_DEFAULT(NULL), - int flags CV_DEFAULT(0) ); - -CVAPI(void) cvCalibrationMatrixValues( const CvMat *calibMatr, - int imgWidth, int imgHeight, - double apertureWidth CV_DEFAULT(0), - double apertureHeight CV_DEFAULT(0), - double *fovx CV_DEFAULT(NULL), - double *fovy CV_DEFAULT(NULL), - double *focalLength CV_DEFAULT(NULL), - CvPoint2D64f *principalPoint CV_DEFAULT(NULL), - double *pixelAspectRatio CV_DEFAULT(NULL)); - -#define CV_CALIB_CB_ADAPTIVE_THRESH 1 -#define CV_CALIB_CB_NORMALIZE_IMAGE 2 -#define CV_CALIB_CB_FILTER_QUADS 4 - -/* Detects corners on a chessboard calibration pattern */ -CVAPI(int) cvFindChessboardCorners( const void* image, CvSize pattern_size, - CvPoint2D32f* corners, - int* corner_count CV_DEFAULT(NULL), - int flags CV_DEFAULT(CV_CALIB_CB_ADAPTIVE_THRESH) ); - -/* Draws individual chessboard corners or the whole chessboard detected */ -CVAPI(void) cvDrawChessboardCorners( CvArr* image, CvSize pattern_size, - CvPoint2D32f* corners, - int count, int pattern_was_found ); - -typedef struct CvPOSITObject CvPOSITObject; - -/* Allocates and initializes CvPOSITObject structure before doing cvPOSIT */ -CVAPI(CvPOSITObject*) cvCreatePOSITObject( CvPoint3D32f* points, int point_count ); - - -/* Runs POSIT (POSe from ITeration) algorithm for determining 3d position of - an object given its model and projection in a weak-perspective case */ -CVAPI(void) cvPOSIT( CvPOSITObject* posit_object, CvPoint2D32f* image_points, - double focal_length, CvTermCriteria criteria, - CvMatr32f rotation_matrix, CvVect32f translation_vector); - -/* Releases CvPOSITObject structure */ -CVAPI(void) cvReleasePOSITObject( CvPOSITObject** posit_object ); - - -/****************************************************************************************\ -* Epipolar Geometry * -\****************************************************************************************/ - -/* updates the number of RANSAC iterations */ -CVAPI(int) cvRANSACUpdateNumIters( double p, double err_prob, - int model_points, int max_iters ); - -CVAPI(void) cvConvertPointsHomogenious( const CvMat* src, CvMat* dst ); - -/* Calculates fundamental matrix given a set of corresponding points */ -#define CV_FM_7POINT 1 -#define CV_FM_8POINT 2 -#define CV_FM_LMEDS_ONLY 4 -#define CV_FM_RANSAC_ONLY 8 -#define CV_FM_LMEDS (CV_FM_LMEDS_ONLY + CV_FM_8POINT) -#define CV_FM_RANSAC (CV_FM_RANSAC_ONLY + CV_FM_8POINT) -CVAPI(int) cvFindFundamentalMat( const CvMat* points1, const CvMat* points2, - CvMat* fundamental_matrix, - int method CV_DEFAULT(CV_FM_RANSAC), - double param1 CV_DEFAULT(1.), double param2 CV_DEFAULT(0.99), - CvMat* status CV_DEFAULT(NULL) ); - -/* For each input point on one of images - computes parameters of the corresponding - epipolar line on the other image */ -CVAPI(void) cvComputeCorrespondEpilines( const CvMat* points, - int which_image, - const CvMat* fundamental_matrix, - CvMat* correspondent_lines ); - -#ifdef __cplusplus -} -#endif - -#ifdef __cplusplus -#include "cv.hpp" -#endif - -/****************************************************************************************\ -* Backward compatibility * -\****************************************************************************************/ - -#ifndef CV_NO_BACKWARD_COMPATIBILITY -#include "cvcompat.h" -#endif - -#endif /*_CV_H_*/