c++计算图像的7个不变hu矩

/*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 _CXCORE_H_ #define _CXCORE_H_ #ifdef __IPL_H__ #define HAVE_IPL #endif #ifndef SKIP_INCLUDES #if defined HAVE_IPL && !defined __IPL_H__ #ifndef _INC_WINDOWS #define CV_PRETEND_WINDOWS #define _INC_WINDOWS typedef struct tagBITMAPINFOHEADER BITMAPINFOHEADER; typedef int BOOL; #endif #if defined WIN32 || defined WIN64 #include "ipl.h" #else #include "ipl/ipl.h" #endif #ifdef CV_PRETEND_WINDOWS #undef _INC_WINDOWS #endif #endif #endif // SKIP_INCLUDES #include "cxtypes.h" #include "cxerror.h" #include "cvver.h" #ifdef __cplusplus extern "C" { #endif /****************************************************************************************\ * Array allocation, deallocation, initialization and access to elements * \****************************************************************************************/ /* <malloc> wrapper. If there is no enough memory, the function (as well as other OpenCV functions that call cvAlloc) raises an error. */ CVAPI(void*) cvAlloc( size_t size ); /* <free> wrapper. Here and further all the memory releasing functions (that all call cvFree) take double pointer in order to to clear pointer to the data after releasing it. Passing pointer to NULL pointer is Ok: nothing happens in this case */ CVAPI(void) cvFree_( void* ptr ); #define cvFree(ptr) (cvFree_(*(ptr)), *(ptr)=0) /* Allocates and initializes IplImage header */ CVAPI(IplImage*) cvCreateImageHeader( CvSize size, int depth, int channels ); /* Inializes IplImage header */ CVAPI(IplImage*) cvInitImageHeader( IplImage* image, CvSize size, int depth, int channels, int origin CV_DEFAULT(0), int align CV_DEFAULT(4)); /* Creates IPL image (header and data) */ CVAPI(IplImage*) cvCreateImage( CvSize size, int depth, int channels ); /* Releases (i.e. deallocates) IPL image header */ CVAPI(void) cvReleaseImageHeader( IplImage** image ); /* Releases IPL image header and data */ CVAPI(void) cvReleaseImage( IplImage** image ); /* Creates a copy of IPL image (widthStep may differ) */ CVAPI(IplImage*) cvCloneImage( const IplImage* image ); /* Sets a Channel Of Interest (only a few functions support COI) - use cvCopy to extract the selected channel and/or put it back */ CVAPI(void) cvSetImageCOI( IplImage* image, int coi ); /* Retrieves image Channel Of Interest */ CVAPI(int) cvGetImageCOI( const IplImage* image ); /* Sets image ROI (region of interest) (COI is not changed) */ CVAPI(void) cvSetImageROI( IplImage* image, CvRect rect ); /* Resets image ROI and COI */ CVAPI(void) cvResetImageROI( IplImage* image ); /* Retrieves image ROI */ CVAPI(CvRect) cvGetImageROI( const IplImage* image ); /* Allocates and initalizes CvMat header */ CVAPI(CvMat*) cvCreateMatHeader( int rows, int cols, int type ); #define CV_AUTOSTEP 0x7fffffff /* Initializes CvMat header */ CVAPI(CvMat*) cvInitMatHeader( CvMat* mat, int rows, int cols, int type, void* data CV_DEFAULT(NULL), int step CV_DEFAULT(CV_AUTOSTEP) ); /* Allocates and initializes CvMat header and allocates data */ CVAPI(CvMat*) cvCreateMat( int rows, int cols, int type ); /* Releases CvMat header and deallocates matrix data (reference counting is used for data) */ CVAPI(void) cvReleaseMat( CvMat** mat ); /* Decrements CvMat data reference counter and deallocates the data if it reaches 0 */ CV_INLINE void cvDecRefData( CvArr* arr ) { if( CV_IS_MAT( arr )) { CvMat* mat = (CvMat*)arr; mat->data.ptr = NULL; if( mat->refcount != NULL && --*mat->refcount == 0 ) cvFree( &mat->refcount ); mat->refcount = NULL; } else if( CV_IS_MATND( arr )) { CvMatND* mat = (CvMatND*)arr; mat->data.ptr = NULL; if( mat->refcount != NULL && --*mat->refcount == 0 ) cvFree( &mat->refcount ); mat->refcount = NULL; } } /* Increments CvMat data reference counter */ CV_INLINE int cvIncRefData( CvArr* arr ) { int refcount = 0; if( CV_IS_MAT( arr )) { CvMat* mat = (CvMat*)arr; if( mat->refcount != NULL ) refcount = ++*mat->refcount; } else if( CV_IS_MATND( arr )) { CvMatND* mat = (CvMatND*)arr; if( mat->refcount != NULL ) refcount = ++*mat->refcount; } return refcount; } /* Creates an exact copy of the input matrix (except, may be, step value) */ CVAPI(CvMat*) cvCloneMat( const CvMat* mat ); /* Makes a new matrix from <rect> subrectangle of input array. No data is copied */ CVAPI(CvMat*) cvGetSubRect( const CvArr* arr, CvMat* submat, CvRect rect ); #define cvGetSubArr cvGetSubRect /* Selects row span of the input array: arr(start_row:delta_row:end_row,:) (end_row is not included into the span). */ CVAPI(CvMat*) cvGetRows( const CvArr* arr, CvMat* submat, int start_row, int end_row, int delta_row CV_DEFAULT(1)); CV_INLINE CvMat* cvGetRow( const CvArr* arr, CvMat* submat, int row ) { return cvGetRows( arr, submat, row, row + 1, 1 ); } /* Selects column span of the input array: arr(:,start_col:end_col) (end_col is not included into the span) */ CVAPI(CvMat*) cvGetCols( const CvArr* arr, CvMat* submat, int start_col, int end_col ); CV_INLINE CvMat* cvGetCol( const CvArr* arr, CvMat* submat, int col ) { return cvGetCols( arr, submat, col, col + 1 ); } /* Select a diagonal of the input array. (diag = 0 means the mai