--- /dev/null
+/*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*/
+
+/*
+ A few macros and definitions for backward compatibility
+ with the previous versions of OpenCV. They are obsolete and
+ are likely to be removed in future. To check whether your code
+ uses any of these, define CV_NO_BACKWARD_COMPATIBILITY before
+ including cv.h.
+*/
+
+#ifndef _CVCOMPAT_H_
+#define _CVCOMPAT_H_
+
+#include <string.h>
+
+#ifdef __cplusplus
+ #define CV_UNREFERENCED(arg)
+#else
+ #define CV_UNREFERENCED(arg) arg
+#endif
+
+#define CvMatType int
+#define CvDisMaskType int
+#define CvMatArray CvMat
+
+#define CvThreshType int
+#define CvAdaptiveThreshMethod int
+#define CvCompareMethod int
+#define CvFontFace int
+#define CvPolyApproxMethod int
+#define CvContoursMatchMethod int
+#define CvContourTreesMatchMethod int
+#define CvCoeffType int
+#define CvRodriguesType int
+#define CvElementShape int
+#define CvMorphOp int
+#define CvTemplMatchMethod int
+
+#define CvPoint2D64d CvPoint2D64f
+#define CvPoint3D64d CvPoint3D64f
+
+#define CV_MAT32F CV_32FC1
+#define CV_MAT3x1_32F CV_32FC1
+#define CV_MAT4x1_32F CV_32FC1
+#define CV_MAT3x3_32F CV_32FC1
+#define CV_MAT4x4_32F CV_32FC1
+
+#define CV_MAT64D CV_64FC1
+#define CV_MAT3x1_64D CV_64FC1
+#define CV_MAT4x1_64D CV_64FC1
+#define CV_MAT3x3_64D CV_64FC1
+#define CV_MAT4x4_64D CV_64FC1
+
+#define IPL_GAUSSIAN_5x5 7
+#define CvBox2D32f CvBox2D
+
+/* allocation/deallocation macros */
+#define cvCreateImageData cvCreateData
+#define cvReleaseImageData cvReleaseData
+#define cvSetImageData cvSetData
+#define cvGetImageRawData cvGetRawData
+
+#define cvmAlloc cvCreateData
+#define cvmFree cvReleaseData
+#define cvmAllocArray cvCreateData
+#define cvmFreeArray cvReleaseData
+
+#define cvIntegralImage cvIntegral
+#define cvMatchContours cvMatchShapes
+
+CV_INLINE CvMat cvMatArray( int rows, int cols, int type,
+ int count, void* data CV_DEFAULT(0))
+{
+ return cvMat( rows*count, cols, type, data );
+}
+
+#define cvUpdateMHIByTime cvUpdateMotionHistory
+
+#define cvAccMask cvAcc
+#define cvSquareAccMask cvSquareAcc
+#define cvMultiplyAccMask cvMultiplyAcc
+#define cvRunningAvgMask(imgY, imgU, mask, alpha) cvRunningAvg(imgY, imgU, alpha, mask)
+
+#define cvSetHistThresh cvSetHistBinRanges
+#define cvCalcHistMask(img, mask, hist, doNotClear) cvCalcHist(img, hist, doNotClear, mask)
+
+CV_INLINE double cvMean( const CvArr* image, const CvArr* mask CV_DEFAULT(0))
+{
+ CvScalar mean = cvAvg( image, mask );
+ return mean.val[0];
+}
+
+
+CV_INLINE double cvSumPixels( const CvArr* image )
+{
+ CvScalar scalar = cvSum( image );
+ return scalar.val[0];
+}
+
+CV_INLINE void cvMean_StdDev( const CvArr* image, double* mean, double* sdv,
+ const CvArr* mask CV_DEFAULT(0))
+{
+ CvScalar _mean, _sdv;
+ cvAvgSdv( image, &_mean, &_sdv, mask );
+
+ if( mean )
+ *mean = _mean.val[0];
+
+ if( sdv )
+ *sdv = _sdv.val[0];
+}
+
+
+CV_INLINE void cvmPerspectiveProject( const CvMat* mat, const CvArr* src, CvArr* dst )
+{
+ CvMat tsrc, tdst;
+
+ cvReshape( src, &tsrc, 3, 0 );
+ cvReshape( dst, &tdst, 3, 0 );
+
+ cvPerspectiveTransform( &tsrc, &tdst, mat );
+}
+
+
+CV_INLINE void cvFillImage( CvArr* mat, double color )
+{
+ cvSet( mat, cvColorToScalar(color, cvGetElemType(mat)), 0 );
+}
+
+
+#define cvCvtPixToPlane cvSplit
+#define cvCvtPlaneToPix cvMerge
+
+typedef struct CvRandState
+{
+ CvRNG state; /* RNG state (the current seed and carry)*/
+ int disttype; /* distribution type */
+ CvScalar param[2]; /* parameters of RNG */
+}
+CvRandState;
+
+
+/* Changes RNG range while preserving RNG state */
+CV_INLINE void cvRandSetRange( CvRandState* state, double param1,
+ double param2, int index CV_DEFAULT(-1))
+{
+ if( !state )
+ {
+ cvError( CV_StsNullPtr, "cvRandSetRange", "Null pointer to RNG state", "cvcompat.h", 0 );
+ return;
+ }
+
+ if( (unsigned)(index + 1) > 4 )
+ {
+ cvError( CV_StsOutOfRange, "cvRandSetRange", "index is not in -1..3", "cvcompat.h", 0 );
+ return;
+ }
+
+ if( index < 0 )
+ {
+ state->param[0].val[0] = state->param[0].val[1] =
+ state->param[0].val[2] = state->param[0].val[3] = param1;
+ state->param[1].val[0] = state->param[1].val[1] =
+ state->param[1].val[2] = state->param[1].val[3] = param2;
+ }
+ else
+ {
+ state->param[0].val[index] = param1;
+ state->param[1].val[index] = param2;
+ }
+}
+
+
+CV_INLINE void cvRandInit( CvRandState* state, double param1,
+ double param2, int seed,
+ int disttype CV_DEFAULT(CV_RAND_UNI))
+{
+ if( !state )
+ {
+ cvError( CV_StsNullPtr, "cvRandInit", "Null pointer to RNG state", "cvcompat.h", 0 );
+ return;
+ }
+
+ if( disttype != CV_RAND_UNI && disttype != CV_RAND_NORMAL )
+ {
+ cvError( CV_StsBadFlag, "cvRandInit", "Unknown distribution type", "cvcompat.h", 0 );
+ return;
+ }
+
+ state->state = (uint64)(seed ? seed : -1);
+ state->disttype = disttype;
+ cvRandSetRange( state, param1, param2, -1 );
+}
+
+
+/* Fills array with random numbers */
+CV_INLINE void cvRand( CvRandState* state, CvArr* arr )
+{
+ if( !state )
+ {
+ cvError( CV_StsNullPtr, "cvRand", "Null pointer to RNG state", "cvcompat.h", 0 );
+ return;
+ }
+ cvRandArr( &state->state, arr, state->disttype, state->param[0], state->param[1] );
+}
+
+#define cvRandNext( _state ) cvRandInt( &(_state)->state )
+
+CV_INLINE void cvbRand( CvRandState* state, float* dst, int len )
+{
+ CvMat mat = cvMat( 1, len, CV_32F, (void*)dst );
+ cvRand( state, &mat );
+}
+
+
+CV_INLINE void cvbCartToPolar( const float* y, const float* x,
+ float* magnitude, float* angle, int len )
+{
+ CvMat mx = cvMat( 1, len, CV_32F, (void*)x );
+ CvMat my = mx;
+ CvMat mm = mx;
+ CvMat ma = mx;
+
+ my.data.fl = (float*)y;
+ mm.data.fl = (float*)magnitude;
+ ma.data.fl = (float*)angle;
+
+ cvCartToPolar( &mx, &my, &mm, angle ? &ma : NULL, 1 );
+}
+
+
+CV_INLINE void cvbFastArctan( const float* y, const float* x,
+ float* angle, int len )
+{
+ CvMat mx = cvMat( 1, len, CV_32F, (void*)x );
+ CvMat my = mx;
+ CvMat ma = mx;
+
+ my.data.fl = (float*)y;
+ ma.data.fl = (float*)angle;
+
+ cvCartToPolar( &mx, &my, NULL, &ma, 1 );
+}
+
+
+CV_INLINE void cvbSqrt( const float* x, float* y, int len )
+{
+ CvMat mx = cvMat( 1, len, CV_32F, (void*)x );
+ CvMat my = mx;
+ my.data.fl = (float*)y;
+
+ cvPow( &mx, &my, 0.5 );
+}
+
+
+CV_INLINE void cvbInvSqrt( const float* x, float* y, int len )
+{
+ CvMat mx = cvMat( 1, len, CV_32F, (void*)x );
+ CvMat my = mx;
+ my.data.fl = (float*)y;
+
+ cvPow( &mx, &my, -0.5 );
+}
+
+
+CV_INLINE void cvbReciprocal( const float* x, float* y, int len )
+{
+ CvMat mx = cvMat( 1, len, CV_32F, (void*)x );
+ CvMat my = mx;
+ my.data.fl = (float*)y;
+
+ cvPow( &mx, &my, -1 );
+}
+
+
+CV_INLINE void cvbFastExp( const float* x, double* y, int len )
+{
+ CvMat mx = cvMat( 1, len, CV_32F, (void*)x );
+ CvMat my = cvMat( 1, len, CV_64F, y );
+ cvExp( &mx, &my );
+}
+
+
+CV_INLINE void cvbFastLog( const double* x, float* y, int len )
+{
+ CvMat mx = cvMat( 1, len, CV_64F, (void*)x );
+ CvMat my = cvMat( 1, len, CV_32F, y );
+ cvLog( &mx, &my );
+}
+
+
+CV_INLINE CvRect cvContourBoundingRect( void* point_set, int update CV_DEFAULT(0))
+{
+ return cvBoundingRect( point_set, update );
+}
+
+
+CV_INLINE double cvPseudoInverse( const CvArr* src, CvArr* dst )
+{
+ return cvInvert( src, dst, CV_SVD );
+}
+
+#define cvPseudoInv cvPseudoInverse
+
+#define cvContourMoments( contour, moments ) \
+ cvMoments( contour, moments, 0 )
+
+#define cvGetPtrAt cvPtr2D
+#define cvGetAt cvGet2D
+#define cvSetAt(arr,val,y,x) cvSet2D((arr),(y),(x),(val))
+
+#define cvMeanMask cvMean
+#define cvMean_StdDevMask(img,mask,mean,sdv) cvMean_StdDev(img,mean,sdv,mask)
+
+#define cvNormMask(imgA,imgB,mask,normType) cvNorm(imgA,imgB,normType,mask)
+
+#define cvMinMaxLocMask(img, mask, min_val, max_val, min_loc, max_loc) \
+ cvMinMaxLoc(img, min_val, max_val, min_loc, max_loc, mask)
+
+#define cvRemoveMemoryManager cvSetMemoryManager
+
+#define cvmSetZero( mat ) cvSetZero( mat )
+#define cvmSetIdentity( mat ) cvSetIdentity( mat )
+#define cvmAdd( src1, src2, dst ) cvAdd( src1, src2, dst, 0 )
+#define cvmSub( src1, src2, dst ) cvSub( src1, src2, dst, 0 )
+#define cvmCopy( src, dst ) cvCopy( src, dst, 0 )
+#define cvmMul( src1, src2, dst ) cvMatMulAdd( src1, src2, 0, dst )
+#define cvmTranspose( src, dst ) cvT( src, dst )
+#define cvmInvert( src, dst ) cvInv( src, dst )
+#define cvmMahalanobis(vec1, vec2, mat) cvMahalanobis( vec1, vec2, mat )
+#define cvmDotProduct( vec1, vec2 ) cvDotProduct( vec1, vec2 )
+#define cvmCrossProduct(vec1, vec2,dst) cvCrossProduct( vec1, vec2, dst )
+#define cvmTrace( mat ) (cvTrace( mat )).val[0]
+#define cvmMulTransposed( src, dst, order ) cvMulTransposed( src, dst, order )
+#define cvmEigenVV( mat, evec, eval, eps) cvEigenVV( mat, evec, eval, eps )
+#define cvmDet( mat ) cvDet( mat )
+#define cvmScale( src, dst, scale ) cvScale( src, dst, scale )
+
+#define cvCopyImage( src, dst ) cvCopy( src, dst, 0 )
+#define cvReleaseMatHeader cvReleaseMat
+
+/* Calculates exact convex hull of 2d point set */
+CV_INLINE void cvConvexHull( CvPoint* points, int num_points,
+ CvRect* CV_UNREFERENCED(bound_rect),
+ int orientation, int* hull, int* hullsize )
+{
+ CvMat points1 = cvMat( 1, num_points, CV_32SC2, points );
+ CvMat hull1 = cvMat( 1, num_points, CV_32SC1, hull );
+
+ cvConvexHull2( &points1, &hull1, orientation, 0 );
+ *hullsize = hull1.cols;
+}
+
+/* Calculates exact convex hull of 2d point set stored in a sequence */
+#define cvContourConvexHull( contour, orientation, storage ) \
+ cvConvexHull2( contour, storage, orientation )
+
+/* Calculates approximate convex hull of 2d point set */
+#define cvConvexHullApprox( points, num_points, bound_rect, bandwidth, \
+ orientation, hull, hullsize ) \
+cvConvexHull( points, num_points, bound_rect, orientation, hull, hullsize )
+
+/* Calculates approximate convex hull of 2d point set stored in a sequence */
+#define cvContourConvexHullApprox( contour, bandwidth, orientation, storage ) \
+ cvConvexHull2( contour, storage, orientation )
+
+
+CV_INLINE void cvMinAreaRect( CvPoint* points, int n,
+ int CV_UNREFERENCED(left), int CV_UNREFERENCED(bottom),
+ int CV_UNREFERENCED(right), int CV_UNREFERENCED(top),
+ CvPoint2D32f* anchor,
+ CvPoint2D32f* vect1,
+ CvPoint2D32f* vect2 )
+{
+ CvMat mat = cvMat( 1, n, CV_32SC2, points );
+ CvBox2D box = cvMinAreaRect2( &mat, 0 );
+ CvPoint2D32f pt[4];
+
+ cvBoxPoints( box, pt );
+ *anchor = pt[0];
+ vect1->x = pt[1].x - pt[0].x;
+ vect1->y = pt[1].y - pt[0].y;
+ vect2->x = pt[3].x - pt[0].x;
+ vect2->y = pt[3].y - pt[0].y;
+
+ CV_UNREFERENCED( (left, bottom, right, top) );
+}
+
+typedef int CvDisType;
+typedef int CvChainApproxMethod;
+typedef int CvContourRetrievalMode;
+
+CV_INLINE void cvFitLine3D( CvPoint3D32f* points, int count, int dist,
+ void *param, float reps, float aeps, float* line )
+{
+ CvMat mat = cvMat( 1, count, CV_32FC3, points );
+ float _param = param != NULL ? *(float*)param : 0.f;
+ assert( dist != CV_DIST_USER );
+ cvFitLine( &mat, dist, _param, reps, aeps, line );
+}
+
+/* Fits a line into set of 2d points in a robust way (M-estimator technique) */
+CV_INLINE void cvFitLine2D( CvPoint2D32f* points, int count, int dist,
+ void *param, float reps, float aeps, float* line )
+{
+ CvMat mat = cvMat( 1, count, CV_32FC2, points );
+ float _param = param != NULL ? *(float*)param : 0.f;
+ assert( dist != CV_DIST_USER );
+ cvFitLine( &mat, dist, _param, reps, aeps, line );
+}
+
+
+CV_INLINE void cvFitEllipse( const CvPoint2D32f* points, int count, CvBox2D* box )
+{
+ CvMat mat = cvMat( 1, count, CV_32FC2, (void*)points );
+ *box = cvFitEllipse2( &mat );
+}
+
+/* Projects 2d points to one of standard coordinate planes
+ (i.e. removes one of coordinates) */
+CV_INLINE void cvProject3D( CvPoint3D32f* points3D, int count,
+ CvPoint2D32f* points2D,
+ int xIndx CV_DEFAULT(0),
+ int yIndx CV_DEFAULT(1))
+{
+ CvMat src = cvMat( 1, count, CV_32FC3, points3D );
+ CvMat dst = cvMat( 1, count, CV_32FC2, points2D );
+ float m[6] = {0,0,0,0,0,0};
+ CvMat M = cvMat( 2, 3, CV_32F, m );
+
+ assert( (unsigned)xIndx < 3 && (unsigned)yIndx < 3 );
+ m[xIndx] = m[yIndx+3] = 1.f;
+
+ cvTransform( &src, &dst, &M, NULL );
+}
+
+
+/* Retrieves value of the particular bin
+ of x-dimensional (x=1,2,3,...) histogram */
+#define cvQueryHistValue_1D( hist, idx0 ) \
+ ((float)cvGetReal1D( (hist)->bins, (idx0)))
+#define cvQueryHistValue_2D( hist, idx0, idx1 ) \
+ ((float)cvGetReal2D( (hist)->bins, (idx0), (idx1)))
+#define cvQueryHistValue_3D( hist, idx0, idx1, idx2 ) \
+ ((float)cvGetReal3D( (hist)->bins, (idx0), (idx1), (idx2)))
+#define cvQueryHistValue_nD( hist, idx ) \
+ ((float)cvGetRealND( (hist)->bins, (idx)))
+
+/* Returns pointer to the particular bin of x-dimesional histogram.
+ For sparse histogram the bin is created if it didn't exist before */
+#define cvGetHistValue_1D( hist, idx0 ) \
+ ((float*)cvPtr1D( (hist)->bins, (idx0), 0))
+#define cvGetHistValue_2D( hist, idx0, idx1 ) \
+ ((float*)cvPtr2D( (hist)->bins, (idx0), (idx1), 0))
+#define cvGetHistValue_3D( hist, idx0, idx1, idx2 ) \
+ ((float*)cvPtr3D( (hist)->bins, (idx0), (idx1), (idx2), 0))
+#define cvGetHistValue_nD( hist, idx ) \
+ ((float*)cvPtrND( (hist)->bins, (idx), 0))
+
+
+#define CV_IS_SET_ELEM_EXISTS CV_IS_SET_ELEM
+
+
+CV_INLINE int cvHoughLines( CvArr* image, double rho,
+ double theta, int threshold,
+ float* lines, int linesNumber )
+{
+ CvMat linesMat = cvMat( 1, linesNumber, CV_32FC2, lines );
+ cvHoughLines2( image, &linesMat, CV_HOUGH_STANDARD,
+ rho, theta, threshold, 0, 0 );
+
+ return linesMat.cols;
+}
+
+
+CV_INLINE int cvHoughLinesP( CvArr* image, double rho,
+ double theta, int threshold,
+ int lineLength, int lineGap,
+ int* lines, int linesNumber )
+{
+ CvMat linesMat = cvMat( 1, linesNumber, CV_32SC4, lines );
+ cvHoughLines2( image, &linesMat, CV_HOUGH_PROBABILISTIC,
+ rho, theta, threshold, lineLength, lineGap );
+
+ return linesMat.cols;
+}
+
+
+CV_INLINE int cvHoughLinesSDiv( CvArr* image, double rho, int srn,
+ double theta, int stn, int threshold,
+ float* lines, int linesNumber )
+{
+ CvMat linesMat = cvMat( 1, linesNumber, CV_32FC2, lines );
+ cvHoughLines2( image, &linesMat, CV_HOUGH_MULTI_SCALE,
+ rho, theta, threshold, srn, stn );
+
+ return linesMat.cols;
+}
+
+
+/* Find fundamental matrix */
+CV_INLINE void cvFindFundamentalMatrix( int* points1, int* points2,
+ int numpoints, int CV_UNREFERENCED(method), float* matrix )
+{
+ CvMat* pointsMat1;
+ CvMat* pointsMat2;
+ CvMat fundMatr = cvMat(3,3,CV_32F,matrix);
+ int i, curr = 0;
+
+ pointsMat1 = cvCreateMat(3,numpoints,CV_64F);
+ pointsMat2 = cvCreateMat(3,numpoints,CV_64F);
+
+ for( i = 0; i < numpoints; i++ )
+ {
+ cvmSet(pointsMat1,0,i,points1[curr]);//x
+ cvmSet(pointsMat1,1,i,points1[curr+1]);//y
+ cvmSet(pointsMat1,2,i,1.0);
+
+ cvmSet(pointsMat2,0,i,points2[curr]);//x
+ cvmSet(pointsMat2,1,i,points2[curr+1]);//y
+ cvmSet(pointsMat2,2,i,1.0);
+ curr += 2;
+ }
+
+ cvFindFundamentalMat(pointsMat1,pointsMat2,&fundMatr,CV_FM_RANSAC,1,0.99,0);
+
+ cvReleaseMat(&pointsMat1);
+ cvReleaseMat(&pointsMat2);
+}
+
+
+
+CV_INLINE int
+cvFindChessBoardCornerGuesses( const void* arr, void* CV_UNREFERENCED(thresharr),
+ CvMemStorage * CV_UNREFERENCED(storage),
+ CvSize pattern_size, CvPoint2D32f * corners,
+ int *corner_count )
+{
+ return cvFindChessboardCorners( arr, pattern_size, corners,
+ corner_count, CV_CALIB_CB_ADAPTIVE_THRESH );
+}
+
+
+/* Calibrates camera using multiple views of calibration pattern */
+CV_INLINE void cvCalibrateCamera( int image_count, int* _point_counts,
+ CvSize image_size, CvPoint2D32f* _image_points, CvPoint3D32f* _object_points,
+ float* _distortion_coeffs, float* _camera_matrix, float* _translation_vectors,
+ float* _rotation_matrices, int flags )
+{
+ int i, total = 0;
+ CvMat point_counts = cvMat( image_count, 1, CV_32SC1, _point_counts );
+ CvMat image_points, object_points;
+ CvMat dist_coeffs = cvMat( 4, 1, CV_32FC1, _distortion_coeffs );
+ CvMat camera_matrix = cvMat( 3, 3, CV_32FC1, _camera_matrix );
+ CvMat rotation_matrices = cvMat( image_count, 9, CV_32FC1, _rotation_matrices );
+ CvMat translation_vectors = cvMat( image_count, 3, CV_32FC1, _translation_vectors );
+
+ for( i = 0; i < image_count; i++ )
+ total += _point_counts[i];
+
+ image_points = cvMat( total, 1, CV_32FC2, _image_points );
+ object_points = cvMat( total, 1, CV_32FC3, _object_points );
+
+ cvCalibrateCamera2( &object_points, &image_points, &point_counts, image_size,
+ &camera_matrix, &dist_coeffs, &rotation_matrices, &translation_vectors,
+ flags );
+}
+
+
+CV_INLINE void cvCalibrateCamera_64d( int image_count, int* _point_counts,
+ CvSize image_size, CvPoint2D64f* _image_points, CvPoint3D64f* _object_points,
+ double* _distortion_coeffs, double* _camera_matrix, double* _translation_vectors,
+ double* _rotation_matrices, int flags )
+{
+ int i, total = 0;
+ CvMat point_counts = cvMat( image_count, 1, CV_32SC1, _point_counts );
+ CvMat image_points, object_points;
+ CvMat dist_coeffs = cvMat( 4, 1, CV_64FC1, _distortion_coeffs );
+ CvMat camera_matrix = cvMat( 3, 3, CV_64FC1, _camera_matrix );
+ CvMat rotation_matrices = cvMat( image_count, 9, CV_64FC1, _rotation_matrices );
+ CvMat translation_vectors = cvMat( image_count, 3, CV_64FC1, _translation_vectors );
+
+ for( i = 0; i < image_count; i++ )
+ total += _point_counts[i];
+
+ image_points = cvMat( total, 1, CV_64FC2, _image_points );
+ object_points = cvMat( total, 1, CV_64FC3, _object_points );
+
+ cvCalibrateCamera2( &object_points, &image_points, &point_counts, image_size,
+ &camera_matrix, &dist_coeffs, &rotation_matrices, &translation_vectors,
+ flags );
+}
+
+
+
+/* Find 3d position of object given intrinsic camera parameters,
+ 3d model of the object and projection of the object into view plane */
+CV_INLINE void cvFindExtrinsicCameraParams( int point_count,
+ CvSize CV_UNREFERENCED(image_size), CvPoint2D32f* _image_points,
+ CvPoint3D32f* _object_points, float* focal_length,
+ CvPoint2D32f principal_point, float* _distortion_coeffs,
+ float* _rotation_vector, float* _translation_vector )
+{
+ CvMat image_points = cvMat( point_count, 1, CV_32FC2, _image_points );
+ CvMat object_points = cvMat( point_count, 1, CV_32FC3, _object_points );
+ CvMat dist_coeffs = cvMat( 4, 1, CV_32FC1, _distortion_coeffs );
+ float a[9];
+ CvMat camera_matrix = cvMat( 3, 3, CV_32FC1, a );
+ CvMat rotation_vector = cvMat( 1, 1, CV_32FC3, _rotation_vector );
+ CvMat translation_vector = cvMat( 1, 1, CV_32FC3, _translation_vector );
+
+ a[0] = focal_length[0]; a[4] = focal_length[1];
+ a[2] = principal_point.x; a[5] = principal_point.y;
+ a[1] = a[3] = a[6] = a[7] = 0.f;
+ a[8] = 1.f;
+
+ cvFindExtrinsicCameraParams2( &object_points, &image_points, &camera_matrix,
+ &dist_coeffs, &rotation_vector, &translation_vector, 0 );
+}
+
+
+/* Variant of the previous function that takes double-precision parameters */
+CV_INLINE void cvFindExtrinsicCameraParams_64d( int point_count,
+ CvSize CV_UNREFERENCED(image_size), CvPoint2D64f* _image_points,
+ CvPoint3D64f* _object_points, double* focal_length,
+ CvPoint2D64f principal_point, double* _distortion_coeffs,
+ double* _rotation_vector, double* _translation_vector )
+{
+ CvMat image_points = cvMat( point_count, 1, CV_64FC2, _image_points );
+ CvMat object_points = cvMat( point_count, 1, CV_64FC3, _object_points );
+ CvMat dist_coeffs = cvMat( 4, 1, CV_64FC1, _distortion_coeffs );
+ double a[9];
+ CvMat camera_matrix = cvMat( 3, 3, CV_64FC1, a );
+ CvMat rotation_vector = cvMat( 1, 1, CV_64FC3, _rotation_vector );
+ CvMat translation_vector = cvMat( 1, 1, CV_64FC3, _translation_vector );
+
+ a[0] = focal_length[0]; a[4] = focal_length[1];
+ a[2] = principal_point.x; a[5] = principal_point.y;
+ a[1] = a[3] = a[6] = a[7] = 0.;
+ a[8] = 1.;
+
+ cvFindExtrinsicCameraParams2( &object_points, &image_points, &camera_matrix,
+ &dist_coeffs, &rotation_vector, &translation_vector, 0 );
+}
+
+
+/* Rodrigues transform */
+#define CV_RODRIGUES_M2V 0
+#define CV_RODRIGUES_V2M 1
+
+/* Converts rotation_matrix matrix to rotation_matrix vector or vice versa */
+CV_INLINE void cvRodrigues( CvMat* rotation_matrix, CvMat* rotation_vector,
+ CvMat* jacobian, int conv_type )
+{
+ if( conv_type == CV_RODRIGUES_V2M )
+ cvRodrigues2( rotation_vector, rotation_matrix, jacobian );
+ else
+ cvRodrigues2( rotation_matrix, rotation_vector, jacobian );
+}
+
+
+/* Does reprojection of 3d object points to the view plane */
+CV_INLINE void cvProjectPoints( int point_count, CvPoint3D64f* _object_points,
+ double* _rotation_vector, double* _translation_vector,
+ double* focal_length, CvPoint2D64f principal_point,
+ double* _distortion, CvPoint2D64f* _image_points,
+ double* _deriv_points_rotation_matrix,
+ double* _deriv_points_translation_vect,
+ double* _deriv_points_focal,
+ double* _deriv_points_principal_point,
+ double* _deriv_points_distortion_coeffs )
+{
+ CvMat object_points = cvMat( point_count, 1, CV_64FC3, _object_points );
+ CvMat image_points = cvMat( point_count, 1, CV_64FC2, _image_points );
+ CvMat rotation_vector = cvMat( 3, 1, CV_64FC1, _rotation_vector );
+ CvMat translation_vector = cvMat( 3, 1, CV_64FC1, _translation_vector );
+ double a[9];
+ CvMat camera_matrix = cvMat( 3, 3, CV_64FC1, a );
+ CvMat dist_coeffs = cvMat( 4, 1, CV_64FC1, _distortion );
+ CvMat dpdr = cvMat( 2*point_count, 3, CV_64FC1, _deriv_points_rotation_matrix );
+ CvMat dpdt = cvMat( 2*point_count, 3, CV_64FC1, _deriv_points_translation_vect );
+ CvMat dpdf = cvMat( 2*point_count, 2, CV_64FC1, _deriv_points_focal );
+ CvMat dpdc = cvMat( 2*point_count, 2, CV_64FC1, _deriv_points_principal_point );
+ CvMat dpdk = cvMat( 2*point_count, 4, CV_64FC1, _deriv_points_distortion_coeffs );
+
+ a[0] = focal_length[0]; a[4] = focal_length[1];
+ a[2] = principal_point.x; a[5] = principal_point.y;
+ a[1] = a[3] = a[6] = a[7] = 0.;
+ a[8] = 1.;
+
+ cvProjectPoints2( &object_points, &rotation_vector, &translation_vector,
+ &camera_matrix, &dist_coeffs, &image_points,
+ &dpdr, &dpdt, &dpdf, &dpdc, &dpdk, 0 );
+}
+
+
+/* Simpler version of the previous function */
+CV_INLINE void cvProjectPointsSimple( int point_count, CvPoint3D64f* _object_points,
+ double* _rotation_matrix, double* _translation_vector,
+ double* _camera_matrix, double* _distortion, CvPoint2D64f* _image_points )
+{
+ CvMat object_points = cvMat( point_count, 1, CV_64FC3, _object_points );
+ CvMat image_points = cvMat( point_count, 1, CV_64FC2, _image_points );
+ CvMat rotation_matrix = cvMat( 3, 3, CV_64FC1, _rotation_matrix );
+ CvMat translation_vector = cvMat( 3, 1, CV_64FC1, _translation_vector );
+ CvMat camera_matrix = cvMat( 3, 3, CV_64FC1, _camera_matrix );
+ CvMat dist_coeffs = cvMat( 4, 1, CV_64FC1, _distortion );
+
+ cvProjectPoints2( &object_points, &rotation_matrix, &translation_vector,
+ &camera_matrix, &dist_coeffs, &image_points,
+ 0, 0, 0, 0, 0, 0 );
+}
+
+
+CV_INLINE void cvUnDistortOnce( const CvArr* src, CvArr* dst,
+ const float* intrinsic_matrix,
+ const float* distortion_coeffs,
+ int CV_UNREFERENCED(interpolate) )
+{
+ CvMat _a = cvMat( 3, 3, CV_32F, (void*)intrinsic_matrix );
+ CvMat _k = cvMat( 4, 1, CV_32F, (void*)distortion_coeffs );
+ cvUndistort2( src, dst, &_a, &_k );
+}
+
+
+/* the two functions below have quite hackerish implementations, use with care
+ (or, which is better, switch to cvUndistortInitMap and cvRemap instead */
+CV_INLINE void cvUnDistortInit( const CvArr* CV_UNREFERENCED(src),
+ CvArr* undistortion_map,
+ const float* A, const float* k,
+ int CV_UNREFERENCED(interpolate) )
+{
+ union { uchar* ptr; float* fl; } data;
+ CvSize sz;
+ cvGetRawData( undistortion_map, &data.ptr, 0, &sz );
+ assert( sz.width >= 8 );
+ /* just save the intrinsic parameters to the map */
+ data.fl[0] = A[0]; data.fl[1] = A[4];
+ data.fl[2] = A[2]; data.fl[3] = A[5];
+ data.fl[4] = k[0]; data.fl[5] = k[1];
+ data.fl[6] = k[2]; data.fl[7] = k[3];
+}
+
+CV_INLINE void cvUnDistort( const CvArr* src, CvArr* dst,
+ const CvArr* undistortion_map,
+ int CV_UNREFERENCED(interpolate) )
+{
+ union { uchar* ptr; float* fl; } data;
+ float a[] = {0,0,0,0,0,0,0,0,1};
+ CvSize sz;
+ cvGetRawData( undistortion_map, &data.ptr, 0, &sz );
+ assert( sz.width >= 8 );
+ a[0] = data.fl[0]; a[4] = data.fl[1];
+ a[2] = data.fl[2]; a[5] = data.fl[3];
+ cvUnDistortOnce( src, dst, a, data.fl + 4, 1 );
+}
+
+
+CV_INLINE float cvCalcEMD( const float* signature1, int size1,
+ const float* signature2, int size2,
+ int dims, int dist_type CV_DEFAULT(CV_DIST_L2),
+ CvDistanceFunction dist_func CV_DEFAULT(0),
+ float* lower_bound CV_DEFAULT(0),
+ void* user_param CV_DEFAULT(0))
+{
+ CvMat sign1 = cvMat( size1, dims + 1, CV_32FC1, (void*)signature1 );
+ CvMat sign2 = cvMat( size2, dims + 1, CV_32FC1, (void*)signature2 );
+
+ return cvCalcEMD2( &sign1, &sign2, dist_type, dist_func, 0, 0, lower_bound, user_param );
+}
+
+
+CV_INLINE void cvKMeans( int num_clusters, float** samples,
+ int num_samples, int vec_size,
+ CvTermCriteria termcrit, int* cluster_idx )
+{
+ CvMat* samples_mat = cvCreateMat( num_samples, vec_size, CV_32FC1 );
+ CvMat cluster_idx_mat = cvMat( num_samples, 1, CV_32SC1, cluster_idx );
+ int i;
+ for( i = 0; i < num_samples; i++ )
+ memcpy( samples_mat->data.fl + i*vec_size, samples[i], vec_size*sizeof(float));
+ cvKMeans2( samples_mat, num_clusters, &cluster_idx_mat, termcrit, 1, 0, 0, 0, 0 );
+ cvReleaseMat( &samples_mat );
+}
+
+
+CV_INLINE void cvStartScanGraph( CvGraph* graph, CvGraphScanner* scanner,
+ CvGraphVtx* vtx CV_DEFAULT(NULL),
+ int mask CV_DEFAULT(CV_GRAPH_ALL_ITEMS))
+{
+ CvGraphScanner* temp_scanner;
+
+ if( !scanner )
+ cvError( CV_StsNullPtr, "cvStartScanGraph", "Null scanner pointer", "cvcompat.h", 0 );
+
+ temp_scanner = cvCreateGraphScanner( graph, vtx, mask );
+ *scanner = *temp_scanner;
+ cvFree( &temp_scanner );
+}
+
+
+CV_INLINE void cvEndScanGraph( CvGraphScanner* scanner )
+{
+ if( !scanner )
+ cvError( CV_StsNullPtr, "cvEndScanGraph", "Null scanner pointer", "cvcompat.h", 0 );
+
+ if( scanner->stack )
+ {
+ CvGraphScanner* temp_scanner = (CvGraphScanner*)cvAlloc( sizeof(*temp_scanner) );
+ *temp_scanner = *scanner;
+ cvReleaseGraphScanner( &temp_scanner );
+ memset( scanner, 0, sizeof(*scanner) );
+ }
+}
+
+
+#define cvKalmanUpdateByTime cvKalmanPredict
+#define cvKalmanUpdateByMeasurement cvKalmanCorrect
+
+/* old drawing functions */
+CV_INLINE void cvLineAA( CvArr* img, CvPoint pt1, CvPoint pt2,
+ double color, int scale CV_DEFAULT(0))
+{
+ cvLine( img, pt1, pt2, cvColorToScalar(color, cvGetElemType(img)), 1, CV_AA, scale );
+}
+
+CV_INLINE void cvCircleAA( CvArr* img, CvPoint center, int radius,
+ double color, int scale CV_DEFAULT(0) )
+{
+ cvCircle( img, center, radius, cvColorToScalar(color, cvGetElemType(img)), 1, CV_AA, scale );
+}
+
+CV_INLINE void cvEllipseAA( CvArr* img, CvPoint center, CvSize axes,
+ double angle, double start_angle,
+ double end_angle, double color,
+ int scale CV_DEFAULT(0) )
+{
+ cvEllipse( img, center, axes, angle, start_angle, end_angle,
+ cvColorToScalar(color, cvGetElemType(img)), 1, CV_AA, scale );
+}
+
+CV_INLINE void cvPolyLineAA( CvArr* img, CvPoint** pts, int* npts, int contours,
+ int is_closed, double color, int scale CV_DEFAULT(0) )
+{
+ cvPolyLine( img, pts, npts, contours, is_closed,
+ cvColorToScalar(color, cvGetElemType(img)),
+ 1, CV_AA, scale );
+}
+
+
+#define cvMake2DPoints cvConvertPointsHomogeneous
+#define cvMake3DPoints cvConvertPointsHomogeneous
+
+#define cvWarpPerspectiveQMatrix cvGetPerspectiveTransform
+
+#define cvConvertPointsHomogenious cvConvertPointsHomogeneous
+
+/****************************************************************************************\
+* Pixel Access Macros *
+\****************************************************************************************/
+
+typedef struct _CvPixelPosition8u
+{
+ uchar* currline; /* pointer to the start of the current pixel line */
+ uchar* topline; /* pointer to the start of the top pixel line */
+ uchar* bottomline; /* pointer to the start of the first line */
+ /* which is below the image */
+ int x; /* current x coordinate ( in pixels ) */
+ int width; /* width of the image ( in pixels ) */
+ int height; /* height of the image ( in pixels ) */
+ int step; /* distance between lines ( in elements of single */
+ /* plane ) */
+ int step_arr[3]; /* array: ( 0, -step, step ). It is used for */
+ /* vertical moving */
+} CvPixelPosition8u;
+
+/* this structure differs from the above only in data type */
+typedef struct _CvPixelPosition8s
+{
+ schar* currline;
+ schar* topline;
+ schar* bottomline;
+ int x;
+ int width;
+ int height;
+ int step;
+ int step_arr[3];
+} CvPixelPosition8s;
+
+/* this structure differs from the CvPixelPosition8u only in data type */
+typedef struct _CvPixelPosition32f
+{
+ float* currline;
+ float* topline;
+ float* bottomline;
+ int x;
+ int width;
+ int height;
+ int step;
+ int step_arr[3];
+} CvPixelPosition32f;
+
+
+/* Initialize one of the CvPixelPosition structures. */
+/* pos - initialized structure */
+/* origin - pointer to the left-top corner of the ROI */
+/* step - width of the whole image in bytes */
+/* roi - width & height of the ROI */
+/* x, y - initial position */
+#define CV_INIT_PIXEL_POS(pos, origin, _step, roi, _x, _y, orientation) \
+ ( \
+ (pos).step = (_step)/sizeof((pos).currline[0]) * (orientation ? -1 : 1), \
+ (pos).width = (roi).width, \
+ (pos).height = (roi).height, \
+ (pos).bottomline = (origin) + (pos).step*(pos).height, \
+ (pos).topline = (origin) - (pos).step, \
+ (pos).step_arr[0] = 0, \
+ (pos).step_arr[1] = -(pos).step, \
+ (pos).step_arr[2] = (pos).step, \
+ (pos).x = (_x), \
+ (pos).currline = (origin) + (pos).step*(_y) )
+
+
+/* Move to specified point ( absolute shift ) */
+/* pos - position structure */
+/* x, y - coordinates of the new position */
+/* cs - number of the image channels */
+#define CV_MOVE_TO( pos, _x, _y, cs ) \
+((pos).currline = (_y) >= 0 && (_y) < (pos).height ? (pos).topline + ((_y)+1)*(pos).step : 0, \
+ (pos).x = (_x) >= 0 && (_x) < (pos).width ? (_x) : 0, (pos).currline + (_x) * (cs) )
+
+/* Get current coordinates */
+/* pos - position structure */
+/* x, y - coordinates of the new position */
+/* cs - number of the image channels */
+#define CV_GET_CURRENT( pos, cs ) ((pos).currline + (pos).x * (cs))
+
+/* Move by one pixel relatively to current position */
+/* pos - position structure */
+/* cs - number of the image channels */
+
+/* left */
+#define CV_MOVE_LEFT( pos, cs ) \
+ ( --(pos).x >= 0 ? (pos).currline + (pos).x*(cs) : 0 )
+
+/* right */
+#define CV_MOVE_RIGHT( pos, cs ) \
+ ( ++(pos).x < (pos).width ? (pos).currline + (pos).x*(cs) : 0 )
+
+/* up */
+#define CV_MOVE_UP( pos, cs ) \
+ (((pos).currline -= (pos).step) != (pos).topline ? (pos).currline + (pos).x*(cs) : 0 )
+
+/* down */
+#define CV_MOVE_DOWN( pos, cs ) \
+ (((pos).currline += (pos).step) != (pos).bottomline ? (pos).currline + (pos).x*(cs) : 0 )
+
+/* left up */
+#define CV_MOVE_LU( pos, cs ) ( CV_MOVE_LEFT(pos, cs), CV_MOVE_UP(pos, cs))
+
+/* right up */
+#define CV_MOVE_RU( pos, cs ) ( CV_MOVE_RIGHT(pos, cs), CV_MOVE_UP(pos, cs))
+
+/* left down */
+#define CV_MOVE_LD( pos, cs ) ( CV_MOVE_LEFT(pos, cs), CV_MOVE_DOWN(pos, cs))
+
+/* right down */
+#define CV_MOVE_RD( pos, cs ) ( CV_MOVE_RIGHT(pos, cs), CV_MOVE_DOWN(pos, cs))
+
+
+
+/* Move by one pixel relatively to current position with wrapping when the position */
+/* achieves image boundary */
+/* pos - position structure */
+/* cs - number of the image channels */
+
+/* left */
+#define CV_MOVE_LEFT_WRAP( pos, cs ) \
+ ((pos).currline + ( --(pos).x >= 0 ? (pos).x : ((pos).x = (pos).width-1))*(cs))
+
+/* right */
+#define CV_MOVE_RIGHT_WRAP( pos, cs ) \
+ ((pos).currline + ( ++(pos).x < (pos).width ? (pos).x : ((pos).x = 0))*(cs) )
+
+/* up */
+#define CV_MOVE_UP_WRAP( pos, cs ) \
+ ((((pos).currline -= (pos).step) != (pos).topline ? \
+ (pos).currline : ((pos).currline = (pos).bottomline - (pos).step)) + (pos).x*(cs) )
+
+/* down */
+#define CV_MOVE_DOWN_WRAP( pos, cs ) \
+ ((((pos).currline += (pos).step) != (pos).bottomline ? \
+ (pos).currline : ((pos).currline = (pos).topline + (pos).step)) + (pos).x*(cs) )
+
+/* left up */
+#define CV_MOVE_LU_WRAP( pos, cs ) ( CV_MOVE_LEFT_WRAP(pos, cs), CV_MOVE_UP_WRAP(pos, cs))
+/* right up */
+#define CV_MOVE_RU_WRAP( pos, cs ) ( CV_MOVE_RIGHT_WRAP(pos, cs), CV_MOVE_UP_WRAP(pos, cs))
+/* left down */
+#define CV_MOVE_LD_WRAP( pos, cs ) ( CV_MOVE_LEFT_WRAP(pos, cs), CV_MOVE_DOWN_WRAP(pos, cs))
+/* right down */
+#define CV_MOVE_RD_WRAP( pos, cs ) ( CV_MOVE_RIGHT_WRAP(pos, cs), CV_MOVE_DOWN_WRAP(pos, cs))
+
+/* Numeric constants which used for moving in arbitrary direction */
+#define CV_SHIFT_NONE 2
+#define CV_SHIFT_LEFT 1
+#define CV_SHIFT_RIGHT 3
+#define CV_SHIFT_UP 6
+#define CV_SHIFT_DOWN 10
+#define CV_SHIFT_LU 5
+#define CV_SHIFT_RU 7
+#define CV_SHIFT_LD 9
+#define CV_SHIFT_RD 11
+
+/* Move by one pixel in specified direction */
+/* pos - position structure */
+/* shift - direction ( it's value must be one of the CV_SHIFT_\85 constants ) */
+/* cs - number of the image channels */
+#define CV_MOVE_PARAM( pos, shift, cs ) \
+ ( (pos).currline += (pos).step_arr[(shift)>>2], (pos).x += ((shift)&3)-2, \
+ ((pos).currline != (pos).topline && (pos).currline != (pos).bottomline && \
+ (pos).x >= 0 && (pos).x < (pos).width) ? (pos).currline + (pos).x*(cs) : 0 )
+
+/* Move by one pixel in specified direction with wrapping when the */
+/* position achieves image boundary */
+/* pos - position structure */
+/* shift - direction ( it's value must be one of the CV_SHIFT_\85 constants ) */
+/* cs - number of the image channels */
+#define CV_MOVE_PARAM_WRAP( pos, shift, cs ) \
+ ( (pos).currline += (pos).step_arr[(shift)>>2], \
+ (pos).currline = ((pos).currline == (pos).topline ? \
+ (pos).bottomline - (pos).step : \
+ (pos).currline == (pos).bottomline ? \
+ (pos).topline + (pos).step : (pos).currline), \
+ \
+ (pos).x += ((shift)&3)-2, \
+ (pos).x = ((pos).x < 0 ? (pos).width-1 : (pos).x >= (pos).width ? 0 : (pos).x), \
+ \
+ (pos).currline + (pos).x*(cs) )
+
+#endif/*_CVCOMPAT_H_*/
projects / opencv / blobdiff