Global $_opencv_worldDLL
#include-once
#include "F:\download\CVConstants.au3"
#include "F:\download\CVTag.au3"
;#include "F:\download\CVcore_c.au3"
;#include "F:\download\CVimgproc_c.au3"

const $CV_AUTOSTEP          = 0x7fffffff
const $CV_LU                = 0
const $CV_REDUCE_SUM        = 0
const $CV_CLOCKWISE         = 1
const $CV_COUNTER_CLOCKWISE = 2

const $CV_GRAPH_ALL_ITEMS   = -1

Func _OpenCV_StartupWorld()
    $_opencv_worldDLL   = DllOpen("F:\download\opencv\build\x64\vc15\bin\opencv_world451.dll")
	$_opencv_core       = DllOpen("opencv_core245.dll")
	$_opencv_highgui    = DllOpen("opencv_highgui245.dll")
    $_opencv_imgproc    = DllOpen("opencv_imgproc245.dll")
	$_opencv_calib3d    = DllOpen("opencv_calib3d245.dll")
	$_opencv_features2d = DllOpen("opencv_features2d245.dll")
EndFunc   ;==>_OpenCV_StartupWorld

#region  core_c.h
Func _cvAlloc($cvsize)
;CVAPI(void*) cvAlloc( size_t size );
    local $_aResult = DllCall($_opencv_worldDLL,"ptr:cdecl","cvAlloc","ulong_ptr",$cvsize)
    If @error Then ConsoleWrite( "error in cvAlloc")
    Return $_aResult[0]
EndFunc ;==>cvAlloc
Func _cvFree_($cvptr)
;CVAPI(void) cvFree_( void* ptr );
    local $_aResult = DllCall($_opencv_worldDLL,"void:cdecl","cvFree_","struct*",$cvptr)
    If @error Then ConsoleWrite( "error in cvFree_")
    Return $_aResult[0]
EndFunc ;==>cvFree_
Func _cvCreateImageHeader($cvsize,$cvdepth,$cvchannels)
;CVAPI(IplImage*) cvCreateImageHeader( CvSize size, int depth, int channels );
    local $_aResult = DllCall($_opencv_worldDLL,"ptr:cdecl","cvCreateImageHeader","struct",$cvsize,"int",$cvdepth,"int",$cvchannels)
    If @error Then ConsoleWrite( "error in cvCreateImageHeader")
    Return $_aResult[0]
EndFunc ;==>cvCreateImageHeader
Func _cvInitImageHeader($cvimage,$cvsize,$cvdepth,$cvchannels,$cvorigin=0,$cvalign=4)
;CVAPI(IplImage*) cvInitImageHeader( IplImage* image, CvSize size, int depth, int channels, int origin CV_DEFAULT(0), int align CV_DEFAULT(4));
    local $_aResult = DllCall($_opencv_worldDLL,"ptr:cdecl","cvInitImageHeader","struct*",$cvimage,"struct",$cvsize,"int",$cvdepth,"int",$cvchannels,"int",$cvorigin,"int",$cvalign)
    If @error Then ConsoleWrite( "error in cvInitImageHeader")
    Return $_aResult[0]
EndFunc ;==>cvInitImageHeader
Func _cvCreateImage($cvsize,$cvdepth,$cvchannels)
;CVAPI(IplImage*) cvCreateImage( CvSize size, int depth, int channels );
    local $_aResult = DllCall($_opencv_worldDLL,"ptr:cdecl","cvCreateImage","struct",$cvsize,"int",$cvdepth,"int",$cvchannels)
    If @error Then ConsoleWrite( "error in cvCreateImage")
    Return $_aResult[0]
EndFunc ;==>cvCreateImage
Func _cvReleaseImageHeader($cvimage)
;CVAPI(void) cvReleaseImageHeader( IplImage** image );
    local $_aResult = DllCall($_opencv_worldDLL,"void:cdecl","cvReleaseImageHeader","struct*",$cvimage)
    If @error Then ConsoleWrite( "error in cvReleaseImageHeader")
    Return $_aResult[0]
EndFunc ;==>cvReleaseImageHeader
Func _cvReleaseImage($cvimage)
;CVAPI(void) cvReleaseImage( IplImage** image );
    local $_aResult = DllCall($_opencv_worldDLL,"void:cdecl","cvReleaseImage","struct*",$cvimage)
    If @error Then ConsoleWrite( "error in cvReleaseImage")
    Return $_aResult[0]
EndFunc ;==>cvReleaseImage
Func _cvCloneImage($cvimage)
;CVAPI(IplImage*) cvCloneImage( const IplImage* image );
    local $_aResult = DllCall($_opencv_worldDLL,"ptr:cdecl","cvCloneImage","struct*",$cvimage)
    If @error Then ConsoleWrite( "error in cvCloneImage")
    Return $_aResult[0]
EndFunc ;==>cvCloneImage
Func _cvSetImageCOI($cvimage,$cvcoi)
;CVAPI(void) cvSetImageCOI( IplImage* image, int coi );
    local $_aResult = DllCall($_opencv_worldDLL,"void:cdecl","cvSetImageCOI","struct*",$cvimage,"int",$cvcoi)
    If @error Then ConsoleWrite( "error in cvSetImageCOI")
    Return $_aResult[0]
EndFunc ;==>cvSetImageCOI
Func _cvGetImageCOI($cvimage)
;CVAPI(int) cvGetImageCOI( const IplImage* image );
    local $_aResult = DllCall($_opencv_worldDLL,"int:cdecl","cvGetImageCOI","struct*",$cvimage)
    If @error Then ConsoleWrite( "error in cvGetImageCOI")
    Return $_aResult[0]
EndFunc ;==>cvGetImageCOI
Func _cvSetImageROI($cvimage,$cvrect)
;CVAPI(void) cvSetImageROI( IplImage* image, CvRect rect );
    local $_aResult = DllCall($_opencv_worldDLL,"void:cdecl","cvSetImageROI","struct*",$cvimage,"struct",$cvrect)
    If @error Then ConsoleWrite( "error in cvSetImageROI")
    Return $_aResult[0]
EndFunc ;==>cvSetImageROI
Func _cvResetImageROI($cvimage)
;CVAPI(void) cvResetImageROI( IplImage* image );
    local $_aResult = DllCall($_opencv_worldDLL,"void:cdecl","cvResetImageROI","struct*",$cvimage)
    If @error Then ConsoleWrite( "error in cvResetImageROI")
    Return $_aResult[0]
EndFunc ;==>cvResetImageROI
Func _cvGetImageROI($cvimage)
;CVAPI(CvRect) cvGetImageROI( const IplImage* image );
    local $_aResult = DllCall($_opencv_worldDLL,"none:cdecl","cvGetImageROI","struct*",$cvimage)
    If @error Then ConsoleWrite( "error in cvGetImageROI")
    Return $_aResult[0]
EndFunc ;==>cvGetImageROI
Func _cvCreateMatHeader($cvrows,$cvcols,$cvtype)
;CVAPI(CvMat*) cvCreateMatHeader( int rows, int cols, int type );
    local $_aResult = DllCall($_opencv_worldDLL,"ptr:cdecl","cvCreateMatHeader","int",$cvrows,"int",$cvcols,"int",$cvtype)
    If @error Then ConsoleWrite( "error in cvCreateMatHeader")
    Return $_aResult[0]
EndFunc ;==>cvCreateMatHeader
Func _cvInitMatHeader($cvmat,$cvrows,$cvcols,$cvtype,$cvdata=NULL,$cvstep=$CV_AUTOSTEP)
;CVAPI(CvMat*) cvInitMatHeader( CvMat* mat, int rows, int cols, int type, void* data CV_DEFAULT(NULL), int step CV_DEFAULT(CV_AUTOSTEP) );
    local $_aResult = DllCall($_opencv_worldDLL,"ptr:cdecl","cvInitMatHeader","struct*",$cvmat,"int",$cvrows,"int",$cvcols,"int",$cvtype,"struct*",$cvdata,"int",$cvstep)
    If @error Then ConsoleWrite( "error in cvInitMatHeader")
    Return $_aResult[0]
EndFunc ;==>cvInitMatHeader
Func _cvCreateMat($cvrows,$cvcols,$cvtype)
;CVAPI(CvMat*) cvCreateMat( int rows, int cols, int type );
    local $_aResult = DllCall($_opencv_worldDLL,"ptr:cdecl","cvCreateMat","int",$cvrows,"int",$cvcols,"int",$cvtype)
    If @error Then ConsoleWrite( "error in cvCreateMat")
    Return $_aResult[0]
EndFunc ;==>cvCreateMat
Func _cvReleaseMat($cvmat)
;CVAPI(void) cvReleaseMat( CvMat** mat );
    local $_aResult = DllCall($_opencv_worldDLL,"void:cdecl","cvReleaseMat","struct*",$cvmat)
    If @error Then ConsoleWrite( "error in cvReleaseMat")
    Return $_aResult[0]
EndFunc ;==>cvReleaseMat
Func _cvCloneMat($cvmat)
;CVAPI(CvMat*) cvCloneMat( const CvMat* mat );
    local $_aResult = DllCall($_opencv_worldDLL,"ptr:cdecl","cvCloneMat","struct*",$cvmat)
    If @error Then ConsoleWrite( "error in cvCloneMat")
    Return $_aResult[0]
EndFunc ;==>cvCloneMat
Func _cvGetSubRect($cvarr,$cvsubmat,$cvrect)
;CVAPI(CvMat*) cvGetSubRect( const CvArr* arr, CvMat* submat, CvRect rect );
    local $_aResult = DllCall($_opencv_worldDLL,"ptr:cdecl","cvGetSubRect","struct*",$cvarr,"struct*",$cvsubmat,"struct",$cvrect)
    If @error Then ConsoleWrite( "error in cvGetSubRect")
    Return $_aResult[0]
EndFunc ;==>cvGetSubRect
Func _cvGetRows($cvarr,$cvsubmat,$cvstart_row,$cvend_row,$cvdelta_row=1)
;CVAPI(CvMat*) cvGetRows( const CvArr* arr, CvMat* submat, int start_row, int end_row, int delta_row CV_DEFAULT(1));
    local $_aResult = DllCall($_opencv_worldDLL,"ptr:cdecl","cvGetRows","struct*",$cvarr,"struct*",$cvsubmat,"int",$cvstart_row,"int",$cvend_row,"int",$cvdelta_row)
    If @error Then ConsoleWrite( "error in cvGetRows")
    Return $_aResult[0]
EndFunc ;==>cvGetRows
Func _cvGetCols($cvarr,$cvsubmat,$cvstart_col,$cvend_col)
;CVAPI(CvMat*) cvGetCols( const CvArr* arr, CvMat* submat, int start_col, int end_col );
    local $_aResult = DllCall($_opencv_worldDLL,"ptr:cdecl","cvGetCols","struct*",$cvarr,"struct*",$cvsubmat,"int",$cvstart_col,"int",$cvend_col)
    If @error Then ConsoleWrite( "error in cvGetCols")
    Return $_aResult[0]
EndFunc ;==>cvGetCols
Func _cvGetDiag($cvarr,$cvsubmat,$cvdiag=0)
;CVAPI(CvMat*) cvGetDiag( const CvArr* arr, CvMat* submat, int diag CV_DEFAULT(0));
    local $_aResult = DllCall($_opencv_worldDLL,"ptr:cdecl","cvGetDiag","struct*",$cvarr,"struct*",$cvsubmat,"int",$cvdiag)
    If @error Then ConsoleWrite( "error in cvGetDiag")
    Return $_aResult[0]
EndFunc ;==>cvGetDiag
Func _cvScalarToRawData($cvscalar,$cvdata,$cvtype,$cvextend_to_12=0)
;CVAPI(void) cvScalarToRawData( const CvScalar* scalar, void* data, int type, int extend_to_12 CV_DEFAULT(0) );
    local $_aResult = DllCall($_opencv_worldDLL,"void:cdecl","cvScalarToRawData","struct*",$cvscalar,"struct*",$cvdata,"int",$cvtype,"int",$cvextend_to_12)
    If @error Then ConsoleWrite( "error in cvScalarToRawData")
    Return $_aResult[0]
EndFunc ;==>cvScalarToRawData
Func _cvRawDataToScalar($cvdata,$cvtype,$cvscalar)
;CVAPI(void) cvRawDataToScalar( const void* data, int type, CvScalar* scalar );
    local $_aResult = DllCall($_opencv_worldDLL,"void:cdecl","cvRawDataToScalar","struct*",$cvdata,"int",$cvtype,"struct*",$cvscalar)
    If @error Then ConsoleWrite( "error in cvRawDataToScalar")
    Return $_aResult[0]
EndFunc ;==>cvRawDataToScalar
Func _cvCreateMatNDHeader($cvdims,$cvsizes,$cvtype)
;CVAPI(CvMatND*) cvCreateMatNDHeader( int dims, const int* sizes, int type );
    local $_aResult = DllCall($_opencv_worldDLL,"ptr:cdecl","cvCreateMatNDHeader","int",$cvdims,"struct*",$cvsizes,"int",$cvtype)
    If @error Then ConsoleWrite( "error in cvCreateMatNDHeader")
    Return $_aResult[0]
EndFunc ;==>cvCreateMatNDHeader
Func _cvCreateMatND($cvdims,$cvsizes,$cvtype)
;CVAPI(CvMatND*) cvCreateMatND( int dims, const int* sizes, int type );
    local $_aResult = DllCall($_opencv_worldDLL,"ptr:cdecl","cvCreateMatND","int",$cvdims,"struct*",$cvsizes,"int",$cvtype)
    If @error Then ConsoleWrite( "error in cvCreateMatND")
    Return $_aResult[0]
EndFunc ;==>cvCreateMatND
Func _cvInitMatNDHeader($cvmat,$cvdims,$cvsizes,$cvtype,$cvdata=NULL)
;CVAPI(CvMatND*) cvInitMatNDHeader( CvMatND* mat, int dims, const int* sizes, int type, void* data CV_DEFAULT(NULL) );
    local $_aResult = DllCall($_opencv_worldDLL,"ptr:cdecl","cvInitMatNDHeader","struct*",$cvmat,"int",$cvdims,"struct*",$cvsizes,"int",$cvtype,"struct*",$cvdata)
    If @error Then ConsoleWrite( "error in cvInitMatNDHeader")
    Return $_aResult[0]
EndFunc ;==>cvInitMatNDHeader
Func _cvCloneMatND($cvmat)
;CVAPI(CvMatND*) cvCloneMatND( const CvMatND* mat );
    local $_aResult = DllCall($_opencv_worldDLL,"ptr:cdecl","cvCloneMatND","struct*",$cvmat)
    If @error Then ConsoleWrite( "error in cvCloneMatND")
    Return $_aResult[0]
EndFunc ;==>cvCloneMatND
Func _cvCreateSparseMat($cvdims,$cvsizes,$cvtype)
;CVAPI(CvSparseMat*) cvCreateSparseMat( int dims, const int* sizes, int type );
    local $_aResult = DllCall($_opencv_worldDLL,"ptr:cdecl","cvCreateSparseMat","int",$cvdims,"struct*",$cvsizes,"int",$cvtype)
    If @error Then ConsoleWrite( "error in cvCreateSparseMat")
    Return $_aResult[0]
EndFunc ;==>cvCreateSparseMat
Func _cvReleaseSparseMat($cvmat)
;CVAPI(void) cvReleaseSparseMat( CvSparseMat** mat );
    local $_aResult = DllCall($_opencv_worldDLL,"void:cdecl","cvReleaseSparseMat","struct*",$cvmat)
    If @error Then ConsoleWrite( "error in cvReleaseSparseMat")
    Return $_aResult[0]
EndFunc ;==>cvReleaseSparseMat
Func _cvCloneSparseMat($cvmat)
;CVAPI(CvSparseMat*) cvCloneSparseMat( const CvSparseMat* mat );
    local $_aResult = DllCall($_opencv_worldDLL,"ptr:cdecl","cvCloneSparseMat","struct*",$cvmat)
    If @error Then ConsoleWrite( "error in cvCloneSparseMat")
    Return $_aResult[0]
EndFunc ;==>cvCloneSparseMat
Func _cvInitSparseMatIterator($cvmat,$cvmat_iterator)
;CVAPI(CvSparseNode*) cvInitSparseMatIterator( const CvSparseMat* mat, CvSparseMatIterator* mat_iterator );
    local $_aResult = DllCall($_opencv_worldDLL,"ptr:cdecl","cvInitSparseMatIterator","struct*",$cvmat,"struct*",$cvmat_iterator)
    If @error Then ConsoleWrite( "error in cvInitSparseMatIterator")
    Return $_aResult[0]
EndFunc ;==>cvInitSparseMatIterator
Func _cvInitNArrayIterator($cvcount,$cvarrs,$cvmask,$cvstubs,$cvarray_iterator,$cvflags=0)
;CVAPI(int) cvInitNArrayIterator( int count, CvArr** arrs, const CvArr* mask, CvMatND* stubs, CvNArrayIterator* array_iterator, int flags CV_DEFAULT(0) );
    local $_aResult = DllCall($_opencv_worldDLL,"int:cdecl","cvInitNArrayIterator","int",$cvcount,"struct*",$cvarrs,"struct*",$cvmask,"struct*",$cvstubs,"struct*",$cvarray_iterator,"int",$cvflags)
    If @error Then ConsoleWrite( "error in cvInitNArrayIterator")
    Return $_aResult[0]
EndFunc ;==>cvInitNArrayIterator
Func _cvNextNArraySlice($cvarray_iterator)
;CVAPI(int) cvNextNArraySlice( CvNArrayIterator* array_iterator );
    local $_aResult = DllCall($_opencv_worldDLL,"int:cdecl","cvNextNArraySlice","struct*",$cvarray_iterator)
    If @error Then ConsoleWrite( "error in cvNextNArraySlice")
    Return $_aResult[0]
EndFunc ;==>cvNextNArraySlice
Func _cvGetElemType($cvarr)
;CVAPI(int) cvGetElemType( const CvArr* arr );
    local $_aResult = DllCall($_opencv_worldDLL,"int:cdecl","cvGetElemType","struct*",$cvarr)
    If @error Then ConsoleWrite( "error in cvGetElemType")
    Return $_aResult[0]
EndFunc ;==>cvGetElemType
Func _cvGetDims($cvarr,$cvsizes=NULL)
;CVAPI(int) cvGetDims( const CvArr* arr, int* sizes CV_DEFAULT(NULL) );
    local $_aResult = DllCall($_opencv_worldDLL,"int:cdecl","cvGetDims","struct*",$cvarr,"struct*",$cvsizes)
    If @error Then ConsoleWrite( "error in cvGetDims")
    Return $_aResult[0]
EndFunc ;==>cvGetDims
Func _cvGetDimSize($cvarr,$cvindex)
;CVAPI(int) cvGetDimSize( const CvArr* arr, int index );
    local $_aResult = DllCall($_opencv_worldDLL,"int:cdecl","cvGetDimSize","struct*",$cvarr,"int",$cvindex)
    If @error Then ConsoleWrite( "error in cvGetDimSize")
    Return $_aResult[0]
EndFunc ;==>cvGetDimSize
Func _cvPtr1D($cvarr,$cvidx0,$cvtype=NULL)
;CVAPI(uchar*) cvPtr1D( const CvArr* arr, int idx0, int* type CV_DEFAULT(NULL));
    local $_aResult = DllCall($_opencv_worldDLL,"ptr:cdecl","cvPtr1D","struct*",$cvarr,"int",$cvidx0,"struct*",$cvtype)
    If @error Then ConsoleWrite( "error in cvPtr1D")
    Return $_aResult[0]
EndFunc ;==>cvPtr1D
Func _cvPtr2D($cvarr,$cvidx0,$cvidx1,$cvtype=NULL)
;CVAPI(uchar*) cvPtr2D( const CvArr* arr, int idx0, int idx1, int* type CV_DEFAULT(NULL) );
    local $_aResult = DllCall($_opencv_worldDLL,"ptr:cdecl","cvPtr2D","struct*",$cvarr,"int",$cvidx0,"int",$cvidx1,"struct*",$cvtype)
    If @error Then ConsoleWrite( "error in cvPtr2D")
    Return $_aResult[0]
EndFunc ;==>cvPtr2D
Func _cvPtr3D($cvarr,$cvidx0,$cvidx1,$cvidx2,$cvtype=NULL)
;CVAPI(uchar*) cvPtr3D( const CvArr* arr, int idx0, int idx1, int idx2, int* type CV_DEFAULT(NULL));
    local $_aResult = DllCall($_opencv_worldDLL,"ptr:cdecl","cvPtr3D","struct*",$cvarr,"int",$cvidx0,"int",$cvidx1,"int",$cvidx2,"struct*",$cvtype)
    If @error Then ConsoleWrite( "error in cvPtr3D")
    Return $_aResult[0]
EndFunc ;==>cvPtr3D
Func _cvPtrND($cvarr,$cvidx,$cvtype=NULL,$cvcreate_node=1,$cvprecalc_hashval=NULL)
;CVAPI(uchar*) cvPtrND( const CvArr* arr, const int* idx, int* type CV_DEFAULT(NULL), int create_node CV_DEFAULT(1), unsigned* precalc_hashval CV_DEFAULT(NULL));
    local $_aResult = DllCall($_opencv_worldDLL,"ptr:cdecl","cvPtrND","struct*",$cvarr,"struct*",$cvidx,"struct*",$cvtype,"int",$cvcreate_node,"struct*",$cvprecalc_hashval)
    If @error Then ConsoleWrite( "error in cvPtrND")
    Return $_aResult[0]
EndFunc ;==>cvPtrND
Func _cvGet1D($cvarr,$cvidx0)
;CVAPI(CvScalar) cvGet1D( const CvArr* arr, int idx0 );
    local $_aResult = DllCall($_opencv_worldDLL,"none:cdecl","cvGet1D","struct*",$cvarr,"int",$cvidx0)
    If @error Then ConsoleWrite( "error in cvGet1D")
    Return $_aResult[0]
EndFunc ;==>cvGet1D
Func _cvGet2D($cvarr,$cvidx0,$cvidx1)
;CVAPI(CvScalar) cvGet2D( const CvArr* arr, int idx0, int idx1 );
    local $_aResult = DllCall($_opencv_worldDLL,"none:cdecl","cvGet2D","struct*",$cvarr,"int",$cvidx0,"int",$cvidx1)
    If @error Then ConsoleWrite( "error in cvGet2D")
    Return $_aResult[0]
EndFunc ;==>cvGet2D
Func _cvGet3D($cvarr,$cvidx0,$cvidx1,$cvidx2)
;CVAPI(CvScalar) cvGet3D( const CvArr* arr, int idx0, int idx1, int idx2 );
    local $_aResult = DllCall($_opencv_worldDLL,"none:cdecl","cvGet3D","struct*",$cvarr,"int",$cvidx0,"int",$cvidx1,"int",$cvidx2)
    If @error Then ConsoleWrite( "error in cvGet3D")
    Return $_aResult[0]
EndFunc ;==>cvGet3D
Func _cvGetND($cvarr,$cvidx)
;CVAPI(CvScalar) cvGetND( const CvArr* arr, const int* idx );
    local $_aResult = DllCall($_opencv_worldDLL,"none:cdecl","cvGetND","struct*",$cvarr,"struct*",$cvidx)
    If @error Then ConsoleWrite( "error in cvGetND")
    Return $_aResult[0]
EndFunc ;==>cvGetND
Func _cvGetReal1D($cvarr,$cvidx0)
;CVAPI(double) cvGetReal1D( const CvArr* arr, int idx0 );
    local $_aResult = DllCall($_opencv_worldDLL,"double:cdecl","cvGetReal1D","struct*",$cvarr,"int",$cvidx0)
    If @error Then ConsoleWrite( "error in cvGetReal1D")
    Return $_aResult[0]
EndFunc ;==>cvGetReal1D
Func _cvGetReal2D($cvarr,$cvidx0,$cvidx1)
;CVAPI(double) cvGetReal2D( const CvArr* arr, int idx0, int idx1 );
    local $_aResult = DllCall($_opencv_worldDLL,"double:cdecl","cvGetReal2D","struct*",$cvarr,"int",$cvidx0,"int",$cvidx1)
    If @error Then ConsoleWrite( "error in cvGetReal2D")
    Return $_aResult[0]
EndFunc ;==>cvGetReal2D
Func _cvGetReal3D($cvarr,$cvidx0,$cvidx1,$cvidx2)
;CVAPI(double) cvGetReal3D( const CvArr* arr, int idx0, int idx1, int idx2 );
    local $_aResult = DllCall($_opencv_worldDLL,"double:cdecl","cvGetReal3D","struct*",$cvarr,"int",$cvidx0,"int",$cvidx1,"int",$cvidx2)
    If @error Then ConsoleWrite( "error in cvGetReal3D")
    Return $_aResult[0]
EndFunc ;==>cvGetReal3D
Func _cvGetRealND($cvarr,$cvidx)
;CVAPI(double) cvGetRealND( const CvArr* arr, const int* idx );
    local $_aResult = DllCall($_opencv_worldDLL,"double:cdecl","cvGetRealND","struct*",$cvarr,"struct*",$cvidx)
    If @error Then ConsoleWrite( "error in cvGetRealND")
    Return $_aResult[0]
EndFunc ;==>cvGetRealND
Func _cvSet1D($cvarr,$cvidx0,$cvvalue)
;CVAPI(void) cvSet1D( CvArr* arr, int idx0, CvScalar value );
    local $_aResult = DllCall($_opencv_worldDLL,"void:cdecl","cvSet1D","struct*",$cvarr,"int",$cvidx0,"struct",$cvvalue)
    If @error Then ConsoleWrite( "error in cvSet1D")
    Return $_aResult[0]
EndFunc ;==>cvSet1D
Func _cvSet2D($cvarr,$cvidx0,$cvidx1,$cvvalue)
;CVAPI(void) cvSet2D( CvArr* arr, int idx0, int idx1, CvScalar value );
    local $_aResult = DllCall($_opencv_worldDLL,"void:cdecl","cvSet2D","struct*",$cvarr,"int",$cvidx0,"int",$cvidx1,"struct",$cvvalue)
    If @error Then ConsoleWrite( "error in cvSet2D")
    Return $_aResult[0]
EndFunc ;==>cvSet2D
Func _cvSet3D($cvarr,$cvidx0,$cvidx1,$cvidx2,$cvvalue)
;CVAPI(void) cvSet3D( CvArr* arr, int idx0, int idx1, int idx2, CvScalar value );
    local $_aResult = DllCall($_opencv_worldDLL,"void:cdecl","cvSet3D","struct*",$cvarr,"int",$cvidx0,"int",$cvidx1,"int",$cvidx2,"struct",$cvvalue)
    If @error Then ConsoleWrite( "error in cvSet3D")
    Return $_aResult[0]
EndFunc ;==>cvSet3D
Func _cvSetND($cvarr,$cvidx,$cvvalue)
;CVAPI(void) cvSetND( CvArr* arr, const int* idx, CvScalar value );
    local $_aResult = DllCall($_opencv_worldDLL,"void:cdecl","cvSetND","struct*",$cvarr,"struct*",$cvidx,"struct",$cvvalue)
    If @error Then ConsoleWrite( "error in cvSetND")
    Return $_aResult[0]
EndFunc ;==>cvSetND
Func _cvSetReal1D($cvarr,$cvidx0,$cvvalue)
;CVAPI(void) cvSetReal1D( CvArr* arr, int idx0, double value );
    local $_aResult = DllCall($_opencv_worldDLL,"void:cdecl","cvSetReal1D","struct*",$cvarr,"int",$cvidx0,"double",$cvvalue)
    If @error Then ConsoleWrite( "error in cvSetReal1D")
    Return $_aResult[0]
EndFunc ;==>cvSetReal1D
Func _cvSetReal2D($cvarr,$cvidx0,$cvidx1,$cvvalue)
;CVAPI(void) cvSetReal2D( CvArr* arr, int idx0, int idx1, double value );
    local $_aResult = DllCall($_opencv_worldDLL,"void:cdecl","cvSetReal2D","struct*",$cvarr,"int",$cvidx0,"int",$cvidx1,"double",$cvvalue)
    If @error Then ConsoleWrite( "error in cvSetReal2D")
    Return $_aResult[0]
EndFunc ;==>cvSetReal2D
Func _cvSetReal3D($cvarr,$cvidx0,$cvidx1,$cvidx2,$cvvalue)
;CVAPI(void) cvSetReal3D( CvArr* arr, int idx0, int idx1, int idx2, double value );
    local $_aResult = DllCall($_opencv_worldDLL,"void:cdecl","cvSetReal3D","struct*",$cvarr,"int",$cvidx0,"int",$cvidx1,"int",$cvidx2,"double",$cvvalue)
    If @error Then ConsoleWrite( "error in cvSetReal3D")
    Return $_aResult[0]
EndFunc ;==>cvSetReal3D
Func _cvSetRealND($cvarr,$cvidx,$cvvalue)
;CVAPI(void) cvSetRealND( CvArr* arr, const int* idx, double value );
    local $_aResult = DllCall($_opencv_worldDLL,"void:cdecl","cvSetRealND","struct*",$cvarr,"struct*",$cvidx,"double",$cvvalue)
    If @error Then ConsoleWrite( "error in cvSetRealND")
    Return $_aResult[0]
EndFunc ;==>cvSetRealND
Func _cvClearND($cvarr,$cvidx)
;CVAPI(void) cvClearND( CvArr* arr, const int* idx );
    local $_aResult = DllCall($_opencv_worldDLL,"void:cdecl","cvClearND","struct*",$cvarr,"struct*",$cvidx)
    If @error Then ConsoleWrite( "error in cvClearND")
    Return $_aResult[0]
EndFunc ;==>cvClearND
Func _cvGetMat($cvarr,$cvheader,$cvcoi=NULL,$cvallowND=0)
;CVAPI(CvMat*) cvGetMat( const CvArr* arr, CvMat* header, int* coi CV_DEFAULT(NULL), int allowND CV_DEFAULT(0));
    local $_aResult = DllCall($_opencv_worldDLL,"ptr:cdecl","cvGetMat","struct*",$cvarr,"struct*",$cvheader,"struct*",$cvcoi,"int",$cvallowND)
    If @error Then ConsoleWrite( "error in cvGetMat")
    Return $_aResult[0]
EndFunc ;==>cvGetMat
Func _cvGetImage($cvarr,$cvimage_header)
;CVAPI(IplImage*) cvGetImage( const CvArr* arr, IplImage* image_header );
    local $_aResult = DllCall($_opencv_worldDLL,"ptr:cdecl","cvGetImage","struct*",$cvarr,"struct*",$cvimage_header)
    If @error Then ConsoleWrite( "error in cvGetImage")
    Return $_aResult[0]
EndFunc ;==>cvGetImage
Func _cvReshapeMatND($cvarr,$cvsizeof_header,$cvheader,$cvnew_cn,$cvnew_dims,$cvnew_sizes)
;CVAPI(CvArr*) cvReshapeMatND( const CvArr* arr, int sizeof_header, CvArr* header, int new_cn, int new_dims, int* new_sizes );
    local $_aResult = DllCall($_opencv_worldDLL,"ptr:cdecl","cvReshapeMatND","struct*",$cvarr,"int",$cvsizeof_header,"struct*",$cvheader,"int",$cvnew_cn,"int",$cvnew_dims,"struct*",$cvnew_sizes)
    If @error Then ConsoleWrite( "error in cvReshapeMatND")
    Return $_aResult[0]
EndFunc ;==>cvReshapeMatND
Func _cvReshape($cvarr,$cvheader,$cvnew_cn,$cvnew_rows=0)
;CVAPI(CvMat*) cvReshape( const CvArr* arr, CvMat* header, int new_cn, int new_rows CV_DEFAULT(0) );
    local $_aResult = DllCall($_opencv_worldDLL,"ptr:cdecl","cvReshape","struct*",$cvarr,"struct*",$cvheader,"int",$cvnew_cn,"int",$cvnew_rows)
    If @error Then ConsoleWrite( "error in cvReshape")
    Return $_aResult[0]
EndFunc ;==>cvReshape
Func _cvRepeat($cvsrc,$cvdst)
;CVAPI(void) cvRepeat( const CvArr* src, CvArr* dst );
    local $_aResult = DllCall($_opencv_worldDLL,"void:cdecl","cvRepeat","struct*",$cvsrc,"struct*",$cvdst)
    If @error Then ConsoleWrite( "error in cvRepeat")
    Return $_aResult[0]
EndFunc ;==>cvRepeat
Func _cvCreateData($cvarr)
;CVAPI(void) cvCreateData( CvArr* arr );
    local $_aResult = DllCall($_opencv_worldDLL,"void:cdecl","cvCreateData","struct*",$cvarr)
    If @error Then ConsoleWrite( "error in cvCreateData")
    Return $_aResult[0]
EndFunc ;==>cvCreateData
Func _cvReleaseData($cvarr)
;CVAPI(void) cvReleaseData( CvArr* arr );
    local $_aResult = DllCall($_opencv_worldDLL,"void:cdecl","cvReleaseData","struct*",$cvarr)
    If @error Then ConsoleWrite( "error in cvReleaseData")
    Return $_aResult[0]
EndFunc ;==>cvReleaseData
Func _cvSetData($cvarr,$cvdata,$cvstep)
;CVAPI(void) cvSetData( CvArr* arr, void* data, int step );
    local $_aResult = DllCall($_opencv_worldDLL,"void:cdecl","cvSetData","struct*",$cvarr,"struct*",$cvdata,"int",$cvstep)
    If @error Then ConsoleWrite( "error in cvSetData")
    Return $_aResult[0]
EndFunc ;==>cvSetData
Func _cvGetRawData($cvarr,$cvdata,$cvstep=NULL,$cvroi_size=NULL)
;CVAPI(void) cvGetRawData( const CvArr* arr, uchar** data, int* step CV_DEFAULT(NULL), CvSize* roi_size CV_DEFAULT(NULL));
    local $_aResult = DllCall($_opencv_worldDLL,"void:cdecl","cvGetRawData","struct*",$cvarr,"struct*",$cvdata,"struct*",$cvstep,"struct*",$cvroi_size)
    If @error Then ConsoleWrite( "error in cvGetRawData")
    Return $_aResult[0]
EndFunc ;==>cvGetRawData
Func _cvGetSize($cvarr)
;CVAPI(CvSize) cvGetSize( const CvArr* arr );
    local $_aResult = DllCall($_opencv_worldDLL,"none:cdecl","cvGetSize","struct*",$cvarr)
    If @error Then ConsoleWrite( "error in cvGetSize")
    Return $_aResult[0]
EndFunc ;==>cvGetSize
Func _cvCopy($cvsrc,$cvdst,$cvmask=NULL)
;CVAPI(void) cvCopy( const CvArr* src, CvArr* dst, const CvArr* mask CV_DEFAULT(NULL) );
    local $_aResult = DllCall($_opencv_worldDLL,"void:cdecl","cvCopy","struct*",$cvsrc,"struct*",$cvdst,"struct*",$cvmask)
    If @error Then ConsoleWrite( "error in cvCopy")
    Return $_aResult[0]
EndFunc ;==>cvCopy
Func _cvSet($cvarr,$cvvalue,$cvmask=NULL)
;CVAPI(void) cvSet( CvArr* arr, CvScalar value, const CvArr* mask CV_DEFAULT(NULL) );
    local $_aResult = DllCall($_opencv_worldDLL,"void:cdecl","cvSet","struct*",$cvarr,"struct",$cvvalue,"struct*",$cvmask)
    If @error Then ConsoleWrite( "error in cvSet")
    Return $_aResult[0]
EndFunc ;==>cvSet
Func _cvSetZero($cvarr)
;CVAPI(void) cvSetZero( CvArr* arr );
    local $_aResult = DllCall($_opencv_worldDLL,"void:cdecl","cvSetZero","struct*",$cvarr)
    If @error Then ConsoleWrite( "error in cvSetZero")
    Return $_aResult[0]
EndFunc ;==>cvSetZero
Func _cvSplit($cvsrc,$cvdst0,$cvdst1,$cvdst2,$cvdst3)
;CVAPI(void) cvSplit( const CvArr* src, CvArr* dst0, CvArr* dst1, CvArr* dst2, CvArr* dst3 );
    local $_aResult = DllCall($_opencv_worldDLL,"void:cdecl","cvSplit","struct*",$cvsrc,"struct*",$cvdst0,"struct*",$cvdst1,"struct*",$cvdst2,"struct*",$cvdst3)
    If @error Then ConsoleWrite( "error in cvSplit")
    Return $_aResult[0]
EndFunc ;==>cvSplit
Func _cvMerge($cvsrc0,$cvsrc1,$cvsrc2,$cvsrc3,$cvdst)
;CVAPI(void) cvMerge( const CvArr* src0, const CvArr* src1, const CvArr* src2, const CvArr* src3, CvArr* dst );
    local $_aResult = DllCall($_opencv_worldDLL,"void:cdecl","cvMerge","struct*",$cvsrc0,"struct*",$cvsrc1,"struct*",$cvsrc2,"struct*",$cvsrc3,"struct*",$cvdst)
    If @error Then ConsoleWrite( "error in cvMerge")
    Return $_aResult[0]
EndFunc ;==>cvMerge
Func _cvMixChannels($cvsrc,$cvsrc_count,$cvdst,$cvdst_count,$cvfrom_to,$cvpair_count)
;CVAPI(void) cvMixChannels( const CvArr** src, int src_count, CvArr** dst, int dst_count, const int* from_to, int pair_count );
    local $_aResult = DllCall($_opencv_worldDLL,"void:cdecl","cvMixChannels","struct*",$cvsrc,"int",$cvsrc_count,"struct*",$cvdst,"int",$cvdst_count,"struct*",$cvfrom_to,"int",$cvpair_count)
    If @error Then ConsoleWrite( "error in cvMixChannels")
    Return $_aResult[0]
EndFunc ;==>cvMixChannels
Func _cvConvertScale($cvsrc,$cvdst,$cvscale=1,$cvshift=0)
;CVAPI(void) cvConvertScale( const CvArr* src, CvArr* dst, double scale CV_DEFAULT(1), double shift CV_DEFAULT(0) );
    local $_aResult = DllCall($_opencv_worldDLL,"void:cdecl","cvConvertScale","struct*",$cvsrc,"struct*",$cvdst,"double",$cvscale,"double",$cvshift)
    If @error Then ConsoleWrite( "error in cvConvertScale")
    Return $_aResult[0]
EndFunc ;==>cvConvertScale
Func _cvConvertScaleAbs($cvsrc,$cvdst,$cvscale=1,$cvshift=0)
;CVAPI(void) cvConvertScaleAbs( const CvArr* src, CvArr* dst, double scale CV_DEFAULT(1), double shift CV_DEFAULT(0) );
    local $_aResult = DllCall($_opencv_worldDLL,"void:cdecl","cvConvertScaleAbs","struct*",$cvsrc,"struct*",$cvdst,"double",$cvscale,"double",$cvshift)
    If @error Then ConsoleWrite( "error in cvConvertScaleAbs")
    Return $_aResult[0]
EndFunc ;==>cvConvertScaleAbs
Func _cvCheckTermCriteria($cvcriteria,$cvdefault_eps,$cvdefault_max_iters)
;CVAPI(CvTermCriteria) cvCheckTermCriteria( CvTermCriteria criteria, double default_eps, int default_max_iters );
    local $_aResult = DllCall($_opencv_worldDLL,"none:cdecl","cvCheckTermCriteria","struct",$cvcriteria,"double",$cvdefault_eps,"int",$cvdefault_max_iters)
    If @error Then ConsoleWrite( "error in cvCheckTermCriteria")
    Return $_aResult[0]
EndFunc ;==>cvCheckTermCriteria
Func _cvAdd($cvsrc1,$cvsrc2,$cvdst,$cvmask=NULL)
;CVAPI(void) cvAdd( const CvArr* src1, const CvArr* src2, CvArr* dst, const CvArr* mask CV_DEFAULT(NULL));
    local $_aResult = DllCall($_opencv_worldDLL,"void:cdecl","cvAdd","struct*",$cvsrc1,"struct*",$cvsrc2,"struct*",$cvdst,"struct*",$cvmask)
    If @error Then ConsoleWrite( "error in cvAdd")
    Return $_aResult[0]
EndFunc ;==>cvAdd
Func _cvAddS($cvsrc,$cvvalue,$cvdst,$cvmask=NULL)
;CVAPI(void) cvAddS( const CvArr* src, CvScalar value, CvArr* dst, const CvArr* mask CV_DEFAULT(NULL));
    local $_aResult = DllCall($_opencv_worldDLL,"void:cdecl","cvAddS","struct*",$cvsrc,"struct",$cvvalue,"struct*",$cvdst,"struct*",$cvmask)
    If @error Then ConsoleWrite( "error in cvAddS")
    Return $_aResult[0]
EndFunc ;==>cvAddS
Func _cvSub($cvsrc1,$cvsrc2,$cvdst,$cvmask=NULL)
;CVAPI(void) cvSub( const CvArr* src1, const CvArr* src2, CvArr* dst, const CvArr* mask CV_DEFAULT(NULL));
    local $_aResult = DllCall($_opencv_worldDLL,"void:cdecl","cvSub","struct*",$cvsrc1,"struct*",$cvsrc2,"struct*",$cvdst,"struct*",$cvmask)
    If @error Then ConsoleWrite( "error in cvSub")
    Return $_aResult[0]
EndFunc ;==>cvSub
Func _cvSubRS($cvsrc,$cvvalue,$cvdst,$cvmask=NULL)
;CVAPI(void) cvSubRS( const CvArr* src, CvScalar value, CvArr* dst, const CvArr* mask CV_DEFAULT(NULL));
    local $_aResult = DllCall($_opencv_worldDLL,"void:cdecl","cvSubRS","struct*",$cvsrc,"struct",$cvvalue,"struct*",$cvdst,"struct*",$cvmask)
    If @error Then ConsoleWrite( "error in cvSubRS")
    Return $_aResult[0]
EndFunc ;==>cvSubRS
Func _cvMul($cvsrc1,$cvsrc2,$cvdst,$cvscale=1)
;CVAPI(void) cvMul( const CvArr* src1, const CvArr* src2, CvArr* dst, double scale CV_DEFAULT(1) );
    local $_aResult = DllCall($_opencv_worldDLL,"void:cdecl","cvMul","struct*",$cvsrc1,"struct*",$cvsrc2,"struct*",$cvdst,"double",$cvscale)
    If @error Then ConsoleWrite( "error in cvMul")
    Return $_aResult[0]
EndFunc ;==>cvMul
Func _cvDiv($cvsrc1,$cvsrc2,$cvdst,$cvscale=1)
;CVAPI(void) cvDiv( const CvArr* src1, const CvArr* src2, CvArr* dst, double scale CV_DEFAULT(1));
    local $_aResult = DllCall($_opencv_worldDLL,"void:cdecl","cvDiv","struct*",$cvsrc1,"struct*",$cvsrc2,"struct*",$cvdst,"double",$cvscale)
    If @error Then ConsoleWrite( "error in cvDiv")
    Return $_aResult[0]
EndFunc ;==>cvDiv
Func _cvScaleAdd($cvsrc1,$cvscale,$cvsrc2,$cvdst)
;CVAPI(void) cvScaleAdd( const CvArr* src1, CvScalar scale, const CvArr* src2, CvArr* dst );
    local $_aResult = DllCall($_opencv_worldDLL,"void:cdecl","cvScaleAdd","struct*",$cvsrc1,"struct",$cvscale,"struct*",$cvsrc2,"struct*",$cvdst)
    If @error Then ConsoleWrite( "error in cvScaleAdd")
    Return $_aResult[0]
EndFunc ;==>cvScaleAdd
Func _cvAddWeighted($cvsrc1,$cvalpha,$cvsrc2,$cvbeta,$cvgamma,$cvdst)
;CVAPI(void) cvAddWeighted( const CvArr* src1, double alpha, const CvArr* src2, double beta, double gamma, CvArr* dst );
    local $_aResult = DllCall($_opencv_worldDLL,"void:cdecl","cvAddWeighted","struct*",$cvsrc1,"double",$cvalpha,"struct*",$cvsrc2,"double",$cvbeta,"double",$cvgamma,"struct*",$cvdst)
    If @error Then ConsoleWrite( "error in cvAddWeighted")
    Return $_aResult[0]
EndFunc ;==>cvAddWeighted
Func _cvDotProduct($cvsrc1,$cvsrc2)
;CVAPI(double) cvDotProduct( const CvArr* src1, const CvArr* src2 );
    local $_aResult = DllCall($_opencv_worldDLL,"double:cdecl","cvDotProduct","struct*",$cvsrc1,"struct*",$cvsrc2)
    If @error Then ConsoleWrite( "error in cvDotProduct")
    Return $_aResult[0]
EndFunc ;==>cvDotProduct
Func _cvAnd($cvsrc1,$cvsrc2,$cvdst,$cvmask=NULL)
;CVAPI(void) cvAnd( const CvArr* src1, const CvArr* src2, CvArr* dst, const CvArr* mask CV_DEFAULT(NULL));
    local $_aResult = DllCall($_opencv_worldDLL,"void:cdecl","cvAnd","struct*",$cvsrc1,"struct*",$cvsrc2,"struct*",$cvdst,"struct*",$cvmask)
    If @error Then ConsoleWrite( "error in cvAnd")
    Return $_aResult[0]
EndFunc ;==>cvAnd
Func _cvAndS($cvsrc,$cvvalue,$cvdst,$cvmask=NULL)
;CVAPI(void) cvAndS( const CvArr* src, CvScalar value, CvArr* dst, const CvArr* mask CV_DEFAULT(NULL));
    local $_aResult = DllCall($_opencv_worldDLL,"void:cdecl","cvAndS","struct*",$cvsrc,"struct",$cvvalue,"struct*",$cvdst,"struct*",$cvmask)
    If @error Then ConsoleWrite( "error in cvAndS")
    Return $_aResult[0]
EndFunc ;==>cvAndS
Func _cvOr($cvsrc1,$cvsrc2,$cvdst,$cvmask=NULL)
;CVAPI(void) cvOr( const CvArr* src1, const CvArr* src2, CvArr* dst, const CvArr* mask CV_DEFAULT(NULL));
    local $_aResult = DllCall($_opencv_worldDLL,"void:cdecl","cvOr","struct*",$cvsrc1,"struct*",$cvsrc2,"struct*",$cvdst,"struct*",$cvmask)
    If @error Then ConsoleWrite( "error in cvOr")
    Return $_aResult[0]
EndFunc ;==>cvOr
Func _cvOrS($cvsrc,$cvvalue,$cvdst,$cvmask=NULL)
;CVAPI(void) cvOrS( const CvArr* src, CvScalar value, CvArr* dst, const CvArr* mask CV_DEFAULT(NULL));
    local $_aResult = DllCall($_opencv_worldDLL,"void:cdecl","cvOrS","struct*",$cvsrc,"struct",$cvvalue,"struct*",$cvdst,"struct*",$cvmask)
    If @error Then ConsoleWrite( "error in cvOrS")
    Return $_aResult[0]
EndFunc ;==>cvOrS
Func _cvXor($cvsrc1,$cvsrc2,$cvdst,$cvmask=NULL)
;CVAPI(void) cvXor( const CvArr* src1, const CvArr* src2, CvArr* dst, const CvArr* mask CV_DEFAULT(NULL));
    local $_aResult = DllCall($_opencv_worldDLL,"void:cdecl","cvXor","struct*",$cvsrc1,"struct*",$cvsrc2,"struct*",$cvdst,"struct*",$cvmask)
    If @error Then ConsoleWrite( "error in cvXor")
    Return $_aResult[0]
EndFunc ;==>cvXor
Func _cvXorS($cvsrc,$cvvalue,$cvdst,$cvmask=NULL)
;CVAPI(void) cvXorS( const CvArr* src, CvScalar value, CvArr* dst, const CvArr* mask CV_DEFAULT(NULL));
    local $_aResult = DllCall($_opencv_worldDLL,"void:cdecl","cvXorS","struct*",$cvsrc,"struct",$cvvalue,"struct*",$cvdst,"struct*",$cvmask)
    If @error Then ConsoleWrite( "error in cvXorS")
    Return $_aResult[0]
EndFunc ;==>cvXorS
Func _cvNot($cvsrc,$cvdst)
;CVAPI(void) cvNot( const CvArr* src, CvArr* dst );
    local $_aResult = DllCall($_opencv_worldDLL,"void:cdecl","cvNot","struct*",$cvsrc,"struct*",$cvdst)
    If @error Then ConsoleWrite( "error in cvNot")
    Return $_aResult[0]
EndFunc ;==>cvNot
Func _cvInRange($cvsrc,$cvlower,$cvupper,$cvdst)
;CVAPI(void) cvInRange( const CvArr* src, const CvArr* lower, const CvArr* upper, CvArr* dst );
    local $_aResult = DllCall($_opencv_worldDLL,"void:cdecl","cvInRange","struct*",$cvsrc,"struct*",$cvlower,"struct*",$cvupper,"struct*",$cvdst)
    If @error Then ConsoleWrite( "error in cvInRange")
    Return $_aResult[0]
EndFunc ;==>cvInRange
Func _cvInRangeS($cvsrc,$cvlower,$cvupper,$cvdst)
;CVAPI(void) cvInRangeS( const CvArr* src, CvScalar lower, CvScalar upper, CvArr* dst );
    local $_aResult = DllCall($_opencv_worldDLL,"void:cdecl","cvInRangeS","struct*",$cvsrc,"struct",$cvlower,"struct",$cvupper,"struct*",$cvdst)
    If @error Then ConsoleWrite( "error in cvInRangeS")
    Return $_aResult[0]
EndFunc ;==>cvInRangeS
Func _cvCmp($cvsrc1,$cvsrc2,$cvdst,$cvcmp_op)
;CVAPI(void) cvCmp( const CvArr* src1, const CvArr* src2, CvArr* dst, int cmp_op );
    local $_aResult = DllCall($_opencv_worldDLL,"void:cdecl","cvCmp","struct*",$cvsrc1,"struct*",$cvsrc2,"struct*",$cvdst,"int",$cvcmp_op)
    If @error Then ConsoleWrite( "error in cvCmp")
    Return $_aResult[0]
EndFunc ;==>cvCmp
Func _cvCmpS($cvsrc,$cvvalue,$cvdst,$cvcmp_op)
;CVAPI(void) cvCmpS( const CvArr* src, double value, CvArr* dst, int cmp_op );
    local $_aResult = DllCall($_opencv_worldDLL,"void:cdecl","cvCmpS","struct*",$cvsrc,"double",$cvvalue,"struct*",$cvdst,"int",$cvcmp_op)
    If @error Then ConsoleWrite( "error in cvCmpS")
    Return $_aResult[0]
EndFunc ;==>cvCmpS
Func _cvMin($cvsrc1,$cvsrc2,$cvdst)
;CVAPI(void) cvMin( const CvArr* src1, const CvArr* src2, CvArr* dst );
    local $_aResult = DllCall($_opencv_worldDLL,"void:cdecl","cvMin","struct*",$cvsrc1,"struct*",$cvsrc2,"struct*",$cvdst)
    If @error Then ConsoleWrite( "error in cvMin")
    Return $_aResult[0]
EndFunc ;==>cvMin
Func _cvMax($cvsrc1,$cvsrc2,$cvdst)
;CVAPI(void) cvMax( const CvArr* src1, const CvArr* src2, CvArr* dst );
    local $_aResult = DllCall($_opencv_worldDLL,"void:cdecl","cvMax","struct*",$cvsrc1,"struct*",$cvsrc2,"struct*",$cvdst)
    If @error Then ConsoleWrite( "error in cvMax")
    Return $_aResult[0]
EndFunc ;==>cvMax
Func _cvMinS($cvsrc,$cvvalue,$cvdst)
;CVAPI(void) cvMinS( const CvArr* src, double value, CvArr* dst );
    local $_aResult = DllCall($_opencv_worldDLL,"void:cdecl","cvMinS","struct*",$cvsrc,"double",$cvvalue,"struct*",$cvdst)
    If @error Then ConsoleWrite( "error in cvMinS")
    Return $_aResult[0]
EndFunc ;==>cvMinS
Func _cvMaxS($cvsrc,$cvvalue,$cvdst)
;CVAPI(void) cvMaxS( const CvArr* src, double value, CvArr* dst );
    local $_aResult = DllCall($_opencv_worldDLL,"void:cdecl","cvMaxS","struct*",$cvsrc,"double",$cvvalue,"struct*",$cvdst)
    If @error Then ConsoleWrite( "error in cvMaxS")
    Return $_aResult[0]
EndFunc ;==>cvMaxS
Func _cvAbsDiff($cvsrc1,$cvsrc2,$cvdst)
;CVAPI(void) cvAbsDiff( const CvArr* src1, const CvArr* src2, CvArr* dst );
    local $_aResult = DllCall($_opencv_worldDLL,"void:cdecl","cvAbsDiff","struct*",$cvsrc1,"struct*",$cvsrc2,"struct*",$cvdst)
    If @error Then ConsoleWrite( "error in cvAbsDiff")
    Return $_aResult[0]
EndFunc ;==>cvAbsDiff
Func _cvAbsDiffS($cvsrc,$cvdst,$cvvalue)
;CVAPI(void) cvAbsDiffS( const CvArr* src, CvArr* dst, CvScalar value );
    local $_aResult = DllCall($_opencv_worldDLL,"void:cdecl","cvAbsDiffS","struct*",$cvsrc,"struct*",$cvdst,"struct",$cvvalue)
    If @error Then ConsoleWrite( "error in cvAbsDiffS")
    Return $_aResult[0]
EndFunc ;==>cvAbsDiffS
Func _cvCartToPolar($cvx,$cvy,$cvmagnitude,$cvangle=NULL,$cvangle_in_degrees=0)
;CVAPI(void) cvCartToPolar( const CvArr* x, const CvArr* y, CvArr* magnitude, CvArr* angle CV_DEFAULT(NULL), int angle_in_degrees CV_DEFAULT(0));
    local $_aResult = DllCall($_opencv_worldDLL,"void:cdecl","cvCartToPolar","struct*",$cvx,"struct*",$cvy,"struct*",$cvmagnitude,"struct*",$cvangle,"int",$cvangle_in_degrees)
    If @error Then ConsoleWrite( "error in cvCartToPolar")
    Return $_aResult[0]
EndFunc ;==>cvCartToPolar
Func _cvPolarToCart($cvmagnitude,$cvangle,$cvx,$cvy,$cvangle_in_degrees=0)
;CVAPI(void) cvPolarToCart( const CvArr* magnitude, const CvArr* angle, CvArr* x, CvArr* y, int angle_in_degrees CV_DEFAULT(0));
    local $_aResult = DllCall($_opencv_worldDLL,"void:cdecl","cvPolarToCart","struct*",$cvmagnitude,"struct*",$cvangle,"struct*",$cvx,"struct*",$cvy,"int",$cvangle_in_degrees)
    If @error Then ConsoleWrite( "error in cvPolarToCart")
    Return $_aResult[0]
EndFunc ;==>cvPolarToCart
Func _cvPow($cvsrc,$cvdst,$cvpower)
;CVAPI(void) cvPow( const CvArr* src, CvArr* dst, double power );
    local $_aResult = DllCall($_opencv_worldDLL,"void:cdecl","cvPow","struct*",$cvsrc,"struct*",$cvdst,"double",$cvpower)
    If @error Then ConsoleWrite( "error in cvPow")
    Return $_aResult[0]
EndFunc ;==>cvPow
Func _cvExp($cvsrc,$cvdst)
;CVAPI(void) cvExp( const CvArr* src, CvArr* dst );
    local $_aResult = DllCall($_opencv_worldDLL,"void:cdecl","cvExp","struct*",$cvsrc,"struct*",$cvdst)
    If @error Then ConsoleWrite( "error in cvExp")
    Return $_aResult[0]
EndFunc ;==>cvExp
Func _cvLog($cvsrc,$cvdst)
;CVAPI(void) cvLog( const CvArr* src, CvArr* dst );
    local $_aResult = DllCall($_opencv_worldDLL,"void:cdecl","cvLog","struct*",$cvsrc,"struct*",$cvdst)
    If @error Then ConsoleWrite( "error in cvLog")
    Return $_aResult[0]
EndFunc ;==>cvLog
Func _cvFastArctan($cvy,$cvx)
;CVAPI(float) cvFastArctan( float y, float x );
    local $_aResult = DllCall($_opencv_worldDLL,"float:cdecl","cvFastArctan","struct",$cvy,"struct",$cvx)
    If @error Then ConsoleWrite( "error in cvFastArctan")
    Return $_aResult[0]
EndFunc ;==>cvFastArctan
Func _cvCbrt($cvvalue)
;CVAPI(float) cvCbrt( float value );
    local $_aResult = DllCall($_opencv_worldDLL,"float:cdecl","cvCbrt","struct",$cvvalue)
    If @error Then ConsoleWrite( "error in cvCbrt")
    Return $_aResult[0]
EndFunc ;==>cvCbrt
Func _cvCheckArr($cvarr,$cvflags=0,$cvmin_val=0,$cvmax_val=0)
;CVAPI(int) cvCheckArr( const CvArr* arr, int flags CV_DEFAULT(0), double min_val CV_DEFAULT(0), double max_val CV_DEFAULT(0));
    local $_aResult = DllCall($_opencv_worldDLL,"int:cdecl","cvCheckArr","struct*",$cvarr,"int",$cvflags,"double",$cvmin_val,"double",$cvmax_val)
    If @error Then ConsoleWrite( "error in cvCheckArr")
    Return $_aResult[0]
EndFunc ;==>cvCheckArr
Func _cvRandArr($cvrng,$cvarr,$cvdist_type,$cvparam1,$cvparam2)
;CVAPI(void) cvRandArr( CvRNG* rng, CvArr* arr, int dist_type, CvScalar param1, CvScalar param2 );
    local $_aResult = DllCall($_opencv_worldDLL,"void:cdecl","cvRandArr","struct*",$cvrng,"struct*",$cvarr,"int",$cvdist_type,"struct",$cvparam1,"struct",$cvparam2)
    If @error Then ConsoleWrite( "error in cvRandArr")
    Return $_aResult[0]
EndFunc ;==>cvRandArr
Func _cvRandShuffle($cvmat,$cvrng,$cviter_factor=1.0)
;CVAPI(void) cvRandShuffle( CvArr* mat, CvRNG* rng, double iter_factor CV_DEFAULT(1.));
    local $_aResult = DllCall($_opencv_worldDLL,"void:cdecl","cvRandShuffle","struct*",$cvmat,"struct*",$cvrng,"double",$cviter_factor)
    If @error Then ConsoleWrite( "error in cvRandShuffle")
    Return $_aResult[0]
EndFunc ;==>cvRandShuffle
Func _cvSort($cvsrc,$cvdst=NULL,$cvidxmat=NULL,$cvflags=0)
;CVAPI(void) cvSort( const CvArr* src, CvArr* dst CV_DEFAULT(NULL), CvArr* idxmat CV_DEFAULT(NULL), int flags CV_DEFAULT(0));
    local $_aResult = DllCall($_opencv_worldDLL,"void:cdecl","cvSort","struct*",$cvsrc,"struct*",$cvdst,"struct*",$cvidxmat,"int",$cvflags)
    If @error Then ConsoleWrite( "error in cvSort")
    Return $_aResult[0]
EndFunc ;==>cvSort
Func _cvSolveCubic($cvcoeffs,$cvroots)
;CVAPI(int) cvSolveCubic( const CvMat* coeffs, CvMat* roots );
    local $_aResult = DllCall($_opencv_worldDLL,"int:cdecl","cvSolveCubic","struct*",$cvcoeffs,"struct*",$cvroots)
    If @error Then ConsoleWrite( "error in cvSolveCubic")
    Return $_aResult[0]
EndFunc ;==>cvSolveCubic
Func _cvSolvePoly($cvcoeffs,$cvroots2,$cvmaxiter=20,$cvfig=100)
;CVAPI(void) cvSolvePoly(const CvMat* coeffs, CvMat* roots2, int maxiter CV_DEFAULT(20), int fig CV_DEFAULT(100));
    local $_aResult = DllCall($_opencv_worldDLL,"void:cdecl","cvSolvePoly","struct*",$cvcoeffs,"struct*",$cvroots2,"int",$cvmaxiter,"int",$cvfig)
    If @error Then ConsoleWrite( "error in cvSolvePoly")
    Return $_aResult[0]
EndFunc ;==>cvSolvePoly
Func _cvCrossProduct($cvsrc1,$cvsrc2,$cvdst)
;CVAPI(void) cvCrossProduct( const CvArr* src1, const CvArr* src2, CvArr* dst );
    local $_aResult = DllCall($_opencv_worldDLL,"void:cdecl","cvCrossProduct","struct*",$cvsrc1,"struct*",$cvsrc2,"struct*",$cvdst)
    If @error Then ConsoleWrite( "error in cvCrossProduct")
    Return $_aResult[0]
EndFunc ;==>cvCrossProduct
Func _cvGEMM($cvsrc1,$cvsrc2,$cvalpha,$cvsrc3,$cvbeta,$cvdst,$cvtABC=0)
;CVAPI(void) cvGEMM( const CvArr* src1, const CvArr* src2, double alpha, const CvArr* src3, double beta, CvArr* dst, int tABC CV_DEFAULT(0));
    local $_aResult = DllCall($_opencv_worldDLL,"void:cdecl","cvGEMM","struct*",$cvsrc1,"struct*",$cvsrc2,"double",$cvalpha,"struct*",$cvsrc3,"double",$cvbeta,"struct*",$cvdst,"int",$cvtABC)
    If @error Then ConsoleWrite( "error in cvGEMM")
    Return $_aResult[0]
EndFunc ;==>cvGEMM
Func _cvTransform($cvsrc,$cvdst,$cvtransmat,$cvshiftvec=NULL)
;CVAPI(void) cvTransform( const CvArr* src, CvArr* dst, const CvMat* transmat, const CvMat* shiftvec CV_DEFAULT(NULL));
    local $_aResult = DllCall($_opencv_worldDLL,"void:cdecl","cvTransform","struct*",$cvsrc,"struct*",$cvdst,"struct*",$cvtransmat,"struct*",$cvshiftvec)
    If @error Then ConsoleWrite( "error in cvTransform")
    Return $_aResult[0]
EndFunc ;==>cvTransform
Func _cvPerspectiveTransform($cvsrc,$cvdst,$cvmat)
;CVAPI(void) cvPerspectiveTransform( const CvArr* src, CvArr* dst, const CvMat* mat );
    local $_aResult = DllCall($_opencv_worldDLL,"void:cdecl","cvPerspectiveTransform","struct*",$cvsrc,"struct*",$cvdst,"struct*",$cvmat)
    If @error Then ConsoleWrite( "error in cvPerspectiveTransform")
    Return $_aResult[0]
EndFunc ;==>cvPerspectiveTransform
Func _cvMulTransposed($cvsrc,$cvdst,$cvorder,$cvdelta=NULL,$cvscale=1.0)
;CVAPI(void) cvMulTransposed( const CvArr* src, CvArr* dst, int order, const CvArr* delta CV_DEFAULT(NULL), double scale CV_DEFAULT(1.) );
    local $_aResult = DllCall($_opencv_worldDLL,"void:cdecl","cvMulTransposed","struct*",$cvsrc,"struct*",$cvdst,"int",$cvorder,"struct*",$cvdelta,"double",$cvscale)
    If @error Then ConsoleWrite( "error in cvMulTransposed")
    Return $_aResult[0]
EndFunc ;==>cvMulTransposed
Func _cvTranspose($cvsrc,$cvdst)
;CVAPI(void) cvTranspose( const CvArr* src, CvArr* dst );
    local $_aResult = DllCall($_opencv_worldDLL,"void:cdecl","cvTranspose","struct*",$cvsrc,"struct*",$cvdst)
    If @error Then ConsoleWrite( "error in cvTranspose")
    Return $_aResult[0]
EndFunc ;==>cvTranspose
Func _cvCompleteSymm($cvmatrix,$cvLtoR=0)
;CVAPI(void) cvCompleteSymm( CvMat* matrix, int LtoR CV_DEFAULT(0) );
    local $_aResult = DllCall($_opencv_worldDLL,"void:cdecl","cvCompleteSymm","struct*",$cvmatrix,"int",$cvLtoR)
    If @error Then ConsoleWrite( "error in cvCompleteSymm")
    Return $_aResult[0]
EndFunc ;==>cvCompleteSymm
Func _cvFlip($cvsrc,$cvdst=NULL,$cvflip_mode=0)
;CVAPI(void) cvFlip( const CvArr* src, CvArr* dst CV_DEFAULT(NULL), int flip_mode CV_DEFAULT(0));
    local $_aResult = DllCall($_opencv_worldDLL,"void:cdecl","cvFlip","struct*",$cvsrc,"struct*",$cvdst,"int",$cvflip_mode)
    If @error Then ConsoleWrite( "error in cvFlip")
    Return $_aResult[0]
EndFunc ;==>cvFlip
Func _cvSVD($cvA,$cvW,$cvU=NULL,$cvV=NULL,$cvflags=0)
;CVAPI(void) cvSVD( CvArr* A, CvArr* W, CvArr* U CV_DEFAULT(NULL), CvArr* V CV_DEFAULT(NULL), int flags CV_DEFAULT(0));
    local $_aResult = DllCall($_opencv_worldDLL,"void:cdecl","cvSVD","struct*",$cvA,"struct*",$cvW,"struct*",$cvU,"struct*",$cvV,"int",$cvflags)
    If @error Then ConsoleWrite( "error in cvSVD")
    Return $_aResult[0]
EndFunc ;==>cvSVD
Func _cvSVBkSb($cvW,$cvU,$cvV,$cvB,$cvX,$cvflags)
;CVAPI(void) cvSVBkSb( const CvArr* W, const CvArr* U, const CvArr* V, const CvArr* B, CvArr* X, int flags );
    local $_aResult = DllCall($_opencv_worldDLL,"void:cdecl","cvSVBkSb","struct*",$cvW,"struct*",$cvU,"struct*",$cvV,"struct*",$cvB,"struct*",$cvX,"int",$cvflags)
    If @error Then ConsoleWrite( "error in cvSVBkSb")
    Return $_aResult[0]
EndFunc ;==>cvSVBkSb
Func _cvInvert($cvsrc,$cvdst,$cvmethod=$CV_LU)
;CVAPI(double) cvInvert( const CvArr* src, CvArr* dst, int method CV_DEFAULT(CV_LU));
    local $_aResult = DllCall($_opencv_worldDLL,"double:cdecl","cvInvert","struct*",$cvsrc,"struct*",$cvdst,"int",$cvmethod)
    If @error Then ConsoleWrite( "error in cvInvert")
    Return $_aResult[0]
EndFunc ;==>cvInvert
Func _cvSolve($cvsrc1,$cvsrc2,$cvdst,$cvmethod=$CV_LU)
;CVAPI(int) cvSolve( const CvArr* src1, const CvArr* src2, CvArr* dst, int method CV_DEFAULT(CV_LU));
    local $_aResult = DllCall($_opencv_worldDLL,"int:cdecl","cvSolve","struct*",$cvsrc1,"struct*",$cvsrc2,"struct*",$cvdst,"int",$cvmethod)
    If @error Then ConsoleWrite( "error in cvSolve")
    Return $_aResult[0]
EndFunc ;==>cvSolve
Func _cvDet($cvmat)
;CVAPI(double) cvDet( const CvArr* mat );
    local $_aResult = DllCall($_opencv_worldDLL,"double:cdecl","cvDet","struct*",$cvmat)
    If @error Then ConsoleWrite( "error in cvDet")
    Return $_aResult[0]
EndFunc ;==>cvDet
Func _cvTrace($cvmat)
;CVAPI(CvScalar) cvTrace( const CvArr* mat );
    local $_aResult = DllCall($_opencv_worldDLL,"none:cdecl","cvTrace","struct*",$cvmat)
    If @error Then ConsoleWrite( "error in cvTrace")
    Return $_aResult[0]
EndFunc ;==>cvTrace
Func _cvEigenVV($cvmat,$cvevects,$cvevals,$cveps=0,$cvlowindex=-1,$cvhighindex=-1)
;CVAPI(void) cvEigenVV( CvArr* mat, CvArr* evects, CvArr* evals, double eps CV_DEFAULT(0), int lowindex CV_DEFAULT(-1), int highindex CV_DEFAULT(-1));
    local $_aResult = DllCall($_opencv_worldDLL,"void:cdecl","cvEigenVV","struct*",$cvmat,"struct*",$cvevects,"struct*",$cvevals,"double",$cveps,"int",$cvlowindex,"int",$cvhighindex)
    If @error Then ConsoleWrite( "error in cvEigenVV")
    Return $_aResult[0]
EndFunc ;==>cvEigenVV
#comments-start
;TODO: Fix function declaration
Func _cvSetIdentity($cvmat,$cvvalue=cvRealScalar,$cv,$cv)
;CVAPI(void) cvSetIdentity( CvArr* mat, CvScalar value CV_DEFAULT(cvRealScalar(1)) );
    local $_aResult = DllCall($_opencv_worldDLL,"void:cdecl","cvSetIdentity","struct*",$cvmat,"struct",$cvvalue,"struct",$cv,"struct",$cv)
    If @error Then ConsoleWrite( "error in cvSetIdentity")
    Return $_aResult[0]
EndFunc ;==>cvSetIdentity
#comments-end
Func _cvRange($cvmat,$cvstart,$cvend)
;CVAPI(CvArr*) cvRange( CvArr* mat, double start, double end );
    local $_aResult = DllCall($_opencv_worldDLL,"ptr:cdecl","cvRange","struct*",$cvmat,"double",$cvstart,"double",$cvend)
    If @error Then ConsoleWrite( "error in cvRange")
    Return $_aResult[0]
EndFunc ;==>cvRange
Func _cvCalcCovarMatrix($cvvects,$cvcount,$cvcov_mat,$cvavg,$cvflags)
;CVAPI(void) cvCalcCovarMatrix( const CvArr** vects, int count, CvArr* cov_mat, CvArr* avg, int flags );
    local $_aResult = DllCall($_opencv_worldDLL,"void:cdecl","cvCalcCovarMatrix","struct*",$cvvects,"int",$cvcount,"struct*",$cvcov_mat,"struct*",$cvavg,"int",$cvflags)
    If @error Then ConsoleWrite( "error in cvCalcCovarMatrix")
    Return $_aResult[0]
EndFunc ;==>cvCalcCovarMatrix
Func _cvCalcPCA($cvdata,$cvmean,$cveigenvals,$cveigenvects,$cvflags)
;CVAPI(void) cvCalcPCA( const CvArr* data, CvArr* mean, CvArr* eigenvals, CvArr* eigenvects, int flags );
    local $_aResult = DllCall($_opencv_worldDLL,"void:cdecl","cvCalcPCA","struct*",$cvdata,"struct*",$cvmean,"struct*",$cveigenvals,"struct*",$cveigenvects,"int",$cvflags)
    If @error Then ConsoleWrite( "error in cvCalcPCA")
    Return $_aResult[0]
EndFunc ;==>cvCalcPCA
Func _cvProjectPCA($cvdata,$cvmean,$cveigenvects,$cvresult)
;CVAPI(void) cvProjectPCA( const CvArr* data, const CvArr* mean, const CvArr* eigenvects, CvArr* result );
    local $_aResult = DllCall($_opencv_worldDLL,"void:cdecl","cvProjectPCA","struct*",$cvdata,"struct*",$cvmean,"struct*",$cveigenvects,"struct*",$cvresult)
    If @error Then ConsoleWrite( "error in cvProjectPCA")
    Return $_aResult[0]
EndFunc ;==>cvProjectPCA
Func _cvBackProjectPCA($cvproj,$cvmean,$cveigenvects,$cvresult)
;CVAPI(void) cvBackProjectPCA( const CvArr* proj, const CvArr* mean, const CvArr* eigenvects, CvArr* result );
    local $_aResult = DllCall($_opencv_worldDLL,"void:cdecl","cvBackProjectPCA","struct*",$cvproj,"struct*",$cvmean,"struct*",$cveigenvects,"struct*",$cvresult)
    If @error Then ConsoleWrite( "error in cvBackProjectPCA")
    Return $_aResult[0]
EndFunc ;==>cvBackProjectPCA
Func _cvMahalanobis($cvvec1,$cvvec2,$cvmat)
;CVAPI(double) cvMahalanobis( const CvArr* vec1, const CvArr* vec2, const CvArr* mat );
    local $_aResult = DllCall($_opencv_worldDLL,"double:cdecl","cvMahalanobis","struct*",$cvvec1,"struct*",$cvvec2,"struct*",$cvmat)
    If @error Then ConsoleWrite( "error in cvMahalanobis")
    Return $_aResult[0]
EndFunc ;==>cvMahalanobis
Func _cvSum($cvarr)
;CVAPI(CvScalar) cvSum( const CvArr* arr );
    local $_aResult = DllCall($_opencv_worldDLL,"none:cdecl","cvSum","struct*",$cvarr)
    If @error Then ConsoleWrite( "error in cvSum")
    Return $_aResult[0]
EndFunc ;==>cvSum
Func _cvCountNonZero($cvarr)
;CVAPI(int) cvCountNonZero( const CvArr* arr );
    local $_aResult = DllCall($_opencv_worldDLL,"int:cdecl","cvCountNonZero","struct*",$cvarr)
    If @error Then ConsoleWrite( "error in cvCountNonZero")
    Return $_aResult[0]
EndFunc ;==>cvCountNonZero
Func _cvAvg($cvarr,$cvmask=NULL)
;CVAPI(CvScalar) cvAvg( const CvArr* arr, const CvArr* mask CV_DEFAULT(NULL) );
    local $_aResult = DllCall($_opencv_worldDLL,"none:cdecl","cvAvg","struct*",$cvarr,"struct*",$cvmask)
    If @error Then ConsoleWrite( "error in cvAvg")
    Return $_aResult[0]
EndFunc ;==>cvAvg
Func _cvAvgSdv($cvarr,$cvmean,$cvstd_dev,$cvmask=NULL)
;CVAPI(void) cvAvgSdv( const CvArr* arr, CvScalar* mean, CvScalar* std_dev, const CvArr* mask CV_DEFAULT(NULL) );
    local $_aResult = DllCall($_opencv_worldDLL,"void:cdecl","cvAvgSdv","struct*",$cvarr,"struct*",$cvmean,"struct*",$cvstd_dev,"struct*",$cvmask)
    If @error Then ConsoleWrite( "error in cvAvgSdv")
    Return $_aResult[0]
EndFunc ;==>cvAvgSdv
Func _cvMinMaxLoc($cvarr,$cvmin_val,$cvmax_val,$cvmin_loc=NULL,$cvmax_loc=NULL,$cvmask=NULL)
;CVAPI(void) cvMinMaxLoc( const CvArr* arr, double* min_val, double* max_val, CvPoint* min_loc CV_DEFAULT(NULL), CvPoint* max_loc CV_DEFAULT(NULL), const CvArr* mask CV_DEFAULT(NULL) );
    local $_aResult = DllCall($_opencv_worldDLL,"void:cdecl","cvMinMaxLoc","struct*",$cvarr,"struct*",$cvmin_val,"struct*",$cvmax_val,"struct*",$cvmin_loc,"struct*",$cvmax_loc,"struct*",$cvmask)
    If @error Then ConsoleWrite( "error in cvMinMaxLoc")
    Return $_aResult[0]
EndFunc ;==>cvMinMaxLoc
Func _cvNorm($cvarr1,$cvarr2=NULL,$cvnorm_type=$CV_L2,$cvmask=NULL)
;CVAPI(double) cvNorm( const CvArr* arr1, const CvArr* arr2 CV_DEFAULT(NULL), int norm_type CV_DEFAULT(CV_L2), const CvArr* mask CV_DEFAULT(NULL) );
    local $_aResult = DllCall($_opencv_worldDLL,"double:cdecl","cvNorm","struct*",$cvarr1,"struct*",$cvarr2,"int",$cvnorm_type,"struct*",$cvmask)
    If @error Then ConsoleWrite( "error in cvNorm")
    Return $_aResult[0]
EndFunc ;==>cvNorm
Func _cvNormalize($cvsrc,$cvdst,$cva=1.0,$cvb=0.0,$cvnorm_type=$CV_L2,$cvmask=NULL)
;CVAPI(void) cvNormalize( const CvArr* src, CvArr* dst, double a CV_DEFAULT(1.), double b CV_DEFAULT(0.), int norm_type CV_DEFAULT(CV_L2), const CvArr* mask CV_DEFAULT(NULL) );
    local $_aResult = DllCall($_opencv_worldDLL,"void:cdecl","cvNormalize","struct*",$cvsrc,"struct*",$cvdst,"double",$cva,"double",$cvb,"int",$cvnorm_type,"struct*",$cvmask)
    If @error Then ConsoleWrite( "error in cvNormalize")
    Return $_aResult[0]
EndFunc ;==>cvNormalize
Func _cvReduce($cvsrc,$cvdst,$cvdim=-1,$cvop=$CV_REDUCE_SUM)
;CVAPI(void) cvReduce( const CvArr* src, CvArr* dst, int dim CV_DEFAULT(-1), int op CV_DEFAULT(CV_REDUCE_SUM) );
    local $_aResult = DllCall($_opencv_worldDLL,"void:cdecl","cvReduce","struct*",$cvsrc,"struct*",$cvdst,"int",$cvdim,"int",$cvop)
    If @error Then ConsoleWrite( "error in cvReduce")
    Return $_aResult[0]
EndFunc ;==>cvReduce
Func _cvDFT($cvsrc,$cvdst,$cvflags,$cvnonzero_rows=0)
;CVAPI(void) cvDFT( const CvArr* src, CvArr* dst, int flags, int nonzero_rows CV_DEFAULT(0) );
    local $_aResult = DllCall($_opencv_worldDLL,"void:cdecl","cvDFT","struct*",$cvsrc,"struct*",$cvdst,"int",$cvflags,"int",$cvnonzero_rows)
    If @error Then ConsoleWrite( "error in cvDFT")
    Return $_aResult[0]
EndFunc ;==>cvDFT
Func _cvMulSpectrums($cvsrc1,$cvsrc2,$cvdst,$cvflags)
;CVAPI(void) cvMulSpectrums( const CvArr* src1, const CvArr* src2, CvArr* dst, int flags );
    local $_aResult = DllCall($_opencv_worldDLL,"void:cdecl","cvMulSpectrums","struct*",$cvsrc1,"struct*",$cvsrc2,"struct*",$cvdst,"int",$cvflags)
    If @error Then ConsoleWrite( "error in cvMulSpectrums")
    Return $_aResult[0]
EndFunc ;==>cvMulSpectrums
Func _cvGetOptimalDFTSize($cvsize0)
;CVAPI(int) cvGetOptimalDFTSize( int size0 );
    local $_aResult = DllCall($_opencv_worldDLL,"int:cdecl","cvGetOptimalDFTSize","int",$cvsize0)
    If @error Then ConsoleWrite( "error in cvGetOptimalDFTSize")
    Return $_aResult[0]
EndFunc ;==>cvGetOptimalDFTSize
Func _cvDCT($cvsrc,$cvdst,$cvflags)
;CVAPI(void) cvDCT( const CvArr* src, CvArr* dst, int flags );
    local $_aResult = DllCall($_opencv_worldDLL,"void:cdecl","cvDCT","struct*",$cvsrc,"struct*",$cvdst,"int",$cvflags)
    If @error Then ConsoleWrite( "error in cvDCT")
    Return $_aResult[0]
EndFunc ;==>cvDCT
#comments-start
;TODO: Fix function declaration
Func _cvSliceLength($cvslice,$cvseq)
;CVAPI(int) cvSliceLength( CvSlice slice, const CvSeq* seq );
    local $_aResult = DllCall($_opencv_worldDLL,"int:cdecl","cvSliceLength","struct",$cvslice,"struct*",$cvseq)
    If @error Then ConsoleWrite( "error in cvSliceLength")
    Return $_aResult[0]
EndFunc ;==>cvSliceLength
#comments-end
Func _cvCreateMemStorage($cvblock_size=0)
;CVAPI(CvMemStorage*) cvCreateMemStorage( int block_size CV_DEFAULT(0));
    local $_aResult = DllCall($_opencv_worldDLL,"ptr:cdecl","cvCreateMemStorage","int",$cvblock_size)
    If @error Then ConsoleWrite( "error in cvCreateMemStorage")
    Return $_aResult[0]
EndFunc ;==>cvCreateMemStorage
Func _cvCreateChildMemStorage($cvparent)
;CVAPI(CvMemStorage*) cvCreateChildMemStorage( CvMemStorage* parent );
    local $_aResult = DllCall($_opencv_worldDLL,"ptr:cdecl","cvCreateChildMemStorage","struct*",$cvparent)
    If @error Then ConsoleWrite( "error in cvCreateChildMemStorage")
    Return $_aResult[0]
EndFunc ;==>cvCreateChildMemStorage
Func _cvReleaseMemStorage($cvstorage)
;CVAPI(void) cvReleaseMemStorage( CvMemStorage** storage );
    local $_aResult = DllCall($_opencv_worldDLL,"void:cdecl","cvReleaseMemStorage","struct*",$cvstorage)
    If @error Then ConsoleWrite( "error in cvReleaseMemStorage")
    Return $_aResult[0]
EndFunc ;==>cvReleaseMemStorage
Func _cvClearMemStorage($cvstorage)
;CVAPI(void) cvClearMemStorage( CvMemStorage* storage );
    local $_aResult = DllCall($_opencv_worldDLL,"void:cdecl","cvClearMemStorage","struct*",$cvstorage)
    If @error Then ConsoleWrite( "error in cvClearMemStorage")
    Return $_aResult[0]
EndFunc ;==>cvClearMemStorage
Func _cvSaveMemStoragePos($cvstorage,$cvpos)
;CVAPI(void) cvSaveMemStoragePos( const CvMemStorage* storage, CvMemStoragePos* pos );
    local $_aResult = DllCall($_opencv_worldDLL,"void:cdecl","cvSaveMemStoragePos","struct*",$cvstorage,"struct*",$cvpos)
    If @error Then ConsoleWrite( "error in cvSaveMemStoragePos")
    Return $_aResult[0]
EndFunc ;==>cvSaveMemStoragePos
Func _cvRestoreMemStoragePos($cvstorage,$cvpos)
;CVAPI(void) cvRestoreMemStoragePos( CvMemStorage* storage, CvMemStoragePos* pos );
    local $_aResult = DllCall($_opencv_worldDLL,"void:cdecl","cvRestoreMemStoragePos","struct*",$cvstorage,"struct*",$cvpos)
    If @error Then ConsoleWrite( "error in cvRestoreMemStoragePos")
    Return $_aResult[0]
EndFunc ;==>cvRestoreMemStoragePos
Func _cvMemStorageAlloc($cvstorage,$cvsize)
;CVAPI(void*) cvMemStorageAlloc( CvMemStorage* storage, size_t size );
    local $_aResult = DllCall($_opencv_worldDLL,"ptr:cdecl","cvMemStorageAlloc","struct*",$cvstorage,"ulong_ptr",$cvsize)
    If @error Then ConsoleWrite( "error in cvMemStorageAlloc")
    Return $_aResult[0]
EndFunc ;==>cvMemStorageAlloc
Func _cvCreateSeq($cvseq_flags,$cvheader_size,$cvelem_size,$cvstorage)
;CVAPI(CvSeq*) cvCreateSeq( int seq_flags, size_t header_size, size_t elem_size, CvMemStorage* storage );
    local $_aResult = DllCall($_opencv_worldDLL,"ptr:cdecl","cvCreateSeq","int",$cvseq_flags,"ulong_ptr",$cvheader_size,"ulong_ptr",$cvelem_size,"struct*",$cvstorage)
    If @error Then ConsoleWrite( "error in cvCreateSeq")
    Return $_aResult[0]
EndFunc ;==>cvCreateSeq
Func _cvSetSeqBlockSize($cvseq,$cvdelta_elems)
;CVAPI(void) cvSetSeqBlockSize( CvSeq* seq, int delta_elems );
    local $_aResult = DllCall($_opencv_worldDLL,"void:cdecl","cvSetSeqBlockSize","struct*",$cvseq,"int",$cvdelta_elems)
    If @error Then ConsoleWrite( "error in cvSetSeqBlockSize")
    Return $_aResult[0]
EndFunc ;==>cvSetSeqBlockSize
Func _cvSeqPush($cvseq,$cvelement=NULL)
;CVAPI(schar*) cvSeqPush( CvSeq* seq, const void* element CV_DEFAULT(NULL));
    local $_aResult = DllCall($_opencv_worldDLL,"ptr:cdecl","cvSeqPush","struct*",$cvseq,"struct*",$cvelement)
    If @error Then ConsoleWrite( "error in cvSeqPush")
    Return $_aResult[0]
EndFunc ;==>cvSeqPush
Func _cvSeqPushFront($cvseq,$cvelement=NULL)
;CVAPI(schar*) cvSeqPushFront( CvSeq* seq, const void* element CV_DEFAULT(NULL));
    local $_aResult = DllCall($_opencv_worldDLL,"ptr:cdecl","cvSeqPushFront","struct*",$cvseq,"struct*",$cvelement)
    If @error Then ConsoleWrite( "error in cvSeqPushFront")
    Return $_aResult[0]
EndFunc ;==>cvSeqPushFront
Func _cvSeqPop($cvseq,$cvelement=NULL)
;CVAPI(void) cvSeqPop( CvSeq* seq, void* element CV_DEFAULT(NULL));
    local $_aResult = DllCall($_opencv_worldDLL,"void:cdecl","cvSeqPop","struct*",$cvseq,"struct*",$cvelement)
    If @error Then ConsoleWrite( "error in cvSeqPop")
    Return $_aResult[0]
EndFunc ;==>cvSeqPop
Func _cvSeqPopFront($cvseq,$cvelement=NULL)
;CVAPI(void) cvSeqPopFront( CvSeq* seq, void* element CV_DEFAULT(NULL));
    local $_aResult = DllCall($_opencv_worldDLL,"void:cdecl","cvSeqPopFront","struct*",$cvseq,"struct*",$cvelement)
    If @error Then ConsoleWrite( "error in cvSeqPopFront")
    Return $_aResult[0]
EndFunc ;==>cvSeqPopFront
Func _cvSeqPushMulti($cvseq,$cvelements,$cvcount,$cvin_front=0)
;CVAPI(void) cvSeqPushMulti( CvSeq* seq, const void* elements, int count, int in_front CV_DEFAULT(0) );
    local $_aResult = DllCall($_opencv_worldDLL,"void:cdecl","cvSeqPushMulti","struct*",$cvseq,"struct*",$cvelements,"int",$cvcount,"int",$cvin_front)
    If @error Then ConsoleWrite( "error in cvSeqPushMulti")
    Return $_aResult[0]
EndFunc ;==>cvSeqPushMulti
Func _cvSeqPopMulti($cvseq,$cvelements,$cvcount,$cvin_front=0)
;CVAPI(void) cvSeqPopMulti( CvSeq* seq, void* elements, int count, int in_front CV_DEFAULT(0) );
    local $_aResult = DllCall($_opencv_worldDLL,"void:cdecl","cvSeqPopMulti","struct*",$cvseq,"struct*",$cvelements,"int",$cvcount,"int",$cvin_front)
    If @error Then ConsoleWrite( "error in cvSeqPopMulti")
    Return $_aResult[0]
EndFunc ;==>cvSeqPopMulti
Func _cvSeqInsert($cvseq,$cvbefore_index,$cvelement=NULL)
;CVAPI(schar*) cvSeqInsert( CvSeq* seq, int before_index, const void* element CV_DEFAULT(NULL));
    local $_aResult = DllCall($_opencv_worldDLL,"ptr:cdecl","cvSeqInsert","struct*",$cvseq,"int",$cvbefore_index,"struct*",$cvelement)
    If @error Then ConsoleWrite( "error in cvSeqInsert")
    Return $_aResult[0]
EndFunc ;==>cvSeqInsert
Func _cvSeqRemove($cvseq,$cvindex)
;CVAPI(void) cvSeqRemove( CvSeq* seq, int index );
    local $_aResult = DllCall($_opencv_worldDLL,"void:cdecl","cvSeqRemove","struct*",$cvseq,"int",$cvindex)
    If @error Then ConsoleWrite( "error in cvSeqRemove")
    Return $_aResult[0]
EndFunc ;==>cvSeqRemove
Func _cvClearSeq($cvseq)
;CVAPI(void) cvClearSeq( CvSeq* seq );
    local $_aResult = DllCall($_opencv_worldDLL,"void:cdecl","cvClearSeq","struct*",$cvseq)
    If @error Then ConsoleWrite( "error in cvClearSeq")
    Return $_aResult[0]
EndFunc ;==>cvClearSeq
Func _cvGetSeqElem($cvseq,$cvindex)
;CVAPI(schar*) cvGetSeqElem( const CvSeq* seq, int index );
    local $_aResult = DllCall($_opencv_worldDLL,"ptr:cdecl","cvGetSeqElem","struct*",$cvseq,"int",$cvindex)
    If @error Then ConsoleWrite( "error in cvGetSeqElem")
    Return $_aResult[0]
EndFunc ;==>cvGetSeqElem
Func _cvSeqElemIdx($cvseq,$cvelement,$cvblock=NULL)
;CVAPI(int) cvSeqElemIdx( const CvSeq* seq, const void* element, CvSeqBlock** block CV_DEFAULT(NULL) );
    local $_aResult = DllCall($_opencv_worldDLL,"int:cdecl","cvSeqElemIdx","struct*",$cvseq,"struct*",$cvelement,"struct*",$cvblock)
    If @error Then ConsoleWrite( "error in cvSeqElemIdx")
    Return $_aResult[0]
EndFunc ;==>cvSeqElemIdx
Func _cvStartAppendToSeq($cvseq,$cvwriter)
;CVAPI(void) cvStartAppendToSeq( CvSeq* seq, CvSeqWriter* writer );
    local $_aResult = DllCall($_opencv_worldDLL,"void:cdecl","cvStartAppendToSeq","struct*",$cvseq,"struct*",$cvwriter)
    If @error Then ConsoleWrite( "error in cvStartAppendToSeq")
    Return $_aResult[0]
EndFunc ;==>cvStartAppendToSeq
Func _cvStartWriteSeq($cvseq_flags,$cvheader_size,$cvelem_size,$cvstorage,$cvwriter)
;CVAPI(void) cvStartWriteSeq( int seq_flags, int header_size, int elem_size, CvMemStorage* storage, CvSeqWriter* writer );
    local $_aResult = DllCall($_opencv_worldDLL,"void:cdecl","cvStartWriteSeq","int",$cvseq_flags,"int",$cvheader_size,"int",$cvelem_size,"struct*",$cvstorage,"struct*",$cvwriter)
    If @error Then ConsoleWrite( "error in cvStartWriteSeq")
    Return $_aResult[0]
EndFunc ;==>cvStartWriteSeq
Func _cvEndWriteSeq($cvwriter)
;CVAPI(CvSeq*) cvEndWriteSeq( CvSeqWriter* writer );
    local $_aResult = DllCall($_opencv_worldDLL,"ptr:cdecl","cvEndWriteSeq","struct*",$cvwriter)
    If @error Then ConsoleWrite( "error in cvEndWriteSeq")
    Return $_aResult[0]
EndFunc ;==>cvEndWriteSeq
Func _cvFlushSeqWriter($cvwriter)
;CVAPI(void) cvFlushSeqWriter( CvSeqWriter* writer );
    local $_aResult = DllCall($_opencv_worldDLL,"void:cdecl","cvFlushSeqWriter","struct*",$cvwriter)
    If @error Then ConsoleWrite( "error in cvFlushSeqWriter")
    Return $_aResult[0]
EndFunc ;==>cvFlushSeqWriter
Func _cvStartReadSeq($cvseq,$cvreader,$cvreverse=0)
;CVAPI(void) cvStartReadSeq( const CvSeq* seq, CvSeqReader* reader, int reverse CV_DEFAULT(0) );
    local $_aResult = DllCall($_opencv_worldDLL,"void:cdecl","cvStartReadSeq","struct*",$cvseq,"struct*",$cvreader,"int",$cvreverse)
    If @error Then ConsoleWrite( "error in cvStartReadSeq")
    Return $_aResult[0]
EndFunc ;==>cvStartReadSeq
Func _cvGetSeqReaderPos($cvreader)
;CVAPI(int) cvGetSeqReaderPos( CvSeqReader* reader );
    local $_aResult = DllCall($_opencv_worldDLL,"int:cdecl","cvGetSeqReaderPos","struct*",$cvreader)
    If @error Then ConsoleWrite( "error in cvGetSeqReaderPos")
    Return $_aResult[0]
EndFunc ;==>cvGetSeqReaderPos
Func _cvSetSeqReaderPos($cvreader,$cvindex,$cvis_relative=0)
;CVAPI(void) cvSetSeqReaderPos( CvSeqReader* reader, int index, int is_relative CV_DEFAULT(0));
    local $_aResult = DllCall($_opencv_worldDLL,"void:cdecl","cvSetSeqReaderPos","struct*",$cvreader,"int",$cvindex,"int",$cvis_relative)
    If @error Then ConsoleWrite( "error in cvSetSeqReaderPos")
    Return $_aResult[0]
EndFunc ;==>cvSetSeqReaderPos
#comments-start
;TODO: Fix function declaration
Func _cvCvtSeqToArray($cvseq,$cvelements,$cvslice=$CV_WHOLE_SEQ)
;CVAPI(void*) cvCvtSeqToArray( const CvSeq* seq, void* elements, CvSlice slice CV_DEFAULT(CV_WHOLE_SEQ) );
    local $_aResult = DllCall($_opencv_worldDLL,"ptr:cdecl","cvCvtSeqToArray","struct*",$cvseq,"struct*",$cvelements,"struct",$cvslice)
    If @error Then ConsoleWrite( "error in cvCvtSeqToArray")
    Return $_aResult[0]
EndFunc ;==>cvCvtSeqToArray
#comments-end
Func _cvMakeSeqHeaderForArray($cvseq_type,$cvheader_size,$cvelem_size,$cvelements,$cvtotal,$cvseq,$cvblock)
;CVAPI(CvSeq*) cvMakeSeqHeaderForArray( int seq_type, int header_size, int elem_size, void* elements, int total, CvSeq* seq, CvSeqBlock* block );
    local $_aResult = DllCall($_opencv_worldDLL,"ptr:cdecl","cvMakeSeqHeaderForArray","int",$cvseq_type,"int",$cvheader_size,"int",$cvelem_size,"struct*",$cvelements,"int",$cvtotal,"struct*",$cvseq,"struct*",$cvblock)
    If @error Then ConsoleWrite( "error in cvMakeSeqHeaderForArray")
    Return $_aResult[0]
EndFunc ;==>cvMakeSeqHeaderForArray
#comments-start
;TODO: Fix function declaration
Func _cvSeqSlice($cvseq,$cvslice,$cvstorage=NULL,$cvcopy_data=0)
;CVAPI(CvSeq*) cvSeqSlice( const CvSeq* seq, CvSlice slice, CvMemStorage* storage CV_DEFAULT(NULL), int copy_data CV_DEFAULT(0));
    local $_aResult = DllCall($_opencv_worldDLL,"ptr:cdecl","cvSeqSlice","struct*",$cvseq,"struct",$cvslice,"struct*",$cvstorage,"int",$cvcopy_data)
    If @error Then ConsoleWrite( "error in cvSeqSlice")
    Return $_aResult[0]
EndFunc ;==>cvSeqSlice
#comments-end
#comments-start
;TODO: Fix function declaration
Func _cvSeqRemoveSlice($cvseq,$cvslice)
;CVAPI(void) cvSeqRemoveSlice( CvSeq* seq, CvSlice slice );
    local $_aResult = DllCall($_opencv_worldDLL,"void:cdecl","cvSeqRemoveSlice","struct*",$cvseq,"struct",$cvslice)
    If @error Then ConsoleWrite( "error in cvSeqRemoveSlice")
    Return $_aResult[0]
EndFunc ;==>cvSeqRemoveSlice
#comments-end
Func _cvSeqInsertSlice($cvseq,$cvbefore_index,$cvfrom_arr)
;CVAPI(void) cvSeqInsertSlice( CvSeq* seq, int before_index, const CvArr* from_arr );
    local $_aResult = DllCall($_opencv_worldDLL,"void:cdecl","cvSeqInsertSlice","struct*",$cvseq,"int",$cvbefore_index,"struct*",$cvfrom_arr)
    If @error Then ConsoleWrite( "error in cvSeqInsertSlice")
    Return $_aResult[0]
EndFunc ;==>cvSeqInsertSlice
Func _cvSeqSort($cvseq,$cvfunc,$cvuserdata=NULL)
;CVAPI(void) cvSeqSort( CvSeq* seq, CvCmpFunc func, void* userdata CV_DEFAULT(NULL) );
    local $_aResult = DllCall($_opencv_worldDLL,"void:cdecl","cvSeqSort","struct*",$cvseq,"struct",$cvfunc,"struct*",$cvuserdata)
    If @error Then ConsoleWrite( "error in cvSeqSort")
    Return $_aResult[0]
EndFunc ;==>cvSeqSort
Func _cvSeqSearch($cvseq,$cvelem,$cvfunc,$cvis_sorted,$cvelem_idx,$cvuserdata=NULL)
;CVAPI(schar*) cvSeqSearch( CvSeq* seq, const void* elem, CvCmpFunc func, int is_sorted, int* elem_idx, void* userdata CV_DEFAULT(NULL) );
    local $_aResult = DllCall($_opencv_worldDLL,"ptr:cdecl","cvSeqSearch","struct*",$cvseq,"struct*",$cvelem,"struct",$cvfunc,"int",$cvis_sorted,"struct*",$cvelem_idx,"struct*",$cvuserdata)
    If @error Then ConsoleWrite( "error in cvSeqSearch")
    Return $_aResult[0]
EndFunc ;==>cvSeqSearch
Func _cvSeqInvert($cvseq)
;CVAPI(void) cvSeqInvert( CvSeq* seq );
    local $_aResult = DllCall($_opencv_worldDLL,"void:cdecl","cvSeqInvert","struct*",$cvseq)
    If @error Then ConsoleWrite( "error in cvSeqInvert")
    Return $_aResult[0]
EndFunc ;==>cvSeqInvert
Func _cvSeqPartition($cvseq,$cvstorage,$cvlabels,$cvis_equal,$cvuserdata)
;CVAPI(int) cvSeqPartition( const CvSeq* seq, CvMemStorage* storage, CvSeq** labels, CvCmpFunc is_equal, void* userdata );
    local $_aResult = DllCall($_opencv_worldDLL,"int:cdecl","cvSeqPartition","struct*",$cvseq,"struct*",$cvstorage,"struct*",$cvlabels,"struct",$cvis_equal,"struct*",$cvuserdata)
    If @error Then ConsoleWrite( "error in cvSeqPartition")
    Return $_aResult[0]
EndFunc ;==>cvSeqPartition
Func _cvChangeSeqBlock($cvreader,$cvdirection)
;CVAPI(void) cvChangeSeqBlock( void* reader, int direction );
    local $_aResult = DllCall($_opencv_worldDLL,"void:cdecl","cvChangeSeqBlock","struct*",$cvreader,"int",$cvdirection)
    If @error Then ConsoleWrite( "error in cvChangeSeqBlock")
    Return $_aResult[0]
EndFunc ;==>cvChangeSeqBlock
Func _cvCreateSeqBlock($cvwriter)
;CVAPI(void) cvCreateSeqBlock( CvSeqWriter* writer );
    local $_aResult = DllCall($_opencv_worldDLL,"void:cdecl","cvCreateSeqBlock","struct*",$cvwriter)
    If @error Then ConsoleWrite( "error in cvCreateSeqBlock")
    Return $_aResult[0]
EndFunc ;==>cvCreateSeqBlock
Func _cvCreateSet($cvset_flags,$cvheader_size,$cvelem_size,$cvstorage)
;CVAPI(CvSet*) cvCreateSet( int set_flags, int header_size, int elem_size, CvMemStorage* storage );
    local $_aResult = DllCall($_opencv_worldDLL,"ptr:cdecl","cvCreateSet","int",$cvset_flags,"int",$cvheader_size,"int",$cvelem_size,"struct*",$cvstorage)
    If @error Then ConsoleWrite( "error in cvCreateSet")
    Return $_aResult[0]
EndFunc ;==>cvCreateSet
Func _cvSetAdd($cvset_header,$cvelem=NULL,$cvinserted_elem=NULL)
;CVAPI(int) cvSetAdd( CvSet* set_header, CvSetElem* elem CV_DEFAULT(NULL), CvSetElem** inserted_elem CV_DEFAULT(NULL) );
    local $_aResult = DllCall($_opencv_worldDLL,"int:cdecl","cvSetAdd","struct*",$cvset_header,"struct*",$cvelem,"struct*",$cvinserted_elem)
    If @error Then ConsoleWrite( "error in cvSetAdd")
    Return $_aResult[0]
EndFunc ;==>cvSetAdd
Func _cvSetRemove($cvset_header,$cvindex)
;CVAPI(void) cvSetRemove( CvSet* set_header, int index );
    local $_aResult = DllCall($_opencv_worldDLL,"void:cdecl","cvSetRemove","struct*",$cvset_header,"int",$cvindex)
    If @error Then ConsoleWrite( "error in cvSetRemove")
    Return $_aResult[0]
EndFunc ;==>cvSetRemove
Func _cvClearSet($cvset_header)
;CVAPI(void) cvClearSet( CvSet* set_header );
    local $_aResult = DllCall($_opencv_worldDLL,"void:cdecl","cvClearSet","struct*",$cvset_header)
    If @error Then ConsoleWrite( "error in cvClearSet")
    Return $_aResult[0]
EndFunc ;==>cvClearSet
Func _cvCreateGraph($cvgraph_flags,$cvheader_size,$cvvtx_size,$cvedge_size,$cvstorage)
;CVAPI(CvGraph*) cvCreateGraph( int graph_flags, int header_size, int vtx_size, int edge_size, CvMemStorage* storage );
    local $_aResult = DllCall($_opencv_worldDLL,"ptr:cdecl","cvCreateGraph","int",$cvgraph_flags,"int",$cvheader_size,"int",$cvvtx_size,"int",$cvedge_size,"struct*",$cvstorage)
    If @error Then ConsoleWrite( "error in cvCreateGraph")
    Return $_aResult[0]
EndFunc ;==>cvCreateGraph
Func _cvGraphAddVtx($cvgraph,$cvvtx=NULL,$cvinserted_vtx=NULL)
;CVAPI(int) cvGraphAddVtx( CvGraph* graph, const CvGraphVtx* vtx CV_DEFAULT(NULL), CvGraphVtx** inserted_vtx CV_DEFAULT(NULL) );
    local $_aResult = DllCall($_opencv_worldDLL,"int:cdecl","cvGraphAddVtx","struct*",$cvgraph,"struct*",$cvvtx,"struct*",$cvinserted_vtx)
    If @error Then ConsoleWrite( "error in cvGraphAddVtx")
    Return $_aResult[0]
EndFunc ;==>cvGraphAddVtx
Func _cvGraphRemoveVtx($cvgraph,$cvindex)
;CVAPI(int) cvGraphRemoveVtx( CvGraph* graph, int index );
    local $_aResult = DllCall($_opencv_worldDLL,"int:cdecl","cvGraphRemoveVtx","struct*",$cvgraph,"int",$cvindex)
    If @error Then ConsoleWrite( "error in cvGraphRemoveVtx")
    Return $_aResult[0]
EndFunc ;==>cvGraphRemoveVtx
Func _cvGraphRemoveVtxByPtr($cvgraph,$cvvtx)
;CVAPI(int) cvGraphRemoveVtxByPtr( CvGraph* graph, CvGraphVtx* vtx );
    local $_aResult = DllCall($_opencv_worldDLL,"int:cdecl","cvGraphRemoveVtxByPtr","struct*",$cvgraph,"struct*",$cvvtx)
    If @error Then ConsoleWrite( "error in cvGraphRemoveVtxByPtr")
    Return $_aResult[0]
EndFunc ;==>cvGraphRemoveVtxByPtr
Func _cvGraphAddEdge($cvgraph,$cvstart_idx,$cvend_idx,$cvedge=NULL,$cvinserted_edge=NULL)
;CVAPI(int) cvGraphAddEdge( CvGraph* graph, int start_idx, int end_idx, const CvGraphEdge* edge CV_DEFAULT(NULL), CvGraphEdge** inserted_edge CV_DEFAULT(NULL) );
    local $_aResult = DllCall($_opencv_worldDLL,"int:cdecl","cvGraphAddEdge","struct*",$cvgraph,"int",$cvstart_idx,"int",$cvend_idx,"struct*",$cvedge,"struct*",$cvinserted_edge)
    If @error Then ConsoleWrite( "error in cvGraphAddEdge")
    Return $_aResult[0]
EndFunc ;==>cvGraphAddEdge
Func _cvGraphAddEdgeByPtr($cvgraph,$cvstart_vtx,$cvend_vtx,$cvedge=NULL,$cvinserted_edge=NULL)
;CVAPI(int) cvGraphAddEdgeByPtr( CvGraph* graph, CvGraphVtx* start_vtx, CvGraphVtx* end_vtx, const CvGraphEdge* edge CV_DEFAULT(NULL), CvGraphEdge** inserted_edge CV_DEFAULT(NULL) );
    local $_aResult = DllCall($_opencv_worldDLL,"int:cdecl","cvGraphAddEdgeByPtr","struct*",$cvgraph,"struct*",$cvstart_vtx,"struct*",$cvend_vtx,"struct*",$cvedge,"struct*",$cvinserted_edge)
    If @error Then ConsoleWrite( "error in cvGraphAddEdgeByPtr")
    Return $_aResult[0]
EndFunc ;==>cvGraphAddEdgeByPtr
Func _cvGraphRemoveEdge($cvgraph,$cvstart_idx,$cvend_idx)
;CVAPI(void) cvGraphRemoveEdge( CvGraph* graph, int start_idx, int end_idx );
    local $_aResult = DllCall($_opencv_worldDLL,"void:cdecl","cvGraphRemoveEdge","struct*",$cvgraph,"int",$cvstart_idx,"int",$cvend_idx)
    If @error Then ConsoleWrite( "error in cvGraphRemoveEdge")
    Return $_aResult[0]
EndFunc ;==>cvGraphRemoveEdge
Func _cvGraphRemoveEdgeByPtr($cvgraph,$cvstart_vtx,$cvend_vtx)
;CVAPI(void) cvGraphRemoveEdgeByPtr( CvGraph* graph, CvGraphVtx* start_vtx, CvGraphVtx* end_vtx );
    local $_aResult = DllCall($_opencv_worldDLL,"void:cdecl","cvGraphRemoveEdgeByPtr","struct*",$cvgraph,"struct*",$cvstart_vtx,"struct*",$cvend_vtx)
    If @error Then ConsoleWrite( "error in cvGraphRemoveEdgeByPtr")
    Return $_aResult[0]
EndFunc ;==>cvGraphRemoveEdgeByPtr
Func _cvFindGraphEdge($cvgraph,$cvstart_idx,$cvend_idx)
;CVAPI(CvGraphEdge*) cvFindGraphEdge( const CvGraph* graph, int start_idx, int end_idx );
    local $_aResult = DllCall($_opencv_worldDLL,"ptr:cdecl","cvFindGraphEdge","struct*",$cvgraph,"int",$cvstart_idx,"int",$cvend_idx)
    If @error Then ConsoleWrite( "error in cvFindGraphEdge")
    Return $_aResult[0]
EndFunc ;==>cvFindGraphEdge
Func _cvFindGraphEdgeByPtr($cvgraph,$cvstart_vtx,$cvend_vtx)
;CVAPI(CvGraphEdge*) cvFindGraphEdgeByPtr( const CvGraph* graph, const CvGraphVtx* start_vtx, const CvGraphVtx* end_vtx );
    local $_aResult = DllCall($_opencv_worldDLL,"ptr:cdecl","cvFindGraphEdgeByPtr","struct*",$cvgraph,"struct*",$cvstart_vtx,"struct*",$cvend_vtx)
    If @error Then ConsoleWrite( "error in cvFindGraphEdgeByPtr")
    Return $_aResult[0]
EndFunc ;==>cvFindGraphEdgeByPtr
Func _cvClearGraph($cvgraph)
;CVAPI(void) cvClearGraph( CvGraph* graph );
    local $_aResult = DllCall($_opencv_worldDLL,"void:cdecl","cvClearGraph","struct*",$cvgraph)
    If @error Then ConsoleWrite( "error in cvClearGraph")
    Return $_aResult[0]
EndFunc ;==>cvClearGraph
Func _cvGraphVtxDegree($cvgraph,$cvvtx_idx)
;CVAPI(int) cvGraphVtxDegree( const CvGraph* graph, int vtx_idx );
    local $_aResult = DllCall($_opencv_worldDLL,"int:cdecl","cvGraphVtxDegree","struct*",$cvgraph,"int",$cvvtx_idx)
    If @error Then ConsoleWrite( "error in cvGraphVtxDegree")
    Return $_aResult[0]
EndFunc ;==>cvGraphVtxDegree
Func _cvGraphVtxDegreeByPtr($cvgraph,$cvvtx)
;CVAPI(int) cvGraphVtxDegreeByPtr( const CvGraph* graph, const CvGraphVtx* vtx );
    local $_aResult = DllCall($_opencv_worldDLL,"int:cdecl","cvGraphVtxDegreeByPtr","struct*",$cvgraph,"struct*",$cvvtx)
    If @error Then ConsoleWrite( "error in cvGraphVtxDegreeByPtr")
    Return $_aResult[0]
EndFunc ;==>cvGraphVtxDegreeByPtr
Func _cvCreateGraphScanner($cvgraph,$cvvtx=NULL,$cvmask=$CV_GRAPH_ALL_ITEMS)
;CVAPI(CvGraphScanner*) cvCreateGraphScanner( CvGraph* graph, CvGraphVtx* vtx CV_DEFAULT(NULL), int mask CV_DEFAULT(CV_GRAPH_ALL_ITEMS));
    local $_aResult = DllCall($_opencv_worldDLL,"ptr:cdecl","cvCreateGraphScanner","struct*",$cvgraph,"struct*",$cvvtx,"int",$cvmask)
    If @error Then ConsoleWrite( "error in cvCreateGraphScanner")
    Return $_aResult[0]
EndFunc ;==>cvCreateGraphScanner
Func _cvReleaseGraphScanner($cvscanner)
;CVAPI(void) cvReleaseGraphScanner( CvGraphScanner** scanner );
    local $_aResult = DllCall($_opencv_worldDLL,"void:cdecl","cvReleaseGraphScanner","struct*",$cvscanner)
    If @error Then ConsoleWrite( "error in cvReleaseGraphScanner")
    Return $_aResult[0]
EndFunc ;==>cvReleaseGraphScanner
Func _cvNextGraphItem($cvscanner)
;CVAPI(int) cvNextGraphItem( CvGraphScanner* scanner );
    local $_aResult = DllCall($_opencv_worldDLL,"int:cdecl","cvNextGraphItem","struct*",$cvscanner)
    If @error Then ConsoleWrite( "error in cvNextGraphItem")
    Return $_aResult[0]
EndFunc ;==>cvNextGraphItem
Func _cvCloneGraph($cvgraph,$cvstorage)
;CVAPI(CvGraph*) cvCloneGraph( const CvGraph* graph, CvMemStorage* storage );
    local $_aResult = DllCall($_opencv_worldDLL,"ptr:cdecl","cvCloneGraph","struct*",$cvgraph,"struct*",$cvstorage)
    If @error Then ConsoleWrite( "error in cvCloneGraph")
    Return $_aResult[0]
EndFunc ;==>cvCloneGraph
Func _cvLUT($cvsrc,$cvdst,$cvlut)
;CVAPI(void) cvLUT( const CvArr* src, CvArr* dst, const CvArr* lut );
    local $_aResult = DllCall($_opencv_worldDLL,"void:cdecl","cvLUT","struct*",$cvsrc,"struct*",$cvdst,"struct*",$cvlut)
    If @error Then ConsoleWrite( "error in cvLUT")
    Return $_aResult[0]
EndFunc ;==>cvLUT
Func _cvInitTreeNodeIterator($cvtree_iterator,$cvfirst,$cvmax_level)
;CVAPI(void) cvInitTreeNodeIterator( CvTreeNodeIterator* tree_iterator, const void* first, int max_level );
    local $_aResult = DllCall($_opencv_worldDLL,"void:cdecl","cvInitTreeNodeIterator","struct*",$cvtree_iterator,"struct*",$cvfirst,"int",$cvmax_level)
    If @error Then ConsoleWrite( "error in cvInitTreeNodeIterator")
    Return $_aResult[0]
EndFunc ;==>cvInitTreeNodeIterator
Func _cvNextTreeNode($cvtree_iterator)
;CVAPI(void*) cvNextTreeNode( CvTreeNodeIterator* tree_iterator );
    local $_aResult = DllCall($_opencv_worldDLL,"ptr:cdecl","cvNextTreeNode","struct*",$cvtree_iterator)
    If @error Then ConsoleWrite( "error in cvNextTreeNode")
    Return $_aResult[0]
EndFunc ;==>cvNextTreeNode
Func _cvPrevTreeNode($cvtree_iterator)
;CVAPI(void*) cvPrevTreeNode( CvTreeNodeIterator* tree_iterator );
    local $_aResult = DllCall($_opencv_worldDLL,"ptr:cdecl","cvPrevTreeNode","struct*",$cvtree_iterator)
    If @error Then ConsoleWrite( "error in cvPrevTreeNode")
    Return $_aResult[0]
EndFunc ;==>cvPrevTreeNode
Func _cvInsertNodeIntoTree($cvnode,$cvparent,$cvframe)
;CVAPI(void) cvInsertNodeIntoTree( void* node, void* parent, void* frame );
    local $_aResult = DllCall($_opencv_worldDLL,"void:cdecl","cvInsertNodeIntoTree","struct*",$cvnode,"struct*",$cvparent,"struct*",$cvframe)
    If @error Then ConsoleWrite( "error in cvInsertNodeIntoTree")
    Return $_aResult[0]
EndFunc ;==>cvInsertNodeIntoTree
Func _cvRemoveNodeFromTree($cvnode,$cvframe)
;CVAPI(void) cvRemoveNodeFromTree( void* node, void* frame );
    local $_aResult = DllCall($_opencv_worldDLL,"void:cdecl","cvRemoveNodeFromTree","struct*",$cvnode,"struct*",$cvframe)
    If @error Then ConsoleWrite( "error in cvRemoveNodeFromTree")
    Return $_aResult[0]
EndFunc ;==>cvRemoveNodeFromTree
Func _cvTreeToNodeSeq($cvfirst,$cvheader_size,$cvstorage)
;CVAPI(CvSeq*) cvTreeToNodeSeq( const void* first, int header_size, CvMemStorage* storage );
    local $_aResult = DllCall($_opencv_worldDLL,"ptr:cdecl","cvTreeToNodeSeq","struct*",$cvfirst,"int",$cvheader_size,"struct*",$cvstorage)
    If @error Then ConsoleWrite( "error in cvTreeToNodeSeq")
    Return $_aResult[0]
EndFunc ;==>cvTreeToNodeSeq
Func _cvKMeans2($cvsamples,$cvcluster_count,$cvlabels,$cvtermcrit,$cvattempts=1,$cvrng=0,$cvflags=0,$cv_centers=0,$cvcompactness=0)
;CVAPI(int) cvKMeans2( const CvArr* samples, int cluster_count, CvArr* labels, CvTermCriteria termcrit, int attempts CV_DEFAULT(1), CvRNG* rng CV_DEFAULT(0), int flags CV_DEFAULT(0), CvArr* _centers CV_DEFAULT(0), double* compactness CV_DEFAULT(0) );
    local $_aResult = DllCall($_opencv_worldDLL,"int:cdecl","cvKMeans2","struct*",$cvsamples,"int",$cvcluster_count,"struct*",$cvlabels,"struct",$cvtermcrit,"int",$cvattempts,"struct*",$cvrng,"int",$cvflags,"struct*",$cv_centers,"struct*",$cvcompactness)
    If @error Then ConsoleWrite( "error in cvKMeans2")
    Return $_aResult[0]
EndFunc ;==>cvKMeans2
Func _cvUseOptimized($cvon_off)
;CVAPI(int) cvUseOptimized( int on_off );
    local $_aResult = DllCall($_opencv_worldDLL,"int:cdecl","cvUseOptimized","int",$cvon_off)
    If @error Then ConsoleWrite( "error in cvUseOptimized")
    Return $_aResult[0]
EndFunc ;==>cvUseOptimized
Func _cvSetIPLAllocators($cvcreate_header,$cvallocate_data,$cvdeallocate,$cvcreate_roi,$cvclone_image)
;CVAPI(void) cvSetIPLAllocators( Cv_iplCreateImageHeader create_header, Cv_iplAllocateImageData allocate_data, Cv_iplDeallocate deallocate, Cv_iplCreateROI create_roi, Cv_iplCloneImage clone_image );
    local $_aResult = DllCall($_opencv_worldDLL,"void:cdecl","cvSetIPLAllocators","struct",$cvcreate_header,"struct",$cvallocate_data,"struct",$cvdeallocate,"struct",$cvcreate_roi,"struct",$cvclone_image)
    If @error Then ConsoleWrite( "error in cvSetIPLAllocators")
    Return $_aResult[0]
EndFunc ;==>cvSetIPLAllocators
Func _cvOpenFileStorage($cvfilename,$cvmemstorage,$cvflags,$cvencoding=NULL)
;CVAPI(CvFileStorage*) cvOpenFileStorage( const char* filename, CvMemStorage* memstorage, int flags, const char* encoding CV_DEFAULT(NULL) );
;TODO: Other dll
   local $_aResult = DllCall($_opencv_worldDLL,"ptr:cdecl","cvOpenFileStorage","struct*",$cvfilename,"struct*",$cvmemstorage,"int",$cvflags,"struct*",$cvencoding)
    If @error Then ConsoleWrite( "error in cvOpenFileStorage")
    Return $_aResult[0]
EndFunc ;==>cvOpenFileStorage
Func _cvReleaseFileStorage($cvfs)
;CVAPI(void) cvReleaseFileStorage( CvFileStorage** fs );
;TODO: Other dll
   local $_aResult = DllCall($_opencv_worldDLL,"void:cdecl","cvReleaseFileStorage","struct*",$cvfs)
    If @error Then ConsoleWrite( "error in cvReleaseFileStorage")
    Return $_aResult[0]
EndFunc ;==>cvReleaseFileStorage
Func _cvAttrValue($cvattr,$cvattr_name)
;CVAPI(const char*) cvAttrValue( const CvAttrList* attr, const char* attr_name );
;TODO: Other dll
   local $_aResult = DllCall($_opencv_worldDLL,"ptr:cdecl","cvAttrValue","struct*",$cvattr,"struct*",$cvattr_name)
    If @error Then ConsoleWrite( "error in cvAttrValue")
    Return $_aResult[0]
EndFunc ;==>cvAttrValue
#comments-start
;TODO: Fix function declaration
Func _cvStartWriteStruct($cvfs,$cvname,$cvstruct_flags,$cvtype_name=NULL,$cvattributes=cvAttrList,$cv,$cv)
;CVAPI(void) cvStartWriteStruct( CvFileStorage* fs, const char* name, int struct_flags, const char* type_name CV_DEFAULT(NULL), CvAttrList attributes CV_DEFAULT(cvAttrList()));
;TODO: Other dll
   local $_aResult = DllCall($_opencv_worldDLL,"void:cdecl","cvStartWriteStruct","struct*",$cvfs,"struct*",$cvname,"int",$cvstruct_flags,"struct*",$cvtype_name,"struct",$cvattributes,"struct",$cv,"struct",$cv)
    If @error Then ConsoleWrite( "error in cvStartWriteStruct")
    Return $_aResult[0]
EndFunc ;==>cvStartWriteStruct
#comments-end
Func _cvEndWriteStruct($cvfs)
;CVAPI(void) cvEndWriteStruct( CvFileStorage* fs );
;TODO: Other dll
   local $_aResult = DllCall($_opencv_worldDLL,"void:cdecl","cvEndWriteStruct","struct*",$cvfs)
    If @error Then ConsoleWrite( "error in cvEndWriteStruct")
    Return $_aResult[0]
EndFunc ;==>cvEndWriteStruct
Func _cvWriteInt($cvfs,$cvname,$cvvalue)
;CVAPI(void) cvWriteInt( CvFileStorage* fs, const char* name, int value );
;TODO: Other dll
   local $_aResult = DllCall($_opencv_worldDLL,"void:cdecl","cvWriteInt","struct*",$cvfs,"struct*",$cvname,"int",$cvvalue)
    If @error Then ConsoleWrite( "error in cvWriteInt")
    Return $_aResult[0]
EndFunc ;==>cvWriteInt
Func _cvWriteReal($cvfs,$cvname,$cvvalue)
;CVAPI(void) cvWriteReal( CvFileStorage* fs, const char* name, double value );
;TODO: Other dll
   local $_aResult = DllCall($_opencv_worldDLL,"void:cdecl","cvWriteReal","struct*",$cvfs,"struct*",$cvname,"double",$cvvalue)
    If @error Then ConsoleWrite( "error in cvWriteReal")
    Return $_aResult[0]
EndFunc ;==>cvWriteReal
Func _cvWriteString($cvfs,$cvname,$cvstr,$cvquote=0)
;CVAPI(void) cvWriteString( CvFileStorage* fs, const char* name, const char* str, int quote CV_DEFAULT(0) );
;TODO: Other dll
   local $_aResult = DllCall($_opencv_worldDLL,"void:cdecl","cvWriteString","struct*",$cvfs,"struct*",$cvname,"struct*",$cvstr,"int",$cvquote)
    If @error Then ConsoleWrite( "error in cvWriteString")
    Return $_aResult[0]
EndFunc ;==>cvWriteString
Func _cvWriteComment($cvfs,$cvcomment,$cveol_comment)
;CVAPI(void) cvWriteComment( CvFileStorage* fs, const char* comment, int eol_comment );
;TODO: Other dll
   local $_aResult = DllCall($_opencv_worldDLL,"void:cdecl","cvWriteComment","struct*",$cvfs,"struct*",$cvcomment,"int",$cveol_comment)
    If @error Then ConsoleWrite( "error in cvWriteComment")
    Return $_aResult[0]
EndFunc ;==>cvWriteComment
#comments-start
;TODO: Fix function declaration
Func _cvWrite($cvfs,$cvname,$cvptr,$cvattributes=cvAttrList,$cv,$cv)
;CVAPI(void) cvWrite( CvFileStorage* fs, const char* name, const void* ptr, CvAttrList attributes CV_DEFAULT(cvAttrList()));
;TODO: Other dll
   local $_aResult = DllCall($_opencv_worldDLL,"void:cdecl","cvWrite","struct*",$cvfs,"struct*",$cvname,"struct*",$cvptr,"struct",$cvattributes,"struct",$cv,"struct",$cv)
    If @error Then ConsoleWrite( "error in cvWrite")
    Return $_aResult[0]
EndFunc ;==>cvWrite
#comments-end
Func _cvStartNextStream($cvfs)
;CVAPI(void) cvStartNextStream( CvFileStorage* fs );
;TODO: Other dll
   local $_aResult = DllCall($_opencv_worldDLL,"void:cdecl","cvStartNextStream","struct*",$cvfs)
    If @error Then ConsoleWrite( "error in cvStartNextStream")
    Return $_aResult[0]
EndFunc ;==>cvStartNextStream
Func _cvWriteRawData($cvfs,$cvsrc,$cvlen,$cvdt)
;CVAPI(void) cvWriteRawData( CvFileStorage* fs, const void* src, int len, const char* dt );
;TODO: Other dll
   local $_aResult = DllCall($_opencv_worldDLL,"void:cdecl","cvWriteRawData","struct*",$cvfs,"struct*",$cvsrc,"int",$cvlen,"struct*",$cvdt)
    If @error Then ConsoleWrite( "error in cvWriteRawData")
    Return $_aResult[0]
EndFunc ;==>cvWriteRawData
Func _cvWriteRawDataBase64($cvfs,$cvsrc,$cvlen,$cvdt)
;CVAPI(void) cvWriteRawDataBase64( CvFileStorage* fs, const void* src, int len, const char* dt );
;TODO: Other dll
   local $_aResult = DllCall($_opencv_worldDLL,"void:cdecl","cvWriteRawDataBase64","struct*",$cvfs,"struct*",$cvsrc,"int",$cvlen,"struct*",$cvdt)
    If @error Then ConsoleWrite( "error in cvWriteRawDataBase64")
    Return $_aResult[0]
EndFunc ;==>cvWriteRawDataBase64
Func _cvGetHashedKey($cvfs,$cvname,$cvlen=-1,$cvcreate_missing=0)
;CVAPI(CvStringHashNode*) cvGetHashedKey( CvFileStorage* fs, const char* name, int len CV_DEFAULT(-1), int create_missing CV_DEFAULT(0));
;TODO: Other dll
   local $_aResult = DllCall($_opencv_worldDLL,"ptr:cdecl","cvGetHashedKey","struct*",$cvfs,"struct*",$cvname,"int",$cvlen,"int",$cvcreate_missing)
    If @error Then ConsoleWrite( "error in cvGetHashedKey")
    Return $_aResult[0]
EndFunc ;==>cvGetHashedKey
Func _cvGetRootFileNode($cvfs,$cvstream_index=0)
;CVAPI(CvFileNode*) cvGetRootFileNode( const CvFileStorage* fs, int stream_index CV_DEFAULT(0) );
;TODO: Other dll
   local $_aResult = DllCall($_opencv_worldDLL,"ptr:cdecl","cvGetRootFileNode","struct*",$cvfs,"int",$cvstream_index)
    If @error Then ConsoleWrite( "error in cvGetRootFileNode")
    Return $_aResult[0]
EndFunc ;==>cvGetRootFileNode
Func _cvGetFileNode($cvfs,$cvmap,$cvkey,$cvcreate_missing=0)
;CVAPI(CvFileNode*) cvGetFileNode( CvFileStorage* fs, CvFileNode* map, const CvStringHashNode* key, int create_missing CV_DEFAULT(0) );
;TODO: Other dll
   local $_aResult = DllCall($_opencv_worldDLL,"ptr:cdecl","cvGetFileNode","struct*",$cvfs,"struct*",$cvmap,"struct*",$cvkey,"int",$cvcreate_missing)
    If @error Then ConsoleWrite( "error in cvGetFileNode")
    Return $_aResult[0]
EndFunc ;==>cvGetFileNode
Func _cvGetFileNodeByName($cvfs,$cvmap,$cvname)
;CVAPI(CvFileNode*) cvGetFileNodeByName( const CvFileStorage* fs, const CvFileNode* map, const char* name );
;TODO: Other dll
   local $_aResult = DllCall($_opencv_worldDLL,"ptr:cdecl","cvGetFileNodeByName","struct*",$cvfs,"struct*",$cvmap,"struct*",$cvname)
    If @error Then ConsoleWrite( "error in cvGetFileNodeByName")
    Return $_aResult[0]
EndFunc ;==>cvGetFileNodeByName
Func _cvRead($cvfs,$cvnode,$cvattributes=NULL)
;CVAPI(void*) cvRead( CvFileStorage* fs, CvFileNode* node, CvAttrList* attributes CV_DEFAULT(NULL));
;TODO: Other dll
   local $_aResult = DllCall($_opencv_worldDLL,"ptr:cdecl","cvRead","struct*",$cvfs,"struct*",$cvnode,"struct*",$cvattributes)
    If @error Then ConsoleWrite( "error in cvRead")
    Return $_aResult[0]
EndFunc ;==>cvRead
Func _cvStartReadRawData($cvfs,$cvsrc,$cvreader)
;CVAPI(void) cvStartReadRawData( const CvFileStorage* fs, const CvFileNode* src, CvSeqReader* reader );
;TODO: Other dll
   local $_aResult = DllCall($_opencv_worldDLL,"void:cdecl","cvStartReadRawData","struct*",$cvfs,"struct*",$cvsrc,"struct*",$cvreader)
    If @error Then ConsoleWrite( "error in cvStartReadRawData")
    Return $_aResult[0]
EndFunc ;==>cvStartReadRawData
Func _cvReadRawDataSlice($cvfs,$cvreader,$cvcount,$cvdst,$cvdt)
;CVAPI(void) cvReadRawDataSlice( const CvFileStorage* fs, CvSeqReader* reader, int count, void* dst, const char* dt );
;TODO: Other dll
   local $_aResult = DllCall($_opencv_worldDLL,"void:cdecl","cvReadRawDataSlice","struct*",$cvfs,"struct*",$cvreader,"int",$cvcount,"struct*",$cvdst,"struct*",$cvdt)
    If @error Then ConsoleWrite( "error in cvReadRawDataSlice")
    Return $_aResult[0]
EndFunc ;==>cvReadRawDataSlice
Func _cvReadRawData($cvfs,$cvsrc,$cvdst,$cvdt)
;CVAPI(void) cvReadRawData( const CvFileStorage* fs, const CvFileNode* src, void* dst, const char* dt );
;TODO: Other dll
   local $_aResult = DllCall($_opencv_worldDLL,"void:cdecl","cvReadRawData","struct*",$cvfs,"struct*",$cvsrc,"struct*",$cvdst,"struct*",$cvdt)
    If @error Then ConsoleWrite( "error in cvReadRawData")
    Return $_aResult[0]
EndFunc ;==>cvReadRawData
Func _cvWriteFileNode($cvfs,$cvnew_node_name,$cvnode,$cvembed)
;CVAPI(void) cvWriteFileNode( CvFileStorage* fs, const char* new_node_name, const CvFileNode* node, int embed );
;TODO: Other dll
   local $_aResult = DllCall($_opencv_worldDLL,"void:cdecl","cvWriteFileNode","struct*",$cvfs,"struct*",$cvnew_node_name,"struct*",$cvnode,"int",$cvembed)
    If @error Then ConsoleWrite( "error in cvWriteFileNode")
    Return $_aResult[0]
EndFunc ;==>cvWriteFileNode
Func _cvGetFileNodeName($cvnode)
;CVAPI(const char*) cvGetFileNodeName( const CvFileNode* node );
;TODO: Other dll
   local $_aResult = DllCall($_opencv_worldDLL,"ptr:cdecl","cvGetFileNodeName","struct*",$cvnode)
    If @error Then ConsoleWrite( "error in cvGetFileNodeName")
    Return $_aResult[0]
EndFunc ;==>cvGetFileNodeName
Func _cvRegisterType($cvinfo)
;CVAPI(void) cvRegisterType( const CvTypeInfo* info );
;TODO: Other dll
   local $_aResult = DllCall($_opencv_worldDLL,"void:cdecl","cvRegisterType","struct*",$cvinfo)
    If @error Then ConsoleWrite( "error in cvRegisterType")
    Return $_aResult[0]
EndFunc ;==>cvRegisterType
Func _cvUnregisterType($cvtype_name)
;CVAPI(void) cvUnregisterType( const char* type_name );
;TODO: Other dll
   local $_aResult = DllCall($_opencv_worldDLL,"void:cdecl","cvUnregisterType","struct*",$cvtype_name)
    If @error Then ConsoleWrite( "error in cvUnregisterType")
    Return $_aResult[0]
EndFunc ;==>cvUnregisterType
#comments-start
;TODO: Fix function declaration
Func _cvFirstType($cv)
;CVAPI(CvTypeInfo*) cvFirstType(void);
;TODO: Other dll
   local $_aResult = DllCall($_opencv_worldDLL,"ptr:cdecl","cvFirstType","struct",$cv)
    If @error Then ConsoleWrite( "error in cvFirstType")
    Return $_aResult[0]
EndFunc ;==>cvFirstType
#comments-end
Func _cvFindType($cvtype_name)
;CVAPI(CvTypeInfo*) cvFindType( const char* type_name );
;TODO: Other dll
   local $_aResult = DllCall($_opencv_worldDLL,"ptr:cdecl","cvFindType","struct*",$cvtype_name)
    If @error Then ConsoleWrite( "error in cvFindType")
    Return $_aResult[0]
EndFunc ;==>cvFindType
Func _cvTypeOf($cvstruct_ptr)
;CVAPI(CvTypeInfo*) cvTypeOf( const void* struct_ptr );
;TODO: Other dll
   local $_aResult = DllCall($_opencv_worldDLL,"ptr:cdecl","cvTypeOf","struct*",$cvstruct_ptr)
    If @error Then ConsoleWrite( "error in cvTypeOf")
    Return $_aResult[0]
EndFunc ;==>cvTypeOf
Func _cvRelease($cvstruct_ptr)
;CVAPI(void) cvRelease( void** struct_ptr );
    local $_aResult = DllCall($_opencv_worldDLL,"void:cdecl","cvRelease","struct*",$cvstruct_ptr)
    If @error Then ConsoleWrite( "error in cvRelease")
    Return $_aResult[0]
EndFunc ;==>cvRelease
Func _cvClone($cvstruct_ptr)
;CVAPI(void*) cvClone( const void* struct_ptr );
    local $_aResult = DllCall($_opencv_worldDLL,"ptr:cdecl","cvClone","struct*",$cvstruct_ptr)
    If @error Then ConsoleWrite( "error in cvClone")
    Return $_aResult[0]
EndFunc ;==>cvClone
#comments-start
;TODO: Fix function declaration
Func _cvGetTickCount($cv)
;CVAPI(int64) cvGetTickCount( void );
    local $_aResult = DllCall($_opencv_worldDLL,"int64:cdecl","cvGetTickCount","struct",$cv)
    If @error Then ConsoleWrite( "error in cvGetTickCount")
    Return $_aResult[0]
EndFunc ;==>cvGetTickCount
#comments-end
#comments-start
;TODO: Fix function declaration
Func _cvGetTickFrequency($cv)
;CVAPI(double) cvGetTickFrequency( void );
    local $_aResult = DllCall($_opencv_worldDLL,"double:cdecl","cvGetTickFrequency","struct",$cv)
    If @error Then ConsoleWrite( "error in cvGetTickFrequency")
    Return $_aResult[0]
EndFunc ;==>cvGetTickFrequency
#comments-end
Func _cvCheckHardwareSupport($cvfeature)
;CVAPI(int) cvCheckHardwareSupport(int feature);
    local $_aResult = DllCall($_opencv_worldDLL,"int:cdecl","cvCheckHardwareSupport","int",$cvfeature)
    If @error Then ConsoleWrite( "error in cvCheckHardwareSupport")
    Return $_aResult[0]
EndFunc ;==>cvCheckHardwareSupport
#comments-start
;TODO: Fix function declaration
Func _cvGetNumThreads($cv)
;CVAPI(int) cvGetNumThreads( void );
    local $_aResult = DllCall($_opencv_worldDLL,"int:cdecl","cvGetNumThreads","struct",$cv)
    If @error Then ConsoleWrite( "error in cvGetNumThreads")
    Return $_aResult[0]
EndFunc ;==>cvGetNumThreads
#comments-end
Func _cvSetNumThreads($cvthreads=0)
;CVAPI(void) cvSetNumThreads( int threads CV_DEFAULT(0) );
    local $_aResult = DllCall($_opencv_worldDLL,"void:cdecl","cvSetNumThreads","int",$cvthreads)
    If @error Then ConsoleWrite( "error in cvSetNumThreads")
    Return $_aResult[0]
EndFunc ;==>cvSetNumThreads
#comments-start
;TODO: Fix function declaration
Func _cvGetThreadNum($cv)
;CVAPI(int) cvGetThreadNum( void );
    local $_aResult = DllCall($_opencv_worldDLL,"int:cdecl","cvGetThreadNum","struct",$cv)
    If @error Then ConsoleWrite( "error in cvGetThreadNum")
    Return $_aResult[0]
EndFunc ;==>cvGetThreadNum
#comments-end
#comments-start
;TODO: Fix function declaration
Func _cvGetErrStatus($cv)
;CVAPI(int) cvGetErrStatus( void );
    local $_aResult = DllCall($_opencv_worldDLL,"int:cdecl","cvGetErrStatus","struct",$cv)
    If @error Then ConsoleWrite( "error in cvGetErrStatus")
    Return $_aResult[0]
EndFunc ;==>cvGetErrStatus
#comments-end
Func _cvSetErrStatus($cvstatus)
;CVAPI(void) cvSetErrStatus( int status );
    local $_aResult = DllCall($_opencv_worldDLL,"void:cdecl","cvSetErrStatus","int",$cvstatus)
    If @error Then ConsoleWrite( "error in cvSetErrStatus")
    Return $_aResult[0]
EndFunc ;==>cvSetErrStatus
#comments-start
;TODO: Fix function declaration
Func _cvGetErrMode($cv)
;CVAPI(int) cvGetErrMode( void );
    local $_aResult = DllCall($_opencv_worldDLL,"int:cdecl","cvGetErrMode","struct",$cv)
    If @error Then ConsoleWrite( "error in cvGetErrMode")
    Return $_aResult[0]
EndFunc ;==>cvGetErrMode
#comments-end
Func _cvSetErrMode($cvmode)
;CVAPI(int) cvSetErrMode( int mode );
    local $_aResult = DllCall($_opencv_worldDLL,"int:cdecl","cvSetErrMode","int",$cvmode)
    If @error Then ConsoleWrite( "error in cvSetErrMode")
    Return $_aResult[0]
EndFunc ;==>cvSetErrMode
Func _cvError($cvstatus,$cvfunc_name,$cverr_msg,$cvfile_name,$cvline)
;CVAPI(void) cvError( int status, const char* func_name, const char* err_msg, const char* file_name, int line );
    local $_aResult = DllCall($_opencv_worldDLL,"void:cdecl","cvError","int",$cvstatus,"struct*",$cvfunc_name,"struct*",$cverr_msg,"struct*",$cvfile_name,"int",$cvline)
    If @error Then ConsoleWrite( "error in cvError")
    Return $_aResult[0]
EndFunc ;==>cvError
Func _cvErrorStr($cvstatus)
;CVAPI(const char*) cvErrorStr( int status );
    local $_aResult = DllCall($_opencv_worldDLL,"ptr:cdecl","cvErrorStr","int",$cvstatus)
    If @error Then ConsoleWrite( "error in cvErrorStr")
    Return $_aResult[0]
EndFunc ;==>cvErrorStr
Func _cvGetErrInfo($cverrcode_desc,$cvdescription,$cvfilename,$cvline)
;CVAPI(int) cvGetErrInfo( const char** errcode_desc, const char** description, const char** filename, int* line );
    local $_aResult = DllCall($_opencv_worldDLL,"int:cdecl","cvGetErrInfo","struct*",$cverrcode_desc,"struct*",$cvdescription,"struct*",$cvfilename,"struct*",$cvline)
    If @error Then ConsoleWrite( "error in cvGetErrInfo")
    Return $_aResult[0]
EndFunc ;==>cvGetErrInfo
Func _cvErrorFromIppStatus($cvipp_status)
;CVAPI(int) cvErrorFromIppStatus( int ipp_status );
    local $_aResult = DllCall($_opencv_worldDLL,"int:cdecl","cvErrorFromIppStatus","int",$cvipp_status)
    If @error Then ConsoleWrite( "error in cvErrorFromIppStatus")
    Return $_aResult[0]
EndFunc ;==>cvErrorFromIppStatus
Func _cvRedirectError($cverror_handler,$cvuserdata=NULL,$cvprev_userdata=NULL)
;CVAPI(CvErrorCallback) cvRedirectError( CvErrorCallback error_handler, void* userdata CV_DEFAULT(NULL), void** prev_userdata CV_DEFAULT(NULL) );
    local $_aResult = DllCall($_opencv_worldDLL,"none:cdecl","cvRedirectError","struct",$cverror_handler,"struct*",$cvuserdata,"struct*",$cvprev_userdata)
    If @error Then ConsoleWrite( "error in cvRedirectError")
    Return $_aResult[0]
EndFunc ;==>cvRedirectError
Func _cvNulDevReport($cvstatus,$cvfunc_name,$cverr_msg,$cvfile_name,$cvline,$cvuserdata)
;CVAPI(int) cvNulDevReport( int status, const char* func_name, const char* err_msg, const char* file_name, int line, void* userdata );
    local $_aResult = DllCall($_opencv_worldDLL,"int:cdecl","cvNulDevReport","int",$cvstatus,"struct*",$cvfunc_name,"struct*",$cverr_msg,"struct*",$cvfile_name,"int",$cvline,"struct*",$cvuserdata)
    If @error Then ConsoleWrite( "error in cvNulDevReport")
    Return $_aResult[0]
EndFunc ;==>cvNulDevReport
Func _cvStdErrReport($cvstatus,$cvfunc_name,$cverr_msg,$cvfile_name,$cvline,$cvuserdata)
;CVAPI(int) cvStdErrReport( int status, const char* func_name, const char* err_msg, const char* file_name, int line, void* userdata );
    local $_aResult = DllCall($_opencv_worldDLL,"int:cdecl","cvStdErrReport","int",$cvstatus,"struct*",$cvfunc_name,"struct*",$cverr_msg,"struct*",$cvfile_name,"int",$cvline,"struct*",$cvuserdata)
    If @error Then ConsoleWrite( "error in cvStdErrReport")
    Return $_aResult[0]
EndFunc ;==>cvStdErrReport
Func _cvGuiBoxReport($cvstatus,$cvfunc_name,$cverr_msg,$cvfile_name,$cvline,$cvuserdata)
;CVAPI(int) cvGuiBoxReport( int status, const char* func_name, const char* err_msg, const char* file_name, int line, void* userdata );
    local $_aResult = DllCall($_opencv_worldDLL,"int:cdecl","cvGuiBoxReport","int",$cvstatus,"struct*",$cvfunc_name,"struct*",$cverr_msg,"struct*",$cvfile_name,"int",$cvline,"struct*",$cvuserdata)
    If @error Then ConsoleWrite( "error in cvGuiBoxReport")
    Return $_aResult[0]
EndFunc ;==>cvGuiBoxReport
#endregion  core_c.h
#region  highgui_c.h
#comments-start
;TODO: Fix function declaration
Func _cvFontQt($cvnameFont,$cvpointSize=-1,$cvcolor=cvScalarAll,$cv,$cv,$cvweight=$CV_FONT_NORMAL,$cvstyle=$CV_STYLE_NORMAL,$cvspacing=0)
;CVAPI(CvFont) cvFontQt(const char* nameFont, int pointSize CV_DEFAULT(-1), CvScalar color CV_DEFAULT(cvScalarAll(0)), int weight CV_DEFAULT(CV_FONT_NORMAL), int style CV_DEFAULT(CV_STYLE_NORMAL), int spacing CV_DEFAULT(0));
;TODO: Other dll
   local $_aResult = DllCall($_opencv_worldDLL,"none:cdecl","cvFontQt","struct*",$cvnameFont,"int",$cvpointSize,"struct",$cvcolor,"struct",$cv,"struct",$cv,"int",$cvweight,"int",$cvstyle,"int",$cvspacing)
    If @error Then ConsoleWrite( "error in cvFontQt")
    Return $_aResult[0]
EndFunc ;==>cvFontQt
#comments-end
Func _cvAddText($cvimg,$cvtext,$cvorg,$cvarg2)
;CVAPI(void) cvAddText(const CvArr* img, const char* text, CvPoint org, CvFont* arg2);
;TODO: Other dll
   local $_aResult = DllCall($_opencv_worldDLL,"void:cdecl","cvAddText","struct*",$cvimg,"struct*",$cvtext,"struct",$cvorg,"struct*",$cvarg2)
    If @error Then ConsoleWrite( "error in cvAddText")
    Return $_aResult[0]
EndFunc ;==>cvAddText
Func _cvDisplayOverlay($cvname,$cvtext,$cvdelayms=0)
;CVAPI(void) cvDisplayOverlay(const char* name, const char* text, int delayms CV_DEFAULT(0));
;TODO: Other dll
   local $_aResult = DllCall($_opencv_worldDLL,"void:cdecl","cvDisplayOverlay","struct*",$cvname,"struct*",$cvtext,"int",$cvdelayms)
    If @error Then ConsoleWrite( "error in cvDisplayOverlay")
    Return $_aResult[0]
EndFunc ;==>cvDisplayOverlay
Func _cvDisplayStatusBar($cvname,$cvtext,$cvdelayms=0)
;CVAPI(void) cvDisplayStatusBar(const char* name, const char* text, int delayms CV_DEFAULT(0));
;TODO: Other dll
   local $_aResult = DllCall($_opencv_worldDLL,"void:cdecl","cvDisplayStatusBar","struct*",$cvname,"struct*",$cvtext,"int",$cvdelayms)
    If @error Then ConsoleWrite( "error in cvDisplayStatusBar")
    Return $_aResult[0]
EndFunc ;==>cvDisplayStatusBar
Func _cvSaveWindowParameters($cvname)
;CVAPI(void) cvSaveWindowParameters(const char* name);
;TODO: Other dll
   local $_aResult = DllCall($_opencv_worldDLL,"void:cdecl","cvSaveWindowParameters","struct*",$cvname)
    If @error Then ConsoleWrite( "error in cvSaveWindowParameters")
    Return $_aResult[0]
EndFunc ;==>cvSaveWindowParameters
Func _cvLoadWindowParameters($cvname)
;CVAPI(void) cvLoadWindowParameters(const char* name);
;TODO: Other dll
   local $_aResult = DllCall($_opencv_worldDLL,"void:cdecl","cvLoadWindowParameters","struct*",$cvname)
    If @error Then ConsoleWrite( "error in cvLoadWindowParameters")
    Return $_aResult[0]
EndFunc ;==>cvLoadWindowParameters
#comments-start
;TODO: Fix function declaration
Func _cvStartLoop($cv,$cv,$cv,$cvargc,$cvargv[],$cv,$cvargc,$cvargv[])
;CVAPI(int) cvStartLoop(int (*pt2Func)(int argc, char* argv[]), int argc, char* argv[]);
;TODO: Other dll
   local $_aResult = DllCall($_opencv_worldDLL,"int:cdecl","cvStartLoop","int",$cv,"struct",$cv,"struct",$cv,"int",$cvargc,"struct*",$cvargv[],"struct",$cv,"int",$cvargc,"struct*",$cvargv[])
    If @error Then ConsoleWrite( "error in cvStartLoop")
    Return $_aResult[0]
EndFunc ;==>cvStartLoop
#comments-end
#comments-start
;TODO: Fix function declaration
Func _cvStopLoop($cv)
;CVAPI(void) cvStopLoop( void );
;TODO: Other dll
   local $_aResult = DllCall($_opencv_worldDLL,"void:cdecl","cvStopLoop","struct",$cv)
    If @error Then ConsoleWrite( "error in cvStopLoop")
    Return $_aResult[0]
EndFunc ;==>cvStopLoop
#comments-end
Func _cvCreateButton($cvbutton_name=NULL,$cvon_change=NULL,$cvuserdata=NULL,$cvbutton_type=$CV_PUSH_BUTTON,$cvinitial_button_state=0)
;CVAPI(int) cvCreateButton( const char* button_name CV_DEFAULT(NULL),CvButtonCallback on_change CV_DEFAULT(NULL), void* userdata CV_DEFAULT(NULL) , int button_type CV_DEFAULT(CV_PUSH_BUTTON), int initial_button_state CV_DEFAULT(0));
;TODO: Other dll
   local $_aResult = DllCall($_opencv_worldDLL,"int:cdecl","cvCreateButton","struct*",$cvbutton_name,"struct",$cvon_change,"struct*",$cvuserdata,"int",$cvbutton_type,"int",$cvinitial_button_state)
    If @error Then ConsoleWrite( "error in cvCreateButton")
    Return $_aResult[0]
EndFunc ;==>cvCreateButton
Func _cvInitSystem($cvargc,$cvargv)
;CVAPI(int) cvInitSystem( int argc, char** argv );
    local $_aResult = DllCall($_opencv_worldDLL,"int:cdecl","cvInitSystem","int",$cvargc,"struct*",$cvargv)
    If @error Then ConsoleWrite( "error in cvInitSystem")
    Return $_aResult[0]
EndFunc ;==>cvInitSystem
#comments-start
;TODO: Fix function declaration
Func _cvStartWindowThread($cv)
;CVAPI(int) cvStartWindowThread( void );
    local $_aResult = DllCall($_opencv_worldDLL,"int:cdecl","cvStartWindowThread","struct",$cv)
    If @error Then ConsoleWrite( "error in cvStartWindowThread")
    Return $_aResult[0]
EndFunc ;==>cvStartWindowThread
#comments-end
Func _cvNamedWindow($cvname,$cvflags=$CV_WINDOW_AUTOSIZE)
;CVAPI(int) cvNamedWindow( const char* name, int flags CV_DEFAULT(CV_WINDOW_AUTOSIZE) );
    local $_aResult = DllCall($_opencv_worldDLL,"int:cdecl","cvNamedWindow","struct*",$cvname,"int",$cvflags)
    If @error Then ConsoleWrite( "error in cvNamedWindow")
    Return $_aResult[0]
EndFunc ;==>cvNamedWindow
Func _cvSetWindowProperty($cvname,$cvprop_id,$cvprop_value)
;CVAPI(void) cvSetWindowProperty(const char* name, int prop_id, double prop_value);
    local $_aResult = DllCall($_opencv_worldDLL,"void:cdecl","cvSetWindowProperty","struct*",$cvname,"int",$cvprop_id,"double",$cvprop_value)
    If @error Then ConsoleWrite( "error in cvSetWindowProperty")
    Return $_aResult[0]
EndFunc ;==>cvSetWindowProperty
Func _cvGetWindowProperty($cvname,$cvprop_id)
;CVAPI(double) cvGetWindowProperty(const char* name, int prop_id);
    local $_aResult = DllCall($_opencv_worldDLL,"double:cdecl","cvGetWindowProperty","struct*",$cvname,"int",$cvprop_id)
    If @error Then ConsoleWrite( "error in cvGetWindowProperty")
    Return $_aResult[0]
EndFunc ;==>cvGetWindowProperty
Func _cvGetWindowImageRect($cvname)
;CVAPI(cv::Rect)cvGetWindowImageRect(const char* name);
    local $_aResult = DllCall($_opencv_worldDLL,"none:cdecl","cvGetWindowImageRect","struct*",$cvname)
    If @error Then ConsoleWrite( "error in cvGetWindowImageRect")
    Return $_aResult[0]
EndFunc ;==>cvGetWindowImageRect
Func _cvShowImage($cvname,$cvimage)
;CVAPI(void) cvShowImage( const char* name, const CvArr* image );
    local $_aResult = DllCall($_opencv_worldDLL,"void:cdecl","cvShowImage","struct*",$cvname,"struct*",$cvimage)
    If @error Then ConsoleWrite( "error in cvShowImage")
    Return $_aResult[0]
EndFunc ;==>cvShowImage
Func _cvResizeWindow($cvname,$cvwidth,$cvheight)
;CVAPI(void) cvResizeWindow( const char* name, int width, int height );
    local $_aResult = DllCall($_opencv_worldDLL,"void:cdecl","cvResizeWindow","struct*",$cvname,"int",$cvwidth,"int",$cvheight)
    If @error Then ConsoleWrite( "error in cvResizeWindow")
    Return $_aResult[0]
EndFunc ;==>cvResizeWindow
Func _cvMoveWindow($cvname,$cvx,$cvy)
;CVAPI(void) cvMoveWindow( const char* name, int x, int y );
    local $_aResult = DllCall($_opencv_worldDLL,"void:cdecl","cvMoveWindow","struct*",$cvname,"int",$cvx,"int",$cvy)
    If @error Then ConsoleWrite( "error in cvMoveWindow")
    Return $_aResult[0]
EndFunc ;==>cvMoveWindow
Func _cvDestroyWindow($cvname)
;CVAPI(void) cvDestroyWindow( const char* name );
    local $_aResult = DllCall($_opencv_worldDLL,"void:cdecl","cvDestroyWindow","struct*",$cvname)
    If @error Then ConsoleWrite( "error in cvDestroyWindow")
    Return $_aResult[0]
EndFunc ;==>cvDestroyWindow
#comments-start
;TODO: Fix function declaration
Func _cvDestroyAllWindows($cv)
;CVAPI(void) cvDestroyAllWindows(void);
    local $_aResult = DllCall($_opencv_worldDLL,"void:cdecl","cvDestroyAllWindows","struct",$cv)
    If @error Then ConsoleWrite( "error in cvDestroyAllWindows")
    Return $_aResult[0]
EndFunc ;==>cvDestroyAllWindows
#comments-end
Func _cvGetWindowHandle($cvname)
;CVAPI(void*) cvGetWindowHandle( const char* name );
    local $_aResult = DllCall($_opencv_worldDLL,"ptr:cdecl","cvGetWindowHandle","struct*",$cvname)
    If @error Then ConsoleWrite( "error in cvGetWindowHandle")
    Return $_aResult[0]
EndFunc ;==>cvGetWindowHandle
Func _cvGetWindowName($cvwindow_handle)
;CVAPI(const char*) cvGetWindowName( void* window_handle );
    local $_aResult = DllCall($_opencv_worldDLL,"ptr:cdecl","cvGetWindowName","struct*",$cvwindow_handle)
    If @error Then ConsoleWrite( "error in cvGetWindowName")
    Return $_aResult[0]
EndFunc ;==>cvGetWindowName
Func _cvCreateTrackbar($cvtrackbar_name,$cvwindow_name,$cvvalue,$cvcount,$cvon_change=NULL)
;CVAPI(int) cvCreateTrackbar( const char* trackbar_name, const char* window_name, int* value, int count, CvTrackbarCallback on_change CV_DEFAULT(NULL));
    local $_aResult = DllCall($_opencv_worldDLL,"int:cdecl","cvCreateTrackbar","struct*",$cvtrackbar_name,"struct*",$cvwindow_name,"struct*",$cvvalue,"int",$cvcount,"struct",$cvon_change)
    If @error Then ConsoleWrite( "error in cvCreateTrackbar")
    Return $_aResult[0]
EndFunc ;==>cvCreateTrackbar
Func _cvCreateTrackbar2($cvtrackbar_name,$cvwindow_name,$cvvalue,$cvcount,$cvon_change,$cvuserdata=0)
;CVAPI(int) cvCreateTrackbar2( const char* trackbar_name, const char* window_name, int* value, int count, CvTrackbarCallback2 on_change, void* userdata CV_DEFAULT(0));
    local $_aResult = DllCall($_opencv_worldDLL,"int:cdecl","cvCreateTrackbar2","struct*",$cvtrackbar_name,"struct*",$cvwindow_name,"struct*",$cvvalue,"int",$cvcount,"struct",$cvon_change,"struct*",$cvuserdata)
    If @error Then ConsoleWrite( "error in cvCreateTrackbar2")
    Return $_aResult[0]
EndFunc ;==>cvCreateTrackbar2
Func _cvGetTrackbarPos($cvtrackbar_name,$cvwindow_name)
;CVAPI(int) cvGetTrackbarPos( const char* trackbar_name, const char* window_name );
    local $_aResult = DllCall($_opencv_worldDLL,"int:cdecl","cvGetTrackbarPos","struct*",$cvtrackbar_name,"struct*",$cvwindow_name)
    If @error Then ConsoleWrite( "error in cvGetTrackbarPos")
    Return $_aResult[0]
EndFunc ;==>cvGetTrackbarPos
Func _cvSetTrackbarPos($cvtrackbar_name,$cvwindow_name,$cvpos)
;CVAPI(void) cvSetTrackbarPos( const char* trackbar_name, const char* window_name, int pos );
    local $_aResult = DllCall($_opencv_worldDLL,"void:cdecl","cvSetTrackbarPos","struct*",$cvtrackbar_name,"struct*",$cvwindow_name,"int",$cvpos)
    If @error Then ConsoleWrite( "error in cvSetTrackbarPos")
    Return $_aResult[0]
EndFunc ;==>cvSetTrackbarPos
Func _cvSetTrackbarMax($cvtrackbar_name,$cvwindow_name,$cvmaxval)
;CVAPI(void) cvSetTrackbarMax(const char* trackbar_name, const char* window_name, int maxval);
    local $_aResult = DllCall($_opencv_worldDLL,"void:cdecl","cvSetTrackbarMax","struct*",$cvtrackbar_name,"struct*",$cvwindow_name,"int",$cvmaxval)
    If @error Then ConsoleWrite( "error in cvSetTrackbarMax")
    Return $_aResult[0]
EndFunc ;==>cvSetTrackbarMax
Func _cvSetTrackbarMin($cvtrackbar_name,$cvwindow_name,$cvminval)
;CVAPI(void) cvSetTrackbarMin(const char* trackbar_name, const char* window_name, int minval);
    local $_aResult = DllCall($_opencv_worldDLL,"void:cdecl","cvSetTrackbarMin","struct*",$cvtrackbar_name,"struct*",$cvwindow_name,"int",$cvminval)
    If @error Then ConsoleWrite( "error in cvSetTrackbarMin")
    Return $_aResult[0]
EndFunc ;==>cvSetTrackbarMin
Func _cvSetMouseCallback($cvwindow_name,$cvon_mouse,$cvparam=NULL)
;CVAPI(void) cvSetMouseCallback( const char* window_name, CvMouseCallback on_mouse, void* param CV_DEFAULT(NULL));
    local $_aResult = DllCall($_opencv_worldDLL,"void:cdecl","cvSetMouseCallback","struct*",$cvwindow_name,"struct",$cvon_mouse,"struct*",$cvparam)
    If @error Then ConsoleWrite( "error in cvSetMouseCallback")
    Return $_aResult[0]
EndFunc ;==>cvSetMouseCallback
Func _cvWaitKey($cvdelay=0)
;CVAPI(int) cvWaitKey(int delay CV_DEFAULT(0));
    local $_aResult = DllCall($_opencv_worldDLL,"int:cdecl","cvWaitKey","int",$cvdelay)
    If @error Then ConsoleWrite( "error in cvWaitKey")
    Return $_aResult[0]
EndFunc ;==>cvWaitKey
Func _cvSetOpenGlDrawCallback($cvwindow_name,$cvcallback,$cvuserdata=NULL)
;CVAPI(void) cvSetOpenGlDrawCallback(const char* window_name, CvOpenGlDrawCallback callback, void* userdata CV_DEFAULT(NULL));
    local $_aResult = DllCall($_opencv_worldDLL,"void:cdecl","cvSetOpenGlDrawCallback","struct*",$cvwindow_name,"struct",$cvcallback,"struct*",$cvuserdata)
    If @error Then ConsoleWrite( "error in cvSetOpenGlDrawCallback")
    Return $_aResult[0]
EndFunc ;==>cvSetOpenGlDrawCallback
Func _cvSetOpenGlContext($cvwindow_name)
;CVAPI(void) cvSetOpenGlContext(const char* window_name);
    local $_aResult = DllCall($_opencv_worldDLL,"void:cdecl","cvSetOpenGlContext","struct*",$cvwindow_name)
    If @error Then ConsoleWrite( "error in cvSetOpenGlContext")
    Return $_aResult[0]
EndFunc ;==>cvSetOpenGlContext
Func _cvUpdateWindow($cvwindow_name)
;CVAPI(void) cvUpdateWindow(const char* window_name);
    local $_aResult = DllCall($_opencv_worldDLL,"void:cdecl","cvUpdateWindow","struct*",$cvwindow_name)
    If @error Then ConsoleWrite( "error in cvUpdateWindow")
    Return $_aResult[0]
EndFunc ;==>cvUpdateWindow
Func _cvSetPreprocessFuncWin32_($cvcallback)
;CVAPI(void) cvSetPreprocessFuncWin32_(const void* callback);
    local $_aResult = DllCall($_opencv_worldDLL,"void:cdecl","cvSetPreprocessFuncWin32_","struct*",$cvcallback)
    If @error Then ConsoleWrite( "error in cvSetPreprocessFuncWin32_")
    Return $_aResult[0]
EndFunc ;==>cvSetPreprocessFuncWin32_
Func _cvSetPostprocessFuncWin32_($cvcallback)
;CVAPI(void) cvSetPostprocessFuncWin32_(const void* callback);
    local $_aResult = DllCall($_opencv_worldDLL,"void:cdecl","cvSetPostprocessFuncWin32_","struct*",$cvcallback)
    If @error Then ConsoleWrite( "error in cvSetPostprocessFuncWin32_")
    Return $_aResult[0]
EndFunc ;==>cvSetPostprocessFuncWin32_
#endregion  highgui_c.h
#region  imgproc_c.h
Func _cvAcc($cvimage,$cvsum,$cvmask=NULL)
;CVAPI(void) cvAcc( const CvArr* image, CvArr* sum, const CvArr* mask CV_DEFAULT(NULL) );
    local $_aResult = DllCall($_opencv_worldDLL,"void:cdecl","cvAcc","struct*",$cvimage,"struct*",$cvsum,"struct*",$cvmask)
    If @error Then ConsoleWrite( "error in cvAcc")
    Return $_aResult[0]
EndFunc ;==>cvAcc
Func _cvSquareAcc($cvimage,$cvsqsum,$cvmask=NULL)
;CVAPI(void) cvSquareAcc( const CvArr* image, CvArr* sqsum, const CvArr* mask CV_DEFAULT(NULL) );
    local $_aResult = DllCall($_opencv_worldDLL,"void:cdecl","cvSquareAcc","struct*",$cvimage,"struct*",$cvsqsum,"struct*",$cvmask)
    If @error Then ConsoleWrite( "error in cvSquareAcc")
    Return $_aResult[0]
EndFunc ;==>cvSquareAcc
Func _cvMultiplyAcc($cvimage1,$cvimage2,$cvacc,$cvmask=NULL)
;CVAPI(void) cvMultiplyAcc( const CvArr* image1, const CvArr* image2, CvArr* acc, const CvArr* mask CV_DEFAULT(NULL) );
    local $_aResult = DllCall($_opencv_worldDLL,"void:cdecl","cvMultiplyAcc","struct*",$cvimage1,"struct*",$cvimage2,"struct*",$cvacc,"struct*",$cvmask)
    If @error Then ConsoleWrite( "error in cvMultiplyAcc")
    Return $_aResult[0]
EndFunc ;==>cvMultiplyAcc
Func _cvRunningAvg($cvimage,$cvacc,$cvalpha,$cvmask=NULL)
;CVAPI(void) cvRunningAvg( const CvArr* image, CvArr* acc, double alpha, const CvArr* mask CV_DEFAULT(NULL) );
    local $_aResult = DllCall($_opencv_worldDLL,"void:cdecl","cvRunningAvg","struct*",$cvimage,"struct*",$cvacc,"double",$cvalpha,"struct*",$cvmask)
    If @error Then ConsoleWrite( "error in cvRunningAvg")
    Return $_aResult[0]
EndFunc ;==>cvRunningAvg
#comments-start
;TODO: Fix function declaration
Func _cvCopyMakeBorder($cvsrc,$cvdst,$cvoffset,$cvbordertype,$cvvalue=cvScalarAll,$cv,$cv)
;CVAPI(void) cvCopyMakeBorder( const CvArr* src, CvArr* dst, CvPoint offset, int bordertype, CvScalar value CV_DEFAULT(cvScalarAll(0)));
    local $_aResult = DllCall($_opencv_worldDLL,"void:cdecl","cvCopyMakeBorder","struct*",$cvsrc,"struct*",$cvdst,"struct",$cvoffset,"int",$cvbordertype,"struct",$cvvalue,"struct",$cv,"struct",$cv)
    If @error Then ConsoleWrite( "error in cvCopyMakeBorder")
    Return $_aResult[0]
EndFunc ;==>cvCopyMakeBorder
#comments-end
Func _cvSmooth($cvsrc,$cvdst,$cvsmoothtype=$CV_GAUSSIAN,$cvsize1=3,$cvsize2=0,$cvsigma1=0,$cvsigma2=0)
;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));
    local $_aResult = DllCall($_opencv_worldDLL,"void:cdecl","cvSmooth","struct*",$cvsrc,"struct*",$cvdst,"int",$cvsmoothtype,"int",$cvsize1,"int",$cvsize2,"double",$cvsigma1,"double",$cvsigma2)
    If @error Then ConsoleWrite( "error in cvSmooth")
    Return $_aResult[0]
EndFunc ;==>cvSmooth
#comments-start
;TODO: Fix function declaration
Func _cvFilter2D($cvsrc,$cvdst,$cvkernel,$cvanchor=cvPoint,$cv,$cv,$cv)
;CVAPI(void) cvFilter2D( const CvArr* src, CvArr* dst, const CvMat* kernel, CvPoint anchor CV_DEFAULT(cvPoint(-1,-1)));
    local $_aResult = DllCall($_opencv_worldDLL,"void:cdecl","cvFilter2D","struct*",$cvsrc,"struct*",$cvdst,"struct*",$cvkernel,"struct",$cvanchor,"struct",$cv,"struct",$cv,"struct",$cv)
    If @error Then ConsoleWrite( "error in cvFilter2D")
    Return $_aResult[0]
EndFunc ;==>cvFilter2D
#comments-end
Func _cvIntegral($cvimage,$cvsum,$cvsqsum=NULL,$cvtilted_sum=NULL)
;CVAPI(void) cvIntegral( const CvArr* image, CvArr* sum, CvArr* sqsum CV_DEFAULT(NULL), CvArr* tilted_sum CV_DEFAULT(NULL));
    local $_aResult = DllCall($_opencv_worldDLL,"void:cdecl","cvIntegral","struct*",$cvimage,"struct*",$cvsum,"struct*",$cvsqsum,"struct*",$cvtilted_sum)
    If @error Then ConsoleWrite( "error in cvIntegral")
    Return $_aResult[0]
EndFunc ;==>cvIntegral
Func _cvPyrDown($cvsrc,$cvdst,$cvfilter=$CV_GAUSSIAN_5x5)
;CVAPI(void) cvPyrDown( const CvArr* src, CvArr* dst, int filter CV_DEFAULT(CV_GAUSSIAN_5x5) );
    local $_aResult = DllCall($_opencv_worldDLL,"void:cdecl","cvPyrDown","struct*",$cvsrc,"struct*",$cvdst,"int",$cvfilter)
    If @error Then ConsoleWrite( "error in cvPyrDown")
    Return $_aResult[0]
EndFunc ;==>cvPyrDown
Func _cvPyrUp($cvsrc,$cvdst,$cvfilter=$CV_GAUSSIAN_5x5)
;CVAPI(void) cvPyrUp( const CvArr* src, CvArr* dst, int filter CV_DEFAULT(CV_GAUSSIAN_5x5) );
    local $_aResult = DllCall($_opencv_worldDLL,"void:cdecl","cvPyrUp","struct*",$cvsrc,"struct*",$cvdst,"int",$cvfilter)
    If @error Then ConsoleWrite( "error in cvPyrUp")
    Return $_aResult[0]
EndFunc ;==>cvPyrUp
Func _cvCreatePyramid($cvimg,$cvextra_layers,$cvrate,$cvlayer_sizes=0,$cvbufarr=0,$cvcalc=1,$cvfilter=$CV_GAUSSIAN_5x5)
;CVAPI(CvMat**) cvCreatePyramid( const CvArr* img, int extra_layers, double rate, const CvSize* layer_sizes CV_DEFAULT(0), CvArr* bufarr CV_DEFAULT(0), int calc CV_DEFAULT(1), int filter CV_DEFAULT(CV_GAUSSIAN_5x5) );
    local $_aResult = DllCall($_opencv_worldDLL,"ptr:cdecl","cvCreatePyramid","struct*",$cvimg,"int",$cvextra_layers,"double",$cvrate,"struct*",$cvlayer_sizes,"struct*",$cvbufarr,"int",$cvcalc,"int",$cvfilter)
    If @error Then ConsoleWrite( "error in cvCreatePyramid")
    Return $_aResult[0]
EndFunc ;==>cvCreatePyramid
Func _cvReleasePyramid($cvpyramid,$cvextra_layers)
;CVAPI(void) cvReleasePyramid( CvMat*** pyramid, int extra_layers );
    local $_aResult = DllCall($_opencv_worldDLL,"void:cdecl","cvReleasePyramid","struct*",$cvpyramid,"int",$cvextra_layers)
    If @error Then ConsoleWrite( "error in cvReleasePyramid")
    Return $_aResult[0]
EndFunc ;==>cvReleasePyramid
#comments-start
;TODO: Fix function declaration
Func _cvPyrMeanShiftFiltering($cvsrc,$cvdst,$cvsp,$cvsr,$cvmax_level=1,$cvtermcrit=cvTermCriteria,$cv,$cv,$cv,$cv)
;CVAPI(void) cvPyrMeanShiftFiltering( const CvArr* src, CvArr* dst, double sp, double sr, int max_level CV_DEFAULT(1), CvTermCriteria termcrit CV_DEFAULT(cvTermCriteria(CV_TERMCRIT_ITER+CV_TERMCRIT_EPS,5,1)));
    local $_aResult = DllCall($_opencv_worldDLL,"void:cdecl","cvPyrMeanShiftFiltering","struct*",$cvsrc,"struct*",$cvdst,"double",$cvsp,"double",$cvsr,"int",$cvmax_level,"struct",$cvtermcrit,"struct",$cv,"struct",$cv,"struct",$cv,"struct",$cv)
    If @error Then ConsoleWrite( "error in cvPyrMeanShiftFiltering")
    Return $_aResult[0]
EndFunc ;==>cvPyrMeanShiftFiltering
#comments-end
Func _cvWatershed($cvimage,$cvmarkers)
;CVAPI(void) cvWatershed( const CvArr* image, CvArr* markers );
    local $_aResult = DllCall($_opencv_worldDLL,"void:cdecl","cvWatershed","struct*",$cvimage,"struct*",$cvmarkers)
    If @error Then ConsoleWrite( "error in cvWatershed")
    Return $_aResult[0]
EndFunc ;==>cvWatershed
Func _cvSobel($cvsrc,$cvdst,$cvxorder,$cvyorder,$cvaperture_size=3)
;CVAPI(void) cvSobel( const CvArr* src, CvArr* dst, int xorder, int yorder, int aperture_size CV_DEFAULT(3));
    local $_aResult = DllCall($_opencv_worldDLL,"void:cdecl","cvSobel","struct*",$cvsrc,"struct*",$cvdst,"int",$cvxorder,"int",$cvyorder,"int",$cvaperture_size)
    If @error Then ConsoleWrite( "error in cvSobel")
    Return $_aResult[0]
EndFunc ;==>cvSobel
Func _cvLaplace($cvsrc,$cvdst,$cvaperture_size=3)
;CVAPI(void) cvLaplace( const CvArr* src, CvArr* dst, int aperture_size CV_DEFAULT(3) );
    local $_aResult = DllCall($_opencv_worldDLL,"void:cdecl","cvLaplace","struct*",$cvsrc,"struct*",$cvdst,"int",$cvaperture_size)
    If @error Then ConsoleWrite( "error in cvLaplace")
    Return $_aResult[0]
EndFunc ;==>cvLaplace
Func _cvCvtColor($cvsrc,$cvdst,$cvcode)
;CVAPI(void) cvCvtColor( const CvArr* src, CvArr* dst, int code );
    local $_aResult = DllCall($_opencv_worldDLL,"void:cdecl","cvCvtColor","struct*",$cvsrc,"struct*",$cvdst,"int",$cvcode)
    If @error Then ConsoleWrite( "error in cvCvtColor")
    Return $_aResult[0]
EndFunc ;==>cvCvtColor
Func _cvResize($cvsrc,$cvdst,$cvinterpolation=$CV_INTER_LINEAR)
;CVAPI(void) cvResize( const CvArr* src, CvArr* dst, int interpolation CV_DEFAULT( CV_INTER_LINEAR ));
    local $_aResult = DllCall($_opencv_worldDLL,"void:cdecl","cvResize","struct*",$cvsrc,"struct*",$cvdst,"int",$cvinterpolation)
    If @error Then ConsoleWrite( "error in cvResize")
    Return $_aResult[0]
EndFunc ;==>cvResize
#comments-start
;TODO: Fix function declaration
Func _cvWarpAffine($cvsrc,$cvdst,$cvmap_matrix,$cvflags=$CV_INTER_LINEAR+$CV_WARP_FILL_OUTLIERS,$cvfillval=cvScalarAll,$cv,$cv)
;CVAPI(void) cvWarpAffine( const CvArr* src, CvArr* dst, const CvMat* map_matrix, int flags CV_DEFAULT(CV_INTER_LINEAR+CV_WARP_FILL_OUTLIERS), CvScalar fillval CV_DEFAULT(cvScalarAll(0)) );
    local $_aResult = DllCall($_opencv_worldDLL,"void:cdecl","cvWarpAffine","struct*",$cvsrc,"struct*",$cvdst,"struct*",$cvmap_matrix,"int",$cvflags,"struct",$cvfillval,"struct",$cv,"struct",$cv)
    If @error Then ConsoleWrite( "error in cvWarpAffine")
    Return $_aResult[0]
EndFunc ;==>cvWarpAffine
#comments-end
#comments-start
;TODO: Fix function declaration
Func _cvGetAffineTransform($cv,$cv,$cv)
;CVAPI(CvMat*) cvGetAffineTransform( const CvPoint2D32f*  src, const CvPoint2D32f*  dst, CvMat*  map_matrix );
    local $_aResult = DllCall($_opencv_worldDLL,"ptr:cdecl","cvGetAffineTransform","struct*",$cv,"struct*",$cv,"struct*",$cv)
    If @error Then ConsoleWrite( "error in cvGetAffineTransform")
    Return $_aResult[0]
EndFunc ;==>cvGetAffineTransform
#comments-end
Func _cv2DRotationMatrix($cvcenter,$cvangle,$cvscale,$cvmap_matrix)
;CVAPI(CvMat*) cv2DRotationMatrix( CvPoint2D32f center, double angle, double scale, CvMat* map_matrix );
    local $_aResult = DllCall($_opencv_worldDLL,"ptr:cdecl","cv2DRotationMatrix","struct",$cvcenter,"double",$cvangle,"double",$cvscale,"struct*",$cvmap_matrix)
    If @error Then ConsoleWrite( "error in cv2DRotationMatrix")
    Return $_aResult[0]
EndFunc ;==>cv2DRotationMatrix
#comments-start
;TODO: Fix function declaration
Func _cvWarpPerspective($cvsrc,$cvdst,$cvmap_matrix,$cvflags=$CV_INTER_LINEAR+$CV_WARP_FILL_OUTLIERS,$cvfillval=cvScalarAll,$cv,$cv)
;CVAPI(void) cvWarpPerspective( const CvArr* src, CvArr* dst, const CvMat* map_matrix, int flags CV_DEFAULT(CV_INTER_LINEAR+CV_WARP_FILL_OUTLIERS), CvScalar fillval CV_DEFAULT(cvScalarAll(0)) );
    local $_aResult = DllCall($_opencv_worldDLL,"void:cdecl","cvWarpPerspective","struct*",$cvsrc,"struct*",$cvdst,"struct*",$cvmap_matrix,"int",$cvflags,"struct",$cvfillval,"struct",$cv,"struct",$cv)
    If @error Then ConsoleWrite( "error in cvWarpPerspective")
    Return $_aResult[0]
EndFunc ;==>cvWarpPerspective
#comments-end
Func _cvGetPerspectiveTransform($cvsrc,$cvdst,$cvmap_matrix)
;CVAPI(CvMat*) cvGetPerspectiveTransform( const CvPoint2D32f* src, const CvPoint2D32f* dst, CvMat* map_matrix );
    local $_aResult = DllCall($_opencv_worldDLL,"ptr:cdecl","cvGetPerspectiveTransform","struct*",$cvsrc,"struct*",$cvdst,"struct*",$cvmap_matrix)
    If @error Then ConsoleWrite( "error in cvGetPerspectiveTransform")
    Return $_aResult[0]
EndFunc ;==>cvGetPerspectiveTransform
#comments-start
;TODO: Fix function declaration
Func _cvRemap($cvsrc,$cvdst,$cvmapx,$cvmapy,$cvflags=$CV_INTER_LINEAR+$CV_WARP_FILL_OUTLIERS,$cvfillval=cvScalarAll,$cv,$cv)
;CVAPI(void) cvRemap( const CvArr* src, CvArr* dst, const CvArr* mapx, const CvArr* mapy, int flags CV_DEFAULT(CV_INTER_LINEAR+CV_WARP_FILL_OUTLIERS), CvScalar fillval CV_DEFAULT(cvScalarAll(0)) );
    local $_aResult = DllCall($_opencv_worldDLL,"void:cdecl","cvRemap","struct*",$cvsrc,"struct*",$cvdst,"struct*",$cvmapx,"struct*",$cvmapy,"int",$cvflags,"struct",$cvfillval,"struct",$cv,"struct",$cv)
    If @error Then ConsoleWrite( "error in cvRemap")
    Return $_aResult[0]
EndFunc ;==>cvRemap
#comments-end
Func _cvConvertMaps($cvmapx,$cvmapy,$cvmapxy,$cvmapalpha)
;CVAPI(void) cvConvertMaps( const CvArr* mapx, const CvArr* mapy, CvArr* mapxy, CvArr* mapalpha );
    local $_aResult = DllCall($_opencv_worldDLL,"void:cdecl","cvConvertMaps","struct*",$cvmapx,"struct*",$cvmapy,"struct*",$cvmapxy,"struct*",$cvmapalpha)
    If @error Then ConsoleWrite( "error in cvConvertMaps")
    Return $_aResult[0]
EndFunc ;==>cvConvertMaps
Func _cvLogPolar($cvsrc,$cvdst,$cvcenter,$cvM,$cvflags=$CV_INTER_LINEAR+$CV_WARP_FILL_OUTLIERS)
;CVAPI(void) cvLogPolar( const CvArr* src, CvArr* dst, CvPoint2D32f center, double M, int flags CV_DEFAULT(CV_INTER_LINEAR+CV_WARP_FILL_OUTLIERS));
    local $_aResult = DllCall($_opencv_worldDLL,"void:cdecl","cvLogPolar","struct*",$cvsrc,"struct*",$cvdst,"struct",$cvcenter,"double",$cvM,"int",$cvflags)
    If @error Then ConsoleWrite( "error in cvLogPolar")
    Return $_aResult[0]
EndFunc ;==>cvLogPolar
Func _cvLinearPolar($cvsrc,$cvdst,$cvcenter,$cvmaxRadius,$cvflags=$CV_INTER_LINEAR+$CV_WARP_FILL_OUTLIERS)
;CVAPI(void) cvLinearPolar( const CvArr* src, CvArr* dst, CvPoint2D32f center, double maxRadius, int flags CV_DEFAULT(CV_INTER_LINEAR+CV_WARP_FILL_OUTLIERS));
    local $_aResult = DllCall($_opencv_worldDLL,"void:cdecl","cvLinearPolar","struct*",$cvsrc,"struct*",$cvdst,"struct",$cvcenter,"double",$cvmaxRadius,"int",$cvflags)
    If @error Then ConsoleWrite( "error in cvLinearPolar")
    Return $_aResult[0]
EndFunc ;==>cvLinearPolar
Func _cvReleaseStructuringElement($cvelement)
;CVAPI(void) cvReleaseStructuringElement( IplConvKernel** element );
    local $_aResult = DllCall($_opencv_worldDLL,"void:cdecl","cvReleaseStructuringElement","struct*",$cvelement)
    If @error Then ConsoleWrite( "error in cvReleaseStructuringElement")
    Return $_aResult[0]
EndFunc ;==>cvReleaseStructuringElement
Func _cvErode($cvsrc,$cvdst,$cvelement=NULL,$cviterations=1)
;CVAPI(void) cvErode( const CvArr* src, CvArr* dst, IplConvKernel* element CV_DEFAULT(NULL), int iterations CV_DEFAULT(1) );
    local $_aResult = DllCall($_opencv_worldDLL,"void:cdecl","cvErode","struct*",$cvsrc,"struct*",$cvdst,"struct*",$cvelement,"int",$cviterations)
    If @error Then ConsoleWrite( "error in cvErode")
    Return $_aResult[0]
EndFunc ;==>cvErode
Func _cvDilate($cvsrc,$cvdst,$cvelement=NULL,$cviterations=1)
;CVAPI(void) cvDilate( const CvArr* src, CvArr* dst, IplConvKernel* element CV_DEFAULT(NULL), int iterations CV_DEFAULT(1) );
    local $_aResult = DllCall($_opencv_worldDLL,"void:cdecl","cvDilate","struct*",$cvsrc,"struct*",$cvdst,"struct*",$cvelement,"int",$cviterations)
    If @error Then ConsoleWrite( "error in cvDilate")
    Return $_aResult[0]
EndFunc ;==>cvDilate
Func _cvMorphologyEx($cvsrc,$cvdst,$cvtemp,$cvelement,$cvoperation,$cviterations=1)
;CVAPI(void) cvMorphologyEx( const CvArr* src, CvArr* dst, CvArr* temp, IplConvKernel* element, int operation, int iterations CV_DEFAULT(1) );
    local $_aResult = DllCall($_opencv_worldDLL,"void:cdecl","cvMorphologyEx","struct*",$cvsrc,"struct*",$cvdst,"struct*",$cvtemp,"struct*",$cvelement,"int",$cvoperation,"int",$cviterations)
    If @error Then ConsoleWrite( "error in cvMorphologyEx")
    Return $_aResult[0]
EndFunc ;==>cvMorphologyEx
Func _cvMoments($cvarr,$cvmoments,$cvbinary=0)
;CVAPI(void) cvMoments( const CvArr* arr, CvMoments* moments, int binary CV_DEFAULT(0));
    local $_aResult = DllCall($_opencv_worldDLL,"void:cdecl","cvMoments","struct*",$cvarr,"struct*",$cvmoments,"int",$cvbinary)
    If @error Then ConsoleWrite( "error in cvMoments")
    Return $_aResult[0]
EndFunc ;==>cvMoments
Func _cvGetSpatialMoment($cvmoments,$cvx_order,$cvy_order)
;CVAPI(double) cvGetSpatialMoment( CvMoments* moments, int x_order, int y_order );
    local $_aResult = DllCall($_opencv_worldDLL,"double:cdecl","cvGetSpatialMoment","struct*",$cvmoments,"int",$cvx_order,"int",$cvy_order)
    If @error Then ConsoleWrite( "error in cvGetSpatialMoment")
    Return $_aResult[0]
EndFunc ;==>cvGetSpatialMoment
Func _cvGetCentralMoment($cvmoments,$cvx_order,$cvy_order)
;CVAPI(double) cvGetCentralMoment( CvMoments* moments, int x_order, int y_order );
    local $_aResult = DllCall($_opencv_worldDLL,"double:cdecl","cvGetCentralMoment","struct*",$cvmoments,"int",$cvx_order,"int",$cvy_order)
    If @error Then ConsoleWrite( "error in cvGetCentralMoment")
    Return $_aResult[0]
EndFunc ;==>cvGetCentralMoment
Func _cvGetNormalizedCentralMoment($cvmoments,$cvx_order,$cvy_order)
;CVAPI(double) cvGetNormalizedCentralMoment( CvMoments* moments, int x_order, int y_order );
    local $_aResult = DllCall($_opencv_worldDLL,"double:cdecl","cvGetNormalizedCentralMoment","struct*",$cvmoments,"int",$cvx_order,"int",$cvy_order)
    If @error Then ConsoleWrite( "error in cvGetNormalizedCentralMoment")
    Return $_aResult[0]
EndFunc ;==>cvGetNormalizedCentralMoment
Func _cvGetHuMoments($cvmoments,$cvhu_moments)
;CVAPI(void) cvGetHuMoments( CvMoments* moments, CvHuMoments* hu_moments );
    local $_aResult = DllCall($_opencv_worldDLL,"void:cdecl","cvGetHuMoments","struct*",$cvmoments,"struct*",$cvhu_moments)
    If @error Then ConsoleWrite( "error in cvGetHuMoments")
    Return $_aResult[0]
EndFunc ;==>cvGetHuMoments
Func _cvSampleLine($cvimage,$cvpt1,$cvpt2,$cvbuffer,$cvconnectivity=8)
;CVAPI(int) cvSampleLine( const CvArr* image, CvPoint pt1, CvPoint pt2, void* buffer, int connectivity CV_DEFAULT(8));
    local $_aResult = DllCall($_opencv_worldDLL,"int:cdecl","cvSampleLine","struct*",$cvimage,"struct",$cvpt1,"struct",$cvpt2,"struct*",$cvbuffer,"int",$cvconnectivity)
    If @error Then ConsoleWrite( "error in cvSampleLine")
    Return $_aResult[0]
EndFunc ;==>cvSampleLine
Func _cvGetRectSubPix($cvsrc,$cvdst,$cvcenter)
;CVAPI(void) cvGetRectSubPix( const CvArr* src, CvArr* dst, CvPoint2D32f center );
    local $_aResult = DllCall($_opencv_worldDLL,"void:cdecl","cvGetRectSubPix","struct*",$cvsrc,"struct*",$cvdst,"struct",$cvcenter)
    If @error Then ConsoleWrite( "error in cvGetRectSubPix")
    Return $_aResult[0]
EndFunc ;==>cvGetRectSubPix
Func _cvGetQuadrangleSubPix($cvsrc,$cvdst,$cvmap_matrix)
;CVAPI(void) cvGetQuadrangleSubPix( const CvArr* src, CvArr* dst, const CvMat* map_matrix );
    local $_aResult = DllCall($_opencv_worldDLL,"void:cdecl","cvGetQuadrangleSubPix","struct*",$cvsrc,"struct*",$cvdst,"struct*",$cvmap_matrix)
    If @error Then ConsoleWrite( "error in cvGetQuadrangleSubPix")
    Return $_aResult[0]
EndFunc ;==>cvGetQuadrangleSubPix
Func _cvMatchTemplate($cvimage,$cvtempl,$cvresult,$cvmethod)
;CVAPI(void) cvMatchTemplate( const CvArr* image, const CvArr* templ, CvArr* result, int method );
    local $_aResult = DllCall($_opencv_worldDLL,"void:cdecl","cvMatchTemplate","struct*",$cvimage,"struct*",$cvtempl,"struct*",$cvresult,"int",$cvmethod)
    If @error Then ConsoleWrite( "error in cvMatchTemplate")
    Return $_aResult[0]
EndFunc ;==>cvMatchTemplate
Func _cvCalcEMD2($cvsignature1,$cvsignature2,$cvdistance_type,$cvdistance_func=NULL,$cvcost_matrix=NULL,$cvflow=NULL,$cvlower_bound=NULL,$cvuserdata=NULL)
;CVAPI(float) cvCalcEMD2( const CvArr* signature1, const CvArr* signature2, int distance_type, CvDistanceFunction distance_func CV_DEFAULT(NULL), const CvArr* cost_matrix CV_DEFAULT(NULL), CvArr* flow CV_DEFAULT(NULL), float* lower_bound CV_DEFAULT(NULL), void* userdata CV_DEFAULT(NULL));
    local $_aResult = DllCall($_opencv_worldDLL,"float:cdecl","cvCalcEMD2","struct*",$cvsignature1,"struct*",$cvsignature2,"int",$cvdistance_type,"struct",$cvdistance_func,"struct*",$cvcost_matrix,"struct*",$cvflow,"struct*",$cvlower_bound,"struct*",$cvuserdata)
    If @error Then ConsoleWrite( "error in cvCalcEMD2")
    Return $_aResult[0]
EndFunc ;==>cvCalcEMD2
#comments-start
;TODO: Fix function declaration
Func _cvFindContours($cvimage,$cvstorage,$cvfirst_contour,$cvheader_size=sizeof,$cv,$cv,$cvmode=$CV_RETR_LIST,$cvmethod=$CV_CHAIN_APPROX_SIMPLE,$cvoffset=cvPoint,$cv,$cv,$cv)
;CVAPI(int) cvFindContours( CvArr* image, CvMemStorage* storage, CvSeq** first_contour, int header_size CV_DEFAULT(sizeof(CvContour)), int mode CV_DEFAULT(CV_RETR_LIST), int method CV_DEFAULT(CV_CHAIN_APPROX_SIMPLE), CvPoint offset CV_DEFAULT(cvPoint(0,0)));
    local $_aResult = DllCall($_opencv_worldDLL,"int:cdecl","cvFindContours","struct*",$cvimage,"struct*",$cvstorage,"struct*",$cvfirst_contour,"int",$cvheader_size,"struct",$cv,"struct",$cv,"int",$cvmode,"int",$cvmethod,"struct",$cvoffset,"struct",$cv,"struct",$cv,"struct",$cv)
    If @error Then ConsoleWrite( "error in cvFindContours")
    Return $_aResult[0]
EndFunc ;==>cvFindContours
#comments-end
#comments-start
;TODO: Fix function declaration
Func _cvStartFindContours($cvimage,$cvstorage,$cvheader_size=sizeof,$cv,$cv,$cvmode=$CV_RETR_LIST,$cvmethod=$CV_CHAIN_APPROX_SIMPLE,$cvoffset=cvPoint,$cv,$cv,$cv)
;CVAPI(CvContourScanner) cvStartFindContours( CvArr* image, CvMemStorage* storage, int header_size CV_DEFAULT(sizeof(CvContour)), int mode CV_DEFAULT(CV_RETR_LIST), int method CV_DEFAULT(CV_CHAIN_APPROX_SIMPLE), CvPoint offset CV_DEFAULT(cvPoint(0,0)));
    local $_aResult = DllCall($_opencv_worldDLL,"none:cdecl","cvStartFindContours","struct*",$cvimage,"struct*",$cvstorage,"int",$cvheader_size,"struct",$cv,"struct",$cv,"int",$cvmode,"int",$cvmethod,"struct",$cvoffset,"struct",$cv,"struct",$cv,"struct",$cv)
    If @error Then ConsoleWrite( "error in cvStartFindContours")
    Return $_aResult[0]
EndFunc ;==>cvStartFindContours
#comments-end
Func _cvFindNextContour($cvscanner)
;CVAPI(CvSeq*) cvFindNextContour( CvContourScanner scanner );
    local $_aResult = DllCall($_opencv_worldDLL,"ptr:cdecl","cvFindNextContour","struct",$cvscanner)
    If @error Then ConsoleWrite( "error in cvFindNextContour")
    Return $_aResult[0]
EndFunc ;==>cvFindNextContour
Func _cvSubstituteContour($cvscanner,$cvnew_contour)
;CVAPI(void) cvSubstituteContour( CvContourScanner scanner, CvSeq* new_contour );
    local $_aResult = DllCall($_opencv_worldDLL,"void:cdecl","cvSubstituteContour","struct",$cvscanner,"struct*",$cvnew_contour)
    If @error Then ConsoleWrite( "error in cvSubstituteContour")
    Return $_aResult[0]
EndFunc ;==>cvSubstituteContour
Func _cvEndFindContours($cvscanner)
;CVAPI(CvSeq*) cvEndFindContours( CvContourScanner* scanner );
    local $_aResult = DllCall($_opencv_worldDLL,"ptr:cdecl","cvEndFindContours","struct*",$cvscanner)
    If @error Then ConsoleWrite( "error in cvEndFindContours")
    Return $_aResult[0]
EndFunc ;==>cvEndFindContours
Func _cvApproxChains($cvsrc_seq,$cvstorage,$cvmethod=$CV_CHAIN_APPROX_SIMPLE,$cvparameter=0,$cvminimal_perimeter=0,$cvrecursive=0)
;CVAPI(CvSeq*) cvApproxChains( CvSeq* src_seq, CvMemStorage* storage, int method CV_DEFAULT(CV_CHAIN_APPROX_SIMPLE), double parameter CV_DEFAULT(0), int minimal_perimeter CV_DEFAULT(0), int recursive CV_DEFAULT(0));
    local $_aResult = DllCall($_opencv_worldDLL,"ptr:cdecl","cvApproxChains","struct*",$cvsrc_seq,"struct*",$cvstorage,"int",$cvmethod,"double",$cvparameter,"int",$cvminimal_perimeter,"int",$cvrecursive)
    If @error Then ConsoleWrite( "error in cvApproxChains")
    Return $_aResult[0]
EndFunc ;==>cvApproxChains
Func _cvStartReadChainPoints($cvchain,$cvreader)
;CVAPI(void) cvStartReadChainPoints( CvChain* chain, CvChainPtReader* reader );
    local $_aResult = DllCall($_opencv_worldDLL,"void:cdecl","cvStartReadChainPoints","struct*",$cvchain,"struct*",$cvreader)
    If @error Then ConsoleWrite( "error in cvStartReadChainPoints")
    Return $_aResult[0]
EndFunc ;==>cvStartReadChainPoints
Func _cvReadChainPoint($cvreader)
;CVAPI(CvPoint) cvReadChainPoint( CvChainPtReader* reader );
    local $_aResult = DllCall($_opencv_worldDLL,"none:cdecl","cvReadChainPoint","struct*",$cvreader)
    If @error Then ConsoleWrite( "error in cvReadChainPoint")
    Return $_aResult[0]
EndFunc ;==>cvReadChainPoint
Func _cvApproxPoly($cvsrc_seq,$cvheader_size,$cvstorage,$cvmethod,$cveps,$cvrecursive=0)
;CVAPI(CvSeq*) cvApproxPoly( const void* src_seq, int header_size, CvMemStorage* storage, int method, double eps, int recursive CV_DEFAULT(0));
    local $_aResult = DllCall($_opencv_worldDLL,"ptr:cdecl","cvApproxPoly","struct*",$cvsrc_seq,"int",$cvheader_size,"struct*",$cvstorage,"int",$cvmethod,"double",$cveps,"int",$cvrecursive)
    If @error Then ConsoleWrite( "error in cvApproxPoly")
    Return $_aResult[0]
EndFunc ;==>cvApproxPoly
#comments-start
;TODO: Fix function declaration
Func _cvArcLength($cvcurve,$cvslice=$CV_WHOLE_SEQ,$cvis_closed=-1)
;CVAPI(double) cvArcLength( const void* curve, CvSlice slice CV_DEFAULT(CV_WHOLE_SEQ), int is_closed CV_DEFAULT(-1));
    local $_aResult = DllCall($_opencv_worldDLL,"double:cdecl","cvArcLength","struct*",$cvcurve,"struct",$cvslice,"int",$cvis_closed)
    If @error Then ConsoleWrite( "error in cvArcLength")
    Return $_aResult[0]
EndFunc ;==>cvArcLength
#comments-end
Func _cvBoundingRect($cvpoints,$cvupdate=0)
;CVAPI(CvRect) cvBoundingRect( CvArr* points, int update CV_DEFAULT(0) );
    local $_aResult = DllCall($_opencv_worldDLL,"none:cdecl","cvBoundingRect","struct*",$cvpoints,"int",$cvupdate)
    If @error Then ConsoleWrite( "error in cvBoundingRect")
    Return $_aResult[0]
EndFunc ;==>cvBoundingRect
#comments-start
;TODO: Fix function declaration
Func _cvContourArea($cvcontour,$cvslice=$CV_WHOLE_SEQ,$cvoriented=0)
;CVAPI(double) cvContourArea( const CvArr* contour, CvSlice slice CV_DEFAULT(CV_WHOLE_SEQ), int oriented CV_DEFAULT(0));
    local $_aResult = DllCall($_opencv_worldDLL,"double:cdecl","cvContourArea","struct*",$cvcontour,"struct",$cvslice,"int",$cvoriented)
    If @error Then ConsoleWrite( "error in cvContourArea")
    Return $_aResult[0]
EndFunc ;==>cvContourArea
#comments-end
Func _cvMinAreaRect2($cvpoints,$cvstorage=NULL)
;CVAPI(CvBox2D) cvMinAreaRect2( const CvArr* points, CvMemStorage* storage CV_DEFAULT(NULL));
    local $_aResult = DllCall($_opencv_worldDLL,"none:cdecl","cvMinAreaRect2","struct*",$cvpoints,"struct*",$cvstorage)
    If @error Then ConsoleWrite( "error in cvMinAreaRect2")
    Return $_aResult[0]
EndFunc ;==>cvMinAreaRect2
Func _cvMinEnclosingCircle($cvpoints,$cvcenter,$cvradius)
;CVAPI(int) cvMinEnclosingCircle( const CvArr* points, CvPoint2D32f* center, float* radius );
    local $_aResult = DllCall($_opencv_worldDLL,"int:cdecl","cvMinEnclosingCircle","struct*",$cvpoints,"struct*",$cvcenter,"struct*",$cvradius)
    If @error Then ConsoleWrite( "error in cvMinEnclosingCircle")
    Return $_aResult[0]
EndFunc ;==>cvMinEnclosingCircle
Func _cvMatchShapes($cvobject1,$cvobject2,$cvmethod,$cvparameter=0)
;CVAPI(double) cvMatchShapes( const void* object1, const void* object2, int method, double parameter CV_DEFAULT(0));
    local $_aResult = DllCall($_opencv_worldDLL,"double:cdecl","cvMatchShapes","struct*",$cvobject1,"struct*",$cvobject2,"int",$cvmethod,"double",$cvparameter)
    If @error Then ConsoleWrite( "error in cvMatchShapes")
    Return $_aResult[0]
EndFunc ;==>cvMatchShapes
Func _cvConvexHull2($cvinput,$cvhull_storage=NULL,$cvorientation=$CV_CLOCKWISE,$cvreturn_points=0)
;CVAPI(CvSeq*) cvConvexHull2( const CvArr* input, void* hull_storage CV_DEFAULT(NULL), int orientation CV_DEFAULT(CV_CLOCKWISE), int return_points CV_DEFAULT(0));
    local $_aResult = DllCall($_opencv_worldDLL,"ptr:cdecl","cvConvexHull2","struct*",$cvinput,"struct*",$cvhull_storage,"int",$cvorientation,"int",$cvreturn_points)
    If @error Then ConsoleWrite( "error in cvConvexHull2")
    Return $_aResult[0]
EndFunc ;==>cvConvexHull2
Func _cvCheckContourConvexity($cvcontour)
;CVAPI(int) cvCheckContourConvexity( const CvArr* contour );
    local $_aResult = DllCall($_opencv_worldDLL,"int:cdecl","cvCheckContourConvexity","struct*",$cvcontour)
    If @error Then ConsoleWrite( "error in cvCheckContourConvexity")
    Return $_aResult[0]
EndFunc ;==>cvCheckContourConvexity
Func _cvConvexityDefects($cvcontour,$cvconvexhull,$cvstorage=NULL)
;CVAPI(CvSeq*) cvConvexityDefects( const CvArr* contour, const CvArr* convexhull, CvMemStorage* storage CV_DEFAULT(NULL));
    local $_aResult = DllCall($_opencv_worldDLL,"ptr:cdecl","cvConvexityDefects","struct*",$cvcontour,"struct*",$cvconvexhull,"struct*",$cvstorage)
    If @error Then ConsoleWrite( "error in cvConvexityDefects")
    Return $_aResult[0]
EndFunc ;==>cvConvexityDefects
Func _cvFitEllipse2($cvpoints)
;CVAPI(CvBox2D) cvFitEllipse2( const CvArr* points );
    local $_aResult = DllCall($_opencv_worldDLL,"none:cdecl","cvFitEllipse2","struct*",$cvpoints)
    If @error Then ConsoleWrite( "error in cvFitEllipse2")
    Return $_aResult[0]
EndFunc ;==>cvFitEllipse2
Func _cvMaxRect($cvrect1,$cvrect2)
;CVAPI(CvRect) cvMaxRect( const CvRect* rect1, const CvRect* rect2 );
    local $_aResult = DllCall($_opencv_worldDLL,"none:cdecl","cvMaxRect","struct*",$cvrect1,"struct*",$cvrect2)
    If @error Then ConsoleWrite( "error in cvMaxRect")
    Return $_aResult[0]
EndFunc ;==>cvMaxRect
#comments-start
;TODO: Fix function declaration
Func _cvBoxPoints($cvbox,$cvpt[4])
;CVAPI(void) cvBoxPoints( CvBox2D box, CvPoint2D32f pt[4] );
    local $_aResult = DllCall($_opencv_worldDLL,"void:cdecl","cvBoxPoints","struct",$cvbox,"struct",$cvpt[4])
    If @error Then ConsoleWrite( "error in cvBoxPoints")
    Return $_aResult[0]
EndFunc ;==>cvBoxPoints
#comments-end
Func _cvPointSeqFromMat($cvseq_kind,$cvmat,$cvcontour_header,$cvblock)
;CVAPI(CvSeq*) cvPointSeqFromMat( int seq_kind, const CvArr* mat, CvContour* contour_header, CvSeqBlock* block );
    local $_aResult = DllCall($_opencv_worldDLL,"ptr:cdecl","cvPointSeqFromMat","int",$cvseq_kind,"struct*",$cvmat,"struct*",$cvcontour_header,"struct*",$cvblock)
    If @error Then ConsoleWrite( "error in cvPointSeqFromMat")
    Return $_aResult[0]
EndFunc ;==>cvPointSeqFromMat
Func _cvPointPolygonTest($cvcontour,$cvpt,$cvmeasure_dist)
;CVAPI(double) cvPointPolygonTest( const CvArr* contour, CvPoint2D32f pt, int measure_dist );
    local $_aResult = DllCall($_opencv_worldDLL,"double:cdecl","cvPointPolygonTest","struct*",$cvcontour,"struct",$cvpt,"int",$cvmeasure_dist)
    If @error Then ConsoleWrite( "error in cvPointPolygonTest")
    Return $_aResult[0]
EndFunc ;==>cvPointPolygonTest
Func _cvCreateHist($cvdims,$cvsizes,$cvtype,$cvranges=NULL,$cvuniform=1)
;CVAPI(CvHistogram*) cvCreateHist( int dims, int* sizes, int type, float** ranges CV_DEFAULT(NULL), int uniform CV_DEFAULT(1));
    local $_aResult = DllCall($_opencv_worldDLL,"ptr:cdecl","cvCreateHist","int",$cvdims,"struct*",$cvsizes,"int",$cvtype,"struct*",$cvranges,"int",$cvuniform)
    If @error Then ConsoleWrite( "error in cvCreateHist")
    Return $_aResult[0]
EndFunc ;==>cvCreateHist
Func _cvSetHistBinRanges($cvhist,$cvranges,$cvuniform=1)
;CVAPI(void) cvSetHistBinRanges( CvHistogram* hist, float** ranges, int uniform CV_DEFAULT(1));
    local $_aResult = DllCall($_opencv_worldDLL,"void:cdecl","cvSetHistBinRanges","struct*",$cvhist,"struct*",$cvranges,"int",$cvuniform)
    If @error Then ConsoleWrite( "error in cvSetHistBinRanges")
    Return $_aResult[0]
EndFunc ;==>cvSetHistBinRanges
Func _cvMakeHistHeaderForArray($cvdims,$cvsizes,$cvhist,$cvdata,$cvranges=NULL,$cvuniform=1)
;CVAPI(CvHistogram*) cvMakeHistHeaderForArray( int dims, int* sizes, CvHistogram* hist, float* data, float** ranges CV_DEFAULT(NULL), int uniform CV_DEFAULT(1));
    local $_aResult = DllCall($_opencv_worldDLL,"ptr:cdecl","cvMakeHistHeaderForArray","int",$cvdims,"struct*",$cvsizes,"struct*",$cvhist,"struct*",$cvdata,"struct*",$cvranges,"int",$cvuniform)
    If @error Then ConsoleWrite( "error in cvMakeHistHeaderForArray")
    Return $_aResult[0]
EndFunc ;==>cvMakeHistHeaderForArray
Func _cvReleaseHist($cvhist)
;CVAPI(void) cvReleaseHist( CvHistogram** hist );
    local $_aResult = DllCall($_opencv_worldDLL,"void:cdecl","cvReleaseHist","struct*",$cvhist)
    If @error Then ConsoleWrite( "error in cvReleaseHist")
    Return $_aResult[0]
EndFunc ;==>cvReleaseHist
Func _cvClearHist($cvhist)
;CVAPI(void) cvClearHist( CvHistogram* hist );
    local $_aResult = DllCall($_opencv_worldDLL,"void:cdecl","cvClearHist","struct*",$cvhist)
    If @error Then ConsoleWrite( "error in cvClearHist")
    Return $_aResult[0]
EndFunc ;==>cvClearHist
Func _cvGetMinMaxHistValue($cvhist,$cvmin_value,$cvmax_value,$cvmin_idx=NULL,$cvmax_idx=NULL)
;CVAPI(void) cvGetMinMaxHistValue( const CvHistogram* hist, float* min_value, float* max_value, int* min_idx CV_DEFAULT(NULL), int* max_idx CV_DEFAULT(NULL));
    local $_aResult = DllCall($_opencv_worldDLL,"void:cdecl","cvGetMinMaxHistValue","struct*",$cvhist,"struct*",$cvmin_value,"struct*",$cvmax_value,"struct*",$cvmin_idx,"struct*",$cvmax_idx)
    If @error Then ConsoleWrite( "error in cvGetMinMaxHistValue")
    Return $_aResult[0]
EndFunc ;==>cvGetMinMaxHistValue
Func _cvNormalizeHist($cvhist,$cvfactor)
;CVAPI(void) cvNormalizeHist( CvHistogram* hist, double factor );
    local $_aResult = DllCall($_opencv_worldDLL,"void:cdecl","cvNormalizeHist","struct*",$cvhist,"double",$cvfactor)
    If @error Then ConsoleWrite( "error in cvNormalizeHist")
    Return $_aResult[0]
EndFunc ;==>cvNormalizeHist
Func _cvThreshHist($cvhist,$cvthreshold)
;CVAPI(void) cvThreshHist( CvHistogram* hist, double threshold );
    local $_aResult = DllCall($_opencv_worldDLL,"void:cdecl","cvThreshHist","struct*",$cvhist,"double",$cvthreshold)
    If @error Then ConsoleWrite( "error in cvThreshHist")
    Return $_aResult[0]
EndFunc ;==>cvThreshHist
Func _cvCompareHist($cvhist1,$cvhist2,$cvmethod)
;CVAPI(double) cvCompareHist( const CvHistogram* hist1, const CvHistogram* hist2, int method);
    local $_aResult = DllCall($_opencv_worldDLL,"double:cdecl","cvCompareHist","struct*",$cvhist1,"struct*",$cvhist2,"int",$cvmethod)
    If @error Then ConsoleWrite( "error in cvCompareHist")
    Return $_aResult[0]
EndFunc ;==>cvCompareHist
Func _cvCopyHist($cvsrc,$cvdst)
;CVAPI(void) cvCopyHist( const CvHistogram* src, CvHistogram** dst );
    local $_aResult = DllCall($_opencv_worldDLL,"void:cdecl","cvCopyHist","struct*",$cvsrc,"struct*",$cvdst)
    If @error Then ConsoleWrite( "error in cvCopyHist")
    Return $_aResult[0]
EndFunc ;==>cvCopyHist
Func _cvCalcBayesianProb($cvsrc,$cvnumber,$cvdst)
;CVAPI(void) cvCalcBayesianProb( CvHistogram** src, int number, CvHistogram** dst);
    local $_aResult = DllCall($_opencv_worldDLL,"void:cdecl","cvCalcBayesianProb","struct*",$cvsrc,"int",$cvnumber,"struct*",$cvdst)
    If @error Then ConsoleWrite( "error in cvCalcBayesianProb")
    Return $_aResult[0]
EndFunc ;==>cvCalcBayesianProb
Func _cvCalcArrHist($cvarr,$cvhist,$cvaccumulate=0,$cvmask=NULL)
;CVAPI(void) cvCalcArrHist( CvArr** arr, CvHistogram* hist, int accumulate CV_DEFAULT(0), const CvArr* mask CV_DEFAULT(NULL) );
    local $_aResult = DllCall($_opencv_worldDLL,"void:cdecl","cvCalcArrHist","struct*",$cvarr,"struct*",$cvhist,"int",$cvaccumulate,"struct*",$cvmask)
    If @error Then ConsoleWrite( "error in cvCalcArrHist")
    Return $_aResult[0]
EndFunc ;==>cvCalcArrHist
Func _cvCalcArrBackProject($cvimage,$cvdst,$cvhist)
;CVAPI(void) cvCalcArrBackProject( CvArr** image, CvArr* dst, const CvHistogram* hist );
    local $_aResult = DllCall($_opencv_worldDLL,"void:cdecl","cvCalcArrBackProject","struct*",$cvimage,"struct*",$cvdst,"struct*",$cvhist)
    If @error Then ConsoleWrite( "error in cvCalcArrBackProject")
    Return $_aResult[0]
EndFunc ;==>cvCalcArrBackProject
Func _cvCalcArrBackProjectPatch($cvimage,$cvdst,$cvrange,$cvhist,$cvmethod,$cvfactor)
;CVAPI(void) cvCalcArrBackProjectPatch( CvArr** image, CvArr* dst, CvSize range, CvHistogram* hist, int method, double factor );
    local $_aResult = DllCall($_opencv_worldDLL,"void:cdecl","cvCalcArrBackProjectPatch","struct*",$cvimage,"struct*",$cvdst,"struct",$cvrange,"struct*",$cvhist,"int",$cvmethod,"double",$cvfactor)
    If @error Then ConsoleWrite( "error in cvCalcArrBackProjectPatch")
    Return $_aResult[0]
EndFunc ;==>cvCalcArrBackProjectPatch
Func _cvCalcProbDensity($cvhist1,$cvhist2,$cvdst_hist,$cvscale=255)
;CVAPI(void) cvCalcProbDensity( const CvHistogram* hist1, const CvHistogram* hist2, CvHistogram* dst_hist, double scale CV_DEFAULT(255) );
    local $_aResult = DllCall($_opencv_worldDLL,"void:cdecl","cvCalcProbDensity","struct*",$cvhist1,"struct*",$cvhist2,"struct*",$cvdst_hist,"double",$cvscale)
    If @error Then ConsoleWrite( "error in cvCalcProbDensity")
    Return $_aResult[0]
EndFunc ;==>cvCalcProbDensity
Func _cvEqualizeHist($cvsrc,$cvdst)
;CVAPI(void) cvEqualizeHist( const CvArr* src, CvArr* dst );
    local $_aResult = DllCall($_opencv_worldDLL,"void:cdecl","cvEqualizeHist","struct*",$cvsrc,"struct*",$cvdst)
    If @error Then ConsoleWrite( "error in cvEqualizeHist")
    Return $_aResult[0]
EndFunc ;==>cvEqualizeHist
Func _cvDistTransform($cvsrc,$cvdst,$cvdistance_type=$CV_DIST_L2,$cvmask_size=3,$cvmask=NULL,$cvlabels=NULL,$cvlabelType=$CV_DIST_LABEL_CCOMP)
;CVAPI(void) cvDistTransform( const CvArr* src, CvArr* dst, int distance_type CV_DEFAULT(CV_DIST_L2), int mask_size CV_DEFAULT(3), const float* mask CV_DEFAULT(NULL), CvArr* labels CV_DEFAULT(NULL), int labelType CV_DEFAULT(CV_DIST_LABEL_CCOMP));
    local $_aResult = DllCall($_opencv_worldDLL,"void:cdecl","cvDistTransform","struct*",$cvsrc,"struct*",$cvdst,"int",$cvdistance_type,"int",$cvmask_size,"struct*",$cvmask,"struct*",$cvlabels,"int",$cvlabelType)
    If @error Then ConsoleWrite( "error in cvDistTransform")
    Return $_aResult[0]
EndFunc ;==>cvDistTransform
Func _cvThreshold($cvsrc,$cvdst,$cvthreshold,$cvmax_value,$cvthreshold_type)
;CVAPI(double) cvThreshold( const CvArr* src, CvArr* dst, double threshold, double max_value, int threshold_type );
    local $_aResult = DllCall($_opencv_worldDLL,"double:cdecl","cvThreshold","struct*",$cvsrc,"struct*",$cvdst,"double",$cvthreshold,"double",$cvmax_value,"int",$cvthreshold_type)
    If @error Then ConsoleWrite( "error in cvThreshold")
    Return $_aResult[0]
EndFunc ;==>cvThreshold
Func _cvAdaptiveThreshold($cvsrc,$cvdst,$cvmax_value,$cvadaptive_method=$CV_ADAPTIVE_THRESH_MEAN_C,$cvthreshold_type=$CV_THRESH_BINARY,$cvblock_size=3,$cvparam1=5)
;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));
    local $_aResult = DllCall($_opencv_worldDLL,"void:cdecl","cvAdaptiveThreshold","struct*",$cvsrc,"struct*",$cvdst,"double",$cvmax_value,"int",$cvadaptive_method,"int",$cvthreshold_type,"int",$cvblock_size,"double",$cvparam1)
    If @error Then ConsoleWrite( "error in cvAdaptiveThreshold")
    Return $_aResult[0]
EndFunc ;==>cvAdaptiveThreshold
#comments-start
;TODO: Fix function declaration
Func _cvFloodFill($cvimage,$cvseed_point,$cvnew_val,$cvlo_diff=cvScalarAll,$cv,$cv,$cvup_diff=cvScalarAll,$cv,$cv,$cvcomp=NULL,$cvflags=4,$cvmask=NULL)
;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));
    local $_aResult = DllCall($_opencv_worldDLL,"void:cdecl","cvFloodFill","struct*",$cvimage,"struct",$cvseed_point,"struct",$cvnew_val,"struct",$cvlo_diff,"struct",$cv,"struct",$cv,"struct",$cvup_diff,"struct",$cv,"struct",$cv,"struct*",$cvcomp,"int",$cvflags,"struct*",$cvmask)
    If @error Then ConsoleWrite( "error in cvFloodFill")
    Return $_aResult[0]
EndFunc ;==>cvFloodFill
#comments-end
Func _cvCanny($cvimage,$cvedges,$cvthreshold1,$cvthreshold2,$cvaperture_size=3)
;CVAPI(void) cvCanny( const CvArr* image, CvArr* edges, double threshold1, double threshold2, int aperture_size CV_DEFAULT(3) );
    local $_aResult = DllCall($_opencv_worldDLL,"void:cdecl","cvCanny","struct*",$cvimage,"struct*",$cvedges,"double",$cvthreshold1,"double",$cvthreshold2,"int",$cvaperture_size)
    If @error Then ConsoleWrite( "error in cvCanny")
    Return $_aResult[0]
EndFunc ;==>cvCanny
Func _cvPreCornerDetect($cvimage,$cvcorners,$cvaperture_size=3)
;CVAPI(void) cvPreCornerDetect( const CvArr* image, CvArr* corners, int aperture_size CV_DEFAULT(3) );
    local $_aResult = DllCall($_opencv_worldDLL,"void:cdecl","cvPreCornerDetect","struct*",$cvimage,"struct*",$cvcorners,"int",$cvaperture_size)
    If @error Then ConsoleWrite( "error in cvPreCornerDetect")
    Return $_aResult[0]
EndFunc ;==>cvPreCornerDetect
Func _cvCornerEigenValsAndVecs($cvimage,$cveigenvv,$cvblock_size,$cvaperture_size=3)
;CVAPI(void) cvCornerEigenValsAndVecs( const CvArr* image, CvArr* eigenvv, int block_size, int aperture_size CV_DEFAULT(3) );
    local $_aResult = DllCall($_opencv_worldDLL,"void:cdecl","cvCornerEigenValsAndVecs","struct*",$cvimage,"struct*",$cveigenvv,"int",$cvblock_size,"int",$cvaperture_size)
    If @error Then ConsoleWrite( "error in cvCornerEigenValsAndVecs")
    Return $_aResult[0]
EndFunc ;==>cvCornerEigenValsAndVecs
Func _cvCornerMinEigenVal($cvimage,$cveigenval,$cvblock_size,$cvaperture_size=3)
;CVAPI(void) cvCornerMinEigenVal( const CvArr* image, CvArr* eigenval, int block_size, int aperture_size CV_DEFAULT(3) );
    local $_aResult = DllCall($_opencv_worldDLL,"void:cdecl","cvCornerMinEigenVal","struct*",$cvimage,"struct*",$cveigenval,"int",$cvblock_size,"int",$cvaperture_size)
    If @error Then ConsoleWrite( "error in cvCornerMinEigenVal")
    Return $_aResult[0]
EndFunc ;==>cvCornerMinEigenVal
Func _cvCornerHarris($cvimage,$cvharris_response,$cvblock_size,$cvaperture_size=3,$cvk=0.04)
;CVAPI(void) cvCornerHarris( const CvArr* image, CvArr* harris_response, int block_size, int aperture_size CV_DEFAULT(3), double k CV_DEFAULT(0.04) );
    local $_aResult = DllCall($_opencv_worldDLL,"void:cdecl","cvCornerHarris","struct*",$cvimage,"struct*",$cvharris_response,"int",$cvblock_size,"int",$cvaperture_size,"double",$cvk)
    If @error Then ConsoleWrite( "error in cvCornerHarris")
    Return $_aResult[0]
EndFunc ;==>cvCornerHarris
Func _cvFindCornerSubPix($cvimage,$cvcorners,$cvcount,$cvwin,$cvzero_zone,$cvcriteria)
;CVAPI(void) cvFindCornerSubPix( const CvArr* image, CvPoint2D32f* corners, int count, CvSize win, CvSize zero_zone, CvTermCriteria criteria );
    local $_aResult = DllCall($_opencv_worldDLL,"void:cdecl","cvFindCornerSubPix","struct*",$cvimage,"struct*",$cvcorners,"int",$cvcount,"struct",$cvwin,"struct",$cvzero_zone,"struct",$cvcriteria)
    If @error Then ConsoleWrite( "error in cvFindCornerSubPix")
    Return $_aResult[0]
EndFunc ;==>cvFindCornerSubPix
Func _cvGoodFeaturesToTrack($cvimage,$cveig_image,$cvtemp_image,$cvcorners,$cvcorner_count,$cvquality_level,$cvmin_distance,$cvmask=NULL,$cvblock_size=3,$cvuse_harris=0,$cvk=0.04)
;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) );
    local $_aResult = DllCall($_opencv_worldDLL,"void:cdecl","cvGoodFeaturesToTrack","struct*",$cvimage,"struct*",$cveig_image,"struct*",$cvtemp_image,"struct*",$cvcorners,"struct*",$cvcorner_count,"double",$cvquality_level,"double",$cvmin_distance,"struct*",$cvmask,"int",$cvblock_size,"int",$cvuse_harris,"double",$cvk)
    If @error Then ConsoleWrite( "error in cvGoodFeaturesToTrack")
    Return $_aResult[0]
EndFunc ;==>cvGoodFeaturesToTrack
Func _cvHoughLines2($cvimage,$cvline_storage,$cvmethod,$cvrho,$cvtheta,$cvthreshold,$cvparam1=0,$cvparam2=0,$cvmin_theta=0,$cvmax_theta=$CV_PI)
;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), double min_theta CV_DEFAULT(0), double max_theta CV_DEFAULT(CV_PI));
    local $_aResult = DllCall($_opencv_worldDLL,"ptr:cdecl","cvHoughLines2","struct*",$cvimage,"struct*",$cvline_storage,"int",$cvmethod,"double",$cvrho,"double",$cvtheta,"int",$cvthreshold,"double",$cvparam1,"double",$cvparam2,"double",$cvmin_theta,"double",$cvmax_theta)
    If @error Then ConsoleWrite( "error in cvHoughLines2")
    Return $_aResult[0]
EndFunc ;==>cvHoughLines2
Func _cvHoughCircles($cvimage,$cvcircle_storage,$cvmethod,$cvdp,$cvmin_dist,$cvparam1=100,$cvparam2=100,$cvmin_radius=0,$cvmax_radius=0)
;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));
    local $_aResult = DllCall($_opencv_worldDLL,"ptr:cdecl","cvHoughCircles","struct*",$cvimage,"struct*",$cvcircle_storage,"int",$cvmethod,"double",$cvdp,"double",$cvmin_dist,"double",$cvparam1,"double",$cvparam2,"int",$cvmin_radius,"int",$cvmax_radius)
    If @error Then ConsoleWrite( "error in cvHoughCircles")
    Return $_aResult[0]
EndFunc ;==>cvHoughCircles
Func _cvFitLine($cvpoints,$cvdist_type,$cvparam,$cvreps,$cvaeps,$cvline)
;CVAPI(void) cvFitLine( const CvArr* points, int dist_type, double param, double reps, double aeps, float* line );
    local $_aResult = DllCall($_opencv_worldDLL,"void:cdecl","cvFitLine","struct*",$cvpoints,"int",$cvdist_type,"double",$cvparam,"double",$cvreps,"double",$cvaeps,"struct*",$cvline)
    If @error Then ConsoleWrite( "error in cvFitLine")
    Return $_aResult[0]
EndFunc ;==>cvFitLine
Func _cvLine($cvimg,$cvpt1,$cvpt2,$cvcolor,$cvthickness=1,$cvline_type=8,$cvshift=0)
;CVAPI(void) cvLine( CvArr* img, CvPoint pt1, CvPoint pt2, CvScalar color, int thickness CV_DEFAULT(1), int line_type CV_DEFAULT(8), int shift CV_DEFAULT(0) );
    local $_aResult = DllCall($_opencv_worldDLL,"void:cdecl","cvLine","struct*",$cvimg,"struct",$cvpt1,"struct",$cvpt2,"struct",$cvcolor,"int",$cvthickness,"int",$cvline_type,"int",$cvshift)
    If @error Then ConsoleWrite( "error in cvLine")
    Return $_aResult[0]
EndFunc ;==>cvLine
Func _cvRectangle($cvimg,$cvpt1,$cvpt2,$cvcolor,$cvthickness=1,$cvline_type=8,$cvshift=0)
;CVAPI(void) cvRectangle( CvArr* img, CvPoint pt1, CvPoint pt2, CvScalar color, int thickness CV_DEFAULT(1), int line_type CV_DEFAULT(8), int shift CV_DEFAULT(0));
    local $_aResult = DllCall($_opencv_worldDLL,"void:cdecl","cvRectangle","struct*",$cvimg,"struct",$cvpt1,"struct",$cvpt2,"struct",$cvcolor,"int",$cvthickness,"int",$cvline_type,"int",$cvshift)
    If @error Then ConsoleWrite( "error in cvRectangle")
    Return $_aResult[0]
EndFunc ;==>cvRectangle
Func _cvRectangleR($cvimg,$cvr,$cvcolor,$cvthickness=1,$cvline_type=8,$cvshift=0)
;CVAPI(void) cvRectangleR( CvArr* img, CvRect r, CvScalar color, int thickness CV_DEFAULT(1), int line_type CV_DEFAULT(8), int shift CV_DEFAULT(0));
    local $_aResult = DllCall($_opencv_worldDLL,"void:cdecl","cvRectangleR","struct*",$cvimg,"struct",$cvr,"struct",$cvcolor,"int",$cvthickness,"int",$cvline_type,"int",$cvshift)
    If @error Then ConsoleWrite( "error in cvRectangleR")
    Return $_aResult[0]
EndFunc ;==>cvRectangleR
Func _cvCircle($cvimg,$cvcenter,$cvradius,$cvcolor,$cvthickness=1,$cvline_type=8,$cvshift=0)
;CVAPI(void) cvCircle( CvArr* img, CvPoint center, int radius, CvScalar color, int thickness CV_DEFAULT(1), int line_type CV_DEFAULT(8), int shift CV_DEFAULT(0));
    local $_aResult = DllCall($_opencv_worldDLL,"void:cdecl","cvCircle","struct*",$cvimg,"struct",$cvcenter,"int",$cvradius,"struct",$cvcolor,"int",$cvthickness,"int",$cvline_type,"int",$cvshift)
    If @error Then ConsoleWrite( "error in cvCircle")
    Return $_aResult[0]
EndFunc ;==>cvCircle
Func _cvEllipse($cvimg,$cvcenter,$cvaxes,$cvangle,$cvstart_angle,$cvend_angle,$cvcolor,$cvthickness=1,$cvline_type=8,$cvshift=0)
;CVAPI(void) cvEllipse( CvArr* img, CvPoint center, CvSize axes, double angle, double start_angle, double end_angle, CvScalar color, int thickness CV_DEFAULT(1), int line_type CV_DEFAULT(8), int shift CV_DEFAULT(0));
    local $_aResult = DllCall($_opencv_worldDLL,"void:cdecl","cvEllipse","struct*",$cvimg,"struct",$cvcenter,"struct",$cvaxes,"double",$cvangle,"double",$cvstart_angle,"double",$cvend_angle,"struct",$cvcolor,"int",$cvthickness,"int",$cvline_type,"int",$cvshift)
    If @error Then ConsoleWrite( "error in cvEllipse")
    Return $_aResult[0]
EndFunc ;==>cvEllipse
Func _cvFillConvexPoly($cvimg,$cvpts,$cvnpts,$cvcolor,$cvline_type=8,$cvshift=0)
;CVAPI(void) cvFillConvexPoly( CvArr* img, const CvPoint* pts, int npts, CvScalar color, int line_type CV_DEFAULT(8), int shift CV_DEFAULT(0));
    local $_aResult = DllCall($_opencv_worldDLL,"void:cdecl","cvFillConvexPoly","struct*",$cvimg,"struct*",$cvpts,"int",$cvnpts,"struct",$cvcolor,"int",$cvline_type,"int",$cvshift)
    If @error Then ConsoleWrite( "error in cvFillConvexPoly")
    Return $_aResult[0]
EndFunc ;==>cvFillConvexPoly
Func _cvFillPoly($cvimg,$cvpts,$cvnpts,$cvcontours,$cvcolor,$cvline_type=8,$cvshift=0)
;CVAPI(void) cvFillPoly( CvArr* img, CvPoint** pts, const int* npts, int contours, CvScalar color, int line_type CV_DEFAULT(8), int shift CV_DEFAULT(0) );
    local $_aResult = DllCall($_opencv_worldDLL,"void:cdecl","cvFillPoly","struct*",$cvimg,"struct*",$cvpts,"struct*",$cvnpts,"int",$cvcontours,"struct",$cvcolor,"int",$cvline_type,"int",$cvshift)
    If @error Then ConsoleWrite( "error in cvFillPoly")
    Return $_aResult[0]
EndFunc ;==>cvFillPoly
Func _cvPolyLine($cvimg,$cvpts,$cvnpts,$cvcontours,$cvis_closed,$cvcolor,$cvthickness=1,$cvline_type=8,$cvshift=0)
;CVAPI(void) cvPolyLine( CvArr* img, CvPoint** pts, const int* npts, int contours, int is_closed, CvScalar color, int thickness CV_DEFAULT(1), int line_type CV_DEFAULT(8), int shift CV_DEFAULT(0) );
    local $_aResult = DllCall($_opencv_worldDLL,"void:cdecl","cvPolyLine","struct*",$cvimg,"struct*",$cvpts,"struct*",$cvnpts,"int",$cvcontours,"int",$cvis_closed,"struct",$cvcolor,"int",$cvthickness,"int",$cvline_type,"int",$cvshift)
    If @error Then ConsoleWrite( "error in cvPolyLine")
    Return $_aResult[0]
EndFunc ;==>cvPolyLine
Func _cvClipLine($cvimg_size,$cvpt1,$cvpt2)
;CVAPI(int) cvClipLine( CvSize img_size, CvPoint* pt1, CvPoint* pt2 );
    local $_aResult = DllCall($_opencv_worldDLL,"int:cdecl","cvClipLine","struct",$cvimg_size,"struct*",$cvpt1,"struct*",$cvpt2)
    If @error Then ConsoleWrite( "error in cvClipLine")
    Return $_aResult[0]
EndFunc ;==>cvClipLine
Func _cvInitLineIterator($cvimage,$cvpt1,$cvpt2,$cvline_iterator,$cvconnectivity=8,$cvleft_to_right=0)
;CVAPI(int) cvInitLineIterator( const CvArr* image, CvPoint pt1, CvPoint pt2, CvLineIterator* line_iterator, int connectivity CV_DEFAULT(8), int left_to_right CV_DEFAULT(0));
    local $_aResult = DllCall($_opencv_worldDLL,"int:cdecl","cvInitLineIterator","struct*",$cvimage,"struct",$cvpt1,"struct",$cvpt2,"struct*",$cvline_iterator,"int",$cvconnectivity,"int",$cvleft_to_right)
    If @error Then ConsoleWrite( "error in cvInitLineIterator")
    Return $_aResult[0]
EndFunc ;==>cvInitLineIterator
Func _cvInitFont($cvfont,$cvfont_face,$cvhscale,$cvvscale,$cvshear=0,$cvthickness=1,$cvline_type=8)
;CVAPI(void) cvInitFont( CvFont* font, int font_face, double hscale, double vscale, double shear CV_DEFAULT(0), int thickness CV_DEFAULT(1), int line_type CV_DEFAULT(8));
    local $_aResult = DllCall($_opencv_worldDLL,"void:cdecl","cvInitFont","struct*",$cvfont,"int",$cvfont_face,"double",$cvhscale,"double",$cvvscale,"double",$cvshear,"int",$cvthickness,"int",$cvline_type)
    If @error Then ConsoleWrite( "error in cvInitFont")
    Return $_aResult[0]
EndFunc ;==>cvInitFont
Func _cvPutText($cvimg,$cvtext,$cvorg,$cvfont,$cvcolor)
;CVAPI(void) cvPutText( CvArr* img, const char* text, CvPoint org, const CvFont* font, CvScalar color );
    local $_aResult = DllCall($_opencv_worldDLL,"void:cdecl","cvPutText","struct*",$cvimg,"struct*",$cvtext,"struct",$cvorg,"struct*",$cvfont,"struct",$cvcolor)
    If @error Then ConsoleWrite( "error in cvPutText")
    Return $_aResult[0]
EndFunc ;==>cvPutText
Func _cvGetTextSize($cvtext_string,$cvfont,$cvtext_size,$cvbaseline)
;CVAPI(void) cvGetTextSize( const char* text_string, const CvFont* font, CvSize* text_size, int* baseline );
    local $_aResult = DllCall($_opencv_worldDLL,"void:cdecl","cvGetTextSize","struct*",$cvtext_string,"struct*",$cvfont,"struct*",$cvtext_size,"struct*",$cvbaseline)
    If @error Then ConsoleWrite( "error in cvGetTextSize")
    Return $_aResult[0]
EndFunc ;==>cvGetTextSize
Func _cvColorToScalar($cvpacked_color,$cvarrtype)
;CVAPI(CvScalar) cvColorToScalar( double packed_color, int arrtype );
    local $_aResult = DllCall($_opencv_worldDLL,"none:cdecl","cvColorToScalar","double",$cvpacked_color,"int",$cvarrtype)
    If @error Then ConsoleWrite( "error in cvColorToScalar")
    Return $_aResult[0]
EndFunc ;==>cvColorToScalar
#comments-start
;TODO: Fix function declaration
Func _cvEllipse2Poly($cvcenter,$cvaxes,$cvangle,$cvarc_start,$cvarc_end,$cv,$cvdelta)
;CVAPI(int) cvEllipse2Poly( CvPoint center, CvSize axes, int angle, int arc_start, int arc_end, CvPoint*  pts, int delta );
    local $_aResult = DllCall($_opencv_worldDLL,"int:cdecl","cvEllipse2Poly","struct",$cvcenter,"struct",$cvaxes,"int",$cvangle,"int",$cvarc_start,"int",$cvarc_end,"struct*",$cv,"int",$cvdelta)
    If @error Then ConsoleWrite( "error in cvEllipse2Poly")
    Return $_aResult[0]
EndFunc ;==>cvEllipse2Poly
#comments-end
#comments-start
;TODO: Fix function declaration
Func _cvDrawContours($cvimg,$cvcontour,$cvexternal_color,$cvhole_color,$cvmax_level,$cvthickness=1,$cvline_type=8,$cvoffset=cvPoint,$cv,$cv,$cv)
;CVAPI(void) cvDrawContours( CvArr* img, CvSeq* contour, CvScalar external_color, CvScalar hole_color, int max_level, int thickness CV_DEFAULT(1), int line_type CV_DEFAULT(8), CvPoint offset CV_DEFAULT(cvPoint(0,0)));
    local $_aResult = DllCall($_opencv_worldDLL,"void:cdecl","cvDrawContours","struct*",$cvimg,"struct*",$cvcontour,"struct",$cvexternal_color,"struct",$cvhole_color,"int",$cvmax_level,"int",$cvthickness,"int",$cvline_type,"struct",$cvoffset,"struct",$cv,"struct",$cv,"struct",$cv)
    If @error Then ConsoleWrite( "error in cvDrawContours")
    Return $_aResult[0]
EndFunc ;==>cvDrawContours
#comments-end
#endregion  imgproc_c.h
#region  videoio_c.h
Func _cvCreateFileCapture($cvfilename)
;CVAPI(CvCapture*) cvCreateFileCapture( const char* filename );
    local $_aResult = DllCall($_opencv_worldDLL,"ptr:cdecl","cvCreateFileCapture","struct*",$cvfilename)
    If @error Then ConsoleWrite( "error in cvCreateFileCapture")
    Return $_aResult[0]
EndFunc ;==>cvCreateFileCapture
Func _cvCreateFileCaptureWithPreference($cvfilename,$cvapiPreference)
;CVAPI(CvCapture*) cvCreateFileCaptureWithPreference( const char* filename , int apiPreference);
    local $_aResult = DllCall($_opencv_worldDLL,"ptr:cdecl","cvCreateFileCaptureWithPreference","struct*",$cvfilename,"int",$cvapiPreference)
    If @error Then ConsoleWrite( "error in cvCreateFileCaptureWithPreference")
    Return $_aResult[0]
EndFunc ;==>cvCreateFileCaptureWithPreference
Func _cvCreateCameraCapture($cvindex)
;CVAPI(CvCapture*) cvCreateCameraCapture( int index );
    local $_aResult = DllCall($_opencv_worldDLL,"ptr:cdecl","cvCreateCameraCapture","int",$cvindex)
    If @error Then ConsoleWrite( "error in cvCreateCameraCapture")
    Return $_aResult[0]
EndFunc ;==>cvCreateCameraCapture
Func _cvGrabFrame($cvcapture)
;CVAPI(int) cvGrabFrame( CvCapture* capture );
    local $_aResult = DllCall($_opencv_worldDLL,"int:cdecl","cvGrabFrame","struct*",$cvcapture)
    If @error Then ConsoleWrite( "error in cvGrabFrame")
    Return $_aResult[0]
EndFunc ;==>cvGrabFrame
Func _cvRetrieveFrame($cvcapture,$cvstreamIdx=0)
;CVAPI(IplImage*) cvRetrieveFrame( CvCapture* capture, int streamIdx CV_DEFAULT(0) );
    local $_aResult = DllCall($_opencv_worldDLL,"ptr:cdecl","cvRetrieveFrame","struct*",$cvcapture,"int",$cvstreamIdx)
    If @error Then ConsoleWrite( "error in cvRetrieveFrame")
    Return $_aResult[0]
EndFunc ;==>cvRetrieveFrame
Func _cvQueryFrame($cvcapture)
;CVAPI(IplImage*) cvQueryFrame( CvCapture* capture );
    local $_aResult = DllCall($_opencv_worldDLL,"ptr:cdecl","cvQueryFrame","struct*",$cvcapture)
    If @error Then ConsoleWrite( "error in cvQueryFrame")
    Return $_aResult[0]
EndFunc ;==>cvQueryFrame
Func _cvReleaseCapture($cvcapture)
;CVAPI(void) cvReleaseCapture( CvCapture** capture );
    local $_aResult = DllCall($_opencv_worldDLL,"void:cdecl","cvReleaseCapture","struct*",$cvcapture)
    If @error Then ConsoleWrite( "error in cvReleaseCapture")
    Return $_aResult[0]
EndFunc ;==>cvReleaseCapture
Func _cvGetCaptureProperty($cvcapture,$cvproperty_id)
;CVAPI(double) cvGetCaptureProperty( CvCapture* capture, int property_id );
    local $_aResult = DllCall($_opencv_worldDLL,"double:cdecl","cvGetCaptureProperty","struct*",$cvcapture,"int",$cvproperty_id)
    If @error Then ConsoleWrite( "error in cvGetCaptureProperty")
    Return $_aResult[0]
EndFunc ;==>cvGetCaptureProperty
Func _cvSetCaptureProperty($cvcapture,$cvproperty_id,$cvvalue)
;CVAPI(int) cvSetCaptureProperty( CvCapture* capture, int property_id, double value );
    local $_aResult = DllCall($_opencv_worldDLL,"int:cdecl","cvSetCaptureProperty","struct*",$cvcapture,"int",$cvproperty_id,"double",$cvvalue)
    If @error Then ConsoleWrite( "error in cvSetCaptureProperty")
    Return $_aResult[0]
EndFunc ;==>cvSetCaptureProperty
Func _cvGetCaptureDomain($cvcapture)
;CVAPI(int) cvGetCaptureDomain( CvCapture* capture);
    local $_aResult = DllCall($_opencv_worldDLL,"int:cdecl","cvGetCaptureDomain","struct*",$cvcapture)
    If @error Then ConsoleWrite( "error in cvGetCaptureDomain")
    Return $_aResult[0]
EndFunc ;==>cvGetCaptureDomain
Func _cvCreateVideoWriter($cvfilename,$cvfourcc,$cvfps,$cvframe_size,$cvis_color=1)
;CVAPI(CvVideoWriter*) cvCreateVideoWriter( const char* filename, int fourcc, double fps, CvSize frame_size, int is_color CV_DEFAULT(1));
    local $_aResult = DllCall($_opencv_worldDLL,"ptr:cdecl","cvCreateVideoWriter","struct*",$cvfilename,"int",$cvfourcc,"double",$cvfps,"struct",$cvframe_size,"int",$cvis_color)
    If @error Then ConsoleWrite( "error in cvCreateVideoWriter")
    Return $_aResult[0]
EndFunc ;==>cvCreateVideoWriter
Func _cvWriteFrame($cvwriter,$cvimage)
;CVAPI(int) cvWriteFrame( CvVideoWriter* writer, const IplImage* image );
    local $_aResult = DllCall($_opencv_worldDLL,"int:cdecl","cvWriteFrame","struct*",$cvwriter,"struct*",$cvimage)
    If @error Then ConsoleWrite( "error in cvWriteFrame")
    Return $_aResult[0]
EndFunc ;==>cvWriteFrame
Func _cvReleaseVideoWriter($cvwriter)
;CVAPI(void) cvReleaseVideoWriter( CvVideoWriter** writer );
    local $_aResult = DllCall($_opencv_worldDLL,"void:cdecl","cvReleaseVideoWriter","struct*",$cvwriter)
    If @error Then ConsoleWrite( "error in cvReleaseVideoWriter")
    Return $_aResult[0]
EndFunc ;==>cvReleaseVideoWriter
#endregion  videoio_c.h