Easy to use Wrapper (DLL) for Intel's OpenCV Library with Examples

//*******************************************************************
// File name: $ CxCore.cs $
// Author:		$ Heiko Kie�ling, (c) iib-chemnitz.de $
// Email:			hki@hrz.tu-chemnitz.de
// 
// License:		There is no explicit license attached. The code is
//						provided 'as is'. Feel free to use the code how you like 
//						but without any warranty.
//						If you include the code in your own projects and/or
//						redistribute pls. include this header.
//
// History:		Rev. 1.0 (beta), hki - initial revision
//						- Update 26.08.08, hki: cvSplit, cvConvertScale
//						cvGetRealxx
// ToDo:			Documentation
//*******************************************************************
// Code generated by cvDocParser V1.0
//*******************************************************************

using System;
using System.Collections.Generic;
using System.Text;
using System.Runtime.InteropServices;


namespace openCV
{
	public partial class cvlib
	{
#if DEBUG
		private const string CXCORE_LIBRARY = "cxcore100d.dll";
#else
			private const string CXCORE_LIBRARY = "cxcore100.dll";
#endif


		/// <summary>
		/// Creates header and allocates data
		/// </summary>
		/// <param name="size">Image width and height.</param>
		/// <param name="depth">Bit depth of image elements. Can be one of:
		/// IPL_DEPTH_8U - uint 8-bit integers
		/// IPL_DEPTH_8S - signed 8-bit integers
		/// IPL_DEPTH_16U - uint 16-bit integers
		/// IPL_DEPTH_16S - signed 16-bit integers
		/// IPL_DEPTH_32S - signed 32-bit integers
		/// IPL_DEPTH_32F - single precision floating-point numbers
		/// IPL_DEPTH_64F - double precision floating-point numbers</param>
		/// <param name="channels">Number of channels per element(pixel). Can be 1, 2, 3 or 4. The channels are interleaved, for example the usual data layout of a color image is:
		/// b0 g0 r0 b1 g1 r1 ...
		/// Although in general IPL image format can store non-interleaved images as well and some of OpenCV can process it, this function can create interleaved images only.</param>
		/// <returns>IplImage</returns>
		public static IplImage CvCreateImage(CvSize size, int depth, int channels)
		{
			IntPtr p = cvCreateImage(size, depth, channels);
			IplImage i = (IplImage)Marshal.PtrToStructure(p, typeof(IplImage));
			i.ptr = p;
			return i;
		}
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern IntPtr cvCreateImage(CvSize size, int depth, int channels);

		/// <summary>
		/// The function CvCreateImageHeader allocates, initializes, and
		/// returns the structure IplImage. This call is an analogue of
		/// iplCreateImageHeader( channels, 0, depth,
		/// channels == 1 ? "GRAY" : "RGB",
		/// channels == 1 ? "GRAY" : channels == 3 ? "BGR" :
		/// channels == 4 ? "BGRA" : "",
		/// IPL_DATA_ORDER_PIXEL, IPL_ORIGIN_TL, 4,
		/// size.width, size.height,0,0,0,0);
		/// though it does not use IPL functions by default
		/// (see also CV_TURN_ON_IPL_COMPATIBILITY macro)
		/// </summary>
		/// <param name="size">Image width and height.</param>
		/// <param name="depth">Image depth (see CreateImage).</param>
		/// <param name="channels">Number of channels (see CreateImage).</param>
		/// <returns>structure IplImage</returns>
		public static IplImage CvCreateImageHeader(CvSize size, int depth, int channels)
		{
			IntPtr p = cvCreateImageHeader(size, depth, channels);
			IplImage i = (IplImage)Marshal.PtrToStructure(p, typeof(IplImage));
			i.ptr = p;
			return i;
		}
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern IntPtr cvCreateImageHeader(CvSize size, int depth, int channels);

		/// <summary>
		/// The function CvReleaseImageHeader releases the header of a Image.
		/// </summary>
		/// <param name="image">ref to the deallocated header.</param>
		public static void CvReleaseImageHeader(ref IplImage image)
		{
			cvReleaseImageHeader(ref image.ptr);
		}
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern void cvReleaseImageHeader(ref IntPtr image);

		/// <summary>
		/// Releases header and image data
		/// The function CvReleaseImage releases the header and 
		/// the image data. This call is a shortened form of
		/// if( image.ptr != IntPtr.Zero )
		/// {
		/// cvReleaseData( ref image );
		/// cvReleaseImageHeader( ref image );
		/// }
		/// </summary>
		/// <param name="image">Reference to IplImage</param>
		public static void CvReleaseImage(ref IplImage image)
		{
			cvReleaseImage(ref image.ptr);
		}
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern void cvReleaseImage(ref IntPtr image);

		/// <summary>
		/// The function cvInitImageHeader initializes the
		/// image header structure, pointer to which is passed by the user,
		/// and returns the pointer.
		/// </summary>
		/// <param name="image">Image header to initialize.</param>
		/// <param name="size">Image width and height.</param>
		/// <param name="depth">Image depth (see CreateImage).</param>
		/// <param name="channels">Number of channels (see CreateImage).</param>
		/// <param name="origin">IPL_ORIGIN_TL or IPL_ORIGIN_BL.</param>
		/// <param name="align">Alignment for image rows, typically 4 or 8 bytes.</param>
		/// <returns>pointer to passed image</returns>
		public static IplImage CvInitImageHeader(ref IplImage image, CvSize size, int depth, int channels, int origin, int align)
		{
			IntPtr p = cvInitImageHeader(ref image, size, depth, channels, origin, align);
			IplImage i = (IplImage)Marshal.PtrToStructure(p, typeof(IplImage));
			i.ptr = p;
			return i;
		}
		/// <summary>
		/// The function cvInitImageHeader initializes the
		/// image header structure, pointer to which is passed by the user,
		/// and returns the pointer.
		/// </summary>
		/// <param name="image">Image header to initialize.</param>
		/// <param name="size">Image width and height.</param>
		/// <param name="depth">Image depth (see CreateImage).</param>
		/// <param name="channels">Number of channels (see CreateImage).</param>
		/// <returns>pointer to passed image</returns>
		public static IplImage CvInitImageHeader(ref IplImage image, CvSize size, int depth, int channels)
		{
			IntPtr p = cvInitImageHeader(ref image, size, depth, channels, 0, 4);
			IplImage i = (IplImage)Marshal.PtrToStructure(p, typeof(IplImage));
			i.ptr = p;
			return i;
		}
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern IntPtr cvInitImageHeader(ref IplImage image, CvSize size, int depth, int channels, int origin, int align);

		/// <summary>
		/// Makes a full copy of image
		/// </summary>
		/// <param name="image">ref to IplImage</param>
		/// <returns>newly allocated image</returns>
		public static IplImage CvCloneImage(ref IplImage image)
		{
			IntPtr p = cvCloneImage(ref image);
			IplImage i = (IplImage)Marshal.PtrToStructure(p, typeof(IplImage));
			i.ptr = p;
			return i;
		}
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern IntPtr cvCloneImage(ref IplImage image);

		/// <summary>
		/// The function cvSetImageCOI sets the channel of interest
		/// to a given value. Value 0 means that all channels are
		/// selected, 1 means that the first channel is selected etc.
		/// If ROI is NULL and coi != 0, ROI is allocated. Note that
		/// most of OpenCV functions do not support COI, so to process
		/// separate image/matrix channel one may copy
		/// (via cvCopy or cvSplit) the channel to separate
		/// image/matrix, process it and copy the result back
		/// (via cvCopy or cvCvtPlaneToPix) if need.
		/// </summary>
		/// <param name="image">reference to Image header.</param>
		/// <param name="coi">The coi.</param>
		public static void CvSetImageCOI(ref IplImage image, int coi)
		{
			cvSetImageCOI(ref image, coi);
		}
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern void cvSetImageCOI(ref IplImage image, int coi);

		/// <summary>
		/// The function cvGetImageCOI returns channel of interest of 
		/// the image (it returns 0 if all the channels are selected).
		/// </summary>
		/// <param name="image">Reference to Image header. </param>
		/// <returns>channel of interest of the image (it returns 0 if 
		/// all the channels are selected)</returns>
		public static int CvGetImageCOI(ref IplImage image)
		{
			return cvGetImageCOI(ref image);
		}
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern int cvGetImageCOI(ref IplImage image);

		/// <summary>
		/// The function cvSetImageROI sets the image ROI to a 
		/// given rectangle. If ROI is NULL and the value of the 
		/// parameter rect is not equal to the whole image, ROI 
		/// is allocated. Unlike COI, most of OpenCV functions do 
		/// support ROI and treat it in a way as it would be a 
		/// separate image (for example, all the pixel coordinates 
		/// are counted from top-left or bottom-left (depending on 
		/// the image origin) corner of ROI)
		/// </summary>
		/// <param name="image">Reference to Image header.</param>
		/// <param name="rect">ROI Rectangle</param>
		public static void CvSetImageROI(ref IplImage image, CvRect rect)
		{
			cvSetImageROI(ref image, rect);
		}
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern void cvSetImageROI(ref IplImage image, CvRect rect);

		/// <summary>
		/// The function cvResetImageROI releases image ROI. After 
		/// that the whole image is considered selected.
		/// </summary>
		/// <param name="image">Image header</param>
		public static void CvResetImageROI(ref IplImage image)
		{
			cvResetImageROI(ref image);
		}
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern void cvResetImageROI(ref IplImage image);

		/// <summary>
		/// The function returns Roi of the channel of interest (coi).
		/// The rectangle cvRect(0,0,image.width,image.height)
		/// is returned if there is no ROI
		/// </summary>
		/// <param name="image">Image header.</param>
		/// <returns>Roi as Rectangle</returns>
		public static CvRect CvGetImageROI(ref IplImage image)
		{
			return cvGetImageROI(ref image);
		}
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern CvRect cvGetImageROI(ref IplImage image);

		/// <summary>
		/// The function cvCreateMat allocates header for the new matrix
		/// and underlying data, and returns a pointer to the created
		/// matrix. It is a short form for:
		/// CvMat mat = cvlib.CvCreateMatHeader( rows, cols, type );
		/// Matrices are stored row by row. All the rows are aligned by
		/// 4 bytes.
		/// </summary>
		/// <param name="rows">Number of rows in the matrix.</param>
		/// <param name="cols">Number of columns in the matrix.</param>
		/// <param name="type">Type of the matrix elements. Usually it
		/// is specified in form CV_bit_depth(S|U|F)Cnumber_of_channels,
		/// for example: CV_8UC1 means an 8-bit unsigned single-channel
		/// matrix, CV_32SC2 means a 32-bit signed matrix with two
		/// channels.</param>
		/// <returns>Math Structure</returns>
		public static CvMat CvCreateMat(int rows, int cols, int type)
		{
			IntPtr p = cvCreateMat(rows, cols, type);
			CvMat i = (CvMat)Marshal.PtrToStructure(p, typeof(CvMat));
			i.ptr = p;
			return i;
		}
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern IntPtr cvCreateMat(int rows, int cols, int type);

		/// <summary>
		/// Creates new matrix header
		/// </summary>
		/// <param name="rows">N rows.</param>
		/// <param name="cols">M cols.</param>
		/// <param name="type">type of Matrix.</param>
		/// <param name="data">Initializing data or zero.</param>
		/// <returns>CvMat</returns>
		public static CvMat CvCreateMatHeader(int rows, int cols, int type, IntPtr data)
		{
			IntPtr p = cvCreateMatHeader(rows, cols, type, data);
			CvMat i = (CvMat)Marshal.PtrToStructure(p, typeof(CvMat));
			i.ptr = p;
			return i;
		}
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern IntPtr cvCreateMatHeader(int rows, int cols, int type, IntPtr data);

		/// <summary>
		/// Deallocates matrix 
		/// </summary>
		/// <param name="mat">Matrix to deallocate</param>
		public static void CvReleaseMat(ref CvMat mat)
		{
			cvReleaseMat(ref mat.ptr);
		}
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern void cvReleaseMat(ref IntPtr mat);

		/// <summary>
		/// Initializes matrix header
		/// </summary>
		/// <param name="mat">The matrix.</param>
		/// <param name="rows">N rows.</param>
		/// <param name="cols">M cols.</param>
		/// <param name="type">The type of the matrix.</param>
		/// <param name="data">Data or zero.
		/// Create a Array with data and use cvtools for creating the IntPtr.
		/// </param>
		/// <param name="step">Stepsize.</param>
		/// <returns>CvMat</returns>
		public static CvMat CvInitMatHeader(ref CvMat mat, int rows, int cols, int type, IntPtr data, int step)
		{
			IntPtr p = cvInitMatHeader(ref mat, rows, cols, type, data, step);
			CvMat i = (CvMat)Marshal.PtrToStructure(p, typeof(CvMat));
			i.ptr = p;
			return i;
		}
		public static CvMat CvInitMatHeader(ref CvMat mat, int rows, int cols, int type)
		{
			IntPtr p = cvInitMatHeader(ref mat, rows, cols, type, IntPtr.Zero, CV_AUTOSTEP);
			CvMat i = (CvMat)Marshal.PtrToStructure(p, typeof(CvMat));
			i.ptr = p;
			return i;
		}
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern IntPtr cvInitMatHeader(ref CvMat mat, int rows, int cols, int type, IntPtr data, int step);


		/// <summary>
		/// Creates matrix copy 
		/// </summary>
		/// <param name="mat">Matrix to clone</param>
		/// <returns>Cloned Matrix</returns>
		public static CvMat CvCloneMat(ref CvMat mat)
		{
			IntPtr p = cvCloneMat(ref mat);
			CvMat i = (CvMat)Marshal.PtrToStructure(p, typeof(CvMat));
			i.ptr = p;
			return i;
		}
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern IntPtr cvCloneMat(ref CvMat mat);

		/// <summary>
		/// Creates multi-dimensional dense array
		/// </summary>
		/// <param name="dims">Number of array dimensions. 
		/// It must not exceed CV_MAX_DIM (=32 by default, though 
		/// it may be changed at build time)</param>
		/// <param name="sizes">Array of dimension sizes.</param>
		/// <param name="type">Type of array elements. The same as for CvMat.</param>
		/// <returns>CvMatND</returns>
		public static CvMatND CvCreateMatND(int dims, int[] sizes, int type)
		{
			IntPtr p = cvCreateMatND(dims, sizes, type);
			CvMatND i = (CvMatND)Marshal.PtrToStructure(p, typeof(CvMatND));
			i.ptr = p;
			return i;
		}
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern IntPtr cvCreateMatND(int dims, int[] sizes, int type);

		/// <summary>
		/// Creates new matrix header
		/// </summary>
		/// <param name="dims">Number of dimension.</param>
		/// <param name="sizes">Array of sizes of the dimensions.</param>
		/// <param name="type">Type of array elements. The same as for CvMat.</param>
		/// <returns>CvMatND</returns>
		public static CvMatND CvCreateMatNDHeader(int dims, int[] sizes, int type)
		{
			IntPtr p = cvCreateMatNDHeader(dims, sizes, type);
			CvMatND i = (CvMatND)Marshal.PtrToStructure(p, typeof(CvMatND));
			i.ptr = p;
			return i;
		}
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern IntPtr cvCreateMatNDHeader(int dims, int[] sizes, int type);

		/// <summary>
		/// Deallocates multi-dimensional array 
		/// </summary>
		/// <param name="mat">The Natrix to deallocate</param>
		public static void CvReleaseMatND(ref CvMatND mat)
		{
			cvReleaseMatND(ref mat.ptr);
		}
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern void cvReleaseMatND(ref IntPtr mat);

		/// <summary>
		/// Initializes multi-dimensional array header
		/// </summary>
		/// <param name="mat">The Matrix.</param>
		/// <param name="dims">Number of dimensions.</param>
		/// <param name="sizes">Array of dimension sizes.</param>
		/// <param name="type">Type of array elements. The same as for CvMat.</param>
		/// <param name="data">Optional data pointer assigned to the matrix header.
		/// Create a Array with data and use cvtools for creating the IntPtr.</param>
		/// <returns>CvMatND</returns>
		public static CvMatND CvInitMatNDHeader(ref CvMatND mat, int dims, int[] sizes, int type, IntPtr data)
		{
			IntPtr p = cvInitMatNDHeader(ref mat, dims, sizes, type, data);
			CvMatND i = (CvMatND)Marshal.PtrToStructure(p, typeof(CvMatND));
			i.ptr = p;
			return i;
		}
		public static CvMatND CvInitMatNDHeader(ref CvMatND mat, int dims, int[] sizes, int type)
		{
			IntPtr p = cvInitMatNDHeader(ref mat, dims, sizes, type, IntPtr.Zero);
			CvMatND i = (CvMatND)Marshal.PtrToStructure(p, typeof(CvMatND));
			i.ptr = p;
			return i;
		}
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern IntPtr cvInitMatNDHeader(ref CvMatND mat, int dims, int[] sizes, int type, IntPtr data);

		/// <summary>
		/// Creates full copy of multi-dimensional array 
		/// </summary>
		/// <param name="mat">Array header.</param>
		/// <returns>CvMatND</returns>
		public static CvMatND CvCloneMatND(ref CvMatND mat)
		{
			IntPtr p = cvCloneMatND(ref mat);
			CvMatND i = (CvMatND)Marshal.PtrToStructure(p, typeof(CvMatND));
			i.ptr = p;
			return i;
		}
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern IntPtr cvCloneMatND(ref CvMatND mat);

		/// <summary>
		/// Decrements array data reference counter 
		/// </summary>
		/// <param name="arr">Array header.</param>
		public static void CvDecRefData(ref IplImage arr)
		{
			cvDecRefData(ref arr);
		}
		public static void CvDecRefData(ref CvMat arr)
		{
			cvDecRefData(ref arr);
		}
		public static void CvDecRefData(ref CvSeq arr)
		{
			cvDecRefData(ref arr);
		}
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern void cvDecRefData(ref IplImage arr);
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern void cvDecRefData(ref CvMat arr);
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern void cvDecRefData(ref CvSeq arr);

		/// <summary>
		/// Increments array data reference counter 
		/// </summary>
		/// <param name="arr">Array header.</param>
		public static int CvIncRefData(ref IplImage arr)
		{
			return cvIncRefData(ref arr);
		}
		public static int CvIncRefData(ref CvMat arr)
		{
			return cvIncRefData(ref arr);
		}
		public static int CvIncRefData(ref CvSeq arr)
		{
			return cvIncRefData(ref arr);
		}
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern int cvIncRefData(ref IplImage arr);
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern int cvIncRefData(ref CvMat arr);
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern int cvIncRefData(ref CvSeq arr);

		/// <summary>
		/// Allocates array data
		/// </summary>
		/// <param name="arr">Array header.</param>
		public static void CvCreateData(ref IplImage arr)
		{
			cvCreateData(ref arr);
		}
		public static void CvCreateData(ref CvMat arr)
		{
			cvCreateData(ref arr);
		}
		public static void CvCreateData(ref CvSeq arr)
		{
			cvCreateData(ref arr);
		}
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern void cvCreateData(ref IplImage arr);
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern void cvCreateData(ref CvMat arr);
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern void cvCreateData(ref CvSeq arr);

		/// <summary>
		/// Releases array data
		/// </summary>
		/// <param name="arr">Array header.</param>
		public static void CvReleaseData(ref IplImage arr)
		{
			cvReleaseData(ref arr);
		}
		public static void CvReleaseData(ref CvMat arr)
		{
			cvReleaseData(ref arr);
		}
		public static void CvReleaseData(ref CvSeq arr)
		{
			cvReleaseData(ref arr);
		}
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern void cvReleaseData(ref IplImage arr);
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern void cvReleaseData(ref CvMat arr);
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern void cvReleaseData(ref CvSeq arr);

		/// <summary>
		/// Assigns user data to the array header
		/// </summary>
		/// <param name="arr">Array Header.</param>
		/// <param name="data">The data. Use cvtools to get the IntPtr</param>
		/// <param name="step">Full row length in bytes.</param>
		public static void CvSetData(ref IplImage arr, IntPtr data, int step)
		{
			cvSetData(ref arr, data, step);
		}
		public static void CvSetData(ref CvMat arr, IntPtr data, int step)
		{
			cvSetData(ref arr, data, step);
		}
		public static void CvSetData(ref CvSeq arr, IntPtr data, int step)
		{
			cvSetData(ref arr, data, step);
		}
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern void cvSetData(ref IplImage arr, IntPtr data, int step);
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern void cvSetData(ref CvMat arr, IntPtr data, int step);
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern void cvSetData(ref CvSeq arr, IntPtr data, int step);

		/// <summary>
		/// Retrieves low-level information about the array.
		/// Create managed Arrays of desired size and use cvtools
		/// to get the IntPtr.
		/// </summary>
		/// <param name="arr">Array header.</param>
		/// <param name="data">Output pointer to the whole image origin or ROI origin if ROI is set.</param>
		/// <param name="step">Output full row length in bytes.</param>
		/// <param name="roi_size">Output ROI size.</param>
		public static void CvGetRawData(ref IplImage arr, ref IntPtr data, int[] step, ref CvSize roi_size)
		{
			cvGetRawData(ref arr, ref data, step, ref roi_size);
		}
		public static void CvGetRawData(ref CvMat arr, ref IntPtr data, int[] step, ref CvSize roi_size)
		{
			cvGetRawData(ref arr, ref data, step, ref roi_size);
		}
		public static void CvGetRawData(ref CvSeq arr, ref IntPtr data, int[] step, ref CvSize roi_size)
		{
			cvGetRawData(ref arr, ref data, step, ref roi_size);
		}
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern void cvGetRawData(ref IplImage arr, ref IntPtr data, int[] step, ref CvSize roi_size);
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern void cvGetRawData(ref CvMat arr, ref IntPtr data, int[] step, ref CvSize roi_size);
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern void cvGetRawData(ref CvSeq arr, ref IntPtr data, int[] step, ref CvSize roi_size);

		/// <summary>
		/// Retrieves low-level information about the array
		/// </summary>
		/// <param name="arr">Array header.</param>
		/// <param name="data">Output pointer to the whole image origin or ROI origin if ROI is set.</param>
		public static void CvGetRawData(ref IplImage arr, ref IntPtr data)
		{
			cvGetRawData(ref arr, ref data, null, IntPtr.Zero);
		}
		public static void CvGetRawData(ref CvMat arr, ref IntPtr data)
		{
			cvGetRawData(ref arr, ref data, null, IntPtr.Zero);
		}
		public static void CvGetRawData(ref CvSeq arr, ref IntPtr data)
		{
			cvGetRawData(ref arr, ref data, null, IntPtr.Zero);
		}
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern void cvGetRawData(ref IplImage arr, ref IntPtr data, int[] step, IntPtr roi_size);
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern void cvGetRawData(ref CvMat arr, ref IntPtr data, int[] step, IntPtr roi_size);
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern void cvGetRawData(ref CvSeq arr, ref IntPtr data, int[] step, IntPtr roi_size);

		/// <summary>
		/// Returns matrix header for arbitrary array
		/// </summary>
		/// <param name="arr">Input array.</param>
		/// <param name="header">Pointer to CvMat structure used as a temporary buffer.</param>
		/// <param name="coi">Optional output parameter for storing COI.</param>
		/// <param name="allowND">If non-zero, the function accepts multi-dimensional dense arrays (CvMatND*) and returns 2D (if CvMatND has two dimensions) or 1D matrix (when CvMatND has 1 dimension or more than 2 dimensions). The array must be continuous.</param>
		/// <returns>CvMat</returns>
		public static CvMat CvGetMat(ref IplImage arr, ref CvMat header, IntPtr coi, int allowND)
		{
			IntPtr p = cvGetMat(ref arr, ref header, coi, allowND);
			CvMat i = (CvMat)Marshal.PtrToStructure(p, typeof(CvMat));
			i.ptr = p;
			return i;
		}
		/// <summary>
		/// Returns matrix header for arbitrary array
		/// </summary>
		/// <param name="arr">Input array.</param>
		/// <param name="header">Pointer to CvMat structure used as a temporary buffer.</param>
		/// <param name="coi">Optional output parameter for storing COI.</param>
		/// <param name="allowND">If non-zero, the function accepts multi-dimensional dense arrays (CvMatND*) and returns 2D (if CvMatND has two dimensions) or 1D matrix (when CvMatND has 1 dimension or more than 2 dimensions). The array must be continuous.</param>
		/// <returns>CvMat</returns>
		public static CvMat CvGetMat(ref CvMat arr, ref CvMat header, IntPtr coi, int allowND)
		{
			IntPtr p = cvGetMat(ref arr, ref header, coi, allowND);
			CvMat i = (CvMat)Marshal.PtrToStructure(p, typeof(CvMat));
			i.ptr = p;
			return i;
		}
		/// <summary>
		/// Returns matrix header for arbitrary array
		/// </summary>
		/// <param name="arr">Input array.</param>
		/// <param name="header">Pointer to CvMat structure used as a temporary buffer.</param>
		/// <param name="coi">Optional output parameter for storing COI.</param>
		/// <param name="allowND">If non-zero, the function accepts multi-dimensional dense arrays (CvMatND*) and returns 2D (if CvMatND has two dimensions) or 1D matrix (when CvMatND has 1 dimension or more than 2 dimensions). The array must be continuous.</param>
		/// <returns>CvMat</returns>
		public static CvMat CvGetMat(ref CvSeq arr, ref CvMat header, IntPtr coi, int allowND)
		{
			IntPtr p = cvGetMat(ref arr, ref header, coi, allowND);
			CvMat i = (CvMat)Marshal.PtrToStructure(p, typeof(CvMat));
			i.ptr = p;
			return i;
		}
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern IntPtr cvGetMat(ref IplImage arr, ref CvMat header, IntPtr coi, int allowND);
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern IntPtr cvGetMat(ref CvMat arr, ref CvMat header, IntPtr coi, int allowND);
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern IntPtr cvGetMat(ref CvSeq arr, ref CvMat header, IntPtr coi, int allowND);

		/// <summary>
		/// Returns image header for arbitrary array
		/// </summary>
		/// <param name="arr">Input Image.</param>
		/// <param name="image_header">Pointer to IplImage structure used as a temporary buffer.</param>
		/// <returns>IplImage</returns>
		public static IplImage CvGetImage(ref IplImage arr, ref IplImage image_header)
		{
			IntPtr p = cvGetImage(ref arr, ref image_header);
			IplImage i = (IplImage)Marshal.PtrToStructure(p, typeof(IplImage));
			i.ptr = p;
			return i;
		}
		public static IplImage CvGetImage(ref CvMat arr, ref IplImage image_header)
		{
			IntPtr p = cvGetImage(ref arr, ref image_header);
			IplImage i = (IplImage)Marshal.PtrToStructure(p, typeof(IplImage));
			i.ptr = p;
			return i;
		}
		public static IplImage CvGetImage(ref CvSeq arr, ref IplImage image_header)
		{
			IntPtr p = cvGetImage(ref arr, ref image_header);
			IplImage i = (IplImage)Marshal.PtrToStructure(p, typeof(IplImage));
			i.ptr = p;
			return i;
		}
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern IntPtr cvGetImage(ref IplImage arr, ref IplImage image_header);
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern IntPtr cvGetImage(ref CvMat arr, ref IplImage image_header);
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern IntPtr cvGetImage(ref CvSeq arr, ref IplImage image_header);

		/// <summary>
		/// CreateSparseMat
		/// </summary>
		/// <param name="dims">Number of array dimensions. As opposite to the dense matrix, the number of dimensions is practically unlimited (up to 216).</param>
		/// <param name="sizes">Array of dimension sizes.</param>
		/// <param name="type">Type of array elements. The same as for CvMat</param>
		/// <returns>CvSparseMat</returns>
		public static CvSparseMat CvCreateSparseMat(int dims, int[] sizes, int type)
		{
			IntPtr p = cvCreateSparseMat(dims, sizes, type);
			CvSparseMat i = (CvSparseMat)Marshal.PtrToStructure(p, typeof(CvSparseMat));
			i.ptr = p;
			return i;
		}
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern IntPtr cvCreateSparseMat(int dims, int[] sizes, int type);

		/// <summary>
		/// Deallocates sparse array 
		/// </summary>
		/// <param name="mat">pointer to the array.</param>
		public static void CvReleaseSparseMat(ref CvSparseMat mat)
		{
			cvReleaseSparseMat(ref mat.ptr);
		}
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern void cvReleaseSparseMat(ref IntPtr mat);

		/// <summary>
		/// Creates full copy of sparse array 
		/// </summary>
		/// <param name="mat">Input array.</param>
		/// <returns>CvSparseMat</returns>
		public static CvSparseMat CvCloneSparseMat(ref CvSparseMat mat)
		{
			IntPtr p = cvCloneSparseMat(ref mat);
			CvSparseMat i = (CvSparseMat)Marshal.PtrToStructure(p, typeof(CvSparseMat));
			i.ptr = p;
			return i;
		}
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern IntPtr cvCloneSparseMat(ref CvSparseMat mat);

		/// <summary>
		/// GetSubRect 
		/// Returns matrix header corresponding to the rectangular sub-array of input image or matrix 
		/// </summary>
		/// <param name="arr"></param>
		/// <returns></returns>
		public static CvMat CvGetSubRect(ref IplImage arr, ref CvMat submat, CvRect rect)
		{
			IntPtr p = cvGetSubRect(ref arr, ref submat, rect);
			CvMat i = (CvMat)Marshal.PtrToStructure(p, typeof(CvMat));
			i.ptr = p;
			return i;
		}
		public static CvMat CvGetSubRect(ref CvMat arr, ref CvMat submat, CvRect rect)
		{
			IntPtr p = cvGetSubRect(ref arr, ref submat, rect);
			CvMat i = (CvMat)Marshal.PtrToStructure(p, typeof(CvMat));
			i.ptr = p;
			return i;
		}
		public static CvMat CvGetSubRect(ref CvSeq arr, ref CvMat submat, CvRect rect)
		{
			IntPtr p = cvGetSubRect(ref arr, ref submat, rect);
			CvMat i = (CvMat)Marshal.PtrToStructure(p, typeof(CvMat));
			i.ptr = p;
			return i;
		}
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern IntPtr cvGetSubRect(ref IplImage arr, ref CvMat submat, CvRect rect);
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern IntPtr cvGetSubRect(ref CvMat arr, ref CvMat submat, CvRect rect);
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern IntPtr cvGetSubRect(ref CvSeq arr, ref CvMat submat, CvRect rect);

		/// <summary>
		/// GetRow, GetRows 
		/// Returns array row or row span 
		/// </summary>
		/// <param name="arr"></param>
		/// <returns></returns>
		public static CvMat CvGetRow(ref IplImage arr, ref CvMat submat, int row)
		{
			IntPtr p = cvGetRows(ref arr, ref submat, row, row + 1, 1);
			CvMat i = (CvMat)Marshal.PtrToStructure(p, typeof(CvMat));
			i.ptr = p;
			return i;
		}
		public static CvMat CvGetRow(ref CvMat arr, ref CvMat submat, int row)
		{
			IntPtr p = cvGetRows(ref arr, ref submat, row, row + 1, 1);
			CvMat i = (CvMat)Marshal.PtrToStructure(p, typeof(CvMat));
			i.ptr = p;
			return i;
		}
		public static CvMat CvGetRow(ref CvSeq arr, ref CvMat submat, int row)
		{
			IntPtr p = cvGetRows(ref arr, ref submat, row, row + 1, 1);
			CvMat i = (CvMat)Marshal.PtrToStructure(p, typeof(CvMat));
			i.ptr = p;
			return i;
		}
		public static CvMat CvGetRows(ref IplImage arr, ref CvMat submat, int start_row, int end_row, int delta_row)
		{
			IntPtr p = cvGetRows(ref arr, ref submat, start_row, end_row, delta_row);
			CvMat i = (CvMat)Marshal.PtrToStructure(p, typeof(CvMat));
			i.ptr = p;
			return i;
		}
		public static CvMat CvGetRows(ref CvMat arr, ref CvMat submat, int start_row, int end_row, int delta_row)
		{
			IntPtr p = cvGetRows(ref arr, ref submat, start_row, end_row, delta_row);
			CvMat i = (CvMat)Marshal.PtrToStructure(p, typeof(CvMat));
			i.ptr = p;
			return i;
		}
		public static CvMat CvGetRows(ref CvSeq arr, ref CvMat submat, int start_row, int end_row, int delta_row)
		{
			IntPtr p = cvGetRows(ref arr, ref submat, start_row, end_row, delta_row);
			CvMat i = (CvMat)Marshal.PtrToStructure(p, typeof(CvMat));
			i.ptr = p;
			return i;
		}
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern IntPtr cvGetRows(ref IplImage arr, ref CvMat submat, int start_row, int end_row, int delta_row);
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern IntPtr cvGetRows(ref CvMat arr, ref CvMat submat, int start_row, int end_row, int delta_row);
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern IntPtr cvGetRows(ref CvSeq arr, ref CvMat submat, int start_row, int end_row, int delta_row);

		/// <summary>
		/// GetCol, GetCols 
		/// Returns array column or column span 
		/// </summary>
		/// <param name="arr"></param>
		/// <returns></returns>
		public static CvMat CvGetCol(ref IplImage arr, ref CvMat submat, int col)
		{
			IntPtr p = cvGetCols(ref arr, ref submat, col, col + 1);
			CvMat i = (CvMat)Marshal.PtrToStructure(p, typeof(CvMat));
			i.ptr = p;
			return i;
		}
		public static CvMat CvGetCol(ref CvMat arr, ref CvMat submat, int col)
		{
			IntPtr p = cvGetCols(ref arr, ref submat, col, col + 1);
			CvMat i = (CvMat)Marshal.PtrToStructure(p, typeof(CvMat));
			i.ptr = p;
			return i;
		}
		public static CvMat CvGetCol(ref CvSeq arr, ref CvMat submat, int col)
		{
			IntPtr p = cvGetCols(ref arr, ref submat, col, col + 1);
			CvMat i = (CvMat)Marshal.PtrToStructure(p, typeof(CvMat));
			i.ptr = p;
			return i;
		}
		public static CvMat CvGetCols(ref IplImage arr, ref CvMat submat, int start_col, int end_col)
		{
			IntPtr p = cvGetCols(ref arr, ref submat, start_col, end_col);
			CvMat i = (CvMat)Marshal.PtrToStructure(p, typeof(CvMat));
			i.ptr = p;
			return i;
		}
		public static CvMat CvGetCols(ref CvMat arr, ref CvMat submat, int start_col, int end_col)
		{
			IntPtr p = cvGetCols(ref arr, ref submat, start_col, end_col);
			CvMat i = (CvMat)Marshal.PtrToStructure(p, typeof(CvMat));
			i.ptr = p;
			return i;
		}
		public static CvMat CvGetCols(ref CvSeq arr, ref CvMat submat, int start_col, int end_col)
		{
			IntPtr p = cvGetCols(ref arr, ref submat, start_col, end_col);
			CvMat i = (CvMat)Marshal.PtrToStructure(p, typeof(CvMat));
			i.ptr = p;
			return i;
		}
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern IntPtr cvGetCols(ref IplImage arr, ref CvMat submat, int start_col, int end_col);
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern IntPtr cvGetCols(ref CvMat arr, ref CvMat submat, int start_col, int end_col);
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern IntPtr cvGetCols(ref CvSeq arr, ref CvMat submat, int start_col, int end_col);

		/// <summary>
		/// GetDiag 
		/// Returns one of array diagonals 
		/// </summary>
		/// <param name="arr"></param>
		/// <returns></returns>
		public static CvMat CvGetDiag(ref IplImage arr, ref CvMat submat, int diag)
		{
			IntPtr p = cvGetDiag(ref arr, ref submat, diag);
			CvMat i = (CvMat)Marshal.PtrToStructure(p, typeof(CvMat));
			i.ptr = p;
			return i;
		}
		public static CvMat CvGetDiag(ref CvMat arr, ref CvMat submat, int diag)
		{
			IntPtr p = cvGetDiag(ref arr, ref submat, diag);
			CvMat i = (CvMat)Marshal.PtrToStructure(p, typeof(CvMat));
			i.ptr = p;
			return i;
		}
		public static CvMat CvGetDiag(ref CvSeq arr, ref CvMat submat, int diag)
		{
			IntPtr p = cvGetDiag(ref arr, ref submat, diag);
			CvMat i = (CvMat)Marshal.PtrToStructure(p, typeof(CvMat));
			i.ptr = p;
			return i;
		}
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern IntPtr cvGetDiag(ref IplImage arr, ref CvMat submat, int diag);
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern IntPtr cvGetDiag(ref CvMat arr, ref CvMat submat, int diag);
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern IntPtr cvGetDiag(ref CvSeq arr, ref CvMat submat, int diag);

		/// <summary>
		/// GetSize 
		/// Returns size of matrix or image ROI 
		/// </summary>
		/// <param name="arr"></param>
		/// <returns></returns>
		public static CvSize CvGetSize(ref IplImage arr)
		{
			return cvGetSize(ref arr);
		}
		public static CvSize CvGetSize(ref CvMat arr)
		{
			return cvGetSize(ref arr);
		}
		public static CvSize CvGetSize(ref CvSeq arr)
		{
			return cvGetSize(ref arr);
		}
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern CvSize cvGetSize(ref IplImage arr);
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern CvSize cvGetSize(ref CvMat arr);
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern CvSize cvGetSize(ref CvSeq arr);

		/// <summary>
		/// InitSparseMatIterator 
		/// Initializes sparse array elements iterator 
		/// </summary>
		/// <param name="mat"></param>
		/// <returns></returns>
		public static CvSparseNode CvInitSparseMatIterator(ref CvSparseMat mat, ref CvSparseMatIterator mat_iterator)
		{
			IntPtr p = cvInitSparseMatIterator(ref mat, ref mat_iterator);
			CvSparseNode i = (CvSparseNode)Marshal.PtrToStructure(p, typeof(CvSparseNode));
			i.ptr = p;
			return i;
		}
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern IntPtr cvInitSparseMatIterator(ref CvSparseMat mat, ref CvSparseMatIterator mat_iterator);

		/// <summary>
		/// GetNextSparseNode 
		/// Initializes sparse array elements iterator 
		/// </summary>
		/// <param name="mat_iterator"></param>
		/// <returns></returns>
		public static CvSparseNode CvGetNextSparseNode(ref CvSparseMatIterator mat_iterator)
		{
			IntPtr p = cvGetNextSparseNode(ref mat_iterator);
			CvSparseNode i = (CvSparseNode)Marshal.PtrToStructure(p, typeof(CvSparseNode));
			i.ptr = p;
			return i;
		}
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern IntPtr cvGetNextSparseNode(ref CvSparseMatIterator mat_iterator);

		/// <summary>
		/// GetElemType 
		/// Returns type of array elements 
		/// </summary>
		/// <param name="arr"></param>
		/// <returns></returns>
		public static int CvGetElemType(ref IplImage arr)
		{
			return cvGetElemType(ref arr);
		}
		public static int CvGetElemType(ref CvMat arr)
		{
			return cvGetElemType(ref arr);
		}
		public static int CvGetElemType(ref CvSeq arr)
		{
			return cvGetElemType(ref arr);
		}
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern int cvGetElemType(ref IplImage arr);
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern int cvGetElemType(ref CvMat arr);
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern int cvGetElemType(ref CvSeq arr);

		/// <summary>
		/// GetDims, GetDimSize 
		/// Return number of array dimensions and their sizes or the size of particular dimension 
		/// </summary>
		/// <param name="arr"></param>
		/// <returns></returns>
		public static int CvGetDims(ref IplImage arr, int[] sizes)
		{
			return cvGetDims(ref arr, sizes);
		}
		public static int CvGetDims(ref CvMat arr, int[] sizes)
		{
			return cvGetDims(ref arr, sizes);
		}
		public static int CvGetDims(ref CvSeq arr, int[] sizes)
		{
			return cvGetDims(ref arr, sizes);
		}
		public static int CvGetDimSize(ref IplImage arr, int index)
		{
			return cvGetDimSize(ref arr, index);
		}
		public static int CvGetDimSize(ref CvMat arr, int index)
		{
			return cvGetDimSize(ref arr, index);
		}
		public static int CvGetDimSize(ref CvSeq arr, int index)
		{
			return cvGetDimSize(ref arr, index);
		}
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern int cvGetDims(ref IplImage arr, int[] sizes);
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern int cvGetDims(ref CvMat arr, int[] sizes);
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern int cvGetDims(ref CvSeq arr, int[] sizes);
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern int cvGetDimSize(ref IplImage arr, int index);
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern int cvGetDimSize(ref CvMat arr, int index);
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern int cvGetDimSize(ref CvSeq arr, int index);

		/// <summary>
		/// Ptr*D 
		/// Return pointer to the particular array element 
		/// </summary>
		/// <param name="arr"></param>
		/// <returns></returns>
		public static IntPtr CvPtr1D(ref IplImage arr, int idx0, ref int type)
		{
			return cvPtr1D(ref arr, idx0, ref type);
		}
		public static IntPtr CvPtr1D(ref CvMat arr, int idx0, ref int type)
		{
			return cvPtr1D(ref arr, idx0, ref type);
		}
		public static IntPtr CvPtr1D(ref CvSeq arr, int idx0, ref int type)
		{
			return cvPtr1D(ref arr, idx0, ref type);
		}
		public static IntPtr CvPtr2D(ref IplImage arr, int idx0, int idx1, ref int type)
		{
			return cvPtr2D(ref arr, idx0, idx1, ref type);
		}
		public static IntPtr CvPtr2D(ref CvMat arr, int idx0, int idx1, ref int type)
		{
			return cvPtr2D(ref arr, idx0, idx1, ref type);
		}
		public static IntPtr CvPtr2D(ref CvSeq arr, int idx0, int idx1, ref int type)
		{
			return cvPtr2D(ref arr, idx0, idx1, ref type);
		}
		public static IntPtr CvPtr3D(ref IplImage arr, int idx0, int idx1, int idx2, ref int type)
		{
			return cvPtr3D(ref arr, idx0, idx1, idx2, ref type);
		}
		public static IntPtr CvPtr3D(ref CvMat arr, int idx0, int idx1, int idx2, ref int type)
		{
			return cvPtr3D(ref arr, idx0, idx1, idx2, ref type);
		}
		public static IntPtr CvPtr3D(ref CvSeq arr, int idx0, int idx1, int idx2, ref int type)
		{
			return cvPtr3D(ref arr, idx0, idx1, idx2, ref type);
		}
		public static IntPtr CvPtrND(ref IplImage arr, int[] idx, ref int type, int create_node, uint[] precalc_hashval)
		{
			return cvPtrND(ref arr, idx, ref type, create_node, precalc_hashval);
		}
		public static IntPtr CvPtrND(ref CvMat arr, int[] idx, ref int type, int create_node, uint[] precalc_hashval)
		{
			return cvPtrND(ref arr, idx, ref type, create_node, precalc_hashval);
		}
		public static IntPtr CvPtrND(ref CvSeq arr, int[] idx, ref int type, int create_node, uint[] precalc_hashval)
		{
			return cvPtrND(ref arr, idx, ref type, create_node, precalc_hashval);
		}
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern IntPtr cvPtr1D(ref IplImage arr, int idx0, ref int type);
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern IntPtr cvPtr1D(ref CvMat arr, int idx0, ref int type);
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern IntPtr cvPtr1D(ref CvSeq arr, int idx0, ref int type);
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern IntPtr cvPtr2D(ref IplImage arr, int idx0, int idx1, ref int type);
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern IntPtr cvPtr2D(ref CvMat arr, int idx0, int idx1, ref int type);
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern IntPtr cvPtr2D(ref CvSeq arr, int idx0, int idx1, ref int type);
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern IntPtr cvPtr3D(ref IplImage arr, int idx0, int idx1, int idx2, ref int type);
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern IntPtr cvPtr3D(ref CvMat arr, int idx0, int idx1, int idx2, ref int type);
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern IntPtr cvPtr3D(ref CvSeq arr, int idx0, int idx1, int idx2, ref int type);
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern IntPtr cvPtrND(ref IplImage arr, int[] idx, ref int type, int create_node, uint[] precalc_hashval);
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern IntPtr cvPtrND(ref CvMat arr, int[] idx, ref int type, int create_node, uint[] precalc_hashval);
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern IntPtr cvPtrND(ref CvSeq arr, int[] idx, ref int type, int create_node, uint[] precalc_hashval);

		/// <summary>
		/// Get*D 
		/// Return the particular array element 
		/// </summary>
		/// <param name="arr"></param>
		/// <returns></returns>
		public static CvScalar CvGet1D(ref IplImage arr, int idx0)
		{
			return cvGet1D(ref arr, idx0);
		}
		public static CvScalar CvGet1D(ref CvMat arr, int idx0)
		{
			return cvGet1D(ref arr, idx0);
		}
		public static CvScalar CvGet1D(ref CvSeq arr, int idx0)
		{
			return cvGet1D(ref arr, idx0);
		}
		public static CvScalar CvGet2D(ref IplImage arr, int idx0, int idx1)
		{
			return cvGet2D(ref arr, idx0, idx1);
		}
		public static CvScalar CvGet2D(ref CvMat arr, int idx0, int idx1)
		{
			return cvGet2D(ref arr, idx0, idx1);
		}
		public static CvScalar CvGet2D(ref CvSeq arr, int idx0, int idx1)
		{
			return cvGet2D(ref arr, idx0, idx1);
		}
		public static CvScalar CvGet3D(ref IplImage arr, int idx0, int idx1, int idx2)
		{
			return cvGet3D(ref arr, idx0, idx1, idx2);
		}
		public static CvScalar CvGet3D(ref CvMat arr, int idx0, int idx1, int idx2)
		{
			return cvGet3D(ref arr, idx0, idx1, idx2);
		}
		public static CvScalar CvGet3D(ref CvSeq arr, int idx0, int idx1, int idx2)
		{
			return cvGet3D(ref arr, idx0, idx1, idx2);
		}
		public static CvScalar CvGetND(ref IplImage arr, int[] idx)
		{
			return cvGetND(ref arr, idx);
		}
		public static CvScalar CvGetND(ref CvMat arr, int[] idx)
		{
			return cvGetND(ref arr, idx);
		}
		public static CvScalar CvGetND(ref CvSeq arr, int[] idx)
		{
			return cvGetND(ref arr, idx);
		}
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern CvScalar cvGet1D(ref IplImage arr, int idx0);
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern CvScalar cvGet1D(ref CvMat arr, int idx0);
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern CvScalar cvGet1D(ref CvSeq arr, int idx0);
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern CvScalar cvGet2D(ref IplImage arr, int idx0, int idx1);
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern CvScalar cvGet2D(ref CvMat arr, int idx0, int idx1);
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern CvScalar cvGet2D(ref CvSeq arr, int idx0, int idx1);
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern CvScalar cvGet3D(ref IplImage arr, int idx0, int idx1, int idx2);
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern CvScalar cvGet3D(ref CvMat arr, int idx0, int idx1, int idx2);
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern CvScalar cvGet3D(ref CvSeq arr, int idx0, int idx1, int idx2);
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern CvScalar cvGetND(ref IplImage arr, int[] idx);
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern CvScalar cvGetND(ref CvMat arr, int[] idx);
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern CvScalar cvGetND(ref CvSeq arr, int[] idx);

		/// <summary>
		/// GetReal*D 
		/// Return the particular element of single-channel array 
		/// </summary>
		/// <param name="arr"></param>
		/// <returns></returns>
		public static double CvGetReal1D(ref IplImage arr, int idx0)
		{
			return cvGetReal1D(ref arr, idx0);
		}
		public static double CvGetReal1D(ref CvMat arr, int idx0)
		{
			return cvGetReal1D(ref arr, idx0);
		}
		public static double CvGetReal1D(ref CvSeq arr, int idx0)
		{
			return cvGetReal1D(ref arr, idx0);
		}
		public static double CvGetReal1D(IntPtr arr, int idx0)
		{
			return cvGetReal1D(arr, idx0);
		}
		public static double CvGetReal2D(ref IplImage arr, int idx0, int idx1)
		{
			return cvGetReal2D(ref arr, idx0, idx1);
		}
		public static double CvGetReal2D(ref CvMat arr, int idx0, int idx1)
		{
			return cvGetReal2D(ref arr, idx0, idx1);
		}
		public static double CvGetReal2D(ref CvSeq arr, int idx0, int idx1)
		{
			return cvGetReal2D(ref arr, idx0, idx1);
		}
		public static double CvGetReal2D(IntPtr arr, int idx0, int idx1)
		{
			return cvGetReal2D(arr, idx0, idx1);
		}
		public static double CvGetReal3D(ref IplImage arr, int idx0, int idx1, int idx2)
		{
			return cvGetReal3D(ref arr, idx0, idx1, idx2);
		}
		public static double CvGetReal3D(ref CvMat arr, int idx0, int idx1, int idx2)
		{
			return cvGetReal3D(ref arr, idx0, idx1, idx2);
		}
		public static double CvGetReal3D(ref CvSeq arr, int idx0, int idx1, int idx2)
		{
			return cvGetReal3D(ref arr, idx0, idx1, idx2);
		}
		public static double CvGetReal3D(IntPtr arr, int idx0, int idx1, int idx2)
		{
			return cvGetReal3D(arr, idx0, idx1, idx2);
		}
		public static double CvGetRealND(ref IplImage arr, int[] idx)
		{
			return cvGetRealND(ref arr, idx);
		}
		public static double CvGetRealND(ref CvMat arr, int[] idx)
		{
			return cvGetRealND(ref arr, idx);
		}
		public static double CvGetRealND(ref CvSeq arr, int[] idx)
		{
			return cvGetRealND(ref arr, idx);
		}
		public static double CvGetRealND(IntPtr arr, int[] idx)
		{
			return cvGetRealND(arr, idx);
		}
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern double cvGetReal1D(ref IplImage arr, int idx0);
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern double cvGetReal1D(ref CvMat arr, int idx0);
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern double cvGetReal1D(ref CvSeq arr, int idx0);
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern double cvGetReal1D(IntPtr arr, int idx0);
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern double cvGetReal2D(ref IplImage arr, int idx0, int idx1);
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern double cvGetReal2D(ref CvMat arr, int idx0, int idx1);
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern double cvGetReal2D(ref CvSeq arr, int idx0, int idx1);
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern double cvGetReal2D(IntPtr arr, int idx0, int idx1);
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern double cvGetReal3D(ref IplImage arr, int idx0, int idx1, int idx2);
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern double cvGetReal3D(ref CvMat arr, int idx0, int idx1, int idx2);
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern double cvGetReal3D(ref CvSeq arr, int idx0, int idx1, int idx2);
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern double cvGetReal3D(IntPtr arr, int idx0, int idx1, int idx2);
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern double cvGetRealND(ref IplImage arr, int[] idx);
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern double cvGetRealND(ref CvMat arr, int[] idx);
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern double cvGetRealND(ref CvSeq arr, int[] idx);
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern double cvGetRealND(IntPtr arr, int[] idx);


		/// <summary>
		/// Set*D 
		/// Change the particular array element 
		/// </summary>
		/// <param name="arr"></param>
		/// <returns></returns>
		public static void CvSet1D(ref IplImage arr, int idx0, CvScalar value)
		{
			cvSet1D(ref arr, idx0, value);
		}
		public static void CvSet1D(ref CvMat arr, int idx0, CvScalar value)
		{
			cvSet1D(ref arr, idx0, value);
		}
		public static void CvSet1D(ref CvSeq arr, int idx0, CvScalar value)
		{
			cvSet1D(ref arr, idx0, value);
		}
		public static void CvSet2D(ref IplImage arr, int idx0, int idx1, CvScalar value)
		{
			cvSet2D(ref arr, idx0, idx1, value);
		}
		public static void CvSet2D(ref CvMat arr, int idx0, int idx1, CvScalar value)
		{
			cvSet2D(ref arr, idx0, idx1, value);
		}
		public static void CvSet2D(ref CvSeq arr, int idx0, int idx1, CvScalar value)
		{
			cvSet2D(ref arr, idx0, idx1, value);
		}
		public static void CvSet3D(ref IplImage arr, int idx0, int idx1, int idx2, CvScalar value)
		{
			cvSet3D(ref arr, idx0, idx1, idx2, value);
		}
		public static void CvSet3D(ref CvMat arr, int idx0, int idx1, int idx2, CvScalar value)
		{
			cvSet3D(ref arr, idx0, idx1, idx2, value);
		}
		public static void CvSet3D(ref CvSeq arr, int idx0, int idx1, int idx2, CvScalar value)
		{
			cvSet3D(ref arr, idx0, idx1, idx2, value);
		}
		public static void CvSetND(ref IplImage arr, int[] idx, CvScalar value)
		{
			cvSetND(ref arr, idx, value);
		}
		public static void CvSetND(ref CvMat arr, int[] idx, CvScalar value)
		{
			cvSetND(ref arr, idx, value);
		}
		public static void CvSetND(ref CvSeq arr, int[] idx, CvScalar value)
		{
			cvSetND(ref arr, idx, value);
		}
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern void cvSet1D(ref IplImage arr, int idx0, CvScalar value);
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern void cvSet1D(ref CvMat arr, int idx0, CvScalar value);
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern void cvSet1D(ref CvSeq arr, int idx0, CvScalar value);
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern void cvSet2D(ref IplImage arr, int idx0, int idx1, CvScalar value);
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern void cvSet2D(ref CvMat arr, int idx0, int idx1, CvScalar value);
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern void cvSet2D(ref CvSeq arr, int idx0, int idx1, CvScalar value);
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern void cvSet3D(ref IplImage arr, int idx0, int idx1, int idx2, CvScalar value);
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern void cvSet3D(ref CvMat arr, int idx0, int idx1, int idx2, CvScalar value);
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern void cvSet3D(ref CvSeq arr, int idx0, int idx1, int idx2, CvScalar value);
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern void cvSetND(ref IplImage arr, int[] idx, CvScalar value);
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern void cvSetND(ref CvMat arr, int[] idx, CvScalar value);
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern void cvSetND(ref CvSeq arr, int[] idx, CvScalar value);

		/// <summary>
		/// SetReal*D 
		/// Change the particular array element 
		/// </summary>
		/// <param name="arr"></param>
		/// <returns></returns>
		public static void CvSetReal1D(ref IplImage arr, int idx0, double value)
		{
			cvSetReal1D(ref arr, idx0, value);
		}
		public static void CvSetReal1D(ref CvMat arr, int idx0, double value)
		{
			cvSetReal1D(ref arr, idx0, value);
		}
		public static void CvSetReal1D(ref CvSeq arr, int idx0, double value)
		{
			cvSetReal1D(ref arr, idx0, value);
		}
		public static void CvSetReal2D(ref IplImage arr, int idx0, int idx1, double value)
		{
			cvSetReal2D(ref arr, idx0, idx1, value);
		}
		public static void CvSetReal2D(ref CvMat arr, int idx0, int idx1, double value)
		{
			cvSetReal2D(ref arr, idx0, idx1, value);
		}
		public static void CvSetReal2D(ref CvSeq arr, int idx0, int idx1, double value)
		{
			cvSetReal2D(ref arr, idx0, idx1, value);
		}
		public static void CvSetReal3D(ref IplImage arr, int idx0, int idx1, int idx2, double value)
		{
			cvSetReal3D(ref arr, idx0, idx1, idx2, value);
		}
		public static void CvSetReal3D(ref CvMat arr, int idx0, int idx1, int idx2, double value)
		{
			cvSetReal3D(ref arr, idx0, idx1, idx2, value);
		}
		public static void CvSetReal3D(ref CvSeq arr, int idx0, int idx1, int idx2, double value)
		{
			cvSetReal3D(ref arr, idx0, idx1, idx2, value);
		}
		public static void CvSetRealND(ref IplImage arr, int[] idx, double value)
		{
			cvSetRealND(ref arr, idx, value);
		}
		public static void CvSetRealND(ref CvMat arr, int[] idx, double value)
		{
			cvSetRealND(ref arr, idx, value);
		}
		public static void CvSetRealND(ref CvSeq arr, int[] idx, double value)
		{
			cvSetRealND(ref arr, idx, value);
		}
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern void cvSetReal1D(ref IplImage arr, int idx0, double value);
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern void cvSetReal1D(ref CvMat arr, int idx0, double value);
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern void cvSetReal1D(ref CvSeq arr, int idx0, double value);
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern void cvSetReal2D(ref IplImage arr, int idx0, int idx1, double value);
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern void cvSetReal2D(ref CvMat arr, int idx0, int idx1, double value);
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern void cvSetReal2D(ref CvSeq arr, int idx0, int idx1, double value);
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern void cvSetReal3D(ref IplImage arr, int idx0, int idx1, int idx2, double value);
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern void cvSetReal3D(ref CvMat arr, int idx0, int idx1, int idx2, double value);
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern void cvSetReal3D(ref CvSeq arr, int idx0, int idx1, int idx2, double value);
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern void cvSetRealND(ref IplImage arr, int[] idx, double value);
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern void cvSetRealND(ref CvMat arr, int[] idx, double value);
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern void cvSetRealND(ref CvSeq arr, int[] idx, double value);


		/// <summary>
		/// ClearND 
		/// Clears the particular array element 
		/// </summary>
		/// <param name="arr"></param>
		/// <returns></returns>
		public static void CvClearND(ref IplImage arr, int[] idx)
		{
			cvClearND(ref arr, idx);
		}
		public static void CvClearND(ref CvMat arr, int[] idx)
		{
			cvClearND(ref arr, idx);
		}
		public static void CvClearND(ref CvSeq arr, int[] idx)
		{
			cvClearND(ref arr, idx);
		}
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern void cvClearND(ref IplImage arr, int[] idx);
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern void cvClearND(ref CvMat arr, int[] idx);
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern void cvClearND(ref CvSeq arr, int[] idx);

		/// <summary>
		/// Copy 
		/// Copies one array to another 
		/// </summary>
		/// <param name="src"></param>
		/// <returns></returns>
		public static void CvCopy(ref IplImage src, ref IplImage dst, ref IplImage mask)
		{
			cvCopy(ref src, ref dst, ref mask);
		}
		public static void CvCopy(ref CvMat src, ref CvMat dst, ref CvMat mask)
		{
			cvCopy(ref src, ref dst, ref mask);
		}
		public static void CvCopy(ref CvSeq src, ref CvSeq dst, ref CvSeq mask)
		{
			cvCopy(ref src, ref dst, ref mask);
		}
		public static void CvCopy(ref IplImage src, ref IplImage dst)
		{
			cvCopy(ref src, ref dst, IntPtr.Zero);
		}
		public static void CvCopy(ref CvMat src, ref CvMat dst)
		{
			cvCopy(ref src, ref dst, IntPtr.Zero);
		}
		public static void CvCopy(ref CvSeq src, ref CvSeq dst)
		{
			cvCopy(ref src, ref dst, IntPtr.Zero);
		}
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern void cvCopy(ref IplImage src, ref IplImage dst, ref IplImage mask);
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern void cvCopy(ref CvMat src, ref CvMat dst, ref CvMat mask);
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern void cvCopy(ref CvSeq src, ref CvSeq dst, ref CvSeq mask);
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern void cvCopy(ref IplImage src, ref IplImage dst, IntPtr mask);
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern void cvCopy(ref CvMat src, ref CvMat dst, IntPtr mask);
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern void cvCopy(ref CvSeq src, ref CvSeq dst, IntPtr mask);

		/// <summary>
		/// Set 
		/// Sets every element of array to given value 
		/// </summary>
		/// <param name="arr"></param>
		/// <returns></returns>
		public static void CvSet(ref IplImage arr, CvScalar value, ref IplImage mask)
		{
			cvSet(ref arr, value, ref mask);
		}
		public static void CvSet(ref CvMat arr, CvScalar value, ref CvMat mask)
		{
			cvSet(ref arr, value, ref mask);
		}
		public static void CvSet(ref CvSeq arr, CvScalar value, ref CvSeq mask)
		{
			cvSet(ref arr, value, ref mask);
		}
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern void cvSet(ref IplImage arr, CvScalar value, ref IplImage mask);
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern void cvSet(ref CvMat arr, CvScalar value, ref CvMat mask);
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern void cvSet(ref CvSeq arr, CvScalar value, ref CvSeq mask);

		public static void CvSet(ref IplImage arr, CvScalar value)
		{
			cvSet(ref arr, value, IntPtr.Zero);
		}
		public static void CvSet(ref CvMat arr, CvScalar value)
		{
			cvSet(ref arr, value, IntPtr.Zero);
		}
		public static void CvSet(ref CvSeq arr, CvScalar value)
		{
			cvSet(ref arr, value, IntPtr.Zero);
		}
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern void cvSet(ref IplImage arr, CvScalar value, IntPtr mask);
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern void cvSet(ref CvMat arr, CvScalar value, IntPtr mask);
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern void cvSet(ref CvSeq arr, CvScalar value, IntPtr mask);

		/// <summary>
		/// SetZero 
		/// Clears the array 
		/// </summary>
		/// <param name="arr"></param>
		/// <returns></returns>
		public static void CvSetZero(ref IplImage arr)
		{
			cvSetZero(ref arr);
		}
		public static void CvSetZero(ref CvMat arr)
		{
			cvSetZero(ref arr);
		}
		public static void CvSetZero(ref CvSeq arr)
		{
			cvSetZero(ref arr);
		}
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern void cvSetZero(ref IplImage arr);
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern void cvSetZero(ref CvMat arr);
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern void cvSetZero(ref CvSeq arr);

		/// <summary>
		/// SetIdentity 
		/// Initializes scaled identity matrix 
		/// </summary>
		/// <param name="arr"></param>
		/// <returns></returns>
		public static void CvSetIdentity(ref IplImage mat, CvScalar value)
		{
			cvSetIdentity(ref mat, value);
		}
		public static void CvSetIdentity(ref CvMat mat, CvScalar value)
		{
			cvSetIdentity(ref mat, value);
		}
		public static void CvSetIdentity(ref CvSeq mat, CvScalar value)
		{
			cvSetIdentity(ref mat, value);
		}
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern void cvSetIdentity(ref IplImage mat, CvScalar value);
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern void cvSetIdentity(ref CvMat mat, CvScalar value);
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern void cvSetIdentity(ref CvSeq mat, CvScalar value);

		/// <summary>
		/// Range 
		/// Fills matrix with given range of numbers 
		/// </summary>
		/// <param name="mat"></param>
		/// <returns></returns>
		public static void CvRange(ref IplImage mat, double start, double end)
		{
			cvRange(ref mat, start, end);
		}
		public static void CvRange(ref CvMat mat, double start, double end)
		{
			cvRange(ref mat, start, end);
		}
		public static void CvRange(ref CvSeq mat, double start, double end)
		{
			cvRange(ref mat, start, end);
		}
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern void cvRange(ref IplImage mat, double start, double end);
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern void cvRange(ref CvMat mat, double start, double end);
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern void cvRange(ref CvSeq mat, double start, double end);

		/// <summary>
		/// Reshape 
		/// Changes shape of matrix/image without copying data 
		/// </summary>
		/// <param name="arr"></param>
		/// <returns></returns>
		public static CvMat CvReshape(ref IplImage arr, ref CvMat header, int new_cn, int new_rows)
		{
			IntPtr p = cvReshape(ref arr, ref header, new_cn, new_rows);
			CvMat i = (CvMat)Marshal.PtrToStructure(p, typeof(CvMat));
			i.ptr = p;
			return i;
		}
		public static CvMat CvReshape(ref CvMat arr, ref CvMat header, int new_cn, int new_rows)
		{
			IntPtr p = cvReshape(ref arr, ref header, new_cn, new_rows);
			CvMat i = (CvMat)Marshal.PtrToStructure(p, typeof(CvMat));
			i.ptr = p;
			return i;
		}
		public static CvMat CvReshape(ref CvSeq arr, ref CvMat header, int new_cn, int new_rows)
		{
			IntPtr p = cvReshape(ref arr, ref header, new_cn, new_rows);
			CvMat i = (CvMat)Marshal.PtrToStructure(p, typeof(CvMat));
			i.ptr = p;
			return i;
		}
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern IntPtr cvReshape(ref IplImage arr, ref CvMat header, int new_cn, int new_rows);
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern IntPtr cvReshape(ref CvMat arr, ref CvMat header, int new_cn, int new_rows);
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern IntPtr cvReshape(ref CvSeq arr, ref CvMat header, int new_cn, int new_rows);

		/// <summary>
		/// ReshapeMatND 
		/// Changes shape of multi-dimensional array w/o copying data 
		/// </summary>
		/// <param name="arr"></param>
		/// <returns></returns>
		public static IplImage CvReshapeMatND(ref IplImage arr, int sizeof_header, ref IplImage header, int new_cn, int new_dims, int[] new_sizes)
		{
			IntPtr p = cvReshapeMatND(ref arr, sizeof_header, ref header, new_cn, new_dims, new_sizes);
			IplImage i = (IplImage)Marshal.PtrToStructure(p, typeof(IplImage));
			i.ptr = p;
			return i;
		}
		public static CvMat CvReshapeMatND(ref CvMat arr, int sizeof_header, ref CvMat header, int new_cn, int new_dims, int[] new_sizes)
		{
			IntPtr p = cvReshapeMatND(ref arr, sizeof_header, ref header, new_cn, new_dims, new_sizes);
			CvMat i = (CvMat)Marshal.PtrToStructure(p, typeof(CvMat));
			i.ptr = p;
			return i;
		}
		public static CvSeq CvReshapeMatND(ref CvSeq arr, int sizeof_header, ref CvSeq header, int new_cn, int new_dims, int[] new_sizes)
		{
			IntPtr p = cvReshapeMatND(ref arr, sizeof_header, ref header, new_cn, new_dims, new_sizes);
			CvSeq i = (CvSeq)Marshal.PtrToStructure(p, typeof(CvSeq));
			i.ptr = p;
			return i;
		}
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern IntPtr cvReshapeMatND(ref IplImage arr, int sizeof_header, ref IplImage header, int new_cn, int new_dims, int[] new_sizes);
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern IntPtr cvReshapeMatND(ref CvMat arr, int sizeof_header, ref CvMat header, int new_cn, int new_dims, int[] new_sizes);
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern IntPtr cvReshapeMatND(ref CvSeq arr, int sizeof_header, ref CvSeq header, int new_cn, int new_dims, int[] new_sizes);

		/// <summary>
		/// Repeat 
		/// Fill destination array with tiled source array 
		/// </summary>
		/// <param name="src"></param>
		/// <returns></returns>
		public static void CvRepeat(ref IplImage src, ref IplImage dst)
		{
			cvRepeat(ref src, ref dst);
		}
		public static void CvRepeat(ref CvMat src, ref CvMat dst)
		{
			cvRepeat(ref src, ref dst);
		}
		public static void CvRepeat(ref CvSeq src, ref CvSeq dst)
		{
			cvRepeat(ref src, ref dst);
		}
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern void cvRepeat(ref IplImage src, ref IplImage dst);
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern void cvRepeat(ref CvMat src, ref CvMat dst);
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern void cvRepeat(ref CvSeq src, ref CvSeq dst);

		/// <summary>
		/// Flip 
		/// Flip a 2D array around vertical, horizontall or both axises 
		/// </summary>
		/// <param name="src"></param>
		/// <returns></returns>
		public static void CvFlip(ref IplImage src, ref IplImage dst, int flip_mode)
		{
			cvFlip(ref src, ref dst, flip_mode);
		}
		public static void CvFlip(ref CvMat src, ref CvMat dst, int flip_mode)
		{
			cvFlip(ref src, ref dst, flip_mode);
		}
		public static void CvFlip(ref CvSeq src, ref CvSeq dst, int flip_mode)
		{
			cvFlip(ref src, ref dst, flip_mode);
		}
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern void cvFlip(ref IplImage src, ref IplImage dst, int flip_mode);
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern void cvFlip(ref CvMat src, ref CvMat dst, int flip_mode);
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern void cvFlip(ref CvSeq src, ref CvSeq dst, int flip_mode);

		public static void CvFlip(ref IplImage src, int flip_mode)
		{
			cvFlip(ref src, IntPtr.Zero, flip_mode);
		}
		public static void CvFlip(ref CvMat src, int flip_mode)
		{
			cvFlip(ref src, IntPtr.Zero, flip_mode);
		}
		public static void CvFlip(ref CvSeq src, int flip_mode)
		{
			cvFlip(ref src, IntPtr.Zero, flip_mode);
		}
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern void cvFlip(ref IplImage src, IntPtr dst, int flip_mode);
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern void cvFlip(ref CvMat src, IntPtr dst, int flip_mode);
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern void cvFlip(ref CvSeq src, IntPtr dst, int flip_mode);

		/// <summary>
		/// Split 
		/// Divides multi-channel array into several single-channel arrays or extracts 
		/// a single channel from the array 
		/// </summary>
		/// <param name="src"></param>
		/// <returns></returns>
		public static void CvSplit(ref IplImage src, ref IplImage dst0, ref IplImage dst1, ref IplImage dst2, ref IplImage dst3)
		{
			cvSplit(ref src, ref dst0, ref dst1, ref dst2, ref dst3);
		}
		public static void CvSplit(ref CvMat src, ref CvMat dst0, ref CvMat dst1, ref CvMat dst2, ref CvMat dst3)
		{
			cvSplit(ref src, ref dst0, ref dst1, ref dst2, ref dst3);
		}
		public static void CvSplit(ref CvSeq src, ref CvSeq dst0, ref CvSeq dst1, ref CvSeq dst2, ref CvSeq dst3)
		{
			cvSplit(ref src, ref dst0, ref dst1, ref dst2, ref dst3);
		}
		public static void CvSplit(ref IplImage src, ref IplImage dst0, ref IplImage dst1, ref IplImage dst2)
		{
			cvSplit(ref src, ref dst0, ref dst1, ref dst2, IntPtr.Zero);
		}
		public static void CvSplit(ref CvMat src, ref CvMat dst0, ref CvMat dst1, ref CvMat dst2)
		{
			cvSplit(ref src, ref dst0, ref dst1, ref dst2, IntPtr.Zero);
		}
		public static void CvSplit(ref CvSeq src, ref CvSeq dst0, ref CvSeq dst1, ref CvSeq dst2)
		{
			cvSplit(ref src, ref dst0, ref dst1, ref dst2, IntPtr.Zero);
		}
		public static void CvSplit(ref IplImage src, ref IplImage dst0, ref IplImage dst1)
		{
			cvSplit(ref src, ref dst0, ref dst1, IntPtr.Zero, IntPtr.Zero);
		}
		public static void CvSplit(ref CvMat src, ref CvMat dst0, ref CvMat dst1)
		{
			cvSplit(ref src, ref dst0, ref dst1, IntPtr.Zero, IntPtr.Zero);
		}
		public static void CvSplit(ref CvSeq src, ref CvSeq dst0, ref CvSeq dst1)
		{
			cvSplit(ref src, ref dst0, ref dst1, IntPtr.Zero, IntPtr.Zero);
		}
		public static void CvSplit(ref IplImage src, ref IplImage dst0)
		{
			cvSplit(ref src, ref dst0, IntPtr.Zero, IntPtr.Zero, IntPtr.Zero);
		}
		public static void CvSplit(ref CvMat src, ref CvMat dst0)
		{
			cvSplit(ref src, ref dst0, IntPtr.Zero, IntPtr.Zero, IntPtr.Zero);
		}
		public static void CvSplit(ref CvSeq src, ref CvSeq dst0)
		{
			cvSplit(ref src, ref dst0, IntPtr.Zero, IntPtr.Zero, IntPtr.Zero);
		}
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern void cvSplit(ref IplImage src, ref IplImage dst0, ref IplImage dst1, ref IplImage dst2, ref IplImage dst3);
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern void cvSplit(ref CvMat src, ref CvMat dst0, ref CvMat dst1, ref CvMat dst2, ref CvMat dst3);
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern void cvSplit(ref CvSeq src, ref CvSeq dst0, ref CvSeq dst1, ref CvSeq dst2, ref CvSeq dst3);
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern void cvSplit(ref IplImage src, ref IplImage dst0, ref IplImage dst1, ref IplImage dst2, IntPtr dst3);
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern void cvSplit(ref CvMat src, ref CvMat dst0, ref CvMat dst1, ref CvMat dst2, IntPtr dst3);
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern void cvSplit(ref CvSeq src, ref CvSeq dst0, ref CvSeq dst1, ref CvSeq dst2, IntPtr dst3);
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern void cvSplit(ref IplImage src, ref IplImage dst0, ref IplImage dst1, IntPtr dst2, IntPtr dst3);
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern void cvSplit(ref CvMat src, ref CvMat dst0, ref CvMat dst1, IntPtr dst2, IntPtr dst3);
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern void cvSplit(ref CvSeq src, ref CvSeq dst0, ref CvSeq dst1, IntPtr dst2, IntPtr dst3);
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern void cvSplit(ref IplImage src, ref IplImage dst0, IntPtr dst1, IntPtr dst2, IntPtr dst3);
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern void cvSplit(ref CvMat src, ref CvMat dst0, IntPtr dst1, IntPtr dst2, IntPtr dst3);
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern void cvSplit(ref CvSeq src, ref CvSeq dst0, IntPtr dst1, IntPtr dst2, IntPtr dst3);

		/// <summary>
		/// Merge 
		/// Composes multi-channel array from several single-channel arrays or inserts a 
		/// single channel into the array 
		/// </summary>
		/// <param name="src0 src3"></param>
		/// <returns></returns>
		public static void CvMerge(ref IplImage src0, ref IplImage src1, ref IplImage src2, ref IplImage src3, ref IplImage dst)
		{
			cvMerge(ref src0, ref src1, ref src2, ref src3, ref dst);
		}
		public static void CvMerge(ref CvMat src0, ref CvMat src1, ref CvMat src2, ref CvMat src3, ref CvMat dst)
		{
			cvMerge(ref src0, ref src1, ref src2, ref src3, ref dst);
		}
		public static void CvMerge(ref CvSeq src0, ref CvSeq src1, ref CvSeq src2, ref CvSeq src3, ref CvSeq dst)
		{
			cvMerge(ref src0, ref src1, ref src2, ref src3, ref dst);
		}
		public static void CvMerge(ref IplImage src0, ref IplImage src1, ref IplImage src2, ref IplImage dst)
		{
			cvMerge(ref src0, ref src1, ref src2, IntPtr.Zero, ref dst);
		}
		public static void CvMerge(ref CvMat src0, ref CvMat src1, ref CvMat src2, ref CvMat dst)
		{
			cvMerge(ref src0, ref src1, ref src2, IntPtr.Zero, ref dst);
		}
		public static void CvMerge(ref CvSeq src0, ref CvSeq src1, ref CvSeq src2, ref CvSeq dst)
		{
			cvMerge(ref src0, ref src1, ref src2, IntPtr.Zero, ref dst);
		}
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern void cvMerge(ref IplImage src0, ref IplImage src1, ref IplImage src2, ref IplImage src3, ref IplImage dst);
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern void cvMerge(ref CvMat src0, ref CvMat src1, ref CvMat src2, ref CvMat src3, ref CvMat dst);
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern void cvMerge(ref CvSeq src0, ref CvSeq src1, ref CvSeq src2, ref CvSeq src3, ref CvSeq dst);
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern void cvMerge(ref IplImage src0, ref IplImage src1, ref IplImage src2, IntPtr src3, ref IplImage dst);
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern void cvMerge(ref CvMat src0, ref CvMat src1, ref CvMat src2, IntPtr src3, ref CvMat dst);
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern void cvMerge(ref CvSeq src0, ref CvSeq src1, ref CvSeq src2, IntPtr src3, ref CvSeq dst);

		/// <summary>
		/// MixChannels 
		/// Copies several channels from input arrays to 
		/// certain channels of output arrays 
		/// </summary>
		/// <param name="src"></param>
		/// <returns></returns>
		public static void CvMixChannels(ref IplImage src, int src_count, ref IplImage dst, int dst_count, int[] from_to, int pair_count)
		{
			cvMixChannels(ref src.ptr, src_count, ref dst.ptr, dst_count, from_to, pair_count);
		}
		public static void CvMixChannels(ref CvMat src, int src_count, ref CvMat dst, int dst_count, int[] from_to, int pair_count)
		{
			cvMixChannels(ref src.ptr, src_count, ref dst.ptr, dst_count, from_to, pair_count);
		}
		public static void CvMixChannels(ref CvSeq src, int src_count, ref CvSeq dst, int dst_count, int[] from_to, int pair_count)
		{
			cvMixChannels(ref src.ptr, src_count, ref dst.ptr, dst_count, from_to, pair_count);
		}
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern void cvMixChannels(ref IntPtr src, int src_count, ref IntPtr dst, int dst_count, int[] from_to, int pair_count);

		/// <summary>
		/// RandShuffle 
		/// Randomly shuffles the array elements 
		/// </summary>
		/// <param name="mat"></param>
		/// <returns></returns>
		public static void CvRandShuffle(ref IplImage mat, ref UInt64 rng, double iter_factor)
		{
			cvRandShuffle(ref mat, ref rng, iter_factor);
		}
		public static void CvRandShuffle(ref CvMat mat, ref UInt64 rng, double iter_factor)
		{
			cvRandShuffle(ref mat, ref rng, iter_factor);
		}
		public static void CvRandShuffle(ref CvSeq mat, ref UInt64 rng, double iter_factor)
		{
			cvRandShuffle(ref mat, ref rng, iter_factor);
		}
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern void cvRandShuffle(ref IplImage mat, ref UInt64 rng, double iter_factor);
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern void cvRandShuffle(ref CvMat mat, ref UInt64 rng, double iter_factor);
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern void cvRandShuffle(ref CvSeq mat, ref UInt64 rng, double iter_factor);

		/// <summary>
		/// LUT 
		/// Performs look-up table transform of array 
		/// </summary>
		/// <param name="src"></param>
		/// <returns></returns>
		public static void CvLUT(ref IplImage src, ref IplImage dst, ref IplImage lut)
		{
			cvLUT(ref src, ref dst, ref lut);
		}
		public static void CvLUT(ref CvMat src, ref CvMat dst, ref CvMat lut)
		{
			cvLUT(ref src, ref dst, ref lut);
		}
		public static void CvLUT(ref CvSeq src, ref CvSeq dst, ref CvSeq lut)
		{
			cvLUT(ref src, ref dst, ref lut);
		}
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern void cvLUT(ref IplImage src, ref IplImage dst, ref IplImage lut);
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern void cvLUT(ref CvMat src, ref CvMat dst, ref CvMat lut);
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern void cvLUT(ref CvSeq src, ref CvSeq dst, ref CvSeq lut);

		/// <summary>
		/// ConvertScale 
		/// Converts one array to another with optional linear transformation 
		/// </summary>
		/// <param name="src"></param>
		/// <returns></returns>
		public static void CvConvertScale(ref IplImage src, ref IplImage dst, double scale, double shift)
		{
			cvConvertScale(ref src, ref dst, scale, shift);
		}
		public static void CvConvertScale(ref CvMat src, ref CvMat dst, double scale, double shift)
		{
			cvConvertScale(ref src, ref dst, scale, shift);
		}
		public static void CvConvertScale(ref CvSeq src, ref CvSeq dst, double scale, double shift)
		{
			cvConvertScale(ref src, ref dst, scale, shift);
		}
		public static void CvConvertScale(IntPtr src, IntPtr dst, double scale, double shift)
		{
			cvConvertScale(src, dst, scale, shift);
		}
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern void cvConvertScale(ref IplImage src, ref IplImage dst, double scale, double shift);
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern void cvConvertScale(ref CvMat src, ref CvMat dst, double scale, double shift);
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern void cvConvertScale(ref CvSeq src, ref CvSeq dst, double scale, double shift);
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern void cvConvertScale(IntPtr src,IntPtr dst, double scale, double shift);

		/// <summary>
		/// ConvertScaleAbs 
		/// Converts input array elements to 8-bit uint integer another with optional linear transformation 
		/// </summary>
		/// <param name="src"></param>
		/// <returns></returns>
		public static void CvConvertScaleAbs(ref IplImage src, ref IplImage dst, double scale, double shift)
		{
			cvConvertScaleAbs(ref src, ref dst, scale, shift);
		}
		public static void CvConvertScaleAbs(ref CvMat src, ref CvMat dst, double scale, double shift)
		{
			cvConvertScaleAbs(ref src, ref dst, scale, shift);
		}
		public static void CvConvertScaleAbs(ref CvSeq src, ref CvSeq dst, double scale, double shift)
		{
			cvConvertScaleAbs(ref src, ref dst, scale, shift);
		}
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern void cvConvertScaleAbs(ref IplImage src, ref IplImage dst, double scale, double shift);
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern void cvConvertScaleAbs(ref CvMat src, ref CvMat dst, double scale, double shift);
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern void cvConvertScaleAbs(ref CvSeq src, ref CvSeq dst, double scale, double shift);

		/// <summary>
		/// Add 
		/// Computes per-element sum of two arrays 
		/// </summary>
		/// <param name="src1"></param>
		/// <returns></returns>
		public static void CvAdd(ref IplImage src1, ref IplImage src2, ref IplImage dst, ref IplImage mask)
		{
			cvAdd(ref src1, ref src2, ref dst, ref mask);
		}
		public static void CvAdd(ref CvMat src1, ref CvMat src2, ref CvMat dst, ref CvMat mask)
		{
			cvAdd(ref src1, ref src2, ref dst, ref mask);
		}
		public static void CvAdd(ref CvSeq src1, ref CvSeq src2, ref CvSeq dst, ref CvSeq mask)
		{
			cvAdd(ref src1, ref src2, ref dst, ref mask);
		}
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern void cvAdd(ref IplImage src1, ref IplImage src2, ref IplImage dst, ref IplImage mask);
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern void cvAdd(ref CvMat src1, ref CvMat src2, ref CvMat dst, ref CvMat mask);
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern void cvAdd(ref CvSeq src1, ref CvSeq src2, ref CvSeq dst, ref CvSeq mask);

		public static void CvAdd(ref IplImage src1, ref IplImage src2, ref IplImage dst)
		{
			cvAdd(ref src1, ref src2, ref dst, IntPtr.Zero);
		}
		public static void CvAdd(ref CvMat src1, ref CvMat src2, ref CvMat dst)
		{
			cvAdd(ref src1, ref src2, ref dst, IntPtr.Zero);
		}
		public static void CvAdd(ref CvSeq src1, ref CvSeq src2, ref CvSeq dst)
		{
			cvAdd(ref src1, ref src2, ref dst, IntPtr.Zero);
		}
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern void cvAdd(ref IplImage src1, ref IplImage src2, ref IplImage dst, IntPtr mask);
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern void cvAdd(ref CvMat src1, ref CvMat src2, ref CvMat dst, IntPtr mask);
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern void cvAdd(ref CvSeq src1, ref CvSeq src2, ref CvSeq dst, IntPtr mask);

		/// <summary>
		/// AddS 
		/// Computes sum of array and scalar 
		/// </summary>
		/// <param name="src"></param>
		/// <returns></returns>
		public static void CvAddS(ref IplImage src, CvScalar value, ref IplImage dst, ref IplImage mask)
		{
			cvAddS(ref src, value, ref dst, ref mask);
		}
		public static void CvAddS(ref CvMat src, CvScalar value, ref CvMat dst, ref CvMat mask)
		{
			cvAddS(ref src, value, ref dst, ref mask);
		}
		public static void CvAddS(ref CvSeq src, CvScalar value, ref CvSeq dst, ref CvSeq mask)
		{
			cvAddS(ref src, value, ref dst, ref mask);
		}
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern void cvAddS(ref IplImage src, CvScalar value, ref IplImage dst, ref IplImage mask);
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern void cvAddS(ref CvMat src, CvScalar value, ref CvMat dst, ref CvMat mask);
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern void cvAddS(ref CvSeq src, CvScalar value, ref CvSeq dst, ref CvSeq mask);

		public static void CvAddS(ref IplImage src, CvScalar value, ref IplImage dst)
		{
			cvAddS(ref src, value, ref dst, IntPtr.Zero);
		}
		public static void CvAddS(ref CvMat src, CvScalar value, ref CvMat dst)
		{
			cvAddS(ref src, value, ref dst, IntPtr.Zero);
		}
		public static void CvAddS(ref CvSeq src, CvScalar value, ref CvSeq dst)
		{
			cvAddS(ref src, value, ref dst, IntPtr.Zero);
		}
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern void cvAddS(ref IplImage src, CvScalar value, ref IplImage dst, IntPtr mask);
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern void cvAddS(ref CvMat src, CvScalar value, ref CvMat dst, IntPtr mask);
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern void cvAddS(ref CvSeq src, CvScalar value, ref CvSeq dst, IntPtr mask);

		/// <summary>
		/// AddWeighted 
		/// Computes weighted sum of two arrays 
		/// </summary>
		/// <param name="src1"></param>
		/// <returns></returns>
		public static void CvAddWeighted(ref IplImage src1, double alpha, ref IplImage src2, double beta, double gamma, ref IplImage dst)
		{
			cvAddWeighted(ref src1, alpha, ref src2, beta, gamma, ref dst);
		}
		public static void CvAddWeighted(ref CvMat src1, double alpha, ref CvMat src2, double beta, double gamma, ref CvMat dst)
		{
			cvAddWeighted(ref src1, alpha, ref src2, beta, gamma, ref dst);
		}
		public static void CvAddWeighted(ref CvSeq src1, double alpha, ref CvSeq src2, double beta, double gamma, ref CvSeq dst)
		{
			cvAddWeighted(ref src1, alpha, ref src2, beta, gamma, ref dst);
		}
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern void cvAddWeighted(ref IplImage src1, double alpha, ref IplImage src2, double beta, double gamma, ref IplImage dst);
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern void cvAddWeighted(ref CvMat src1, double alpha, ref CvMat src2, double beta, double gamma, ref CvMat dst);
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern void cvAddWeighted(ref CvSeq src1, double alpha, ref CvSeq src2, double beta, double gamma, ref CvSeq dst);

		/// <summary>
		/// Sub 
		/// Computes per-element difference between two arrays 
		/// </summary>
		/// <param name="src1"></param>
		/// <returns></returns>
		public static void CvSub(ref IplImage src1, ref IplImage src2, ref IplImage dst, ref IplImage mask)
		{
			cvSub(ref src1, ref src2, ref dst, ref mask);
		}
		public static void CvSub(ref CvMat src1, ref CvMat src2, ref CvMat dst, ref CvMat mask)
		{
			cvSub(ref src1, ref src2, ref dst, ref mask);
		}
		public static void CvSub(ref CvSeq src1, ref CvSeq src2, ref CvSeq dst, ref CvSeq mask)
		{
			cvSub(ref src1, ref src2, ref dst, ref mask);
		}
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern void cvSub(ref IplImage src1, ref IplImage src2, ref IplImage dst, ref IplImage mask);
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern void cvSub(ref CvMat src1, ref CvMat src2, ref CvMat dst, ref CvMat mask);
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern void cvSub(ref CvSeq src1, ref CvSeq src2, ref CvSeq dst, ref CvSeq mask);

		/// <summary>
		/// SubS 
		/// Computes difference between array and scalar 
		/// </summary>
		/// <param name="src"></param>
		/// <returns></returns>
		public static void CvSubS(ref IplImage src, CvScalar value, ref IplImage dst, ref IplImage mask)
		{
			cvSubS(ref src, value, ref dst, ref mask);
		}
		public static void CvSubS(ref CvMat src, CvScalar value, ref CvMat dst, ref CvMat mask)
		{
			cvSubS(ref src, value, ref dst, ref mask);
		}
		public static void CvSubS(ref CvSeq src, CvScalar value, ref CvSeq dst, ref CvSeq mask)
		{
			cvSubS(ref src, value, ref dst, ref mask);
		}
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern void cvSubS(ref IplImage src, CvScalar value, ref IplImage dst, ref IplImage mask);
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern void cvSubS(ref CvMat src, CvScalar value, ref CvMat dst, ref CvMat mask);
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern void cvSubS(ref CvSeq src, CvScalar value, ref CvSeq dst, ref CvSeq mask);

		/// <summary>
		/// SubRS 
		/// Computes difference between scalar and array 
		/// </summary>
		/// <param name="src"></param>
		/// <returns></returns>
		public static void CvSubRS(ref IplImage src, CvScalar value, ref IplImage dst, ref IplImage mask)
		{
			cvSubRS(ref src, value, ref dst, ref mask);
		}
		public static void CvSubRS(ref CvMat src, CvScalar value, ref CvMat dst, ref CvMat mask)
		{
			cvSubRS(ref src, value, ref dst, ref mask);
		}
		public static void CvSubRS(ref CvSeq src, CvScalar value, ref CvSeq dst, ref CvSeq mask)
		{
			cvSubRS(ref src, value, ref dst, ref mask);
		}
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern void cvSubRS(ref IplImage src, CvScalar value, ref IplImage dst, ref IplImage mask);
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern void cvSubRS(ref CvMat src, CvScalar value, ref CvMat dst, ref CvMat mask);
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern void cvSubRS(ref CvSeq src, CvScalar value, ref CvSeq dst, ref CvSeq mask);

		/// <summary>
		/// Mul 
		/// Calculates per-element product of two arrays 
		/// </summary>
		/// <param name="src1"></param>
		/// <returns></returns>
		public static void CvMul(ref IplImage src1, ref IplImage src2, ref IplImage dst, double scale)
		{
			cvMul(ref src1, ref src2, ref dst, scale);
		}
		public static void CvMul(ref CvMat src1, ref CvMat src2, ref CvMat dst, double scale)
		{
			cvMul(ref src1, ref src2, ref dst, scale);
		}
		public static void CvMul(ref CvSeq src1, ref CvSeq src2, ref CvSeq dst, double scale)
		{
			cvMul(ref src1, ref src2, ref dst, scale);
		}
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern void cvMul(ref IplImage src1, ref IplImage src2, ref IplImage dst, double scale);
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern void cvMul(ref CvMat src1, ref CvMat src2, ref CvMat dst, double scale);
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern void cvMul(ref CvSeq src1, ref CvSeq src2, ref CvSeq dst, double scale);

		/// <summary>
		/// Div 
		/// Performs per-element division of two arrays 
		/// </summary>
		/// <param name="src1"></param>
		/// <returns></returns>
		public static void CvDiv(ref IplImage src1, ref IplImage src2, ref IplImage dst, double scale)
		{
			cvDiv(ref src1, ref src2, ref dst, scale);
		}
		public static void CvDiv(ref CvMat src1, ref CvMat src2, ref CvMat dst, double scale)
		{
			cvDiv(ref src1, ref src2, ref dst, scale);
		}
		public static void CvDiv(ref CvSeq src1, ref CvSeq src2, ref CvSeq dst, double scale)
		{
			cvDiv(ref src1, ref src2, ref dst, scale);
		}
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern void cvDiv(ref IplImage src1, ref IplImage src2, ref IplImage dst, double scale);
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern void cvDiv(ref CvMat src1, ref CvMat src2, ref CvMat dst, double scale);
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern void cvDiv(ref CvSeq src1, ref CvSeq src2, ref CvSeq dst, double scale);

		/// <summary>
		/// And 
		/// Calculates per-element bit-wise conjunction of two arrays 
		/// </summary>
		/// <param name="src1"></param>
		/// <returns></returns>
		public static void CvAnd(ref IplImage src1, ref IplImage src2, ref IplImage dst, ref IplImage mask)
		{
			cvAnd(ref src1, ref src2, ref dst, ref mask);
		}
		public static void CvAnd(ref CvMat src1, ref CvMat src2, ref CvMat dst, ref CvMat mask)
		{
			cvAnd(ref src1, ref src2, ref dst, ref mask);
		}
		public static void CvAnd(ref CvSeq src1, ref CvSeq src2, ref CvSeq dst, ref CvSeq mask)
		{
			cvAnd(ref src1, ref src2, ref dst, ref mask);
		}
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern void cvAnd(ref IplImage src1, ref IplImage src2, ref IplImage dst, ref IplImage mask);
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern void cvAnd(ref CvMat src1, ref CvMat src2, ref CvMat dst, ref CvMat mask);
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern void cvAnd(ref CvSeq src1, ref CvSeq src2, ref CvSeq dst, ref CvSeq mask);

		/// <summary>
		/// AndS 
		/// Calculates per-element bit-wise conjunction of array and scalar 
		/// </summary>
		/// <param name="src"></param>
		/// <returns></returns>
		public static void CvAndS(ref IplImage src, CvScalar value, ref IplImage dst, ref IplImage mask)
		{
			cvAndS(ref src, value, ref dst, ref mask);
		}
		public static void CvAndS(ref CvMat src, CvScalar value, ref CvMat dst, ref CvMat mask)
		{
			cvAndS(ref src, value, ref dst, ref mask);
		}
		public static void CvAndS(ref CvSeq src, CvScalar value, ref CvSeq dst, ref CvSeq mask)
		{
			cvAndS(ref src, value, ref dst, ref mask);
		}
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern void cvAndS(ref IplImage src, CvScalar value, ref IplImage dst, ref IplImage mask);
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern void cvAndS(ref CvMat src, CvScalar value, ref CvMat dst, ref CvMat mask);
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern void cvAndS(ref CvSeq src, CvScalar value, ref CvSeq dst, ref CvSeq mask);

		/// <summary>
		/// Or 
		/// Calculates per-element bit-wise disjunction of two arrays 
		/// </summary>
		/// <param name="src1"></param>
		/// <returns></returns>
		public static void CvOr(ref IplImage src1, ref IplImage src2, ref IplImage dst, ref IplImage mask)
		{
			cvOr(ref src1, ref src2, ref dst, ref mask);
		}
		public static void CvOr(ref CvMat src1, ref CvMat src2, ref CvMat dst, ref CvMat mask)
		{
			cvOr(ref src1, ref src2, ref dst, ref mask);
		}
		public static void CvOr(ref CvSeq src1, ref CvSeq src2, ref CvSeq dst, ref CvSeq mask)
		{
			cvOr(ref src1, ref src2, ref dst, ref mask);
		}
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern void cvOr(ref IplImage src1, ref IplImage src2, ref IplImage dst, ref IplImage mask);
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern void cvOr(ref CvMat src1, ref CvMat src2, ref CvMat dst, ref CvMat mask);
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern void cvOr(ref CvSeq src1, ref CvSeq src2, ref CvSeq dst, ref CvSeq mask);

		/// <summary>
		/// OrS 
		/// Calculates per-element bit-wise disjunction of array and scalar 
		/// </summary>
		/// <param name="src1"></param>
		/// <returns></returns>
		public static void CvOrS(ref IplImage src, CvScalar value, ref IplImage dst, ref IplImage mask)
		{
			cvOrS(ref src, value, ref dst, ref mask);
		}
		public static void CvOrS(ref CvMat src, CvScalar value, ref CvMat dst, ref CvMat mask)
		{
			cvOrS(ref src, value, ref dst, ref mask);
		}
		public static void CvOrS(ref CvSeq src, CvScalar value, ref CvSeq dst, ref CvSeq mask)
		{
			cvOrS(ref src, value, ref dst, ref mask);
		}
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern void cvOrS(ref IplImage src, CvScalar value, ref IplImage dst, ref IplImage mask);
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern void cvOrS(ref CvMat src, CvScalar value, ref CvMat dst, ref CvMat mask);
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern void cvOrS(ref CvSeq src, CvScalar value, ref CvSeq dst, ref CvSeq mask);

		/// <summary>
		/// Xor 
		/// Performs per-element bit-wise exclusive or operation on two arrays 
		/// </summary>
		/// <param name="src1"></param>
		/// <returns></returns>
		public static void CvXor(ref IplImage src1, ref IplImage src2, ref IplImage dst, ref IplImage mask)
		{
			cvXor(ref src1, ref src2, ref dst, ref mask);
		}
		public static void CvXor(ref CvMat src1, ref CvMat src2, ref CvMat dst, ref CvMat mask)
		{
			cvXor(ref src1, ref src2, ref dst, ref mask);
		}
		public static void CvXor(ref CvSeq src1, ref CvSeq src2, ref CvSeq dst, ref CvSeq mask)
		{
			cvXor(ref src1, ref src2, ref dst, ref mask);
		}
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern void cvXor(ref IplImage src1, ref IplImage src2, ref IplImage dst, ref IplImage mask);
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern void cvXor(ref CvMat src1, ref CvMat src2, ref CvMat dst, ref CvMat mask);
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern void cvXor(ref CvSeq src1, ref CvSeq src2, ref CvSeq dst, ref CvSeq mask);

		/// <summary>
		/// XorS 
		/// Performs per-element bit-wise exclusive or operation on array and scalar 
		/// </summary>
		/// <param name="src"></param>
		/// <returns></returns>
		public static void CvXorS(ref IplImage src, CvScalar value, ref IplImage dst, ref IplImage mask)
		{
			cvXorS(ref src, value, ref dst, ref mask);
		}
		public static void CvXorS(ref CvMat src, CvScalar value, ref CvMat dst, ref CvMat mask)
		{
			cvXorS(ref src, value, ref dst, ref mask);
		}
		public static void CvXorS(ref CvSeq src, CvScalar value, ref CvSeq dst, ref CvSeq mask)
		{
			cvXorS(ref src, value, ref dst, ref mask);
		}
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern void cvXorS(ref IplImage src, CvScalar value, ref IplImage dst, ref IplImage mask);
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern void cvXorS(ref CvMat src, CvScalar value, ref CvMat dst, ref CvMat mask);
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern void cvXorS(ref CvSeq src, CvScalar value, ref CvSeq dst, ref CvSeq mask);

		/// <summary>
		/// Not 
		/// Performs per-element bit-wise inversion of array elements 
		/// </summary>
		/// <param name="src1"></param>
		/// <returns></returns>
		public static void CvNot(ref IplImage src, ref IplImage dst)
		{
			cvNot(ref src, ref dst);
		}
		public static void CvNot(ref CvMat src, ref CvMat dst)
		{
			cvNot(ref src, ref dst);
		}
		public static void CvNot(ref CvSeq src, ref CvSeq dst)
		{
			cvNot(ref src, ref dst);
		}
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern void cvNot(ref IplImage src, ref IplImage dst);
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern void cvNot(ref CvMat src, ref CvMat dst);
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern void cvNot(ref CvSeq src, ref CvSeq dst);

		/// <summary>
		/// Cmp 
		/// Performs per-element comparison of two arrays 
		/// </summary>
		/// <param name="src1"></param>
		/// <returns></returns>
		public static void CvCmp(ref IplImage src1, ref IplImage src2, ref IplImage dst, int cmp_op)
		{
			cvCmp(ref src1, ref src2, ref dst, cmp_op);
		}
		public static void CvCmp(ref CvMat src1, ref CvMat src2, ref CvMat dst, int cmp_op)
		{
			cvCmp(ref src1, ref src2, ref dst, cmp_op);
		}
		public static void CvCmp(ref CvSeq src1, ref CvSeq src2, ref CvSeq dst, int cmp_op)
		{
			cvCmp(ref src1, ref src2, ref dst, cmp_op);
		}
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern void cvCmp(ref IplImage src1, ref IplImage src2, ref IplImage dst, int cmp_op);
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern void cvCmp(ref CvMat src1, ref CvMat src2, ref CvMat dst, int cmp_op);
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern void cvCmp(ref CvSeq src1, ref CvSeq src2, ref CvSeq dst, int cmp_op);

		/// <summary>
		/// CmpS 
		/// Performs per-element comparison of array and scalar 
		/// </summary>
		/// <param name="src"></param>
		/// <returns></returns>
		public static void CvCmpS(ref IplImage src, double value, ref IplImage dst, int cmp_op)
		{
			cvCmpS(ref src, value, ref dst, cmp_op);
		}
		public static void CvCmpS(ref CvMat src, double value, ref CvMat dst, int cmp_op)
		{
			cvCmpS(ref src, value, ref dst, cmp_op);
		}
		public static void CvCmpS(ref CvSeq src, double value, ref CvSeq dst, int cmp_op)
		{
			cvCmpS(ref src, value, ref dst, cmp_op);
		}
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern void cvCmpS(ref IplImage src, double value, ref IplImage dst, int cmp_op);
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern void cvCmpS(ref CvMat src, double value, ref CvMat dst, int cmp_op);
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern void cvCmpS(ref CvSeq src, double value, ref CvSeq dst, int cmp_op);

		/// <summary>
		/// InRange 
		/// Checks that array elements lie between elements of two other arrays 
		/// </summary>
		/// <param name="src"></param>
		/// <returns></returns>
		public static void CvInRange(ref IplImage src, ref IplImage lower, ref IplImage upper, ref IplImage dst)
		{
			cvInRange(ref src, ref lower, ref upper, ref dst);
		}
		public static void CvInRange(ref CvMat src, ref CvMat lower, ref CvMat upper, ref CvMat dst)
		{
			cvInRange(ref src, ref lower, ref upper, ref dst);
		}
		public static void CvInRange(ref CvSeq src, ref CvSeq lower, ref CvSeq upper, ref CvSeq dst)
		{
			cvInRange(ref src, ref lower, ref upper, ref dst);
		}
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern void cvInRange(ref IplImage src, ref IplImage lower, ref IplImage upper, ref IplImage dst);
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern void cvInRange(ref CvMat src, ref CvMat lower, ref CvMat upper, ref CvMat dst);
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern void cvInRange(ref CvSeq src, ref CvSeq lower, ref CvSeq upper, ref CvSeq dst);

		/// <summary>
		/// InRangeS 
		/// Checks that array elements lie between two scalars 
		/// </summary>
		/// <param name="src"></param>
		/// <returns></returns>
		public static void CvInRangeS(ref IplImage src, CvScalar lower, CvScalar upper, ref IplImage dst)
		{
			cvInRangeS(ref src, lower, upper, ref dst);
		}
		public static void CvInRangeS(ref CvMat src, CvScalar lower, CvScalar upper, ref CvMat dst)
		{
			cvInRangeS(ref src, lower, upper, ref dst);
		}
		public static void CvInRangeS(ref CvSeq src, CvScalar lower, CvScalar upper, ref CvSeq dst)
		{
			cvInRangeS(ref src, lower, upper, ref dst);
		}
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern void cvInRangeS(ref IplImage src, CvScalar lower, CvScalar upper, ref IplImage dst);
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern void cvInRangeS(ref CvMat src, CvScalar lower, CvScalar upper, ref CvMat dst);
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern void cvInRangeS(ref CvSeq src, CvScalar lower, CvScalar upper, ref CvSeq dst);

		/// <summary>
		/// Max 
		/// Finds per-element maximum of two arrays 
		/// </summary>
		/// <param name="src1"></param>
		/// <returns></returns>
		public static void CvMax(ref IplImage src1, ref IplImage src2, ref IplImage dst)
		{
			cvMax(ref src1, ref src2, ref dst);
		}
		public static void CvMax(ref CvMat src1, ref CvMat src2, ref CvMat dst)
		{
			cvMax(ref src1, ref src2, ref dst);
		}
		public static void CvMax(ref CvSeq src1, ref CvSeq src2, ref CvSeq dst)
		{
			cvMax(ref src1, ref src2, ref dst);
		}
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern void cvMax(ref IplImage src1, ref IplImage src2, ref IplImage dst);
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern void cvMax(ref CvMat src1, ref CvMat src2, ref CvMat dst);
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern void cvMax(ref CvSeq src1, ref CvSeq src2, ref CvSeq dst);

		/// <summary>
		/// MaxS 
		/// Finds per-element maximum of array and scalar 
		/// </summary>
		/// <param name="src"></param>
		/// <returns></returns>
		public static void CvMaxS(ref IplImage src, double value, ref IplImage dst)
		{
			cvMaxS(ref src, value, ref dst);
		}
		public static void CvMaxS(ref CvMat src, double value, ref CvMat dst)
		{
			cvMaxS(ref src, value, ref dst);
		}
		public static void CvMaxS(ref CvSeq src, double value, ref CvSeq dst)
		{
			cvMaxS(ref src, value, ref dst);
		}
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern void cvMaxS(ref IplImage src, double value, ref IplImage dst);
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern void cvMaxS(ref CvMat src, double value, ref CvMat dst);
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern void cvMaxS(ref CvSeq src, double value, ref CvSeq dst);

		/// <summary>
		/// Min 
		/// Finds per-element minimum of two arrays 
		/// </summary>
		/// <param name="src1"></param>
		/// <returns></returns>
		public static void CvMin(ref IplImage src1, ref IplImage src2, ref IplImage dst)
		{
			cvMin(ref src1, ref src2, ref dst);
		}
		public static void CvMin(ref CvMat src1, ref CvMat src2, ref CvMat dst)
		{
			cvMin(ref src1, ref src2, ref dst);
		}
		public static void CvMin(ref CvSeq src1, ref CvSeq src2, ref CvSeq dst)
		{
			cvMin(ref src1, ref src2, ref dst);
		}
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern void cvMin(ref IplImage src1, ref IplImage src2, ref IplImage dst);
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern void cvMin(ref CvMat src1, ref CvMat src2, ref CvMat dst);
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern void cvMin(ref CvSeq src1, ref CvSeq src2, ref CvSeq dst);

		/// <summary>
		/// MinS 
		/// Finds per-element minimum of array and scalar 
		/// </summary>
		/// <param name="src"></param>
		/// <returns></returns>
		public static void CvMinS(ref IplImage src, double value, ref IplImage dst)
		{
			cvMinS(ref src, value, ref dst);
		}
		public static void CvMinS(ref CvMat src, double value, ref CvMat dst)
		{
			cvMinS(ref src, value, ref dst);
		}
		public static void CvMinS(ref CvSeq src, double value, ref CvSeq dst)
		{
			cvMinS(ref src, value, ref dst);
		}
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern void cvMinS(ref IplImage src, double value, ref IplImage dst);
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern void cvMinS(ref CvMat src, double value, ref CvMat dst);
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern void cvMinS(ref CvSeq src, double value, ref CvSeq dst);

		/// <summary>
		/// AbsDiff 
		/// Calculates absolute difference between two arrays 
		/// </summary>
		/// <param name="src1"></param>
		/// <returns></returns>
		public static void CvAbsDiff(ref IplImage src1, ref IplImage src2, ref IplImage dst)
		{
			cvAbsDiff(ref src1, ref src2, ref dst);
		}
		public static void CvAbsDiff(ref CvMat src1, ref CvMat src2, ref CvMat dst)
		{
			cvAbsDiff(ref src1, ref src2, ref dst);
		}
		public static void CvAbsDiff(ref CvSeq src1, ref CvSeq src2, ref CvSeq dst)
		{
			cvAbsDiff(ref src1, ref src2, ref dst);
		}
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern void cvAbsDiff(ref IplImage src1, ref IplImage src2, ref IplImage dst);
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern void cvAbsDiff(ref CvMat src1, ref CvMat src2, ref CvMat dst);
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern void cvAbsDiff(ref CvSeq src1, ref CvSeq src2, ref CvSeq dst);

		/// <summary>
		/// AbsDiffS 
		/// Calculates absolute difference between array and scalar 
		/// </summary>
		/// <param name="src"></param>
		/// <returns></returns>
		public static void CvAbsDiffS(ref IplImage src, ref IplImage dst, CvScalar value)
		{
			cvAbsDiffS(ref src, ref dst, value);
		}
		public static void CvAbsDiffS(ref CvMat src, ref CvMat dst, CvScalar value)
		{
			cvAbsDiffS(ref src, ref dst, value);
		}
		public static void CvAbsDiffS(ref CvSeq src, ref CvSeq dst, CvScalar value)
		{
			cvAbsDiffS(ref src, ref dst, value);
		}
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern void cvAbsDiffS(ref IplImage src, ref IplImage dst, CvScalar value);
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern void cvAbsDiffS(ref CvMat src, ref CvMat dst, CvScalar value);
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern void cvAbsDiffS(ref CvSeq src, ref CvSeq dst, CvScalar value);

		/// <summary>
		/// CountNonZero 
		/// Counts non-zero array elements 
		/// </summary>
		/// <param name="arr"></param>
		/// <returns></returns>
		public static int CvCountNonZero(ref IplImage arr)
		{
			return cvCountNonZero(ref arr);
		}
		public static int CvCountNonZero(ref CvMat arr)
		{
			return cvCountNonZero(ref arr);
		}
		public static int CvCountNonZero(ref CvSeq arr)
		{
			return cvCountNonZero(ref arr);
		}
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern int cvCountNonZero(ref IplImage arr);
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern int cvCountNonZero(ref CvMat arr);
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern int cvCountNonZero(ref CvSeq arr);

		/// <summary>
		/// Sum 
		/// Summarizes array elements 
		/// </summary>
		/// <param name="arr"></param>
		/// <returns></returns>
		public static CvScalar CvSum(ref IplImage arr)
		{
			return cvSum(ref arr);
		}
		public static CvScalar CvSum(ref CvMat arr)
		{
			return cvSum(ref arr);
		}
		public static CvScalar CvSum(ref CvSeq arr)
		{
			return cvSum(ref arr);
		}
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern CvScalar cvSum(ref IplImage arr);
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern CvScalar cvSum(ref CvMat arr);
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern CvScalar cvSum(ref CvSeq arr);

		/// <summary>
		/// Avg 
		/// Calculates average (mean) of array elements 
		/// </summary>
		/// <param name="arr"></param>
		/// <returns></returns>
		public static CvScalar CvAvg(ref IplImage arr, ref IplImage mask)
		{
			return cvAvg(ref arr, ref mask);
		}
		public static CvScalar CvAvg(ref CvMat arr, ref CvMat mask)
		{
			return cvAvg(ref arr, ref mask);
		}
		public static CvScalar CvAvg(ref CvSeq arr, ref CvSeq mask)
		{
			return cvAvg(ref arr, ref mask);
		}
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern CvScalar cvAvg(ref IplImage arr, ref IplImage mask);
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern CvScalar cvAvg(ref CvMat arr, ref CvMat mask);
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern CvScalar cvAvg(ref CvSeq arr, ref CvSeq mask);

		/// <summary>
		/// AvgSdv 
		/// Calculates average (mean) of array elements 
		/// </summary>
		/// <param name="arr"></param>
		/// <returns></returns>
		public static void CvAvgSdv(ref IplImage arr, ref CvScalar mean, ref CvScalar std_dev, ref IplImage mask)
		{
			cvAvgSdv(ref arr, ref mean, ref std_dev, ref mask);
		}
		public static void CvAvgSdv(ref CvMat arr, ref CvScalar mean, ref CvScalar std_dev, ref CvMat mask)
		{
			cvAvgSdv(ref arr, ref mean, ref std_dev, ref mask);
		}
		public static void CvAvgSdv(ref CvSeq arr, ref CvScalar mean, ref CvScalar std_dev, ref CvSeq mask)
		{
			cvAvgSdv(ref arr, ref mean, ref std_dev, ref mask);
		}
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern void cvAvgSdv(ref IplImage arr, ref CvScalar mean, ref CvScalar std_dev, ref IplImage mask);
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern void cvAvgSdv(ref CvMat arr, ref CvScalar mean, ref CvScalar std_dev, ref CvMat mask);
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern void cvAvgSdv(ref CvSeq arr, ref CvScalar mean, ref CvScalar std_dev, ref CvSeq mask);

		/// <summary>
		/// MinMaxLoc 
		/// Finds global minimum and maximum in array or subarray 
		/// </summary>
		/// <param name="arr"></param>
		/// <returns></returns>
		public static void CvMinMaxLoc(ref IplImage arr, out double min_val, out double max_val, ref CvPoint min_loc, ref CvPoint max_loc, ref IplImage mask)
		{
			cvMinMaxLoc(ref arr, out min_val, out max_val, ref  min_loc, ref max_loc, ref mask);
		}
		public static void CvMinMaxLoc(ref CvMat arr, out double min_val, out double max_val, ref CvPoint min_loc, ref CvPoint max_loc, ref CvMat mask)
		{
			cvMinMaxLoc(ref arr, out min_val, out max_val, ref  min_loc, ref max_loc, ref mask);
		}
		public static void CvMinMaxLoc(ref CvSeq arr, out double min_val, out double max_val, ref CvPoint min_loc, ref CvPoint max_loc, ref CvSeq mask)
		{
			cvMinMaxLoc(ref arr, out min_val, out max_val, ref min_loc, ref max_loc, ref mask);
		}
		public static void CvMinMaxLoc(ref IplImage arr, out double min_val, out double max_val, ref CvPoint min_loc, ref CvPoint max_loc)
		{
			cvMinMaxLoc(ref arr, out min_val, out max_val, ref min_loc, ref max_loc);
		}
		public static void CvMinMaxLoc(ref CvMat arr, out double min_val, out double max_val, ref CvPoint min_loc, ref CvPoint max_loc)
		{
			cvMinMaxLoc(ref arr, out min_val, out max_val, ref min_loc, ref max_loc);
		}
		public static void CvMinMaxLoc(ref CvSeq arr, out double min_val, out double max_val, ref CvPoint min_loc, ref CvPoint max_loc)
		{
			cvMinMaxLoc(ref arr, out min_val, out max_val, ref min_loc, ref max_loc);
		}
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern void cvMinMaxLoc(ref IplImage arr, out double min_val, out double max_val, ref CvPoint min_loc, ref CvPoint max_loc, ref IplImage mask);
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern void cvMinMaxLoc(ref CvMat arr, out double min_val, out double max_val, ref CvPoint min_loc, ref CvPoint max_loc, ref CvMat mask);
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern void cvMinMaxLoc(ref CvSeq arr, out double min_val, out double max_val, ref CvPoint min_loc, ref CvPoint max_loc, ref CvSeq mask);
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern void cvMinMaxLoc(ref IplImage arr, out double min_val, out double max_val, ref CvPoint min_loc, ref CvPoint max_loc);
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern void cvMinMaxLoc(ref CvMat arr, out double min_val, out double max_val, ref CvPoint min_loc, ref CvPoint max_loc);
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern void cvMinMaxLoc(ref CvSeq arr, out double min_val, out double max_val, ref CvPoint min_loc, ref CvPoint max_loc);

		/// <summary>
		/// Norm 
		/// Calculates absolute array norm, absolute difference norm or relative difference norm 
		/// </summary>
		/// <param name="arr1"></param>
		/// <returns></returns>
		public static double CvNorm(ref IplImage arr1, ref IplImage arr2, int norm_type, IntPtr mask)
		{
			return cvNorm(ref arr1, ref arr2, norm_type, mask);
		}
		public static double CvNorm(ref CvMat arr1, ref CvMat arr2, int norm_type, IntPtr mask)
		{
			return cvNorm(ref arr1, ref arr2, norm_type, mask);
		}
		public static double CvNorm(ref CvSeq arr1, ref CvSeq arr2, int norm_type, IntPtr mask)
		{
			return cvNorm(ref arr1, ref arr2, norm_type, mask);
		}
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern double cvNorm(ref IplImage arr1, ref IplImage arr2, int norm_type, IntPtr mask);
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern double cvNorm(ref CvMat arr1, ref CvMat arr2, int norm_type, IntPtr mask);
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern double cvNorm(ref CvSeq arr1, ref CvSeq arr2, int norm_type, IntPtr mask);

		/// <summary>
		/// Reduce 
		/// Reduces matrix to a vector 
		/// </summary>
		/// <param name="src"></param>
		/// <returns></returns>
		public static void CvReduce(ref IplImage src, ref IplImage dst, int op)
		{
			cvReduce(ref src, ref dst, op);
		}
		public static void CvReduce(ref CvMat src, ref CvMat dst, int op)
		{
			cvReduce(ref src, ref dst, op);
		}
		public static void CvReduce(ref CvSeq src, ref CvSeq dst, int op)
		{
			cvReduce(ref src, ref dst, op);
		}
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern void cvReduce(ref IplImage src, ref IplImage dst, int op);
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern void cvReduce(ref CvMat src, ref CvMat dst, int op);
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern void cvReduce(ref CvSeq src, ref CvSeq dst, int op);

		/// <summary>
		/// DotProduct 
		/// Calculates dot product of two arrays in Euclidian metrics 
		/// </summary>
		/// <param name="src1"></param>
		/// <returns></returns>
		public static double CvDotProduct(ref IplImage src1, ref IplImage src2)
		{
			return cvDotProduct(ref src1, ref src2);
		}
		public static double CvDotProduct(ref CvMat src1, ref CvMat src2)
		{
			return cvDotProduct(ref src1, ref src2);
		}
		public static double CvDotProduct(ref CvSeq src1, ref CvSeq src2)
		{
			return cvDotProduct(ref src1, ref src2);
		}
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern double cvDotProduct(ref IplImage src1, ref IplImage src2);
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern double cvDotProduct(ref CvMat src1, ref CvMat src2);
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern double cvDotProduct(ref CvSeq src1, ref CvSeq src2);

		/// <summary>
		/// Normalize 
		/// Normalizes array to a certain norm or value range 
		/// </summary>
		/// <param name="src"></param>
		/// <returns></returns>
		public static void CvNormalize(ref IplImage src, ref IplImage dst, double a, double b, int norm_type, ref IplImage mask)
		{
			cvNormalize(ref src, ref dst, a, b, norm_type, ref mask);
		}
		public static void CvNormalize(ref CvMat src, ref CvMat dst, double a, double b, int norm_type, ref CvMat mask)
		{
			cvNormalize(ref src, ref dst, a, b, norm_type, ref mask);
		}
		public static void CvNormalize(ref CvSeq src, ref CvSeq dst, double a, double b, int norm_type, ref CvSeq mask)
		{
			cvNormalize(ref src, ref dst, a, b, norm_type, ref mask);
		}
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern void cvNormalize(ref IplImage src, ref IplImage dst, double a, double b, int norm_type, ref IplImage mask);
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern void cvNormalize(ref CvMat src, ref CvMat dst, double a, double b, int norm_type, ref CvMat mask);
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern void cvNormalize(ref CvSeq src, ref CvSeq dst, double a, double b, int norm_type, ref CvSeq mask);

		/// <summary>
		/// CrossProduct 
		/// Calculates cross product of two 3D vectors 
		/// </summary>
		/// <param name="src1"></param>
		/// <returns></returns>
		public static void CvCrossProduct(ref IplImage src1, ref IplImage src2, ref IplImage dst)
		{
			cvCrossProduct(ref src1, ref src2, ref dst);
		}
		public static void CvCrossProduct(ref CvMat src1, ref CvMat src2, ref CvMat dst)
		{
			cvCrossProduct(ref src1, ref src2, ref dst);
		}
		public static void CvCrossProduct(ref CvSeq src1, ref CvSeq src2, ref CvSeq dst)
		{
			cvCrossProduct(ref src1, ref src2, ref dst);
		}
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern void cvCrossProduct(ref IplImage src1, ref IplImage src2, ref IplImage dst);
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern void cvCrossProduct(ref CvMat src1, ref CvMat src2, ref CvMat dst);
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern void cvCrossProduct(ref CvSeq src1, ref CvSeq src2, ref CvSeq dst);

		/// <summary>
		/// ScaleAdd 
		/// Calculates sum of scaled array and another array 
		/// </summary>
		/// <param name="src1"></param>
		/// <returns></returns>
		public static void CvScaleAdd(ref IplImage src1, CvScalar scale, ref IplImage src2, ref IplImage dst)
		{
			cvScaleAdd(ref src1, scale, ref src2, ref dst);
		}
		public static void CvScaleAdd(ref CvMat src1, CvScalar scale, ref CvMat src2, ref CvMat dst)
		{
			cvScaleAdd(ref src1, scale, ref src2, ref dst);
		}
		public static void CvScaleAdd(ref CvSeq src1, CvScalar scale, ref CvSeq src2, ref CvSeq dst)
		{
			cvScaleAdd(ref src1, scale, ref src2, ref dst);
		}
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern void cvScaleAdd(ref IplImage src1, CvScalar scale, ref IplImage src2, ref IplImage dst);
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern void cvScaleAdd(ref CvMat src1, CvScalar scale, ref CvMat src2, ref CvMat dst);
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern void cvScaleAdd(ref CvSeq src1, CvScalar scale, ref CvSeq src2, ref CvSeq dst);

		/// <summary>
		/// GEMM 
		/// Performs generalized matrix multiplication 
		/// </summary>
		/// <param name="src1"></param>
		/// <returns></returns>
		public static void CvGEMM(ref IplImage src1, ref IplImage src2, double alpha, ref IplImage src3, double beta, ref IplImage dst, int tABC)
		{
			cvGEMM(ref src1, ref src2, alpha, ref src3, beta, ref dst, tABC);
		}
		public static void CvGEMM(ref CvMat src1, ref CvMat src2, double alpha, ref CvMat src3, double beta, ref CvMat dst, int tABC)
		{
			cvGEMM(ref src1, ref src2, alpha, ref src3, beta, ref dst, tABC);
		}
		public static void CvGEMM(ref CvSeq src1, ref CvSeq src2, double alpha, ref CvSeq src3, double beta, ref CvSeq dst, int tABC)
		{
			cvGEMM(ref src1, ref src2, alpha, ref src3, beta, ref dst, tABC);
		}
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern void cvGEMM(ref IplImage src1, ref IplImage src2, double alpha, ref IplImage src3, double beta, ref IplImage dst, int tABC);
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern void cvGEMM(ref CvMat src1, ref CvMat src2, double alpha, ref CvMat src3, double beta, ref CvMat dst, int tABC);
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern void cvGEMM(ref CvSeq src1, ref CvSeq src2, double alpha, ref CvSeq src3, double beta, ref CvSeq dst, int tABC);
		
		// #defines
		public static void CvMatMulAdd(ref IplImage src1, ref IplImage src2, ref IplImage src3, ref IplImage dst)
		{
			cvGEMM(ref src1, ref src2, 1, ref src3, 1, ref dst, 0);
		}
		public static void CvMatMulAdd(ref CvMat src1, ref CvMat src2, ref CvMat src3, ref CvMat dst)
		{
			cvGEMM(ref src1, ref src2, 1, ref src3, 1, ref dst, 0);
		}
		public static void CvMatMulAdd(ref CvSeq src1, ref CvSeq src2, ref CvSeq src3, ref CvSeq dst)
		{
			cvGEMM(ref src1, ref src2, 1, ref src3, 1, ref dst, 0);
		}
		//public static void CvMatMul(ref IplImage src1, ref IplImage src2, ref IplImage dst)
		//{
		//  cvGEMM(ref src1, ref src2, 1, ref (IplImage)0, 1, ref dst, 0);
		//}
		//public static void CvMatMul(ref CvMat src1, ref CvMat src2, ref CvMat dst)
		//{
		//  cvGEMM(ref src1, ref src2, 1, ref null, 1, ref dst, 0);
		//}
		//public static void CvMatMul(ref CvSeq src1, ref CvSeq src2, ref CvSeq dst)
		//{
		//  cvGEMM(ref src1, ref src2, 1, ref null, 1, ref dst, 0);
		//}

		/// <summary>
		/// Transform 
		/// Performs matrix transform of every array element 
		/// </summary>
		/// <param name="src"></param>
		/// <returns></returns>
		public static void CvTransform(ref IplImage src, ref IplImage dst, ref CvMat transmat, ref CvMat shiftvec)
		{
			cvTransform(ref src, ref dst, ref transmat, ref shiftvec);
		}
		public static void CvTransform(ref CvMat src, ref CvMat dst, ref CvMat transmat, ref CvMat shiftvec)
		{
			cvTransform(ref src, ref dst, ref transmat, ref shiftvec);
		}
		public static void CvTransform(ref CvSeq src, ref CvSeq dst, ref CvMat transmat, ref CvMat shiftvec)
		{
			cvTransform(ref src, ref dst, ref transmat, ref shiftvec);
		}
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern void cvTransform(ref IplImage src, ref IplImage dst, ref CvMat transmat, ref CvMat shiftvec);
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern void cvTransform(ref CvMat src, ref CvMat dst, ref CvMat transmat, ref CvMat shiftvec);
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern void cvTransform(ref CvSeq src, ref CvSeq dst, ref CvMat transmat, ref CvMat shiftvec);

		/// <summary>
		/// PerspectiveTransform 
		/// Performs perspective matrix transform of vector array 
		/// </summary>
		/// <param name="src"></param>
		/// <returns></returns>
		public static void CvPerspectiveTransform(ref IplImage src, ref IplImage dst, ref CvMat mat)
		{
			cvPerspectiveTransform(ref src, ref dst, ref mat);
		}
		public static void CvPerspectiveTransform(ref CvMat src, ref CvMat dst, ref CvMat mat)
		{
			cvPerspectiveTransform(ref src, ref dst, ref mat);
		}
		public static void CvPerspectiveTransform(ref CvSeq src, ref CvSeq dst, ref CvMat mat)
		{
			cvPerspectiveTransform(ref src, ref dst, ref mat);
		}
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern void cvPerspectiveTransform(ref IplImage src, ref IplImage dst, ref CvMat mat);
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern void cvPerspectiveTransform(ref CvMat src, ref CvMat dst, ref CvMat mat);
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern void cvPerspectiveTransform(ref CvSeq src, ref CvSeq dst, ref CvMat mat);

		/// <summary>
		/// MulTransposed 
		/// Calculates product of array and transposed array 
		/// </summary>
		/// <param name="src"></param>
		/// <returns></returns>
		public static void CvMulTransposed(ref IplImage src, ref IplImage dst, int order, ref IplImage delta)
		{
			cvMulTransposed(ref src, ref dst, order, ref delta);
		}
		public static void CvMulTransposed(ref CvMat src, ref CvMat dst, int order, ref CvMat delta)
		{
			cvMulTransposed(ref src, ref dst, order, ref delta);
		}
		public static void CvMulTransposed(ref CvSeq src, ref CvSeq dst, int order, ref CvSeq delta)
		{
			cvMulTransposed(ref src, ref dst, order, ref delta);
		}
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern void cvMulTransposed(ref IplImage src, ref IplImage dst, int order, ref IplImage delta);
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern void cvMulTransposed(ref CvMat src, ref CvMat dst, int order, ref CvMat delta);
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern void cvMulTransposed(ref CvSeq src, ref CvSeq dst, int order, ref CvSeq delta);

		/// <summary>
		/// Trace 
		/// Returns trace of matrix 
		/// </summary>
		/// <param name="mat"></param>
		/// <returns></returns>
		public static CvScalar CvTrace(ref IplImage mat)
		{
			return cvTrace(ref mat);
		}
		public static CvScalar CvTrace(ref CvMat mat)
		{
			return cvTrace(ref mat);
		}
		public static CvScalar CvTrace(ref CvSeq mat)
		{
			return cvTrace(ref mat);
		}
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern CvScalar cvTrace(ref IplImage mat);
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern CvScalar cvTrace(ref CvMat mat);
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern CvScalar cvTrace(ref CvSeq mat);

		/// <summary>
		/// Transpose 
		/// Transposes matrix 
		/// </summary>
		/// <param name="src"></param>
		/// <returns></returns>
		public static void CvTranspose(ref IplImage src, ref IplImage dst)
		{
			cvTranspose(ref src, ref dst);
		}
		public static void CvTranspose(ref CvMat src, ref CvMat dst)
		{
			cvTranspose(ref src, ref dst);
		}
		public static void CvTranspose(ref CvSeq src, ref CvSeq dst)
		{
			cvTranspose(ref src, ref dst);
		}
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern void cvTranspose(ref IplImage src, ref IplImage dst);
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern void cvTranspose(ref CvMat src, ref CvMat dst);
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern void cvTranspose(ref CvSeq src, ref CvSeq dst);

		/// <summary>
		/// Det 
		/// Returns determinant of matrix 
		/// </summary>
		/// <param name="mat"></param>
		/// <returns></returns>
		public static double CvDet(ref IplImage mat)
		{
			return cvDet(ref mat);
		}
		public static double CvDet(ref CvMat mat)
		{
			return cvDet(ref mat);
		}
		public static double CvDet(ref CvSeq mat)
		{
			return cvDet(ref mat);
		}
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern double cvDet(ref IplImage mat);
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern double cvDet(ref CvMat mat);
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern double cvDet(ref CvSeq mat);

		/// <summary>
		/// Invert 
		/// Finds inverse or pseudo-inverse of matrix 
		/// </summary>
		/// <param name="src"></param>
		/// <returns></returns>
		public static double CvInvert(ref IplImage src, ref IplImage dst, int method)
		{
			return cvInvert(ref src, ref dst, method);
		}
		public static double CvInvert(ref CvMat src, ref CvMat dst, int method)
		{
			return cvInvert(ref src, ref dst, method);
		}
		public static double CvInvert(ref CvSeq src, ref CvSeq dst, int method)
		{
			return cvInvert(ref src, ref dst, method);
		}
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern double cvInvert(ref IplImage src, ref IplImage dst, int method);
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern double cvInvert(ref CvMat src, ref CvMat dst, int method);
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern double cvInvert(ref CvSeq src, ref CvSeq dst, int method);

		/// <summary>
		/// Solve 
		/// Solves linear system or least-squares problem 
		/// </summary>
		/// <param name="A"></param>
		/// <returns></returns>
		public static int CvSolve(ref IplImage A, ref IplImage B, ref IplImage X, int method)
		{
			return cvSolve(ref A, ref B, ref X, method);
		}
		public static int CvSolve(ref CvMat A, ref CvMat B, ref CvMat X, int method)
		{
			return cvSolve(ref A, ref B, ref X, method);
		}
		public static int CvSolve(ref CvSeq A, ref CvSeq B, ref CvSeq X, int method)
		{
			return cvSolve(ref A, ref B, ref X, method);
		}
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern int cvSolve(ref IplImage A, ref IplImage B, ref IplImage X, int method);
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern int cvSolve(ref CvMat A, ref CvMat B, ref CvMat X, int method);
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern int cvSolve(ref CvSeq A, ref CvSeq B, ref CvSeq X, int method);

		/// <summary>
		/// SVD 
		/// Performs singular value decomposition of real floating-point matrix 
		/// </summary>
		/// <param name="A"></param>
		/// <returns></returns>
		public static void CvSVD(ref IplImage A, ref IplImage W, ref IplImage U, ref IplImage V, int flags)
		{
			cvSVD(ref A, ref W, ref U, ref V, flags);
		}
		public static void CvSVD(ref CvMat A, ref CvMat W, ref CvMat U, ref CvMat V, int flags)
		{
			cvSVD(ref A, ref W, ref U, ref V, flags);
		}
		public static void CvSVD(ref CvSeq A, ref CvSeq W, ref CvSeq U, ref CvSeq V, int flags)
		{
			cvSVD(ref A, ref W, ref U, ref V, flags);
		}
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern void cvSVD(ref IplImage A, ref IplImage W, ref IplImage U, ref IplImage V, int flags);
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern void cvSVD(ref CvMat A, ref CvMat W, ref CvMat U, ref CvMat V, int flags);
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern void cvSVD(ref CvSeq A, ref CvSeq W, ref CvSeq U, ref CvSeq V, int flags);

		/// <summary>
		/// SVBkSb 
		/// Performs singular value back substitution 
		/// </summary>
		/// <param name="W"></param>
		/// <returns></returns>
		public static void CvSVBkSb(ref IplImage W, ref IplImage U, ref IplImage V, ref IplImage B, ref IplImage X, int flags)
		{
			cvSVBkSb(ref W, ref U, ref V, ref B, ref X, flags);
		}
		public static void CvSVBkSb(ref CvMat W, ref CvMat U, ref CvMat V, ref CvMat B, ref CvMat X, int flags)
		{
			cvSVBkSb(ref W, ref U, ref V, ref B, ref X, flags);
		}
		public static void CvSVBkSb(ref CvSeq W, ref CvSeq U, ref CvSeq V, ref CvSeq B, ref CvSeq X, int flags)
		{
			cvSVBkSb(ref W, ref U, ref V, ref B, ref X, flags);
		}
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern void cvSVBkSb(ref IplImage W, ref IplImage U, ref IplImage V, ref IplImage B, ref IplImage X, int flags);
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern void cvSVBkSb(ref CvMat W, ref CvMat U, ref CvMat V, ref CvMat B, ref CvMat X, int flags);
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern void cvSVBkSb(ref CvSeq W, ref CvSeq U, ref CvSeq V, ref CvSeq B, ref CvSeq X, int flags);

		/// <summary>
		/// EigenVV 
		/// Computes eigenvalues and eigenvectors of symmetric matrix 
		/// </summary>
		/// <param name="mat"></param>
		/// <returns></returns>
		public static void CvEigenVV(ref IplImage mat, ref IplImage evects, ref IplImage evals, double eps)
		{
			cvEigenVV(ref mat, ref evects, ref evals, eps);
		}
		public static void CvEigenVV(ref CvMat mat, ref CvMat evects, ref CvMat evals, double eps)
		{
			cvEigenVV(ref mat, ref evects, ref evals, eps);
		}
		public static void CvEigenVV(ref CvSeq mat, ref CvSeq evects, ref CvSeq evals, double eps)
		{
			cvEigenVV(ref mat, ref evects, ref evals, eps);
		}
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern void cvEigenVV(ref IplImage mat, ref IplImage evects, ref IplImage evals, double eps);
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern void cvEigenVV(ref CvMat mat, ref CvMat evects, ref CvMat evals, double eps);
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern void cvEigenVV(ref CvSeq mat, ref CvSeq evects, ref CvSeq evals, double eps);

		/// <summary>
		/// CalcCovarMatrix 
		/// Calculates covariation matrix of the set of vectors 
		/// </summary>
		/// <param name="vects"></param>
		/// <returns></returns>
		public static void CvCalcCovarMatrix(ref IplImage vects, int count, ref IplImage cov_mat, ref IplImage avg, int flags)
		{
			cvCalcCovarMatrix(ref vects.ptr, count, ref cov_mat, ref avg, flags);
		}
		public static void CvCalcCovarMatrix(ref CvMat vects, int count, ref CvMat cov_mat, ref CvMat avg, int flags)
		{
			cvCalcCovarMatrix(ref vects.ptr, count, ref cov_mat, ref avg, flags);
		}
		public static void CvCalcCovarMatrix(ref CvSeq vects, int count, ref CvSeq cov_mat, ref CvSeq avg, int flags)
		{
			cvCalcCovarMatrix(ref vects.ptr, count, ref cov_mat, ref avg, flags);
		}
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern void cvCalcCovarMatrix(ref IntPtr vects, int count, ref IplImage cov_mat, ref IplImage avg, int flags);
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern void cvCalcCovarMatrix(ref IntPtr vects, int count, ref CvMat cov_mat, ref CvMat avg, int flags);
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern void cvCalcCovarMatrix(ref IntPtr vects, int count, ref CvSeq cov_mat, ref CvSeq avg, int flags);

		/// <summary>
		/// Mahalonobis 
		/// Calculates Mahalonobis distance between two vectors 
		/// </summary>
		/// <param name="vec1"></param>
		/// <returns></returns>
		public static double CvMahalanobis(ref IplImage vec1, ref IplImage vec2, ref IplImage mat)
		{
			return cvMahalanobis(ref vec1, ref vec2, ref mat);
		}
		public static double CvMahalanobis(ref CvMat vec1, ref CvMat vec2, ref CvMat mat)
		{
			return cvMahalanobis(ref vec1, ref vec2, ref mat);
		}
		public static double CvMahalanobis(ref CvSeq vec1, ref CvSeq vec2, ref CvSeq mat)
		{
			return cvMahalanobis(ref vec1, ref vec2, ref mat);
		}
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern double cvMahalanobis(ref IplImage vec1, ref IplImage vec2, ref IplImage mat);
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern double cvMahalanobis(ref CvMat vec1, ref CvMat vec2, ref CvMat mat);
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern double cvMahalanobis(ref CvSeq vec1, ref CvSeq vec2, ref CvSeq mat);

		/// <summary>
		/// CalcPCA 
		/// Performs Principal Component Analysis of a vector set 
		/// </summary>
		/// <param name="data"></param>
		/// <returns></returns>
		public static void CvCalcPCA(ref IplImage data, ref IplImage avg, ref IplImage eigenvalues, ref IplImage eigenvectors, int flags)
		{
			cvCalcPCA(ref data, ref avg, ref eigenvalues, ref eigenvectors, flags);
		}
		public static void CvCalcPCA(ref CvMat data, ref CvMat avg, ref CvMat eigenvalues, ref CvMat eigenvectors, int flags)
		{
			cvCalcPCA(ref data, ref avg, ref eigenvalues, ref eigenvectors, flags);
		}
		public static void CvCalcPCA(ref CvSeq data, ref CvSeq avg, ref CvSeq eigenvalues, ref CvSeq eigenvectors, int flags)
		{
			cvCalcPCA(ref data, ref avg, ref eigenvalues, ref eigenvectors, flags);
		}
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern void cvCalcPCA(ref IplImage data, ref IplImage avg, ref IplImage eigenvalues, ref IplImage eigenvectors, int flags);
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern void cvCalcPCA(ref CvMat data, ref CvMat avg, ref CvMat eigenvalues, ref CvMat eigenvectors, int flags);
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern void cvCalcPCA(ref CvSeq data, ref CvSeq avg, ref CvSeq eigenvalues, ref CvSeq eigenvectors, int flags);

		/// <summary>
		/// ProjectPCA 
		/// Projects vectors to the specified subspace 
		/// </summary>
		/// <param name="data"></param>
		/// <returns></returns>
		public static void CvProjectPCA(ref IplImage data, ref IplImage avg, ref IplImage eigenvectors, ref IplImage result)
		{
			cvProjectPCA(ref data, ref avg, ref eigenvectors, ref result);
		}
		public static void CvProjectPCA(ref CvMat data, ref CvMat avg, ref CvMat eigenvectors, ref CvMat result)
		{
			cvProjectPCA(ref data, ref avg, ref eigenvectors, ref result);
		}
		public static void CvProjectPCA(ref CvSeq data, ref CvSeq avg, ref CvSeq eigenvectors, ref CvSeq result)
		{
			cvProjectPCA(ref data, ref avg, ref eigenvectors, ref result);
		}
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern void cvProjectPCA(ref IplImage data, ref IplImage avg, ref IplImage eigenvectors, ref IplImage result);
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern void cvProjectPCA(ref CvMat data, ref CvMat avg, ref CvMat eigenvectors, ref CvMat result);
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern void cvProjectPCA(ref CvSeq data, ref CvSeq avg, ref CvSeq eigenvectors, ref CvSeq result);

		/// <summary>
		/// BackProjectPCA 
		/// Reconstructs the original vectors from the projection coefficients 
		/// </summary>
		/// <param name="proj"></param>
		/// <returns></returns>
		public static void CvBackProjectPCA(ref IplImage proj, ref IplImage avg, ref IplImage eigenvects, ref IplImage result)
		{
			cvBackProjectPCA(ref proj, ref avg, ref eigenvects, ref result);
		}
		public static void CvBackProjectPCA(ref CvMat proj, ref CvMat avg, ref CvMat eigenvects, ref CvMat result)
		{
			cvBackProjectPCA(ref proj, ref avg, ref eigenvects, ref result);
		}
		public static void CvBackProjectPCA(ref CvSeq proj, ref CvSeq avg, ref CvSeq eigenvects, ref CvSeq result)
		{
			cvBackProjectPCA(ref proj, ref avg, ref eigenvects, ref result);
		}
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern void cvBackProjectPCA(ref IplImage proj, ref IplImage avg, ref IplImage eigenvects, ref IplImage result);
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern void cvBackProjectPCA(ref CvMat proj, ref CvMat avg, ref CvMat eigenvects, ref CvMat result);
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern void cvBackProjectPCA(ref CvSeq proj, ref CvSeq avg, ref CvSeq eigenvects, ref CvSeq result);

		/// <summary>
		/// Round, Floor, Ceil 
		/// Converts floating-point number to integer 
		/// </summary>
		/// <param name="value"></param>
		/// <returns></returns>
		public static int CvRound(double value)
		{
			return (int)Math.Round(value);
		}
		public static int CvFloor(double value)
		{
			return (int)Math.Floor(value);
		}
		public static int CvCeil(double value)
		{
			return (int)Math.Ceiling(value);
		}

		/// <summary>
		/// Sqrt 
		/// Calculates square root 
		/// </summary>
		/// <param name="value"></param>
		/// <returns></returns>
		public static float CvSqrt(float value)
		{
			return cvSqrt(value);
		}
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern float cvSqrt(float value);

		/// <summary>
		/// InvSqrt 
		/// Calculates inverse square root 
		/// </summary>
		/// <param name="value"></param>
		/// <returns></returns>
		public static float CvInvSqrt(float value)
		{
			return cvInvSqrt(value);
		}
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern float cvInvSqrt(float value);

		/// <summary>
		/// Cbrt 
		/// Calculates cubic root 
		/// </summary>
		/// <param name="value"></param>
		/// <returns></returns>
		public static float CvCbrt(float value)
		{
			return cvCbrt(value);
		}
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern float cvCbrt(float value);

		/// <summary>
		/// FastArctan 
		/// Calculates angle of 2D vector 
		/// </summary>
		/// <param name="x"></param>
		/// <returns></returns>
		public static float CvFastArctan(float y, float x)
		{
			return cvFastArctan(y, x);
		}
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern float cvFastArctan(float y, float x);

		/// <summary>
		/// IsNaN 
		/// Determines if the argument is Not A Number 
		/// </summary>
		/// <param name="value"></param>
		/// <returns></returns>
		public static int CvIsNaN(double value)
		{
			return cvIsNaN(value);
		}
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern int cvIsNaN(double value);

		/// <summary>
		/// IsInf 
		/// Determines if the argument is Infinity 
		/// </summary>
		/// <param name="value"></param>
		/// <returns></returns>
		public static int CvIsInf(double value)
		{
			return cvIsInf(value);
		}
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern int cvIsInf(double value);

		/// <summary>
		/// CartToPolar 
		/// Calculates magnitude and/or angle of 2d vectors 
		/// </summary>
		/// <param name="x"></param>
		/// <returns></returns>
		public static void CvCartToPolar(ref IplImage x, ref IplImage y, ref IplImage magnitude, ref IplImage angle, int angle_in_degrees)
		{
			cvCartToPolar(ref x, ref y, ref magnitude, ref angle, angle_in_degrees);
		}
		public static void CvCartToPolar(ref CvMat x, ref CvMat y, ref CvMat magnitude, ref CvMat angle, int angle_in_degrees)
		{
			cvCartToPolar(ref x, ref y, ref magnitude, ref angle, angle_in_degrees);
		}
		public static void CvCartToPolar(ref CvSeq x, ref CvSeq y, ref CvSeq magnitude, ref CvSeq angle, int angle_in_degrees)
		{
			cvCartToPolar(ref x, ref y, ref magnitude, ref angle, angle_in_degrees);
		}
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern void cvCartToPolar(ref IplImage x, ref IplImage y, ref IplImage magnitude, ref IplImage angle, int angle_in_degrees);
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern void cvCartToPolar(ref CvMat x, ref CvMat y, ref CvMat magnitude, ref CvMat angle, int angle_in_degrees);
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern void cvCartToPolar(ref CvSeq x, ref CvSeq y, ref CvSeq magnitude, ref CvSeq angle, int angle_in_degrees);

		/// <summary>
		/// PolarToCart 
		/// Calculates cartesian coordinates of 2d vectors represented in polar form 
		/// </summary>
		/// <param name="magnitude"></param>
		/// <returns></returns>
		public static void CvPolarToCart(ref IplImage magnitude, ref IplImage angle, ref IplImage x, ref IplImage y, int angle_in_degrees)
		{
			cvPolarToCart(ref magnitude, ref angle, ref x, ref y, angle_in_degrees);
		}
		public static void CvPolarToCart(ref CvMat magnitude, ref CvMat angle, ref CvMat x, ref CvMat y, int angle_in_degrees)
		{
			cvPolarToCart(ref magnitude, ref angle, ref x, ref y, angle_in_degrees);
		}
		public static void CvPolarToCart(ref CvSeq magnitude, ref CvSeq angle, ref CvSeq x, ref CvSeq y, int angle_in_degrees)
		{
			cvPolarToCart(ref magnitude, ref angle, ref x, ref y, angle_in_degrees);
		}
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern void cvPolarToCart(ref IplImage magnitude, ref IplImage angle, ref IplImage x, ref IplImage y, int angle_in_degrees);
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern void cvPolarToCart(ref CvMat magnitude, ref CvMat angle, ref CvMat x, ref CvMat y, int angle_in_degrees);
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern void cvPolarToCart(ref CvSeq magnitude, ref CvSeq angle, ref CvSeq x, ref CvSeq y, int angle_in_degrees);

		/// <summary>
		/// Pow 
		/// Raises every array element to power 
		/// </summary>
		/// <param name="src"></param>
		/// <returns></returns>
		public static void CvPow(ref IplImage src, ref IplImage dst, double power)
		{
			cvPow(ref src, ref dst, power);
		}
		public static void CvPow(ref CvMat src, ref CvMat dst, double power)
		{
			cvPow(ref src, ref dst, power);
		}
		public static void CvPow(ref CvSeq src, ref CvSeq dst, double power)
		{
			cvPow(ref src, ref dst, power);
		}
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern void cvPow(ref IplImage src, ref IplImage dst, double power);
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern void cvPow(ref CvMat src, ref CvMat dst, double power);
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern void cvPow(ref CvSeq src, ref CvSeq dst, double power);

		/// <summary>
		/// Exp 
		/// Calculates exponent of every array element 
		/// </summary>
		/// <param name="src"></param>
		/// <returns></returns>
		public static void CvExp(ref IplImage src, ref IplImage dst)
		{
			cvExp(ref src, ref dst);
		}
		public static void CvExp(ref CvMat src, ref CvMat dst)
		{
			cvExp(ref src, ref dst);
		}
		public static void CvExp(ref CvSeq src, ref CvSeq dst)
		{
			cvExp(ref src, ref dst);
		}
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern void cvExp(ref IplImage src, ref IplImage dst);
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern void cvExp(ref CvMat src, ref CvMat dst);
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern void cvExp(ref CvSeq src, ref CvSeq dst);

		/// <summary>
		/// Log 
		/// Calculates natural logarithm of every array element absolute value 
		/// </summary>
		/// <param name="src"></param>
		/// <returns></returns>
		public static void CvLog(ref IplImage src, ref IplImage dst)
		{
			cvLog(ref src, ref dst);
		}
		public static void CvLog(ref CvMat src, ref CvMat dst)
		{
			cvLog(ref src, ref dst);
		}
		public static void CvLog(ref CvSeq src, ref CvSeq dst)
		{
			cvLog(ref src, ref dst);
		}
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern void cvLog(ref IplImage src, ref IplImage dst);
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern void cvLog(ref CvMat src, ref CvMat dst);
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern void cvLog(ref CvSeq src, ref CvSeq dst);

		/// <summary>
		/// SolveCubic 
		/// Finds real roots of a cubic equation 
		/// </summary>
		/// <param name="coeffs"></param>
		/// <returns></returns>
		public static int CvSolveCubic(ref CvMat coeffs, ref CvMat roots)
		{
			return cvSolveCubic(ref coeffs, ref roots);
		}
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern int cvSolveCubic(ref CvMat coeffs, ref CvMat roots);

		/// <summary>
		/// RNG 
		/// Initializes random number generator state 
		/// </summary>
		/// <param name="seed"></param>
		/// <returns></returns>
		public static UInt64 CvRNG(Int64 seed)
		{
			return cvRNG(seed);
		}
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern UInt64 cvRNG(Int64 seed);

		/// <summary>
		/// RandArr 
		/// Fills array with random numbers and updates the RNG state 
		/// </summary>
		/// <param name="rng"></param>
		/// <returns></returns>
		public static void CvRandArr(ref UInt64 rng, ref IplImage arr, int dist_type, CvScalar param1, CvScalar param2)
		{
			cvRandArr(ref rng, ref arr, dist_type, param1, param2);
		}
		public static void CvRandArr(ref UInt64 rng, ref CvMat arr, int dist_type, CvScalar param1, CvScalar param2)
		{
			cvRandArr(ref rng, ref arr, dist_type, param1, param2);
		}
		public static void CvRandArr(ref UInt64 rng, ref CvSeq arr, int dist_type, CvScalar param1, CvScalar param2)
		{
			cvRandArr(ref rng, ref arr, dist_type, param1, param2);
		}
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern void cvRandArr(ref UInt64 rng, ref IplImage arr, int dist_type, CvScalar param1, CvScalar param2);
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern void cvRandArr(ref UInt64 rng, ref CvMat arr, int dist_type, CvScalar param1, CvScalar param2);
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern void cvRandArr(ref UInt64 rng, ref CvSeq arr, int dist_type, CvScalar param1, CvScalar param2);

		/// <summary>
		/// RandInt 
		/// Returns 32-bit uint integer and updates RNG 
		/// </summary>
		/// <param name="rng"></param>
		/// <returns></returns>
		public static uint CvRandInt(UInt64 rng)
		{
			UInt64 temp = rng;
			temp = (UInt64)(uint)temp * 1554115554 + (temp >> 32);
			rng = temp;
			return (uint)temp;
		}

		/// <summary>
		/// RandReal 
		/// Returns floating-point random number and updates RNG 
		/// </summary>
		/// <param name="rng"></param>
		/// <returns></returns>
		public static double CvRandReal(UInt64 rng)
		{
			return (double)CvRandInt(rng) * 2.3283064365386962890625e-10;
		}

		/// <summary>
		/// DFT 
		/// Performs forward or inverse Discrete Fourier transform of 1D or 2D floating-point array 
		/// </summary>
		/// <param name="src"></param>
		/// <returns></returns>
		public static void CvDFT(ref IplImage src, ref IplImage dst, int flags, int nonzero_rows)
		{
			cvDFT(ref src, ref dst, flags, nonzero_rows);
		}
		public static void CvDFT(ref CvMat src, ref CvMat dst, int flags, int nonzero_rows)
		{
			cvDFT(ref src, ref dst, flags, nonzero_rows);
		}
		public static void CvDFT(ref CvSeq src, ref CvSeq dst, int flags, int nonzero_rows)
		{
			cvDFT(ref src, ref dst, flags, nonzero_rows);
		}
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern void cvDFT(ref IplImage src, ref IplImage dst, int flags, int nonzero_rows);
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern void cvDFT(ref CvMat src, ref CvMat dst, int flags, int nonzero_rows);
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern void cvDFT(ref CvSeq src, ref CvSeq dst, int flags, int nonzero_rows);

		/// <summary>
		/// GetOptimalDFTSize 
		/// Returns optimal DFT size for given vector size 
		/// </summary>
		/// <param name="size0"></param>
		/// <returns></returns>
		public static int CvGetOptimalDFTSize(int size0)
		{
			return cvGetOptimalDFTSize(size0);
		}
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern int cvGetOptimalDFTSize(int size0);

		/// <summary>
		/// MulSpectrums 
		/// Performs per-element multiplication of two Fourier spectrums 
		/// </summary>
		/// <param name="src1"></param>
		/// <returns></returns>
		public static void CvMulSpectrums(ref IplImage src1, ref IplImage src2, ref IplImage dst, int flags)
		{
			cvMulSpectrums(ref src1, ref src2, ref dst, flags);
		}
		public static void CvMulSpectrums(ref CvMat src1, ref CvMat src2, ref CvMat dst, int flags)
		{
			cvMulSpectrums(ref src1, ref src2, ref dst, flags);
		}
		public static void CvMulSpectrums(ref CvSeq src1, ref CvSeq src2, ref CvSeq dst, int flags)
		{
			cvMulSpectrums(ref src1, ref src2, ref dst, flags);
		}
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern void cvMulSpectrums(ref IplImage src1, ref IplImage src2, ref IplImage dst, int flags);
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern void cvMulSpectrums(ref CvMat src1, ref CvMat src2, ref CvMat dst, int flags);
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern void cvMulSpectrums(ref CvSeq src1, ref CvSeq src2, ref CvSeq dst, int flags);

		/// <summary>
		/// DCT 
		/// Performs forward or inverse Discrete Cosine transform of 1D or 2D floating-point array 
		/// </summary>
		/// <param name="src"></param>
		/// <returns></returns>
		public static void CvDCT(ref IplImage src, ref IplImage dst, int flags, int nonzero_rows)
		{
			cvDFT(ref src, ref dst, flags, nonzero_rows);
		}
		public static void CvDCT(ref CvMat src, ref CvMat dst, int flags, int nonzero_rows)
		{
			cvDFT(ref src, ref dst, flags, nonzero_rows);
		}
		public static void CvDCT(ref CvSeq src, ref CvSeq dst, int flags, int nonzero_rows)
		{
			cvDFT(ref src, ref dst, flags, nonzero_rows);
		}
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern void cvDCT(ref IplImage src, ref IplImage dst, int flags, int nonzero_rows);
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern void cvDCT(ref CvMat src, ref CvMat dst, int flags, int nonzero_rows);
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern void cvDCT(ref CvSeq src, ref CvSeq dst, int flags, int nonzero_rows);


		/// <summary>
		/// CvMemStorage 
		/// Creates Memory storage 
		/// </summary>
		/// <param name="block_size"></param>
		/// <returns></returns>
		public static CvMemStorage CvCreateMemStorage(int block_size)
		{
			IntPtr p = cvCreateMemStorage(block_size);
			CvMemStorage i = (CvMemStorage)Marshal.PtrToStructure(p, typeof(CvMemStorage));
			i.ptr = p;
			return i;
		}
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern IntPtr cvCreateMemStorage(int block_size);

		/// <summary>
		/// CreateChildMemStorage 
		/// Creates child memory storage 
		/// </summary>
		/// <param name="parent"></param>
		/// <returns></returns>
		public static CvMemStorage CvCreateChildMemStorage(ref CvMemStorage parent)
		{
			IntPtr p = cvCreateChildMemStorage(ref parent);
			CvMemStorage i = (CvMemStorage)Marshal.PtrToStructure(p, typeof(CvMemStorage));
			i.ptr = p;
			return i;
		}
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern IntPtr cvCreateChildMemStorage(ref CvMemStorage parent);

		/// <summary>
		/// ReleaseMemStorage 
		/// Releases memory storage 
		/// </summary>
		/// <param name="storage"></param>
		/// <returns></returns>
		public static void CvReleaseMemStorage(ref CvMemStorage storage)
		{
			cvReleaseMemStorage(ref storage.ptr);
		}
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern void cvReleaseMemStorage(ref IntPtr storage);

		/// <summary>
		/// ClearMemStorage 
		/// Clears memory storage 
		/// </summary>
		/// <param name="storage"></param>
		/// <returns></returns>
		public static void CvClearMemStorage(ref CvMemStorage storage)
		{
			cvClearMemStorage(ref storage);
		}
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern void cvClearMemStorage(ref CvMemStorage storage);

		/// <summary>
		/// MemStorageAlloc 
		/// Allocates memory buffer in the storage 
		/// </summary>
		/// <param name="storage"></param>
		/// <returns></returns>
		public static IntPtr CvMemStorageAlloc(ref CvMemStorage storage, int size)
		{
			return cvMemStorageAlloc(ref storage, size);
		}
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern IntPtr cvMemStorageAlloc(ref CvMemStorage storage, int size);

		/// <summary>
		/// MemStorageAllocString 
		/// Allocates text string in the storage 
		/// </summary>
		/// <param name="storage"></param>
		/// <returns></returns>
		public static CvString CvMemStorageAllocString(ref CvMemStorage storage, string ptr, int len)
		{
			IntPtr p = cvMemStorageAllocString(ref storage, ptr, len);
			return (CvString)Marshal.PtrToStructure(p, typeof(CvString));
		}
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern IntPtr cvMemStorageAllocString(ref CvMemStorage storage, [MarshalAs(UnmanagedType.LPStr)] String ptr, int len);

		/// <summary>
		/// SaveMemStoragePos 
		/// Saves memory storage position 
		/// </summary>
		/// <param name="storage"></param>
		/// <returns></returns>
		public static void CvSaveMemStoragePos(ref CvMemStorage storage, ref CvMemStoragePos pos)
		{
			cvSaveMemStoragePos(ref storage, ref pos);
		}
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern void cvSaveMemStoragePos(ref CvMemStorage storage, ref CvMemStoragePos pos);

		/// <summary>
		/// RestoreMemStoragePos 
		/// Restores memory storage position 
		/// </summary>
		/// <param name="storage"></param>
		/// <returns></returns>
		public static void CvRestoreMemStoragePos(ref CvMemStorage storage, ref CvMemStoragePos pos)
		{
			cvRestoreMemStoragePos(ref storage, ref pos);
		}
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern void cvRestoreMemStoragePos(ref CvMemStorage storage, ref CvMemStoragePos pos);


		public static int CvSliceLength(CvSlice slice, ref CvSeq seq)
		{
			return cvSliceLength(slice, ref seq);
		}
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern int cvSliceLength(CvSlice slice, ref CvSeq seq);


		public static CvSeq CvCreateSeq(int seq_flags, int header_size, int elem_size, ref CvMemStorage storage)
		{
			IntPtr p = cvCreateSeq(seq_flags, header_size, elem_size, ref storage);
			CvSeq i = (CvSeq)Marshal.PtrToStructure(p, typeof(CvSeq));
			i.ptr = p;
			return i;
		}
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern IntPtr cvCreateSeq(int seq_flags, int header_size, int elem_size, ref CvMemStorage storage);


		/// <summary>
		/// SetSeqBlockSize 
		/// Sets up sequence block size 
		/// </summary>
		/// <param name="seq"></param>
		/// <returns></returns>
		public static void CvSetSeqBlockSize(ref CvSeq seq, int delta_elems)
		{
			cvSetSeqBlockSize(ref seq, delta_elems);
		}
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern void cvSetSeqBlockSize(ref CvSeq seq, int delta_elems);

		/// <summary>
		/// SeqPush 
		/// Adds element to sequence end 
		/// </summary>
		/// <param name="seq"></param>
		/// <returns></returns>
		public static string CvSeqPush(ref CvSeq seq, IntPtr element)
		{
			return Marshal.PtrToStringAnsi(cvSeqPush(ref seq, element));
		}
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern IntPtr cvSeqPush(ref CvSeq seq, IntPtr element);

		/// <summary>
		/// SeqPop 
		/// Removes element from sequence end 
		/// </summary>
		/// <param name="seq"></param>
		/// <returns></returns>
		public static void CvSeqPop(ref CvSeq seq, IntPtr element)
		{
			cvSeqPop(ref seq, element);
		}
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern void cvSeqPop(ref CvSeq seq, IntPtr element);

		/// <summary>
		/// SeqPushFront 
		/// Adds element to sequence beginning 
		/// </summary>
		/// <param name="seq"></param>
		/// <returns></returns>
		public static IntPtr CvSeqPushFront(ref CvSeq seq, IntPtr element)
		{
			return cvSeqPushFront(ref seq, element);
		}
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern IntPtr cvSeqPushFront(ref CvSeq seq, IntPtr element);

		/// <summary>
		/// SeqPopFront 
		/// Removes element from sequence beginning 
		/// </summary>
		/// <param name="seq"></param>
		/// <returns></returns>
		public static void CvSeqPopFront(ref CvSeq seq, IntPtr element)
		{
			cvSeqPopFront(ref seq, element);
		}
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern void cvSeqPopFront(ref CvSeq seq, IntPtr element);

		/// <summary>
		/// SeqPushMulti 
		/// Pushes several elements to the either end of sequence 
		/// </summary>
		/// <param name="seq"></param>
		/// <returns></returns>
		public static void CvSeqPushMulti(ref CvSeq seq, IntPtr elements, int count, int in_front)
		{
			cvSeqPushMulti(ref seq, elements, count, in_front);
		}
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern void cvSeqPushMulti(ref CvSeq seq, IntPtr elements, int count, int in_front);

		/// <summary>
		/// SeqPopMulti 
		/// Removes several elements from the either end of sequence 
		/// </summary>
		/// <param name="seq"></param>
		/// <returns></returns>
		public static void CvSeqPopMulti(ref CvSeq seq, IntPtr elements, int count, int in_front)
		{
			cvSeqPopMulti(ref seq, elements, count, in_front);
		}
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern void cvSeqPopMulti(ref CvSeq seq, IntPtr elements, int count, int in_front);

		/// <summary>
		/// SeqInsert 
		/// Inserts element in sequence middle 
		/// </summary>
		/// <param name="seq"></param>
		/// <returns></returns>
		public static IntPtr CvSeqInsert(ref CvSeq seq, int before_index, IntPtr element)
		{
			return cvSeqPushFront(ref seq, element);
		}
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern IntPtr cvSeqInsert(ref CvSeq seq, int before_index, IntPtr element);

		/// <summary>
		/// SeqRemove 
		/// Removes element from sequence middle 
		/// </summary>
		/// <param name="seq"></param>
		/// <returns></returns>
		public static void CvSeqRemove(ref CvSeq seq, int index)
		{
			cvSeqRemove(ref seq, index);
		}
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern void cvSeqRemove(ref CvSeq seq, int index);

		/// <summary>
		/// ClearSeq 
		/// Clears sequence 
		/// </summary>
		/// <param name="seq"></param>
		/// <returns></returns>
		public static void CvClearSeq(ref CvSeq seq)
		{
			cvClearSeq(ref seq);
		}
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern void cvClearSeq(ref CvSeq seq);

		/// <summary>
		/// GetSeqElem 
		/// Returns pointer to sequence element by its index 
		/// </summary>
		/// <param name="seq"></param>
		/// <returns></returns>
		public static IntPtr CvGetSeqElem(ref CvSeq seq, int index)
		{
			return cvGetSeqElem(ref seq, index);
		}
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern IntPtr cvGetSeqElem(ref CvSeq seq, int index);

		/// <summary>
		/// SeqElemIdx 
		/// Returns index of concrete sequence element 
		/// </summary>
		/// <param name="seq"></param>
		/// <returns></returns>
		public static int CvSeqElemIdx(ref CvSeq seq, IntPtr element, ref CvSeqBlock block)
		{
			return cvSeqElemIdx(ref seq, element, ref block.ptr);
		}
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern int cvSeqElemIdx(ref CvSeq seq, IntPtr element, ref IntPtr block);

		/// <summary>
		/// CvtSeqToArray 
		/// Copies sequence to one continuous block of memory 
		/// </summary>
		/// <param name="seq"></param>
		/// <returns></returns>
		public static IntPtr CvCvtSeqToArray(ref CvSeq seq, IntPtr elements, CvSlice slice)
		{
			return cvCvtSeqToArray(ref seq, elements, slice);
		}
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern IntPtr cvCvtSeqToArray(ref CvSeq seq, IntPtr elements, CvSlice slice);

		/// <summary>
		/// MakeSeqHeaderForArray 
		/// Constructs sequence from array 
		/// </summary>
		/// <param name="seq_type"></param>
		/// <returns></returns>
		public static CvSeq CvMakeSeqHeaderForArray(int seq_type, int header_size, int elem_size, ref CvSeq seq, ref CvSeqBlock block)
		{
			IntPtr p = cvMakeSeqHeaderForArray(seq_type, header_size, elem_size, ref seq, ref block);
			CvSeq i = (CvSeq)Marshal.PtrToStructure(p, typeof(CvSeq));
			i.ptr = p;
			return i;
		}
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern IntPtr cvMakeSeqHeaderForArray(int seq_type, int header_size, int elem_size, ref CvSeq seq, ref CvSeqBlock block);

		/// <summary>
		/// SeqSlice 
		/// Makes separate header for the sequence slice 
		/// </summary>
		/// <param name="seq"></param>
		/// <returns></returns>
		public static CvSeq CvSeqSlice(ref CvSeq seq, CvSlice slice, ref CvMemStorage storage, int copy_data)
		{
			IntPtr p = cvSeqSlice(ref seq, slice, ref storage, copy_data);
			CvSeq i = (CvSeq)Marshal.PtrToStructure(p, typeof(CvSeq));
			i.ptr = p;
			return i;
		}
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern IntPtr cvSeqSlice(ref CvSeq seq, CvSlice slice, ref CvMemStorage storage, int copy_data);

		/// <summary>
		/// SeqSlice 
		/// Makes separate header for the sequence slice 
		/// </summary>
		/// <param name="seq"></param>
		/// <returns></returns>
		public static CvSeq CvSeqSlice(ref CvSeq seq, CvSlice slice, int copy_data)
		{
			IntPtr p = cvSeqSlice(ref seq, slice, IntPtr.Zero, copy_data);
			CvSeq i = (CvSeq)Marshal.PtrToStructure(p, typeof(CvSeq));
			i.ptr = p;
			return i;
		}
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern IntPtr cvSeqSlice(ref CvSeq seq, CvSlice slice, IntPtr storage, int copy_data);

		/// <summary>
		/// CloneSeq
		public static CvSeq CvCloneSeq(ref CvSeq seq, ref CvMemStorage storage)
		{
			return CvSeqSlice(ref seq, new CvSlice(0, 0x3fffffff), ref storage, 1);
		}

		public static CvSeq CvCloneSeq(ref CvSeq seq)
		{
			return CvSeqSlice(ref seq, new CvSlice(0, 0x3fffffff), 1);
		}

		/// <summary>
		/// SeqRemoveSlice 
		/// Removes sequence slice 
		/// </summary>
		/// <param name="seq"></param>
		/// <returns></returns>
		public static void CvSeqRemoveSlice(ref CvSeq seq, CvSlice slice)
		{
			cvSeqRemoveSlice(ref seq, slice);
		}
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern void cvSeqRemoveSlice(ref CvSeq seq, CvSlice slice);

		/// <summary>
		/// SeqInsertSlice 
		/// Inserts array in the middle of sequence 
		/// </summary>
		/// <param name="seq"></param>
		/// <returns></returns>
		public static void CvSeqInsertSlice(ref CvSeq seq, int before_index, ref IplImage from_arr)
		{
			cvSeqInsertSlice(ref seq, before_index, ref from_arr);
		}
		public static void CvSeqInsertSlice(ref CvSeq seq, int before_index, ref CvMat from_arr)
		{
			cvSeqInsertSlice(ref seq, before_index, ref from_arr);
		}
		public static void CvSeqInsertSlice(ref CvSeq seq, int before_index, ref CvSeq from_arr)
		{
			cvSeqInsertSlice(ref seq, before_index, ref from_arr);
		}
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern void cvSeqInsertSlice(ref CvSeq seq, int before_index, ref IplImage from_arr);
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern void cvSeqInsertSlice(ref CvSeq seq, int before_index, ref CvMat from_arr);
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern void cvSeqInsertSlice(ref CvSeq seq, int before_index, ref CvSeq from_arr);

		/// <summary>
		/// SeqInvert 
		/// Reverses the order of sequence elements 
		/// </summary>
		/// <param name="seq"></param>
		/// <returns></returns>
		public static void CvSeqInvert(ref CvSeq seq)
		{
			cvSeqInvert(ref seq);
		}
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern void cvSeqInvert(ref CvSeq seq);

		/// <summary>
		/// SeqSort 
		/// Sorts sequence element using the specified comparison function 
		/// </summary>
		/// <param name="seq"></param>
		/// <returns></returns>
		public static void CvSeqSort(ref CvSeq seq, OnCompareCallback func, IntPtr userdata)
		{
			cvSeqSort(ref seq, func, userdata);
		}
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern void cvSeqSort(ref CvSeq seq, [MarshalAs(UnmanagedType.FunctionPtr)] OnCompareCallback func, IntPtr userdata);
		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public delegate int OnCompareCallback(IntPtr a, IntPtr b, IntPtr userdata);

		/// <summary>
		/// SeqSearch 
		/// Searches element in sequence 
		/// </summary>
		/// <param name="seq"></param>
		/// <returns></returns>
		public static IntPtr CvSeqSearch(ref CvSeq seq, IntPtr elem, IntPtr func, int is_sorted, ref int elem_idx, IntPtr userdata)
		{
			return cvSeqSearch(ref seq, elem, func, is_sorted, ref elem_idx, userdata);
		}
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern IntPtr cvSeqSearch(ref CvSeq seq, IntPtr elem, IntPtr func, int is_sorted, ref int elem_idx, IntPtr userdata);

		/// <summary>
		/// StartAppendToSeq 
		/// Initializes process of writing data to sequence 
		/// </summary>
		/// <param name="seq"></param>
		/// <returns></returns>
		public static void CvStartAppendToSeq(ref CvSeq seq, ref CvSeqWriter writer)
		{
			cvStartAppendToSeq(ref seq, ref writer);
		}
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern void cvStartAppendToSeq(ref CvSeq seq, ref CvSeqWriter writer);

		/// <summary>
		/// StartWriteSeq 
		/// Creates new sequence and initializes writer for it 
		/// </summary>
		/// <param name="seq_flags"></param>
		/// <returns></returns>
		public static void CvStartWriteSeq(int seq_flags, int header_size, int elem_size, ref CvMemStorage storage, ref CvSeqWriter writer)
		{
			cvStartWriteSeq(seq_flags, header_size, elem_size, ref storage, ref writer);
		}
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern void cvStartWriteSeq(int seq_flags, int header_size, int elem_size, ref CvMemStorage storage, ref CvSeqWriter writer);

		/// <summary>
		/// EndWriteSeq 
		/// Finishes process of writing sequence 
		/// </summary>
		/// <param name="writer"></param>
		/// <returns></returns>
		public static CvSeq CvEndWriteSeq(ref CvSeqWriter writer)
		{
			IntPtr p = cvEndWriteSeq(ref writer);
			CvSeq i = (CvSeq)Marshal.PtrToStructure(p, typeof(CvSeq));
			i.ptr = p;
			return i;
		}
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern IntPtr cvEndWriteSeq(ref CvSeqWriter writer);

		/// <summary>
		/// FlushSeqWriter 
		/// Updates sequence headers from the writer state 
		/// </summary>
		/// <param name="writer"></param>
		/// <returns></returns>
		public static void CvFlushSeqWriter(ref CvSeqWriter writer)
		{
			cvFlushSeqWriter(ref writer);
		}
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern void cvFlushSeqWriter(ref CvSeqWriter writer);

		/// <summary>
		/// StartReadSeq 
		/// Initializes process of sequential reading from sequence 
		/// </summary>
		/// <param name="seq"></param>
		/// <returns></returns>
		public static void CvStartReadSeq(ref CvSeq seq, ref CvSeqReader reader, int reverse)
		{
			cvStartReadSeq(ref seq, ref reader, reverse);
		}
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern void cvStartReadSeq(ref CvSeq seq, ref CvSeqReader reader, int reverse);

		/// <summary>
		/// GetSeqReaderPos 
		/// Returns the current reader position 
		/// </summary>
		/// <param name="reader"></param>
		/// <returns></returns>
		public static int CvGetSeqReaderPos(ref CvSeqReader reader)
		{
			return cvGetSeqReaderPos(ref reader);
		}
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern int cvGetSeqReaderPos(ref CvSeqReader reader);

		/// <summary>
		/// SetSeqReaderPos 
		/// Moves the reader to specified position 
		/// </summary>
		/// <param name="reader"></param>
		/// <returns></returns>
		public static void CvSetSeqReaderPos(ref CvSeqReader reader, int index, int is_relative)
		{
			cvSetSeqReaderPos(ref reader, index, is_relative);
		}
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern void cvSetSeqReaderPos(ref CvSeqReader reader, int index, int is_relative);


		public static void CvChangeSeqBlock(ref CvSeqReader reader, int direction)
		{
			cvChangeSeqBlock(ref reader, direction);		
		}
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern void cvChangeSeqBlock(ref CvSeqReader reader, int direction);

		public static void CvCreateSeqBlock(ref CvSeqWriter writer)
		{
			cvCreateSeqBlock(ref writer);
		}
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern void cvCreateSeqBlock(ref CvSeqWriter writer);

		public static CvSet CvCreateSet(int set_flags, int header_size, int elem_size, ref CvMemStorage storage)
		{
			IntPtr p = cvCreateSet(set_flags, header_size, elem_size, ref storage);
			CvSet i = (CvSet)Marshal.PtrToStructure(p, typeof(CvSet));
			i.ptr = p;
			return i;
		}
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern IntPtr cvCreateSet(int set_flags, int header_size, int elem_size, ref CvMemStorage storage);


		/// <summary>
		/// SetAdd 
		/// Occupies a node in the set 
		/// </summary>
		/// <param name="set_header"></param>
		/// <returns></returns>
		public static int CvSetAdd(ref CvSet set_header, ref CvSetElem elem, ref CvSetElem inserted_elem)
		{
			return cvSetAdd(ref set_header, ref elem, ref inserted_elem.ptr);
		}
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern int cvSetAdd(ref CvSet set_header, ref CvSetElem elem, ref IntPtr inserted_elem);

		/// <summary>
		/// SetRemove 
		/// Removes element from set 
		/// </summary>
		/// <param name="set_header"></param>
		/// <returns></returns>
		public static void CvSetRemove(ref CvSet set_header, int index)
		{
			cvSetRemove(ref set_header, index);
		}
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern void cvSetRemove(ref CvSet set_header, int index);

		/// <summary>
		/// SetNew 
		/// Adds element to set (fast variant) 
		/// </summary>
		/// <param name="set_header"></param>
		/// <returns></returns>
		public static CvSetElem CvSetNew(ref CvSet set_header)
		{
			IntPtr p = cvSetNew(ref set_header);
			CvSetElem i = (CvSetElem)Marshal.PtrToStructure(p, typeof(CvSetElem));
			i.ptr = p;
			return i;
		}
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern IntPtr cvSetNew(ref CvSet set_header);

		/// <summary>
		/// SetRemoveByPtr 
		/// Removes set element given its pointer 
		/// </summary>
		/// <param name="set_header"></param>
		/// <returns></returns>
		public static void CvSetRemoveByPtr(ref CvSet set_header, IntPtr elem)
		{
			cvSetRemoveByPtr(ref set_header, elem);
		}
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern void cvSetRemoveByPtr(ref CvSet set_header, IntPtr elem);

		/// <summary>
		/// GetSetElem 
		/// Finds set element by its index 
		/// </summary>
		/// <param name="set_header"></param>
		/// <returns></returns>
		public static CvSetElem CvGetSetElem(ref CvSet set_header, int index)
		{
			IntPtr p = cvGetSetElem(ref set_header, index);
			CvSetElem i = (CvSetElem)Marshal.PtrToStructure(p, typeof(CvSetElem));
			i.ptr = p;
			return i;
		}
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern IntPtr cvGetSetElem(ref CvSet set_header, int index);

		/// <summary>
		/// ClearSet 
		/// Clears set 
		/// </summary>
		/// <param name="set_header"></param>
		/// <returns></returns>
		public static void CvClearSet(ref CvSet set_header)
		{
			cvClearSet(ref set_header);
		}
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern void cvClearSet(ref CvSet set_header);

		/// <summary>
		/// CvGraph 
		/// Oriented or unoriented weigted graph 
		/// </summary>
		/// <param name="graph_flags"></param>
		/// <returns></returns>
		public static CvGraph CvCreateGraph(int set_flags, int header_size, int elem_size, ref CvMemStorage storage)
		{
			IntPtr p = cvCreateGraph(set_flags, header_size, elem_size, ref storage);
			CvGraph i = (CvGraph)Marshal.PtrToStructure(p, typeof(CvGraph));
			i.ptr = p;
			return i;
		}
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern IntPtr cvCreateGraph(int set_flags, int header_size, int elem_size, ref CvMemStorage storage);

		/// <summary>
		/// GraphAddVtx 
		/// Adds vertex to graph 
		/// </summary>
		/// <param name="graph"></param>
		/// <returns></returns>
		public static int CvGraphAddVtx(ref CvGraph graph, ref CvGraphVtx vtx, ref CvGraphVtx inserted_vtx)
		{
			return cvGraphAddVtx(ref graph, ref vtx, ref inserted_vtx.ptr);
		}
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern int cvGraphAddVtx(ref CvGraph graph, ref CvGraphVtx vtx, ref IntPtr inserted_vtx);

		/// <summary>
		/// GraphRemoveVtx 
		/// Removes vertex from graph 
		/// </summary>
		/// <param name="graph"></param>
		/// <returns></returns>
		public static int CvGraphRemoveVtx(ref CvGraph graph, int index)
		{
			return cvGraphRemoveVtx(ref graph, index);
		}
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern int cvGraphRemoveVtx(ref CvGraph graph, int index);

		/// <summary>
		/// GraphRemoveVtxByPtr 
		/// Removes vertex from graph 
		/// </summary>
		/// <param name="graph"></param>
		/// <returns></returns>
		public static int CvGraphRemoveVtxByPtr(ref CvGraph graph, ref CvGraphVtx vtx)
		{
			return cvGraphRemoveVtxByPtr(ref graph, ref vtx);
		}
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern int cvGraphRemoveVtxByPtr(ref CvGraph graph, ref CvGraphVtx vtx);

		/// <summary>
		/// GetGraphVtx 
		/// Finds graph vertex by index 
		/// </summary>
		/// <param name="graph"></param>
		/// <returns></returns>
		public static CvGraphVtx CvGetGraphVtx(ref CvGraph graph, int vtx_idx)
		{
			IntPtr p = cvGetGraphVtx(ref graph, vtx_idx);
			CvGraphVtx i = (CvGraphVtx)Marshal.PtrToStructure(p, typeof(CvGraphVtx));
			i.ptr = p;
			return i;
		}
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern IntPtr cvGetGraphVtx(ref CvGraph graph, int vtx_idx);

		/// <summary>
		/// GraphVtxIdx 
		/// Returns index of graph vertex 
		/// </summary>
		/// <param name="graph"></param>
		/// <returns></returns>
		public static int CvGraphVtxIdx(ref CvGraph graph, ref CvGraphVtx vtx)
		{
			return cvGraphVtxIdx(ref graph, ref vtx);
		}
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern int cvGraphVtxIdx(ref CvGraph graph, ref CvGraphVtx vtx);

		/// <summary>
		/// GraphAddEdge 
		/// Adds edge to graph 
		/// </summary>
		/// <param name="graph"></param>
		/// <returns></returns>
		public static int CvGraphAddEdge(ref CvGraph graph, int start_idx, int end_idx, ref CvGraphEdge edge, ref CvGraphEdge inserted_edge)
		{
			return cvGraphAddEdge(ref graph, start_idx, end_idx, ref edge, ref inserted_edge.ptr);
		}
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern int cvGraphAddEdge(ref CvGraph graph, int start_idx, int end_idx, ref CvGraphEdge edge, ref IntPtr inserted_edge);

		/// <summary>
		/// GraphAddEdgeByPtr 
		/// Adds edge to graph 
		/// </summary>
		/// <param name="graph"></param>
		/// <returns></returns>
		public static int CvGraphAddEdgeByPtr(ref CvGraph graph, ref CvGraphVtx start_vtx, ref CvGraphVtx end_vtx, ref CvGraphEdge edge, ref CvGraphEdge inserted_edge)
		{
			return cvGraphAddEdgeByPtr(ref graph, ref start_vtx, ref end_vtx, ref edge, ref inserted_edge.ptr);
		}
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern int cvGraphAddEdgeByPtr(ref CvGraph graph, ref CvGraphVtx start_vtx, ref CvGraphVtx end_vtx, ref CvGraphEdge edge, ref IntPtr inserted_edge);

		/// <summary>
		/// GraphRemoveEdge 
		/// Removes edge from graph 
		/// </summary>
		/// <param name="graph"></param>
		/// <returns></returns>
		public static void CvGraphRemoveEdge(ref CvGraph graph, int start_idx, int end_idx)
		{
			cvGraphRemoveEdge(ref graph, start_idx, end_idx);
		}
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern void cvGraphRemoveEdge(ref CvGraph graph, int start_idx, int end_idx);

		/// <summary>
		/// GraphRemoveEdgeByPtr 
		/// Removes edge from graph 
		/// </summary>
		/// <param name="graph"></param>
		/// <returns></returns>
		public static void CvGraphRemoveEdgeByPtr(ref CvGraph graph, ref CvGraphVtx start_vtx, ref CvGraphVtx end_vtx)
		{
			cvGraphRemoveEdgeByPtr(ref graph, ref start_vtx, ref end_vtx);
		}
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern void cvGraphRemoveEdgeByPtr(ref CvGraph graph, ref CvGraphVtx start_vtx, ref CvGraphVtx end_vtx);

		/// <summary>
		/// FindGraphEdge 
		/// Finds edge in graph 
		/// </summary>
		/// <param name="graph"></param>
		/// <returns></returns>
		public static CvGraphEdge CvFindGraphEdge(ref CvGraph graph, int start_idx, int end_idx)
		{
			IntPtr p = cvFindGraphEdge(ref graph, start_idx, end_idx);
			CvGraphEdge i = (CvGraphEdge)Marshal.PtrToStructure(p, typeof(CvGraphEdge));
			i.ptr = p;
			return i;
		}
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern IntPtr cvFindGraphEdge(ref CvGraph graph, int start_idx, int end_idx);

		/// <summary>
		/// FindGraphEdgeByPtr 
		/// Finds edge in graph 
		/// </summary>
		/// <param name="graph"></param>
		/// <returns></returns>
		public static CvGraphEdge CvFindGraphEdgeByPtr(ref CvGraph graph, ref CvGraphVtx start_vtx, ref CvGraphVtx end_vtx)
		{
			IntPtr p = cvFindGraphEdgeByPtr(ref graph, ref start_vtx, ref end_vtx);
			CvGraphEdge i = (CvGraphEdge)Marshal.PtrToStructure(p, typeof(CvGraphEdge));
			i.ptr = p;
			return i;
		}
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern IntPtr cvFindGraphEdgeByPtr(ref CvGraph graph, ref CvGraphVtx start_vtx, ref CvGraphVtx end_vtx);

		/// <summary>
		/// GraphEdgeIdx 
		/// Returns index of graph edge 
		/// </summary>
		/// <param name="graph"></param>
		/// <returns></returns>
		public static int CvGraphEdgeIdx(ref CvGraph graph, ref CvGraphEdge edge)
		{
			return cvGraphEdgeIdx(ref graph, ref edge);
		}
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern int cvGraphEdgeIdx(ref CvGraph graph, ref CvGraphEdge edge);

		/// <summary>
		/// GraphVtxDegree 
		/// Counts edges indicent to the vertex 
		/// </summary>
		/// <param name="graph"></param>
		/// <returns></returns>
		public static int CvGraphVtxDegree(ref CvGraph graph, int vtx_idx)
		{
			return cvGraphVtxDegree(ref graph, vtx_idx);
		}
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern int cvGraphVtxDegree(ref CvGraph graph, int vtx_idx);

		/// <summary>
		/// GraphVtxDegreeByPtr 
		/// Finds edge in graph 
		/// </summary>
		/// <param name="graph"></param>
		/// <returns></returns>
		public static int CvGraphVtxDegreeByPtr(ref CvGraph graph, ref CvGraphVtx vtx)
		{
			return cvGraphVtxDegreeByPtr(ref graph, ref vtx);
		}
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern int cvGraphVtxDegreeByPtr(ref CvGraph graph, ref CvGraphVtx vtx);

		/// <summary>
		/// ClearGraph 
		/// Clears graph 
		/// </summary>
		/// <param name="graph"></param>
		/// <returns></returns>
		public static void CvClearGraph(ref CvGraph graph)
		{
			cvClearGraph(ref graph);
		}
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern void cvClearGraph(ref CvGraph graph);

		/// <summary>
		/// CloneGraph 
		/// Clone graph 
		/// </summary>
		/// <param name="graph"></param>
		/// <returns></returns>
		public static CvGraph CvCloneGraph(ref CvGraph graph, ref CvMemStorage storage)
		{
			IntPtr p = cvCloneGraph(ref graph, ref storage);
			CvGraph i = (CvGraph)Marshal.PtrToStructure(p, typeof(CvGraph));
			i.ptr = p;
			return i;
		}
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern IntPtr cvCloneGraph(ref CvGraph graph, ref CvMemStorage storage);

		/// <summary>
		/// CvGraphScanner 
		/// Graph traversal state 
		/// </summary>
		/// <param name="graph"></param>
		/// <returns></returns>
		public static CvGraphScanner CvCreateGraphScanner(ref CvGraph graph, ref CvGraphVtx vtx, int mask)
		{
			IntPtr p = cvCreateGraphScanner(ref graph, ref vtx, mask);
			CvGraphScanner i = (CvGraphScanner)Marshal.PtrToStructure(p, typeof(CvGraphScanner));
			i.ptr = p;
			return i;
		}
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern IntPtr cvCreateGraphScanner(ref CvGraph graph, ref CvGraphVtx vtx, int mask);

		public static CvGraphScanner CvCreateGraphScanner(ref CvGraph graph, int mask)
		{
			IntPtr p = cvCreateGraphScanner(ref graph, IntPtr.Zero, mask);
			CvGraphScanner i = (CvGraphScanner)Marshal.PtrToStructure(p, typeof(CvGraphScanner));
			i.ptr = p;
			return i;
		}
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern IntPtr cvCreateGraphScanner(ref CvGraph graph, IntPtr vtx, int mask);

		/// <summary>
		/// NextGraphItem 
		/// Makes one or more steps of the graph traversal procedure 
		/// </summary>
		/// <param name="scanner"></param>
		/// <returns></returns>
		public static int CvNextGraphItem(ref CvGraphScanner scanner)
		{
			return cvNextGraphItem(ref scanner);
		}
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern int cvNextGraphItem(ref CvGraphScanner scanner);

		/// <summary>
		/// ReleaseGraphScanner 
		/// Finishes graph traversal procedure 
		/// </summary>
		/// <param name="scanner"></param>
		/// <returns></returns>
		public static void CvReleaseGraphScanner(ref CvGraphScanner scanner)
		{
			cvReleaseGraphScanner(ref scanner.ptr);
		}
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern void cvReleaseGraphScanner(ref IntPtr scanner);

		/// <summary>
		/// CV_TREE_NODE_FIELDS 
		/// Helper macro for a tree node type declaration 
		/// </summary>
		/// <param name="tree_iterator"></param>
		/// <returns></returns>
		public static void CvInitTreeNodeIterator(ref CvTreeNodeIterator tree_iterator, IntPtr first, int max_level)
		{
			cvInitTreeNodeIterator(ref tree_iterator, first, max_level);
		}
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern void cvInitTreeNodeIterator(ref CvTreeNodeIterator tree_iterator, IntPtr first, int max_level);


		/// <summary>
		/// NextTreeNode 
		/// Returns the currently observed node and moves iterator toward the next node 
		/// </summary>
		/// <param name="tree_iterator"></param>
		/// <returns></returns>
		public static IntPtr CvNextTreeNode(ref CvTreeNodeIterator tree_iterator)
		{
			return cvNextTreeNode(ref tree_iterator);
		}
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern IntPtr cvNextTreeNode(ref CvTreeNodeIterator tree_iterator);

		/// <summary>
		/// PrevTreeNode 
		/// Returns the currently observed node and moves iterator toward the previous node 
		/// </summary>
		/// <param name="tree_iterator"></param>
		/// <returns></returns>
		public static IntPtr CvPrevTreeNode(ref CvTreeNodeIterator tree_iterator)
		{
			return cvPrevTreeNode(ref tree_iterator);
		}
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern IntPtr cvPrevTreeNode(ref CvTreeNodeIterator tree_iterator);

		/// <summary>
		/// TreeToNodeSeq 
		/// Gathers all node pointers to the single sequence 
		/// </summary>
		/// <param name="first"></param>
		/// <returns></returns>
		public static CvSeq CvTreeToNodeSeq(IntPtr first, int header_size, ref CvMemStorage storage)
		{
			IntPtr p = cvTreeToNodeSeq(first, header_size, ref storage);
			CvSeq i = (CvSeq)Marshal.PtrToStructure(p, typeof(CvSeq));
			i.ptr = p;
			return i;
		}
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern IntPtr cvTreeToNodeSeq(IntPtr first, int header_size, ref CvMemStorage storage);

		/// <summary>
		/// InsertNodeIntoTree 
		/// Adds new node to the tree 
		/// </summary>
		/// <param name="node"></param>
		/// <returns></returns>
		public static void CvInsertNodeIntoTree(IntPtr node, IntPtr parent, IntPtr frame)
		{
			cvInsertNodeIntoTree(node, parent, frame);
		}
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern void cvInsertNodeIntoTree(IntPtr node, IntPtr parent, IntPtr frame);

		/// <summary>
		/// RemoveNodeFromTree 
		/// Removes node from tree 
		/// </summary>
		/// <param name="node"></param>
		/// <returns></returns>
		public static void CvRemoveNodeFromTree(IntPtr node, IntPtr frame)
		{
			cvRemoveNodeFromTree(node, frame);
		}
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern void cvRemoveNodeFromTree(IntPtr node, IntPtr frame);

		/// <summary>
		/// CV_RGB 
		/// Constructs a color value 
		/// </summary>
		/// <param name="img"></param>
		/// <returns></returns>
		// this is defined in header file
		public static void CvLine(ref IplImage img, CvPoint pt1, CvPoint pt2, CvScalar color, int thickness, int line_type, int shift)
		{
			cvLine(ref img, pt1, pt2, color, thickness, line_type, shift);
		}
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern void cvLine(ref IplImage img, CvPoint pt1, CvPoint pt2, CvScalar color, int thickness, int line_type, int shift);
		/// <summary>
		/// Rectangle 
		/// Draws simple, thick or filled rectangle 
		/// </summary>
		/// <param name="img"></param>
		/// <returns></returns>
		public static void CvRectangle(ref IplImage img, CvPoint pt1, CvPoint pt2, CvScalar color, int thickness, int line_type, int shift)
		{
			cvRectangle(ref img, pt1, pt2, color, thickness, line_type, shift);
		}
		public static void CvRectangle(ref CvMat img, CvPoint pt1, CvPoint pt2, CvScalar color, int thickness, int line_type, int shift)
		{
			cvRectangle(ref img, pt1, pt2, color, thickness, line_type, shift);
		}
		public static void CvRectangle(ref CvSeq img, CvPoint pt1, CvPoint pt2, CvScalar color, int thickness, int line_type, int shift)
		{
			cvRectangle(ref img, pt1, pt2, color, thickness, line_type, shift);
		}
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern void cvRectangle(ref IplImage img, CvPoint pt1, CvPoint pt2, CvScalar color, int thickness, int line_type, int shift);
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern void cvRectangle(ref CvMat img, CvPoint pt1, CvPoint pt2, CvScalar color, int thickness, int line_type, int shift);
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern void cvRectangle(ref CvSeq img, CvPoint pt1, CvPoint pt2, CvScalar color, int thickness, int line_type, int shift);

		/// <summary>
		/// Circle 
		/// Draws a circle 
		/// </summary>
		/// <param name="img"></param>
		/// <returns></returns>
		public static void CvCircle(ref IplImage img, CvPoint center, int radius, CvScalar color, int thickness, int line_type, int shift)
		{
			cvCircle(ref img, center, radius, color, thickness, line_type, shift);
		}
		public static void CvCircle(ref CvMat img, CvPoint center, int radius, CvScalar color, int thickness, int line_type, int shift)
		{
			cvCircle(ref img, center, radius, color, thickness, line_type, shift);
		}
		public static void CvCircle(ref CvSeq img, CvPoint center, int radius, CvScalar color, int thickness, int line_type, int shift)
		{
			cvCircle(ref img, center, radius, color, thickness, line_type, shift);
		}
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern void cvCircle(ref IplImage img, CvPoint center, int radius, CvScalar color, int thickness, int line_type, int shift);
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern void cvCircle(ref CvMat img, CvPoint center, int radius, CvScalar color, int thickness, int line_type, int shift);
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern void cvCircle(ref CvSeq img, CvPoint center, int radius, CvScalar color, int thickness, int line_type, int shift);

		/// <summary>
		/// Ellipse 
		/// Draws simple or thick elliptic arc or fills ellipse sector 
		/// </summary>
		/// <param name="img"></param>
		/// <returns></returns>
		public static void CvEllipse(ref IplImage img, CvPoint center, CvSize axes, double angle, double start_angle, double end_angle, CvScalar color, int thickness, int line_type, int shift)
		{
			cvEllipse(ref img, center, axes, angle, start_angle, end_angle, color, thickness, line_type, shift);
		}
		public static void CvEllipse(ref CvMat img, CvPoint center, CvSize axes, double angle, double start_angle, double end_angle, CvScalar color, int thickness, int line_type, int shift)
		{
			cvEllipse(ref img, center, axes, angle, start_angle, end_angle, color, thickness, line_type, shift);
		}
		public static void CvEllipse(ref CvSeq img, CvPoint center, CvSize axes, double angle, double start_angle, double end_angle, CvScalar color, int thickness, int line_type, int shift)
		{
			cvEllipse(ref img, center, axes, angle, start_angle, end_angle, color, thickness, line_type, shift);
		}
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern void cvEllipse(ref IplImage img, CvPoint center, CvSize axes, double angle, double start_angle, double end_angle, CvScalar color, int thickness, int line_type, int shift);
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern void cvEllipse(ref CvMat img, CvPoint center, CvSize axes, double angle, double start_angle, double end_angle, CvScalar color, int thickness, int line_type, int shift);
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern void cvEllipse(ref CvSeq img, CvPoint center, CvSize axes, double angle, double start_angle, double end_angle, CvScalar color, int thickness, int line_type, int shift);

		/// <summary>
		/// EllipseBox 
		/// Draws simple or thick elliptic arc or fills ellipse sector 
		/// </summary>
		/// <param name="img"></param>
		/// <returns></returns>
		public static void CvEllipseBox(ref IplImage img, CvBox2D box, CvScalar color, int thickness, int line_type, int shift)
		{
			cvEllipseBox(ref img, box, color, thickness, line_type, shift);
		}
		public static void CvEllipseBox(ref CvMat img, CvBox2D box, CvScalar color, int thickness, int line_type, int shift)
		{
			cvEllipseBox(ref img, box, color, thickness, line_type, shift);
		}
		public static void CvEllipseBox(ref CvSeq img, CvBox2D box, CvScalar color, int thickness, int line_type, int shift)
		{
			cvEllipseBox(ref img, box, color, thickness, line_type, shift);
		}
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern void cvEllipseBox(ref IplImage img, CvBox2D box, CvScalar color, int thickness, int line_type, int shift);
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern void cvEllipseBox(ref CvMat img, CvBox2D box, CvScalar color, int thickness, int line_type, int shift);
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern void cvEllipseBox(ref CvSeq img, CvBox2D box, CvScalar color, int thickness, int line_type, int shift);

		/// <summary>
		/// FillPoly 
		/// Fills polygons interior 
		/// </summary>
		/// <param name="img"></param>
		/// <returns></returns>
		public static void CvFillPoly(ref IplImage img, ref IntPtr pts, int[] npts, int contours, CvScalar color, int line_type, int shift)
		{
			cvFillPoly(ref img, ref pts, npts, contours, color, line_type, shift);
		}
		public static void CvFillPoly(ref CvMat img, ref IntPtr pts, int[] npts, int contours, CvScalar color, int line_type, int shift)
		{
			cvFillPoly(ref img, ref pts, npts, contours, color, line_type, shift);
		}
		public static void CvFillPoly(ref CvSeq img, ref IntPtr pts, int[] npts, int contours, CvScalar color, int line_type, int shift)
		{
			cvFillPoly(ref img, ref pts, npts, contours, color, line_type, shift);
		}
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern void cvFillPoly(ref IplImage img, ref IntPtr pts, int[] npts, int contours, CvScalar color, int line_type, int shift);
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern void cvFillPoly(ref CvMat img, ref IntPtr pts, int[] npts, int contours, CvScalar color, int line_type, int shift);
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern void cvFillPoly(ref CvSeq img, ref IntPtr pts, int[] npts, int contours, CvScalar color, int line_type, int shift);

		/// <summary>
		/// FillConvexPoly 
		/// Fills convex polygon 
		/// </summary>
		/// <param name="img"></param>
		/// <returns></returns>
		public static void CvFillConvexPoly(ref IplImage img, ref CvPoint pts, int npts, CvScalar color, int line_type, int shift)
		{
			cvFillConvexPoly(ref img, ref pts, npts, color, line_type, shift);
		}
		public static void CvFillConvexPoly(ref CvMat img, ref CvPoint pts, int npts, CvScalar color, int line_type, int shift)
		{
			cvFillConvexPoly(ref img, ref pts, npts, color, line_type, shift);
		}
		public static void CvFillConvexPoly(ref CvSeq img, ref CvPoint pts, int npts, CvScalar color, int line_type, int shift)
		{
			cvFillConvexPoly(ref img, ref pts, npts, color, line_type, shift);
		}
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern void cvFillConvexPoly(ref IplImage img, ref CvPoint pts, int npts, CvScalar color, int line_type, int shift);
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern void cvFillConvexPoly(ref CvMat img, ref CvPoint pts, int npts, CvScalar color, int line_type, int shift);
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern void cvFillConvexPoly(ref CvSeq img, ref CvPoint pts, int npts, CvScalar color, int line_type, int shift);

		/// <summary>
		/// PolyLine 
		/// Draws simple or thick polygons 
		/// </summary>
		/// <param name="img"></param>
		/// <returns></returns>
		public static void CvPolyLine(ref IplImage img, ref CvPoint[] pts, ref int npts, int contours, int is_closed, CvScalar color, int thickness, int line_type, int shift)
		{
			cvPolyLine(ref img, ref pts, ref npts, contours, is_closed, color, thickness, line_type, shift);
		}
		public static void CvPolyLine(ref CvMat img, ref CvPoint[] pts, ref int npts, int contours, int is_closed, CvScalar color, int thickness, int line_type, int shift)
		{
			cvPolyLine(ref img, ref pts, ref npts, contours, is_closed, color, thickness, line_type, shift);
		}
		public static void CvPolyLine(ref CvSeq img, ref CvPoint[] pts, ref int npts, int contours, int is_closed, CvScalar color, int thickness, int line_type, int shift)
		{
			cvPolyLine(ref img, ref pts, ref npts, contours, is_closed, color, thickness, line_type, shift);
		}
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern void cvPolyLine(ref IplImage img, ref CvPoint[] pts, ref int npts, int contours, int is_closed, CvScalar color, int thickness, int line_type, int shift);
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern void cvPolyLine(ref CvMat img, ref CvPoint[] pts, ref int npts, int contours, int is_closed, CvScalar color, int thickness, int line_type, int shift);
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern void cvPolyLine(ref CvSeq img, ref CvPoint[] pts, ref int npts, int contours, int is_closed, CvScalar color, int thickness, int line_type, int shift);

		/// <summary>
		/// InitFont 
		/// Initializes font structure 
		/// </summary>
		/// <param name="font"></param>
		/// <returns></returns>
		public static void CvInitFont(ref CvFont font, int font_face, double hscale, double vscale, double shear, int thickness, int line_type)
		{
			cvInitFont(ref font, font_face, hscale, vscale, shear, thickness, line_type);
		}
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern void cvInitFont(ref CvFont font, int font_face, double hscale, double vscale, double shear, int thickness, int line_type);

		/// <summary>
		/// PutText 
		/// Draws text string 
		/// </summary>
		/// <param name="img"></param>
		/// <returns></returns>
		public static void CvPutText(ref IplImage img, string text, CvPoint org, ref CvFont font, CvScalar color)
		{
			cvPutText(ref img, text, org, ref font, color);
		}
		public static void CvPutText(ref CvMat img, string text, CvPoint org, ref CvFont font, CvScalar color)
		{
			cvPutText(ref img, text, org, ref font, color);
		}
		public static void CvPutText(ref CvSeq img, string text, CvPoint org, ref CvFont font, CvScalar color)
		{
			cvPutText(ref img, text, org, ref font, color);
		}
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern void cvPutText(ref IplImage img, [MarshalAs(UnmanagedType.LPStr)] String text, CvPoint org, ref CvFont font, CvScalar color);
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern void cvPutText(ref CvMat img, [MarshalAs(UnmanagedType.LPStr)] String text, CvPoint org, ref CvFont font, CvScalar color);
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern void cvPutText(ref CvSeq img, [MarshalAs(UnmanagedType.LPStr)] String text, CvPoint org, ref CvFont font, CvScalar color);

		/// <summary>
		/// GetTextSize 
		/// Retrieves width and height of text string 
		/// </summary>
		/// <param name="font"></param>
		/// <returns></returns>
		public static void CvGetTextSize(string text_string, ref CvFont font, ref CvSize text_size, ref int baseline)
		{
			cvGetTextSize(text_string, ref font, ref text_size, ref baseline);
		}
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern void cvGetTextSize([MarshalAs(UnmanagedType.LPStr)] String text_string, ref CvFont font, ref CvSize text_size, ref int baseline);

		/// <summary>
		/// DrawContours 
		/// Draws contour outlines or interiors in the image 
		/// </summary>
		/// <param name="img"></param>
		/// <returns></returns>
		public static void CvDrawContours(ref IplImage img, ref CvSeq contour, CvScalar external_color, CvScalar hole_color,
                     int max_level, int thickness,int line_type, CvPoint offset)
		{
			cvDrawContours(ref img, ref contour, external_color, hole_color, max_level, thickness, line_type, offset);
		}
		public static void CvDrawContours(ref CvMat img, ref CvSeq contour, CvScalar external_color, CvScalar hole_color,
                     int max_level, int thickness,int line_type, CvPoint offset)
		{
			cvDrawContours(ref img, ref contour, external_color, hole_color, max_level, thickness, line_type, offset);
		}
		public static void CvDrawContours(ref CvSeq img, ref CvSeq contour, CvScalar external_color, CvScalar hole_color,
                     int max_level, int thickness,int line_type, CvPoint offset)
		{
			cvDrawContours(ref img, ref contour, external_color, hole_color, max_level, thickness, line_type, offset);
		}
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern void cvDrawContours(ref IplImage img, ref CvSeq contour, CvScalar external_color, CvScalar hole_color,
                     int max_level, int thickness,int line_type, CvPoint offset);
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern void cvDrawContours(ref CvMat img, ref CvSeq contour, CvScalar external_color, CvScalar hole_color,
                     int max_level, int thickness,int line_type, CvPoint offset);
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern void cvDrawContours(ref CvSeq img, ref CvSeq contour, CvScalar external_color, CvScalar hole_color,
                     int max_level, int thickness,int line_type, CvPoint offset);

		/// <summary>
		/// InitLineIterator 
		/// Initializes line iterator 
		/// </summary>
		/// <param name="image"></param>
		/// <returns></returns>
		public static int CvInitLineIterator(ref IplImage image, CvPoint pt1, CvPoint pt2, ref CvLineIterator line_iterator, int connectivity, int left_to_right)
		{
			return cvInitLineIterator(ref image, pt1, pt2, ref line_iterator, connectivity, left_to_right);
		}
		public static int CvInitLineIterator(ref CvMat image, CvPoint pt1, CvPoint pt2, ref CvLineIterator line_iterator, int connectivity, int left_to_right)
		{
			return cvInitLineIterator(ref image, pt1, pt2, ref line_iterator, connectivity, left_to_right);
		}
		public static int CvInitLineIterator(ref CvSeq image, CvPoint pt1, CvPoint pt2, ref CvLineIterator line_iterator, int connectivity, int left_to_right)
		{
			return cvInitLineIterator(ref image, pt1, pt2, ref line_iterator, connectivity, left_to_right);
		}
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern int cvInitLineIterator(ref IplImage image, CvPoint pt1, CvPoint pt2, ref CvLineIterator line_iterator, int connectivity, int left_to_right);
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern int cvInitLineIterator(ref CvMat image, CvPoint pt1, CvPoint pt2, ref CvLineIterator line_iterator, int connectivity, int left_to_right);
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern int cvInitLineIterator(ref CvSeq image, CvPoint pt1, CvPoint pt2, ref CvLineIterator line_iterator, int connectivity, int left_to_right);

		/// <summary>
		/// ClipLine 
		/// Clips the line against the image rectangle 
		/// </summary>
		/// <param name="img_size"></param>
		/// <returns></returns>
		public static int CvClipLine(CvSize img_size, ref CvPoint pt1, ref CvPoint pt2)
		{
			return cvClipLine(img_size, ref pt1, ref pt2);
		}
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern int cvClipLine(CvSize img_size, ref CvPoint pt1, ref CvPoint pt2);

		/// <summary>
		/// Ellipse2Poly 
		/// Approximates elliptic arc with polyline 
		/// </summary>
		/// <param name="center"></param>
		/// <returns></returns>
		public static int CvEllipse2Poly(CvPoint center, CvSize axes, int angle, int arc_start, int arc_end, ref CvPoint pts, int delta)
		{
			return cvEllipse2Poly(center, axes, angle, arc_start, arc_end, ref pts, delta);
		}
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern int cvEllipse2Poly(CvPoint center, CvSize axes, int angle, int arc_start, int arc_end, ref CvPoint pts, int delta);


		/// <summary>
		/// CvAttrValue
		/// </summary>
		/// <param name="attr"></param>
		/// <returns></returns>
		public static string CvAttrValue(ref CvAttrList attr, string attr_name) 
		{
			return Marshal.PtrToStringAnsi(cvAttrValue(ref attr, attr_name));
		}
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern IntPtr cvAttrValue(ref CvAttrList attr, [MarshalAs(UnmanagedType.LPStr)] String attr_name);


		public static CvFileStorage CvOpenFileStorage(string filename, ref CvMemStorage memstorage, int flags)
		{
			IntPtr p = cvOpenFileStorage(filename, ref memstorage, flags );
			CvFileStorage i = (CvFileStorage)Marshal.PtrToStructure(p, typeof(CvFileStorage));
			i.ptr = p;
			return i;
		}
		public static CvFileStorage CvOpenFileStorage(string filename, int flags)
		{
			IntPtr p = cvOpenFileStorage(filename, IntPtr.Zero, flags);
			CvFileStorage i = (CvFileStorage)Marshal.PtrToStructure(p, typeof(CvFileStorage));
			i.ptr = p;
			return i;
		}
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern IntPtr cvOpenFileStorage([MarshalAs(UnmanagedType.LPStr)] String filename, ref CvMemStorage memstorage, int flags);
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern IntPtr cvOpenFileStorage([MarshalAs(UnmanagedType.LPStr)] String filename, IntPtr memstorage, int flags);


		/// <summary>
		/// ReleaseFileStorage 
		/// Releases file storage 
		/// </summary>
		/// <param name="fs"></param>
		/// <returns></returns>
		public static void CvReleaseFileStorage(ref CvFileStorage fs)
		{
			cvReleaseFileStorage(ref fs.ptr);
		}
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern void cvReleaseFileStorage(ref IntPtr fs);

		/// <summary>
		/// StartWriteStruct 
		/// Starts writing a new structure 
		/// </summary>
		/// <param name="fs"></param>
		/// <returns></returns>
		public static void CvStartWriteStruct(ref CvFileStorage fs, string name, int struct_flags, string type_name, CvAttrList attributes)
		{
			cvStartWriteStruct(ref fs, name, struct_flags, type_name, attributes);
		}
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern void cvStartWriteStruct(ref CvFileStorage fs, [MarshalAs(UnmanagedType.LPStr)] String name, int struct_flags, [MarshalAs(UnmanagedType.LPStr)] String type_name, CvAttrList attributes);

		/// <summary>
		/// EndWriteStruct 
		/// Ends writing a structure 
		/// </summary>
		/// <param name="fs"></param>
		/// <returns></returns>
		public static void CvEndWriteStruct(ref CvFileStorage fs)
		{
			cvEndWriteStruct(ref fs);
		}
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern void cvEndWriteStruct(ref CvFileStorage fs);

		/// <summary>
		/// WriteInt 
		/// Writes an integer value 
		/// </summary>
		/// <param name="fs"></param>
		/// <returns></returns>
		public static void CvWriteInt(ref CvFileStorage fs, string name, int value)
		{
			cvWriteInt(ref fs, name, value);
		}
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern void cvWriteInt(ref CvFileStorage fs, [MarshalAs(UnmanagedType.LPStr)] String name, int value);

		/// <summary>
		/// WriteReal 
		/// Writes a floating-point value 
		/// </summary>
		/// <param name="fs"></param>
		/// <returns></returns>
		public static void CvWriteReal(ref CvFileStorage fs, string name, double value)
		{
			cvWriteReal(ref fs, name, value);
		}
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern void cvWriteReal(ref CvFileStorage fs, [MarshalAs(UnmanagedType.LPStr)] String name, double value);

		/// <summary>
		/// WriteString 
		/// Writes a text string 
		/// </summary>
		/// <param name="fs"></param>
		/// <returns></returns>
		public static void CvWriteString(ref CvFileStorage fs, string name, string str, int quote)
		{
			cvWriteString(ref fs, name, str, quote);
		}
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern void cvWriteString(ref CvFileStorage fs, [MarshalAs(UnmanagedType.LPStr)] String name, [MarshalAs(UnmanagedType.LPStr)] String str, int quote);

		/// <summary>
		/// WriteComment 
		/// Writes comment 
		/// </summary>
		/// <param name="fs"></param>
		/// <returns></returns>
		public static void CvWriteComment(ref CvFileStorage fs, string comment, int eol_comment)
		{
			cvWriteComment(ref fs, comment, eol_comment);
		}
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern void cvWriteComment(ref CvFileStorage fs, [MarshalAs(UnmanagedType.LPStr)] String comment, int eol_comment);

		/// <summary>
		/// StartNextStream 
		/// Starts the next stream 
		/// </summary>
		/// <param name="fs"></param>
		/// <returns></returns>
		public static void CvStartNextStream(ref CvFileStorage fs)
		{
			cvStartNextStream(ref fs);
		}
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern void cvStartNextStream(ref CvFileStorage fs);

		/// <summary>
		/// Write 
		/// Writes user object 
		/// </summary>
		/// <param name="fs"></param>
		/// <returns></returns>
		public static void CvWrite(ref CvFileStorage fs, string name, IntPtr ptr, CvAttrList attributes)
		{
			cvWrite(ref fs, name, ptr, attributes);
		}
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern void cvWrite(ref CvFileStorage fs, [MarshalAs(UnmanagedType.LPStr)] String name, IntPtr ptr, CvAttrList attributes);

		/// <summary>
		/// WriteRawData 
		/// Writes multiple numbers 
		/// </summary>
		/// <param name="fs"></param>
		/// <returns></returns>
		public static void CvWriteRawData(ref CvFileStorage fs, IntPtr src, int len, string dt)
		{
			cvWriteRawData(ref fs, src, len, dt);
		}
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern void cvWriteRawData(ref CvFileStorage fs, IntPtr src, int len, [MarshalAs(UnmanagedType.LPStr)] String dt);

		/// <summary>
		/// WriteFileNode 
		/// Writes file node to another file storage 
		/// </summary>
		/// <param name="fs"></param>
		/// <returns></returns>
		public static void CvWriteFileNode(ref CvFileStorage fs, string new_node_name, ref CvFileNode node, int embed)
		{
			cvWriteFileNode(ref fs, new_node_name, ref node, embed);
		}
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern void cvWriteFileNode(ref CvFileStorage fs, [MarshalAs(UnmanagedType.LPStr)] String new_node_name, ref CvFileNode node, int embed);

		/// <summary>
		/// GetRootFileNode 
		/// Retrieves one of top-level nodes of the file storage 
		/// </summary>
		/// <param name="fs"></param>
		/// <returns></returns>
		public static CvFileNode CvGetRootFileNode(ref CvFileStorage fs, int stream_index)
		{
			IntPtr p = cvGetRootFileNode(ref fs, stream_index);
			CvFileNode i = (CvFileNode)Marshal.PtrToStructure(p, typeof(CvFileNode));
			i.ptr = p;
			return i;
		}
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern IntPtr cvGetRootFileNode(ref CvFileStorage fs, int stream_index);

		/// <summary>
		/// GetFileNodeByName 
		/// Finds node in the map or file storage 
		/// </summary>
		/// <param name="fs"></param>
		/// <returns></returns>
		public static CvFileNode CvGetFileNodeByName(ref CvFileStorage fs, string name)
		{
			IntPtr p = cvGetFileNodeByName(ref fs, IntPtr.Zero, name);
			CvFileNode i = (CvFileNode)Marshal.PtrToStructure(p, typeof(CvFileNode));
			i.ptr = p;
			return i;
		}
		public static CvFileNode CvGetFileNodeByName(ref CvFileStorage fs, ref CvFileNode map, string name)
		{
			IntPtr p = cvGetFileNodeByName(ref fs, ref map, name);
			CvFileNode i = (CvFileNode)Marshal.PtrToStructure(p, typeof(CvFileNode));
			i.ptr = p;
			return i;
		}
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern IntPtr cvGetFileNodeByName(ref CvFileStorage fs, ref CvFileNode map, [MarshalAs(UnmanagedType.LPStr)] String name);
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern IntPtr cvGetFileNodeByName(ref CvFileStorage fs, IntPtr map, [MarshalAs(UnmanagedType.LPStr)] String name);
		
		/// <summary>
		/// GetHashedKey 
		/// Returns a unique pointer for given name 
		/// </summary>
		/// <param name="fs"></param>
		/// <returns></returns>
		public static CvStringHashNode CvGetHashedKey(ref CvFileStorage fs, string name, int len, int create_missing)
		{
			IntPtr p = cvGetHashedKey(ref fs, name, len, create_missing);
			CvStringHashNode i = (CvStringHashNode)Marshal.PtrToStructure(p, typeof(CvStringHashNode));
			i.ptr = p;
			return i;
		}
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern IntPtr cvGetHashedKey(ref CvFileStorage fs, [MarshalAs(UnmanagedType.LPStr)] String name, int len, int create_missing);

		/// <summary>
		/// GetFileNode 
		/// Finds node in the map or file storage 
		/// </summary>
		/// <param name="fs"></param>
		/// <returns></returns>
		public static CvFileNode CvGetFileNode(ref CvFileStorage fs, ref CvFileNode map, ref CvStringHashNode key, int create_missing)
		{
			IntPtr p = cvGetFileNode(ref fs, ref map, ref key, create_missing);
			CvFileNode i = (CvFileNode)Marshal.PtrToStructure(p, typeof(CvFileNode));
			i.ptr = p;
			return i;
		}
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern IntPtr cvGetFileNode(ref CvFileStorage fs, ref CvFileNode map, ref CvStringHashNode key, int create_missing);

		/// <summary>
		/// GetFileNodeName 
		/// Returns name of file node 
		/// </summary>
		/// <param name="node"></param>
		/// <returns></returns>
		public static string CvGetFileNodeName(ref CvFileNode node)
		{
			return Marshal.PtrToStringAnsi(cvGetFileNodeName(ref node));
		}
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern IntPtr cvGetFileNodeName(ref CvFileNode node);

		/// <summary>
		/// ReadInt 
		/// Retrieves integer value from file node 
		/// </summary>
		/// <param name="node"></param>
		/// <returns></returns>
		public static int CvReadInt(ref CvFileNode node, int default_value)
		{
			return cvReadInt(ref node, default_value);
		}
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern int cvReadInt(ref CvFileNode node, int default_value);

		/// <summary>
		/// ReadIntByName 
		/// Finds file node and returns its value 
		/// </summary>
		/// <param name="fs"></param>
		/// <returns></returns>
		public static int CvReadIntByName(ref CvFileStorage fs, ref CvFileNode map, string name, int default_value)
		{
			return cvReadIntByName(ref fs, ref map, name, default_value);
		}
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern int cvReadIntByName(ref CvFileStorage fs, ref CvFileNode map, [MarshalAs(UnmanagedType.LPStr)] String name, int default_value);

		/// <summary>
		/// ReadReal 
		/// Retrieves floating-point value from file node 
		/// </summary>
		/// <param name="node"></param>
		/// <returns></returns>
		public static double CvReadReal(ref CvFileNode node, double default_value)
		{
			return cvReadReal(ref node, default_value);
		}
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern double cvReadReal(ref CvFileNode node, double default_value);

		/// <summary>
		/// ReadRealByName 
		/// Finds file node and returns its value 
		/// </summary>
		/// <param name="fs"></param>
		/// <returns></returns>
		public static double CvReadRealByName(ref CvFileStorage fs, ref CvFileNode map, string name, double default_value)
		{
			return cvReadRealByName(ref fs, ref map, name, default_value);
		}
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern double cvReadRealByName(ref CvFileStorage fs, ref CvFileNode map, [MarshalAs(UnmanagedType.LPStr)] String name, double default_value);

		/// <summary>
		/// ReadString 
		/// Retrieves text string from file node 
		/// </summary>
		/// <param name="node"></param>
		/// <returns></returns>
		public static string CvReadString(ref CvFileNode node, string default_value)
		{
			return Marshal.PtrToStringAnsi(cvReadString(ref node, default_value));
		}
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern IntPtr cvReadString(ref CvFileNode node, [MarshalAs(UnmanagedType.LPStr)] String default_value);

		/// <summary>
		/// ReadStringByName 
		/// Finds file node and returns its value 
		/// </summary>
		/// <param name="fs"></param>
		/// <returns></returns>
		public static string CvReadStringByName(ref CvFileStorage fs, ref CvFileNode map, string name, string default_value)
		{
			return Marshal.PtrToStringAnsi(cvReadStringByName(ref fs, ref map, name, default_value));
		}
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern IntPtr cvReadStringByName(ref CvFileStorage fs, ref CvFileNode map, [MarshalAs(UnmanagedType.LPStr)] String name, [MarshalAs(UnmanagedType.LPStr)] String default_value);

		/// <summary>
		/// Read 
		/// Decodes object and returns pointer to it 
		/// </summary>
		/// <param name="fs"></param>
		/// <returns></returns>
		public static IntPtr CvRead(ref CvFileStorage fs, ref CvFileNode node)
		{
			return cvRead(ref fs, ref node, IntPtr.Zero);
		}
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern IntPtr cvRead(ref CvFileStorage fs, ref CvFileNode node, IntPtr attributes);


		/// <summary>
		/// ReadRawData 
		/// Reads multiple numbers 
		/// </summary>
		/// <param name="fs"></param>
		/// <returns></returns>
		public static void CvReadRawData(ref CvFileStorage fs, ref CvFileNode src, IntPtr dst, string dt)
		{
			cvReadRawData(ref fs, ref src, dst, dt);
		}
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern void cvReadRawData(ref CvFileStorage fs, ref CvFileNode src, IntPtr dst, [MarshalAs(UnmanagedType.LPStr)] String dt);

		/// <summary>
		/// StartReadRawData 
		/// Initializes file node sequence reader 
		/// </summary>
		/// <param name="fs"></param>
		/// <returns></returns>
		public static void CvStartReadRawData(ref CvFileStorage fs, ref CvFileNode src, ref CvSeqReader reader)
		{
			cvStartReadRawData(ref fs, ref src, ref reader);
		}
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern void cvStartReadRawData(ref CvFileStorage fs, ref CvFileNode src, ref CvSeqReader reader);

		/// <summary>
		/// ReadRawDataSlice 
		/// Initializes file node sequence reader 
		/// </summary>
		/// <param name="fs"></param>
		/// <returns></returns>
		public static void CvReadRawDataSlice(ref CvFileStorage fs, ref CvSeqReader reader, int count, IntPtr dst, string dt)
		{
			cvReadRawDataSlice(ref fs, ref reader, count, dst, dt);
		}
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern void cvReadRawDataSlice(ref CvFileStorage fs, ref CvSeqReader reader, int count, IntPtr dst, [MarshalAs(UnmanagedType.LPStr)] String dt);

		/// <summary>
		/// CvTypeInfo 
		/// Type information 
		/// </summary>
		/// <param name="info"></param>
		/// <returns></returns>
		public static void CvRegisterType(ref CvTypeInfo info)
		{
			cvRegisterType(ref info);
		}
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern void cvRegisterType(ref CvTypeInfo info);


		/// <summary>
		/// UnregisterType 
		/// Unregisters the type 
		/// </summary>
		/// <param name="type_name"></param>
		/// <returns></returns>
		public static void CvUnregisterType(string type_name)
		{
			cvUnregisterType(type_name);
		}
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern void cvUnregisterType([MarshalAs(UnmanagedType.LPStr)] String type_name);

		
		public static CvTypeInfo CvFindType(string name)
		{
			IntPtr p = cvFindType(name);
			CvTypeInfo i = (CvTypeInfo)Marshal.PtrToStructure(p, typeof(CvTypeInfo));
			i.ptr = p;
			return i;
		}
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern IntPtr cvFindType([MarshalAs(UnmanagedType.LPStr)] String name);

		/// <summary>
		/// FirstType 
		/// Returns the beginning of type list 
		/// </summary>
		/// <param name="type_name"></param>
		/// <returns></returns>
		public static CvTypeInfo CvFirstType()
		{
			IntPtr p = cvFirstType();
			CvTypeInfo i = (CvTypeInfo)Marshal.PtrToStructure(p, typeof(CvTypeInfo));
			i.ptr = p;
			return i;
		}
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern IntPtr cvFirstType();

		/// <summary>
		/// TypeOf 
		/// Returns type of the object 
		/// </summary>
		/// <param name="struct_ptr"></param>
		/// <returns></returns>
		public static CvTypeInfo CvTypeOf(IntPtr struct_ptr)
		{
			IntPtr p = cvTypeOf(struct_ptr);
			CvTypeInfo i = (CvTypeInfo)Marshal.PtrToStructure(p, typeof(CvTypeInfo));
			i.ptr = p;
			return i;
		}
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern IntPtr cvTypeOf(IntPtr struct_ptr);

		/// <summary>
		/// Release 
		/// Releases the object 
		/// </summary>
		/// <param name="struct_ptr"></param>
		/// <returns></returns>
		public static void CvRelease(ref IntPtr struct_ptr)
		{
			cvRelease(ref struct_ptr);
		}
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern void cvRelease(ref IntPtr struct_ptr);

		/// <summary>
		/// Clone 
		/// Makes a clone of the object 
		/// </summary>
		/// <param name="struct_ptr"></param>
		/// <returns></returns>
		public static IntPtr CvClone(IntPtr struct_ptr)
		{
			return cvClone(struct_ptr);
		}
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern IntPtr cvClone(IntPtr struct_ptr);

		/// <summary>
		/// Save 
		/// Saves object to file 
		/// </summary>
		/// <param name="filename"></param>
		/// <returns></returns>
		public static void CvSave(string filename, IntPtr struct_ptr, string name, string comment, CvAttrList attributes)
		{
			cvSave(filename, struct_ptr, name, comment, attributes);
		}
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern void cvSave([MarshalAs(UnmanagedType.LPStr)] String filename, IntPtr struct_ptr, [MarshalAs(UnmanagedType.LPStr)] String name, [MarshalAs(UnmanagedType.LPStr)] String comment, CvAttrList attributes);

		/// <summary>
		/// Load 
		/// Loads object from file 
		/// </summary>
		/// <param name="filename"></param>
		/// <returns></returns>
		public static IntPtr CvLoad([MarshalAs(UnmanagedType.LPStr)] String filename, ref CvMemStorage memstorage, [MarshalAs(UnmanagedType.LPStr)] String name, ref StringBuilder real_name)
		{
			return cvLoad(filename, ref memstorage, name, ref real_name);
		}
		public static IntPtr CvLoad(string filename)
		{
			return cvLoad(filename, IntPtr.Zero, null, IntPtr.Zero);
		}
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		public static extern IntPtr cvLoad([MarshalAs(UnmanagedType.LPStr)] String filename, IntPtr memstorage, [MarshalAs(UnmanagedType.LPStr)] String name, IntPtr real_name);
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern IntPtr cvLoad([MarshalAs(UnmanagedType.LPStr)] String filename, ref CvMemStorage memstorage, [MarshalAs(UnmanagedType.LPStr)] String name, ref StringBuilder real_name);

		/// <summary>
		/// CheckArr 
		/// Checks every element of input array for invalid values 
		/// </summary>
		/// <param name="arr"></param>
		/// <returns></returns>
		public static int CvCheckArr(ref IplImage arr, int flags, double min_val, double max_val)
		{
			return cvCheckArr(ref arr, flags, min_val, max_val);
		}
		public static int CvCheckArr(ref CvMat arr, int flags, double min_val, double max_val)
		{
			return cvCheckArr(ref arr, flags, min_val, max_val);
		}
		public static int CvCheckArr(ref CvSeq arr, int flags, double min_val, double max_val)
		{
			return cvCheckArr(ref arr, flags, min_val, max_val);
		}
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern int cvCheckArr(ref IplImage arr, int flags, double min_val, double max_val);
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern int cvCheckArr(ref CvMat arr, int flags, double min_val, double max_val);
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern int cvCheckArr(ref CvSeq arr, int flags, double min_val, double max_val);

		/// <summary>
		/// KMeans2 
		/// Splits set of vectors by given number of clusters 
		/// </summary>
		/// <param name="samples"></param>
		/// <returns></returns>
		public static void CvKMeans2(ref IplImage samples, int cluster_count, ref IplImage labels, CvTermCriteria termcrit)
		{
			cvKMeans2(ref samples, cluster_count, ref labels, termcrit);
		}
		public static void CvKMeans2(ref CvMat samples, int cluster_count, ref CvMat labels, CvTermCriteria termcrit)
		{
			cvKMeans2(ref samples, cluster_count, ref labels, termcrit);
		}
		public static void CvKMeans2(ref CvSeq samples, int cluster_count, ref CvSeq labels, CvTermCriteria termcrit)
		{
			cvKMeans2(ref samples, cluster_count, ref labels, termcrit);
		}
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern void cvKMeans2(ref IplImage samples, int cluster_count, ref IplImage labels, CvTermCriteria termcrit);
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern void cvKMeans2(ref CvMat samples, int cluster_count, ref CvMat labels, CvTermCriteria termcrit);
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern void cvKMeans2(ref CvSeq samples, int cluster_count, ref CvSeq labels, CvTermCriteria termcrit);

		/// <summary>
		/// SeqPartition 
		/// Splits sequence into equivalency classes 
		/// </summary>
		/// <param name="seq"></param>
		/// <returns></returns>
		public static int CvSeqPartition(ref CvSeq seq, ref CvMemStorage storage, ref CvSeq labels, IntPtr is_equal, IntPtr userdata)
		{
			return cvSeqPartition(ref seq, ref storage, ref labels, is_equal, userdata);
		}
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern int cvSeqPartition(ref CvSeq seq, ref CvMemStorage storage, ref CvSeq labels, IntPtr is_equal, IntPtr userdata);


		/// <summary>
		/// ERROR Handling Macros 
		/// Macros for raising an error, checking for errors etc 
		/// </summary>
		/// <param name="status"></param>
		/// <returns></returns>
		public static int CvSetErrMode(int mode)
		{
			return cvSetErrMode(mode);
		}
		[DllImport(CXCORE_LIBRARY)]
		private static extern int cvSetErrMode(int mode);

		public static void CvSetErrStatus(int status)
		{
			cvSetErrStatus(status);
		}
		[DllImport(CXCORE_LIBRARY)]
		private static extern void cvSetErrStatus(int status);

		/// <summary>
		/// GetErrMode 
		/// Returns the current error mode 
		/// </summary>
		/// <param name="mode"></param>
		/// <returns></returns>
		public static int CvGetErrMode()
		{
			return cvGetErrMode();
		}
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern int cvGetErrMode();

		public static int CvGetErrStatus()
		{
			return cvGetErrStatus();
		}
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern int cvGetErrStatus();

		/// <summary>
		/// Error 
		/// Raises an error 
		/// </summary>
		/// <param name="status"></param>
		/// <returns></returns>
		public static int CvError(int status, string func_name, string err_msg, string file_name, int line)
		{
			return cvError(status, func_name, err_msg, file_name, line);
		}
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern int cvError(int status, [MarshalAs(UnmanagedType.LPStr)] String func_name, [MarshalAs(UnmanagedType.LPStr)] String err_msg, [MarshalAs(UnmanagedType.LPStr)] String file_name, int line);

		/// <summary>
		/// ErrorStr 
		/// Returns textual description of error status code 
		/// </summary>
		/// <param name="status"></param>
		/// <returns></returns>
		public static string CvErrorStr(int status)
		{
			return Marshal.PtrToStringAnsi(cvErrorStr(status));
		}
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern IntPtr cvErrorStr(int status);

		/// <summary>
		/// RedirectError 
		/// Sets a new error handler 
		/// </summary>
		/// <param name="error_handler"></param>
		/// <returns></returns>
		public static OnErrorCallback CvRedirectError(OnErrorCallback on_error)
		{
			return cvRedirectError(on_error, IntPtr.Zero, IntPtr.Zero);
		}
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern OnErrorCallback cvRedirectError(
			[MarshalAs(UnmanagedType.FunctionPtr)] OnErrorCallback error_handler,
																						 IntPtr userdata, 
																						 IntPtr prev_userdata);
		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		public delegate int OnErrorCallback(int status, 
			[MarshalAs(UnmanagedType.LPStr)] String func_name,
			[MarshalAs(UnmanagedType.LPStr)] String err_msg,
			[MarshalAs(UnmanagedType.LPStr)] String file_name, 
			int line);

		/// <summary>
		/// Alloc 
		/// Allocates memory buffer 
		/// </summary>
		/// <param name="size"></param>
		/// <returns></returns>
		public static IntPtr CvAlloc(int size)
		{
			return cvAlloc(size);
		}
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern IntPtr cvAlloc(int size);

		/// <summary>
		/// Free 
		/// Deallocates memory buffer 
		/// </summary>
		/// <param name="buffer"></param>
		/// <returns></returns>
		public static void CvFree(ref IntPtr arr)
		{
			cvFree(ref arr);
		}
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern void cvFree(ref IntPtr ptr);

		/// <summary>
		/// GetTickCount 
		/// Returns number of tics 
		/// </summary>
		/// <param name="module_info"></param>
		/// <returns></returns>
		public static Int64 CvGetTickCount()
		{
			return cvGetTickCount();
		}
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern Int64 cvGetTickCount();

		public static double CvGetTickFrequency()
		{
			return cvGetTickFrequency();
		}
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern double cvGetTickFrequency();


		public static int CvRegisterModule(ref CvModuleInfo module_info )
		{
			return cvRegisterModule(ref module_info );
		}
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern int cvRegisterModule(ref CvModuleInfo module_info );
		/// <summary>
		/// GetModuleInfo 
		/// Retrieves information about the registered module(s) and plugins 
		/// </summary>
		/// <param name="module_name"></param>
		/// <returns></returns>
		public static void CvGetModuleInfo(string module_name, ref StringBuilder loaded_addon_plugins)
		{
			cvGetModuleInfo(module_name, ref loaded_addon_plugins);
		}
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern void cvGetModuleInfo([MarshalAs(UnmanagedType.LPStr)] String module_name, ref StringBuilder loaded_addon_plugins);

		/// <summary>
		/// UseOptimized 
		/// Switches between optimized/non-optimized modes 
		/// </summary>
		/// <param name="on_off"></param>
		/// <returns></returns>
		public static int CvUseOptimized(int on_off)
		{
			return cvUseOptimized(on_off);
		}
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern int cvUseOptimized(int on_off);

		/// <summary>
		/// SetMemoryManager 
		/// Assings custom/default memory managing functions 
		/// </summary>
		/// <param name="alloc_func"></param>
		/// <returns></returns>
		// This function is not implemented

		/// <summary>
		/// SetIPLAllocators 
		/// Switches to IPL functions for image allocation/deallocation 
		/// </summary>
		/// <param name="create_header"></param>
		/// <returns></returns>
		// This function is not implemented



		public static int CvGetNumThreads()
		{
			return cvGetNumThreads();
		}
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern int cvGetNumThreads();

		/// <summary>
		/// GetNumThreads 
		/// Returns the current number of threads used 
		/// </summary>
		/// <param name="threads"></param>
		/// <returns></returns>
		public static int CvSetNumThreads(int threads)
		{
			return cvSetNumThreads(threads);
		}
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern int cvSetNumThreads(int threads);

		/// <summary>
		/// GetThreadNum 
		/// Returns index of the current thread 
		/// </summary>
		/// <returns></returns>
		public static int CvGetThreadNum()
		{
			return cvGetThreadNum();
		}
		[DllImport(CXCORE_LIBRARY, CharSet = CharSet.Ansi)]
		private static extern int cvGetThreadNum();

	}
}