//*******************************************************************
// File name: $ Cv.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: cvGetMinMaxHistValue
// - Update 25.09.08, hki/gassner: CvCalcOpticalFlowPyrLK
// 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 CV_LIBRARY = "cv100d.dll";
#else
private const string CV_LIBRARY = "cv100.dll";
#endif
/// <summary>
/// Sobel
/// Calculates first, second, third or mixed image derivatives using extended Sobel operator
/// </summary>
/// <param name="src"></param>
/// <returns></returns>
public static void CvSobel(ref IplImage src, ref IplImage dst, int xorder, int yorder, int aperture_size)
{
cvSobel(ref src, ref dst, xorder, yorder, aperture_size);
}
public static void CvSobel(ref CvMat src, ref CvMat dst, int xorder, int yorder, int aperture_size)
{
cvSobel(ref src, ref dst, xorder, yorder, aperture_size);
}
public static void CvSobel(ref CvSeq src, ref CvSeq dst, int xorder, int yorder, int aperture_size)
{
cvSobel(ref src, ref dst, xorder, yorder, aperture_size);
}
[DllImport(CV_LIBRARY)]
private static extern void cvSobel(ref IplImage src, ref IplImage dst, int xorder, int yorder, int aperture_size);
[DllImport(CV_LIBRARY)]
private static extern void cvSobel(ref CvMat src, ref CvMat dst, int xorder, int yorder, int aperture_size);
[DllImport(CV_LIBRARY)]
private static extern void cvSobel(ref CvSeq src, ref CvSeq dst, int xorder, int yorder, int aperture_size);
/// <summary>
/// Laplace
/// Calculates Laplacian of the image
/// </summary>
/// <param name="src"></param>
/// <returns></returns>
public static void CvLaplace(ref IplImage src, ref IplImage dst, int aperture_size)
{
cvLaplace(ref src, ref dst, aperture_size);
}
public static void CvLaplace(ref CvMat src, ref CvMat dst, int aperture_size)
{
cvLaplace(ref src, ref dst, aperture_size);
}
public static void CvLaplace(ref CvSeq src, ref CvSeq dst, int aperture_size)
{
cvLaplace(ref src, ref dst, aperture_size);
}
[DllImport(CV_LIBRARY)]
private static extern void cvLaplace(ref IplImage src, ref IplImage dst, int aperture_size);
[DllImport(CV_LIBRARY)]
private static extern void cvLaplace(ref CvMat src, ref CvMat dst, int aperture_size);
[DllImport(CV_LIBRARY)]
private static extern void cvLaplace(ref CvSeq src, ref CvSeq dst, int aperture_size);
/// <summary>
/// Canny
/// Implements Canny algorithm for edge detection
/// </summary>
/// <param name="image"></param>
/// <returns></returns>
public static void CvCanny(ref IplImage image, ref IplImage edges, double threshold1, double threshold2, int aperture_size)
{
cvCanny(ref image, ref edges, threshold1, threshold2, aperture_size);
}
public static void CvCanny(ref CvMat image, ref CvMat edges, double threshold1, double threshold2, int aperture_size)
{
cvCanny(ref image, ref edges, threshold1, threshold2, aperture_size);
}
public static void CvCanny(ref CvSeq image, ref CvSeq edges, double threshold1, double threshold2, int aperture_size)
{
cvCanny(ref image, ref edges, threshold1, threshold2, aperture_size);
}
[DllImport(CV_LIBRARY)]
private static extern void cvCanny(ref IplImage image, ref IplImage edges, double threshold1, double threshold2, int aperture_size);
[DllImport(CV_LIBRARY)]
private static extern void cvCanny(ref CvMat image, ref CvMat edges, double threshold1, double threshold2, int aperture_size);
[DllImport(CV_LIBRARY)]
private static extern void cvCanny(ref CvSeq image, ref CvSeq edges, double threshold1, double threshold2, int aperture_size);
/// <summary>
/// PreCornerDetect
/// Calculates feature map for corner detection
/// </summary>
/// <param name="image"></param>
/// <returns></returns>
public static void CvPreCornerDetect(ref IplImage image, ref IplImage corners, int aperture_size)
{
cvPreCornerDetect(ref image, ref corners, aperture_size);
}
public static void CvPreCornerDetect(ref CvMat image, ref CvMat corners, int aperture_size)
{
cvPreCornerDetect(ref image, ref corners, aperture_size);
}
public static void CvPreCornerDetect(ref CvSeq image, ref CvSeq corners, int aperture_size)
{
cvPreCornerDetect(ref image, ref corners, aperture_size);
}
[DllImport(CV_LIBRARY)]
private static extern void cvPreCornerDetect(ref IplImage image, ref IplImage corners, int aperture_size);
[DllImport(CV_LIBRARY)]
private static extern void cvPreCornerDetect(ref CvMat image, ref CvMat corners, int aperture_size);
[DllImport(CV_LIBRARY)]
private static extern void cvPreCornerDetect(ref CvSeq image, ref CvSeq corners, int aperture_size);
/// <summary>
/// CornerEigenValsAndVecs
/// Calculates eigenvalues and eigenvectors of image blocks for corner detection
/// </summary>
/// <param name="image"></param>
/// <returns></returns>
public static void CvCornerEigenValsAndVecs(ref IplImage image, ref IplImage eigenvv, int block_size, int aperture_size)
{
cvCornerEigenValsAndVecs(ref image, ref eigenvv, block_size, aperture_size);
}
public static void CvCornerEigenValsAndVecs(ref CvMat image, ref CvMat eigenvv, int block_size, int aperture_size)
{
cvCornerEigenValsAndVecs(ref image, ref eigenvv, block_size, aperture_size);
}
public static void CvCornerEigenValsAndVecs(ref CvSeq image, ref CvSeq eigenvv, int block_size, int aperture_size)
{
cvCornerEigenValsAndVecs(ref image, ref eigenvv, block_size, aperture_size);
}
[DllImport(CV_LIBRARY)]
private static extern void cvCornerEigenValsAndVecs(ref IplImage image, ref IplImage eigenvv, int block_size, int aperture_size);
[DllImport(CV_LIBRARY)]
private static extern void cvCornerEigenValsAndVecs(ref CvMat image, ref CvMat eigenvv, int block_size, int aperture_size);
[DllImport(CV_LIBRARY)]
private static extern void cvCornerEigenValsAndVecs(ref CvSeq image, ref CvSeq eigenvv, int block_size, int aperture_size);
/// <summary>
/// CornerMinEigenVal
/// Calculates minimal eigenvalue of gradient matrices for corner detection
/// </summary>
/// <param name="image"></param>
/// <returns></returns>
public static void CvCornerMinEigenVal(ref IplImage image, ref IplImage eigenval, int block_size, int aperture_size)
{
cvCornerMinEigenVal(ref image, ref eigenval, block_size, aperture_size);
}
public static void CvCornerMinEigenVal(ref CvMat image, ref CvMat eigenval, int block_size, int aperture_size)
{
cvCornerMinEigenVal(ref image, ref eigenval, block_size, aperture_size);
}
public static void CvCornerMinEigenVal(ref CvSeq image, ref CvSeq eigenval, int block_size, int aperture_size)
{
cvCornerMinEigenVal(ref image, ref eigenval, block_size, aperture_size);
}
[DllImport(CV_LIBRARY)]
private static extern void cvCornerMinEigenVal(ref IplImage image, ref IplImage eigenval, int block_size, int aperture_size);
[DllImport(CV_LIBRARY)]
private static extern void cvCornerMinEigenVal(ref CvMat image, ref CvMat eigenval, int block_size, int aperture_size);
[DllImport(CV_LIBRARY)]
private static extern void cvCornerMinEigenVal(ref CvSeq image, ref CvSeq eigenval, int block_size, int aperture_size);
/// <summary>
/// CornerHarris
/// Harris edge detector
/// </summary>
/// <param name="image"></param>
/// <returns></returns>
public static void CvCornerHarris(ref IplImage image, ref IplImage harris_responce, int block_size, int aperture_size, double k)
{
cvCornerHarris(ref image, ref harris_responce, block_size, aperture_size, k);
}
public static void CvCornerHarris(ref CvMat image, ref CvMat harris_responce, int block_size, int aperture_size, double k)
{
cvCornerHarris(ref image, ref harris_responce, block_size, aperture_size, k);
}
public static void CvCornerHarris(ref CvSeq image, ref CvSeq harris_responce, int block_size, int aperture_size, double k)
{
cvCornerHarris(ref image, ref harris_responce, block_size, aperture_size, k);
}
[DllImport(CV_LIBRARY)]
private static extern void cvCornerHarris(ref IplImage image, ref IplImage harris_responce, int block_size, int aperture_size, double k);
[DllImport(CV_LIBRARY)]
private static extern void cvCornerHarris(ref CvMat image, ref CvMat harris_responce, int block_size, int aperture_size, double k);
[DllImport(CV_LIBRARY)]
private static extern void cvCornerHarris(ref CvSeq image, ref CvSeq harris_responce, int block_size, int aperture_size, double k);
/// <summary>
/// FindCornerSubPix
/// Refines corner locations
/// </summary>
/// <param name="image"></param>
/// <returns></returns>
public static void CvFindCornerSubPix(ref IplImage image, IntPtr corners, int count, CvSize win, CvSize zero_zone, CvTermCriteria criteria)
{
cvFindCornerSubPix(ref image, corners, count, win, zero_zone, criteria);
}
public static void CvFindCornerSubPix(ref CvMat image, IntPtr corners, int count, CvSize win, CvSize zero_zone, CvTermCriteria criteria)
{
cvFindCornerSubPix(ref image, corners, count, win, zero_zone, criteria);
}
public static void CvFindCornerSubPix(ref CvSeq image, IntPtr corners, int count, CvSize win, CvSize zero_zone, CvTermCriteria criteria)
{
cvFindCornerSubPix(ref image, corners, count, win, zero_zone, criteria);
}
[DllImport(CV_LIBRARY)]
private static extern void cvFindCornerSubPix(ref IplImage image, IntPtr corners, int count, CvSize win, CvSize zero_zone, CvTermCriteria criteria);
[DllImport(CV_LIBRARY)]
private static extern void cvFindCornerSubPix(ref CvMat image, IntPtr corners, int count, CvSize win, CvSize zero_zone, CvTermCriteria criteria);
[DllImport(CV_LIBRARY)]
private static extern void cvFindCornerSubPix(ref CvSeq image, IntPtr corners, int count, CvSize win, CvSize zero_zone, CvTermCriteria criteria);
/// <summary>
/// GoodFeaturesToTrack
/// Determines strong corners on image
/// </summary>
/// <param name="image"></param>
/// <returns></returns>
public static void CvGoodFeaturesToTrack(ref IplImage image, ref IplImage eig_image, ref IplImage temp_image, IntPtr corners, ref int corner_count, double quality_level, double min_distance, IntPtr mask, int block_size, int use_harris, double k)
{
cvGoodFeaturesToTrack(ref image, ref eig_image, ref temp_image, corners, ref corner_count, quality_level, min_distance, mask, block_size, use_harris, k);
}
public static void CvGoodFeaturesToTrack(ref CvMat image, ref CvMat eig_image, ref CvMat temp_image, IntPtr corners, ref int corner_count, double quality_level, double min_distance, IntPtr mask, int block_size, int use_harris, double k)
{
cvGoodFeaturesToTrack(ref image, ref eig_image, ref temp_image, corners, ref corner_count, quality_level, min_distance, mask, block_size, use_harris, k);
}
public static void CvGoodFeaturesToTrack(ref CvSeq image, ref CvSeq eig_image, ref CvSeq temp_image, IntPtr corners, ref int corner_count, double quality_level, double min_distance, IntPtr mask, int block_size, int use_harris, double k)
{
cvGoodFeaturesToTrack(ref image, ref eig_image, ref temp_image, corners, ref corner_count, quality_level, min_distance, mask, block_size, use_harris, k);
}
[DllImport(CV_LIBRARY)]
private static extern void cvGoodFeaturesToTrack(ref IplImage image, ref IplImage eig_image, ref IplImage temp_image, IntPtr corners, ref int corner_count, double quality_level, double min_distance, IntPtr mask, int block_size, int use_harris, double k);
[DllImport(CV_LIBRARY)]
private static extern void cvGoodFeaturesToTrack(ref CvMat image, ref CvMat eig_image, ref CvMat temp_image, IntPtr corners, ref int corner_count, double quality_level, double min_distance, IntPtr mask, int block_size, int use_harris, double k);
[DllImport(CV_LIBRARY)]
private static extern void cvGoodFeaturesToTrack(ref CvSeq image, ref CvSeq eig_image, ref CvSeq temp_image, IntPtr corners, ref int corner_count, double quality_level, double min_distance, IntPtr mask, int block_size, int use_harris, double k);
/// <summary>
/// SampleLine
/// Reads raster line to buffer
/// </summary>
/// <param name="image"></param>
/// <returns></returns>
public static int CvSampleLine(ref IplImage image, CvPoint pt1, CvPoint pt2, IntPtr buffer, int connectivity)
{
return cvSampleLine(ref image, pt1, pt2, buffer, connectivity);
}
public static int CvSampleLine(ref CvMat image, CvPoint pt1, CvPoint pt2, IntPtr buffer, int connectivity)
{
return cvSampleLine(ref image, pt1, pt2, buffer, connectivity);
}
public static int CvSampleLine(ref CvSeq image, CvPoint pt1, CvPoint pt2, IntPtr buffer, int connectivity)
{
return cvSampleLine(ref image, pt1, pt2, buffer, connectivity);
}
[DllImport(CV_LIBRARY)]
private static extern int cvSampleLine(ref IplImage image, CvPoint pt1, CvPoint pt2, IntPtr buffer, int connectivity);
[DllImport(CV_LIBRARY)]
private static extern int cvSampleLine(ref CvMat image, CvPoint pt1, CvPoint pt2, IntPtr buffer, int connectivity);
[DllImport(CV_LIBRARY)]
private static extern int cvSampleLine(ref CvSeq image, CvPoint pt1, CvPoint pt2, IntPtr buffer, int connectivity);
/// <summary>
/// GetRectSubPix
/// Retrieves pixel rectangle from image with sub-pixel accuracy
/// </summary>
/// <param name="src"></param>
/// <returns></returns>
public static void CvGetRectSubPix(ref IplImage src, ref IplImage dst, CvPoint2D32f center)
{
cvGetRectSubPix(ref src, ref dst, center);
}
public static void CvGetRectSubPix(ref CvMat src, ref CvMat dst, CvPoint2D32f center)
{
cvGetRectSubPix(ref src, ref dst, center);
}
public static void CvGetRectSubPix(ref CvSeq src, ref CvSeq dst, CvPoint2D32f center)
{
cvGetRectSubPix(ref src, ref dst, center);
}
[DllImport(CV_LIBRARY)]
private static extern void cvGetRectSubPix(ref IplImage src, ref IplImage dst, CvPoint2D32f center);
[DllImport(CV_LIBRARY)]
private static extern void cvGetRectSubPix(ref CvMat src, ref CvMat dst, CvPoint2D32f center);
[DllImport(CV_LIBRARY)]
private static extern void cvGetRectSubPix(ref CvSeq src, ref CvSeq dst, CvPoint2D32f center);
/// <summary>
/// GetQuadrangleSubPix
/// Retrieves pixel quadrangle from image with sub-pixel accuracy
/// </summary>
/// <param name="src"></param>
/// <returns></returns>
public static void CvGetQuadrangleSubPix(ref IplImage src, ref IplImage dst, ref CvMat map_matrix)
{
cvGetQuadrangleSubPix(ref src, ref dst, ref map_matrix);
}
public static void CvGetQuadrangleSubPix(ref CvMat src, ref CvMat dst, ref CvMat map_matrix)
{
cvGetQuadrangleSubPix(ref src, ref dst, ref map_matrix);
}
public static void CvGetQuadrangleSubPix(ref CvSeq src, ref CvSeq dst, ref CvMat map_matrix)
{
cvGetQuadrangleSubPix(ref src, ref dst, ref map_matrix);
}
[DllImport(CV_LIBRARY)]
private static extern void cvGetQuadrangleSubPix(ref IplImage src, ref IplImage dst, ref CvMat map_matrix);
[DllImport(CV_LIBRARY)]
private static extern void cvGetQuadrangleSubPix(ref CvMat src, ref CvMat dst, ref CvMat map_matrix);
[DllImport(CV_LIBRARY)]
private static extern void cvGetQuadrangleSubPix(ref CvSeq src, ref CvSeq dst, ref CvMat map_matrix);
/// <summary>
/// Resize
/// Resizes image
/// </summary>
/// <param name="src"></param>
/// <returns></returns>
public static void CvResize(ref IplImage src, ref IplImage dst, int interpolation)
{
cvResize(ref src, ref dst, interpolation);
}
public static void CvResize(ref CvMat src, ref CvMat dst, int interpolation)
{
cvResize(ref src, ref dst, interpolation);
}
public static void CvResize(ref CvSeq src, ref CvSeq dst, int interpolation)
{
cvResize(ref src, ref dst, interpolation);
}
[DllImport(CV_LIBRARY)]
private static extern void cvResize(ref IplImage src, ref IplImage dst, int interpolation);
[DllImport(CV_LIBRARY)]
private static extern void cvResize(ref CvMat src, ref CvMat dst, int interpolation);
[DllImport(CV_LIBRARY)]
private static extern void cvResize(ref CvSeq src, ref CvSeq dst, int interpolation);
/// <summary>
/// WarpAffine
/// Applies affine transformation to the image
/// </summary>
/// <param name="src"></param>
/// <returns></returns>
public static void CvWarpAffine(ref IplImage src, ref IplImage dst, ref CvMat map_matrix, int flags, CvScalar fillval)
{
cvWarpAffine(ref src, ref dst, ref map_matrix, flags, fillval);
}
public static void CvWarpAffine(ref CvMat src, ref CvMat dst, ref CvMat map_matrix, int flags, CvScalar fillval)
{
cvWarpAffine(ref src, ref dst, ref map_matrix, flags, fillval);
}
public static void CvWarpAffine(ref CvSeq src, ref CvSeq dst, ref CvMat map_matrix, int flags, CvScalar fillval)
{
cvWarpAffine(ref src, ref dst, ref map_matrix, flags, fillval);
}
[DllImport(CV_LIBRARY)]
private static extern void cvWarpAffine(ref IplImage src, ref IplImage dst, ref CvMat map_matrix, int flags, CvScalar fillval);
[DllImport(CV_LIBRARY)]
private static extern void cvWarpAffine(ref CvMat src, ref CvMat dst, ref CvMat map_matrix, int flags, CvScalar fillval);
[DllImport(CV_LIBRARY)]
private static extern void cvWarpAffine(ref CvSeq src, ref CvSeq dst, ref CvMat map_matrix, int flags, CvScalar fillval);
/// <summary>
/// GetAffineTransform
/// Calculates affine transform from 3 corresponding points
/// </summary>
/// <param name="src"></param>
/// <returns></returns>
public static CvMat CvGetAffineTransform(IntPtr src, IntPtr dst, ref CvMat map_matrix)
{
IntPtr p = cvGetAffineTransform(src, dst, ref map_matrix);
CvMat i = (CvMat)Marshal.PtrToStructure(p, typeof(CvMat));
i.ptr = p;
return i;
}
[DllImport(CV_LIBRARY)]
private static extern IntPtr cvGetAffineTransform(IntPtr src, IntPtr dst, ref CvMat map_matrix);
/// <summary>
/// 2DRotationMatrix
/// Calculates affine matrix of 2d rotation
/// </summary>
/// <param name="center"></param>
/// <returns></returns>
public static CvMat Cv2DRotationMatrix(CvPoint2D32f center, double angle, double scale, ref CvMat map_matrix)
{
IntPtr p = cv2DRotationMatrix(center, angle, scale, ref map_matrix);
CvMat i = (CvMat)Marshal.PtrToStructure(p, typeof(CvMat));
i.ptr = p;
return i;
}
[DllImport(CV_LIBRARY)]
private static extern IntPtr cv2DRotationMatrix(CvPoint2D32f center, double angle, double scale, ref CvMat map_matrix);
/// <summary>
/// WarpPerspective
/// Applies perspective transformation to the image
/// </summary>
/// <param name="src"></param>
/// <returns></returns>
public static void CvWarpPerspective(ref IplImage src, ref IplImage dst, ref CvMat map_matrix, int flags, CvScalar fillval)
{
cvWarpPerspective(ref src, ref dst, ref map_matrix, flags, fillval);
}
public static void CvWarpPerspective(ref CvMat src, ref CvMat dst, ref CvMat map_matrix, int flags, CvScalar fillval)
{
cvWarpPerspective(ref src, ref dst, ref map_matrix, flags, fillval);
}
public static void CvWarpPerspective(ref CvSeq src, ref CvSeq dst, ref CvMat map_matrix, int flags, CvScalar fillval)
{
cvWarpPerspective(ref src, ref dst, ref map_matrix, flags, fillval);
}
[DllImport(CV_LIBRARY)]
private static extern void cvWarpPerspective(ref IplImage src, ref IplImage dst, ref CvMat map_matrix, int flags, CvScalar fillval);
[DllImport(CV_LIBRARY)]
private static extern void cvWarpPerspective(ref CvMat src, ref CvMat dst, ref CvMat map_matrix, int flags, CvScalar fillval);
[DllImport(CV_LIBRARY)]
private static extern void cvWarpPerspective(ref CvSeq src, ref CvSeq dst, ref CvMat map_matrix, int flags, CvScalar fillval);
/// <summary>
/// GetPerspectiveTransform
/// Calculates perspective transform from 4 corresponding points
/// </summary>
/// <param name="src"></param>
/// <returns></returns>
public static CvMat CvGetPerspectiveTransform(IntPtr src, IntPtr dst, ref CvMat map_matrix)
{
IntPtr p = cvGetPerspectiveTransform(src, dst, ref map_matrix);
CvMat i = (CvMat)Marshal.PtrToStructure(p, typeof(CvMat));
i.ptr = p;
return i;
}
[DllImport(CV_LIBRARY)]
private static extern IntPtr cvGetPerspectiveTransform(IntPtr src, IntPtr dst, ref CvMat map_matrix);
/// <summary>
/// Remap
/// Applies generic geometrical transformation to the image
/// </summary>
/// <param name="src"></param>
/// <returns></returns>
public static void CvRemap(ref IplImage src, ref IplImage dst, ref IplImage mapx, ref IplImage mapy, int flags, CvScalar fillval)
{
cvRemap(ref src, ref dst, ref mapx, ref mapy, flags, fillval);
}
public static void CvRemap(ref CvMat src, ref CvMat dst, ref IplImage mapx, ref IplImage mapy, int flags, CvScalar fillval)
{
cvRemap(ref src, ref dst, ref mapx, ref mapy, flags, fillval);
}
public static void CvRemap(ref CvSeq src, ref CvSeq dst, ref IplImage mapx, ref IplImage mapy, int flags, CvScalar fillval)
{
cvRemap(ref src, ref dst, ref mapx, ref mapy, flags, fillval);
}
[DllImport(CV_LIBRARY)]
private static extern void cvRemap(ref IplImage src, ref IplImage dst, ref IplImage mapx, ref IplImage mapy, int flags, CvScalar fillval);
[DllImport(CV_LIBRARY)]
private static extern void cvRemap(ref CvMat src, ref CvMat dst, ref IplImage mapx, ref IplImage mapy, int flags, CvScalar fillval);
[DllImport(CV_LIBRARY)]
private static extern void cvRemap(ref CvSeq src, ref CvSeq dst, ref IplImage mapx, ref IplImage mapy, int flags, CvScalar fillval);
/// <summary>
/// LogPolar
/// Remaps image to log-polar space
/// </summary>
/// <param name="src"></param>
/// <returns></returns>
public static void CvLogPolar(ref IplImage src, ref IplImage dst, CvPoint2D32f center, double M, int flags)
{
cvLogPolar(ref src, ref dst, center, M, flags);
}
public static void CvLogPolar(ref CvMat src, ref CvMat dst, CvPoint2D32f center, double M, int flags)
{
cvLogPolar(ref src, ref dst, center, M, flags);
}
public static void CvLogPolar(ref CvSeq src, ref CvSeq dst, CvPoint2D32f center, double M, int flags)
{
cvLogPolar(ref src, ref dst, center, M, flags);
}
[DllImport(CV_LIBRARY)]
private static extern void cvLogPolar(ref IplImage src, ref IplImage dst, CvPoint2D32f center, double M, int flags);
[DllImport(CV_LIBRARY)]
private static extern void cvLogPolar(ref CvMat src, ref CvMat dst, CvPoint2D32f center, double M, int flags);
[DllImport(CV_LIBRARY)]
private static extern void cvLogPolar(ref CvSeq src, ref CvSeq dst, CvPoint2D32f center, double M, int flags);
/// <summary>
/// CreateStructuringElementEx
/// Creates structuring element
/// </summary>
/// <param name="cols"></param>
/// <returns></returns>
public static IplConvKernel CvCreateStructuringElementEx(int cols, int rows, int anchor_x, int anchor_y, int shape, int[] values)
{
IntPtr p = cvCreateStructuringElementEx(cols, rows, anchor_x, anchor_y, shape, values);
IplConvKernel i = (IplConvKernel)Marshal.PtrToStructure(p, typeof(IplConvKernel));
i.ptr = p;
return i;
}
[DllImport(CV_LIBRARY)]
private static extern IntPtr cvCreateStructuringElementEx(int cols, int rows, int anchor_x, int anchor_y, int shape, int[] values);
/// <summary>
/// ReleaseStructuringElement
/// Deletes structuring element
/// </summary>
/// <param name="element"></param>
/// <returns></returns>
public static void CvReleaseStructuringElement(ref IplConvKernel element)
{
cvReleaseStructuringElement(ref element.ptr);
}
[DllImport(CV_LIBRARY)]
private static extern void cvReleaseStructuringElement(ref IntPtr element);
/// <summary>
/// Erode
/// Erodes image by using arbitrary structuring element
/// </summary>
/// <param name="src"></param>
/// <returns></returns>
public static void CvErode(ref IplImage src, ref IplImage dst, ref IplConvKernel element, int iterations)
{
cvErode(ref src, ref dst, ref element, iterations);
}
public static void CvErode(ref CvMat src, ref CvMat dst, ref IplConvKernel element, int iterations)
{
cvErode(ref src, ref dst, ref element, iterations);
}
public static void CvErode(ref CvSeq src, ref CvSeq dst, ref IplConvKernel element, int iterations)
{
cvErode(ref src, ref dst, ref element, iterations);
}
[DllImport(CV_LIBRARY)]
private static extern void cvErode(ref IplImage src, ref IplImage dst, ref IplConvKernel element, int iterations);
[DllImport(CV_LIBRARY)]
private static extern void cvErode(ref CvMat src, ref CvMat dst, ref IplConvKernel element, int iterations);
[DllImport(CV_LIBRARY)]
private static extern void cvErode(ref CvSeq src, ref CvSeq dst, ref IplConvKernel element, int iterations);
/// <summary>
/// Dilate
/// Dilates image by using arbitrary structuring element
/// </summary>
/// <param name="src"></param>
/// <returns></returns>
public static void CvDilate(ref IplImage src, ref IplImage dst, ref IplConvKernel element, int iterations)
{
cvDilate(ref src, ref dst, ref element, iterations);
}
public static void CvDilate(ref CvMat src, ref CvMat dst, ref IplConvKernel element, int iterations)
{
cvDilate(ref src, ref dst, ref element, iterations);
}
public static void CvDilate(ref CvSeq src, ref CvSeq dst, ref IplConvKernel element, int iterations)
{
cvDilate(ref src, ref dst, ref element, iterations);
}
[DllImport(CV_LIBRARY)]
private static extern void cvDilate(ref IplImage src, ref IplImage dst, ref IplConvKernel element, int iterations);
[DllImport(CV_LIBRARY)]
private static extern void cvDilate(ref CvMat src, ref CvMat dst, ref IplConvKernel element, int iterations);
[DllImport(CV_LIBRARY)]
private static extern void cvDilate(ref CvSeq src, ref CvSeq dst, ref IplConvKernel element, int iterations);
/// <summary>
/// MorphologyEx
/// Performs advanced morphological transformations
/// </summary>
/// <param name="src"></param>
/// <returns></returns>
public static void CvMorphologyEx(ref IplImage src, ref IplImage dst, ref IplImage temp, ref IplConvKernel element, int operation, int iterations)
{
cvMorphologyEx(ref src, ref dst, ref temp, ref element, operation, iterations);
}
public static void CvMorphologyEx(ref CvMat src, ref CvMat dst, ref CvMat temp, ref IplConvKernel element, int operation, int iterations)
{
cvMorphologyEx(ref src, ref dst, ref temp, ref element, operation, iterations);
}
public static void CvMorphologyEx(ref CvSeq src, ref CvSeq dst, ref CvSeq temp, ref IplConvKernel element, int operation, int iterations)
{
cvMorphologyEx(ref src, ref dst, ref temp, ref element, operation, iterations);
}
[DllImport(CV_LIBRARY)]
private static extern void cvMorphologyEx(ref IplImage src, ref IplImage dst, ref IplImage temp, ref IplConvKernel element, int operation, int iterations);
[DllImport(CV_LIBRARY)]
private static extern void cvMorphologyEx(ref CvMat src, ref CvMat dst, ref CvMat temp, ref IplConvKernel element, int operation, int iterations);
[DllImport(CV_LIBRARY)]
private static extern void cvMorphologyEx(ref CvSeq src, ref CvSeq dst, ref CvSeq temp, ref IplConvKernel element, int operation, int iterations);
/// <summary>
/// Smooth
/// Smooths the image in one of several ways
/// </summary>
/// <param name="src"></param>
/// <returns></returns>
public static void CvSmooth(ref IplImage src, ref IplImage dst, int smoothtype, int param1, int param2, double param3, double param4)
{
cvSmooth(ref src, ref dst, smoothtype, param1, param2, param3, param4);
}
public static void CvSmooth(ref CvMat src, ref CvMat dst, int smoothtype, int param1, int param2, double param3, double param4)
{
cvSmooth(ref src, ref dst, smoothtype, param1, param2, param3, param4);
}
public static void CvSmooth(ref CvSeq src, ref CvSeq dst, int smoothtype, int param1, int param2, double param3, double param4)
{
cvSmooth(ref src, ref dst, smoothtype, param1, param2, param3, param4);
}
[DllImport(CV_LIBRARY)]
private static extern void cvSmooth(ref IplImage src, ref IplImage dst, int smoothtype, int param1, int param2, double param3, double param4);
[DllImport(CV_LIBRARY)]
private static extern void cvSmooth(ref CvMat src, ref CvMat dst, int smoothtype, int param1, int param2, double param3, double param4);
[DllImport(CV_LIBRARY)]
private static extern void cvSmooth(ref CvSeq src, ref CvSeq dst, int smoothtype, int param1, int param2, double param3, double param4);
/// <summary>
/// Filter2D
/// Convolves image with the kernel
/// </summary>
/// <param name="src"></param>
/// <returns></returns>
public static void CvFilter2D(ref IplImage src, ref IplImage dst, ref CvMat kernel, CvPoint anchor)
{
cvFilter2D(ref src, ref dst, ref kernel, anchor);
}
public static void CvFilter2D(ref CvMat src, ref CvMat dst, ref CvMat kernel, CvPoint anchor)
{
cvFilter2D(ref src, ref dst, ref kernel, anchor);
}
public static void CvFilter2D(ref CvSeq src, ref CvSeq dst, ref CvMat kernel, CvPoint anchor)
{
cvFilter2D(ref src, ref dst, ref kernel, anchor);
}
[DllImport(CV_LIBRARY)]
private static extern void cvFilter2D(ref IplImage src, ref IplImage dst, ref CvMat kernel, CvPoint anchor);
[DllImport(CV_LIBRARY)]
private static extern void cvFilter2D(ref CvMat src, ref CvMat dst, ref CvMat kernel, CvPoint anchor);
[DllImport(CV_LIBRARY)]
private static extern void cvFilter2D(ref CvSeq src, ref CvSeq dst, ref CvMat kernel, CvPoint anchor);
/// <summary>
/// CopyMakeBorder
/// Copies image and makes border around it
/// </summary>
/// <param name="src"></param>
/// <returns></returns>
public static void CvCopyMakeBorder(ref IplImage src, ref IplImage dst, CvPoint offset, int bordertype, CvScalar value)
{
cvCopyMakeBorder(ref src, ref dst, offset, bordertype, value);
}
public static void CvCopyMakeBorder(ref CvMat src, ref CvMat dst, CvPoint offset, int bordertype, CvScalar value)
{
cvCopyMakeBorder(ref src, ref dst, offset, bordertype, value);
}
public static void CvCopyMakeBorder(ref CvSeq src, ref CvSeq dst, CvPoint offset, int bordertype, CvScalar value)
{
cvCopyMakeBorder(ref src, ref dst, offset, bordertype, value);
}
[DllImport(CV_LIBRARY)]
private static extern void cvCopyMakeBorder(ref IplImage src, ref IplImage dst, CvPoint offset, int bordertype, CvScalar value);
[DllImport(CV_LIBRARY)]
private static extern void cvCopyMakeBorder(ref CvMat src, ref CvMat dst, CvPoint offset, int bordertype, CvScalar value);
[DllImport(CV_LIBRARY)]
private static extern void cvCopyMakeBorder(ref CvSeq src, ref CvSeq dst, CvPoint offset, int bordertype, CvScalar value);
/// <summary>
/// Integral
/// Calculates integral images
/// </summary>
/// <param name="image"></param>
/// <returns></returns>
public static void CvIntegral(ref IplImage image, ref IplImage sum, ref IplImage sqsum, ref IplImage tilted_sum)
{
cvIntegral(ref image, ref sum, ref sqsum, ref tilted_sum);
}
public static void CvIntegral(ref CvMat image, ref CvMat sum, ref CvMat sqsum, ref CvMat tilted_sum)
{
cvIntegral(ref image, ref sum, ref sqsum, ref tilted_sum);
}
public static void CvIntegral(ref CvSeq image, ref CvSeq sum, ref CvSeq sqsum, ref CvSeq tilted_sum)
{
cvIntegral(ref image, ref sum, ref sqsum, ref tilted_sum);
}
[DllImport(CV_LIBRARY)]
private static extern void cvIntegral(ref IplImage image, ref IplImage sum, ref IplImage sqsum, ref IplImage tilted_sum);
[DllImport(CV_LIBRARY)]
private static extern void cvIntegral(ref CvMat image, ref CvMat sum, ref CvMat sqsum, ref CvMat tilted_sum);
[DllImport(CV_LIBRARY)]
private static extern void cvIntegral(ref CvSeq image, ref CvSeq sum, ref CvSeq sqsum, ref CvSeq tilted_sum);
/// <summary>
/// CvtColor
/// Converts image from one color space to another
/// </summary>
/// <param name="src"></param>
/// <returns></returns>
public static void CvCvtColor(ref IplImage src, ref IplImage dst, int code)
{
cvCvtColor(ref src, ref dst, code);
}
public static void CvCvtColor(ref CvMat src, ref CvMat dst, int code)
{
cvCvtColor(ref src, ref dst, code);
}
public static void CvCvtColor(ref CvSeq src, ref CvSeq dst, int code)
{
cvCvtColor(ref src, ref dst, code);
}
[DllImport(CV_LIBRARY)]
private static extern void cvCvtColor(ref IplImage src, ref IplImage dst, int code);
[DllImport(CV_LIBRARY)]
private static extern void cvCvtColor(ref CvMat src, ref CvMat dst, int code);
[DllImport(CV_LIBRARY)]
private static extern void cvCvtColor(ref CvSeq src, ref CvSeq dst, int code);
/// <summary>
/// Threshold
/// Applies fixed-level threshold to array elements
/// </summary>
/// <param name="src"></param>
/// <returns></returns>
public static void CvThreshold(ref IplImage src, ref IplImage dst, double threshold, double max_value, int threshold_type)
{
cvThreshold(ref src, ref dst, threshold, max_value, threshold_type);
}
public static void CvThreshold(ref CvMat src, ref CvMat dst, double threshold, double max_value, int threshold_type)
{
cvThreshold(ref src, ref dst, threshold, max_value, threshold_type);
}
public static void CvThreshold(ref CvSeq src, ref CvSeq dst, double threshold, double max_value, int threshold_type)
{
cvThreshold(ref src, ref dst, threshold, max_value, threshold_type);
}
[DllImport(CV_LIBRARY)]
private static extern void cvThreshold(ref IplImage src, ref IplImage dst, double threshold, double max_value, int threshold_type);
[DllImport(CV_LIBRARY)]
private static extern void cvThreshold(ref CvMat src, ref CvMat dst, double threshold, double max_value, int threshold_type);
[DllImport(CV_LIBRARY)]
private static extern void cvThreshold(ref CvSeq src, ref CvSeq dst, double threshold, double max_value, int threshold_type);
/// <summary>
/// AdaptiveThreshold
/// Applies adaptive threshold to array
/// </summary>
/// <param name="src"></param>
/// <returns></returns>
public static void CvAdaptiveThreshold(ref IplImage src, ref IplImage dst, double max_value, int adaptive_method, int threshold_type, int block_size, double param1)
{
cvAdaptiveThreshold(ref src, ref dst, max_value, adaptive_method, threshold_type, block_size, param1);
}
public static void CvAdaptiveThreshold(ref CvMat src, ref CvMat dst, double max_value, int adaptive_method, int threshold_type, int block_size, double param1)
{
cvAdaptiveThreshold(ref src, ref dst, max_value, adaptive_method, threshold_type, block_size, param1);
}
public static void CvAdaptiveThreshold(ref CvSeq src, ref CvSeq dst, double max_value, int adaptive_method, int threshold_type, int block_size, double param1)
{
cvAdaptiveThreshold(ref src, ref dst, max_value, adaptive_method, threshold_type, block_size, param1);
}
[DllImport(CV_LIBRARY)]
private static extern void cvAdaptiveThreshold(ref IplImage src, ref IplImage dst, double max_value, int adaptive_method, int threshold_type, int block_size, double param1);
[DllImport(CV_LIBRARY)]
private static extern void cvAdaptiveThreshold(ref CvMat src, ref CvMat dst, double max_value, int adaptive_method, int threshold_type, int block_size, double param1);
[DllImport(CV_LIBRARY)]
private static extern void cvAdaptiveThreshold(ref CvSeq src, ref CvSeq dst, double max_value, int adaptive_method, int threshold_type, int block_size, double param1);
/// <summary>
/// PyrDown
/// Downsamples image
/// </summary>
/// <param name="src"></param>
/// <returns></returns>
public static void CvPyrDown(ref IplImage src, ref IplImage dst, int filter)
{
cvPyrDown(ref src, ref dst, filter);
}
public static void CvPyrDown(ref CvMat src, ref CvMat dst, int filter)
{
cvPyrDown(ref src, ref dst, filter);
}
public static void CvPyrDown(ref CvSeq src, ref CvSeq dst, int filter)
{
cvPyrDown(ref src, ref dst, filter);
}
[DllImport(CV_LIBRARY)]
private static extern void cvPyrDown(ref IplImage src, ref IplImage dst, int filter);
[DllImport(CV_LIBRARY)]
private static extern void cvPyrDown(ref CvMat src, ref CvMat dst, int filter);
[DllImport(CV_LIBRARY)]
private static extern void cvPyrDown(ref CvSeq src, ref CvSeq dst, int filter);
/// <summary>
/// PyrUp
/// Upsamples image
/// </summary>
/// <param name="src"></param>
/// <returns></returns>
public static void CvPyrUp(ref IplImage src, ref IplImage dst, int filter)
{
cvPyrUp(ref src, ref dst, filter);
}
public static void CvPyrUp(ref CvMat src, ref CvMat dst, int filter)
{
cvPyrUp(ref src, ref dst, filter);
}
public static void CvPyrUp(ref CvSeq src, ref CvSeq dst, int filter)
{
cvPyrUp(ref src, ref dst, filter);
}
[DllImport(CV_LIBRARY)]
private static extern void cvPyrUp(ref IplImage src, ref IplImage dst, int filter);
[DllImport(CV_LIBRARY)]
private static extern void cvPyrUp(ref CvMat src, ref CvMat dst, int filter);
[DllImport(CV_LIBRARY)]
private static extern void cvPyrUp(ref CvSeq src, ref CvSeq dst, int filter);
/// <summary>
/// CvFloodFill
/// Connected component
/// </summary>
/// <param name="image"></param>
/// <returns></returns>
public static void CvFloodFill(ref IplImage image, CvPoint seed_point, CvScalar new_val,
CvScalar lo_diff, CvScalar up_diff,
ref CvConnectedComp comp, int flags, ref IplImage mask)
{
cvFloodFill(ref image, seed_point, new_val, lo_diff, up_diff, ref comp, flags, ref mask);
}
public static void CvFloodFill(ref CvMat image, CvPoint seed_point, CvScalar new_val,
CvScalar lo_diff, CvScalar up_diff,
ref CvConnectedComp comp, int flags, ref CvMat mask)
{
cvFloodFill(ref image, seed_point, new_val, lo_diff, up_diff, ref comp, flags, ref mask);
}
public static void CvFloodFill(ref CvSeq image, CvPoint seed_point, CvScalar new_val,
CvScalar lo_diff, CvScalar up_diff,
ref CvConnectedComp comp, int flags, ref CvSeq mask)
{
cvFloodFill(ref image, seed_point, new_val, lo_diff, up_diff, ref comp, flags, ref mask);
}
[DllImport(CV_LIBRARY)]
private static extern void cvFloodFill(ref IplImage image, CvPoint seed_point, CvScalar new_val,
CvScalar lo_diff, CvScalar up_diff,
ref CvConnectedComp comp, int flags, ref IplImage mask);
[DllImport(CV_LIBRARY)]
private static extern void cvFloodFill(ref CvMat image, CvPoint seed_point, CvScalar new_val,
CvScalar lo_diff, CvScalar up_diff,
ref CvConnectedComp comp, int flags, ref CvMat mask);
[DllImport(CV_LIBRARY)]
private static extern void cvFloodFill(ref CvSeq image, CvPoint seed_point, CvScalar new_val,
CvScalar lo_diff, CvScalar up_diff,
ref CvConnectedComp comp, int flags, ref CvSeq mask);
/// <summary>
/// FindContours
/// Finds contours in binary image
/// </summary>
/// <param name="image"></param>
/// <returns></returns>
public static int CvFindContours(ref IplImage image, ref CvMemStorage storage, ref IntPtr first_contour, int header_size, int mode, int method, CvPoint offset)
{
return cvFindContours(ref image, ref storage, ref first_contour, header_size, mode, method, offset);
}
public static int CvFindContours(ref CvMat image, ref CvMemStorage storage, ref IntPtr first_contour, int header_size, int mode, int method, CvPoint offset)
{
return cvFindContours(ref image, ref storage, ref first_contour, header_size, mode, method, offset);
}
public static int CvFindContours(ref CvSeq image, ref CvMemStorage storage, ref IntPtr first_contour, int header_size, int mode, int method, CvPoint offset)
{
return cvFindContours(ref image, ref storage, ref first_contour, header_size, mode, method, offset);
}
[DllImport(CV_LIBRARY)]
private static extern int cvFindContours(ref IplImage image, ref CvMemStorage storage, ref IntPtr first_contour, int header_size, int mode, int method, CvPoint offset);
[DllImport(CV_LIBRARY)]
private static extern int cvFindContours(ref CvMat image, ref CvMemStorage storage, ref IntPtr first_contour, int header_size, int mode, int method, CvPoint offset);
[DllImport(CV_LIBRARY)]
private static extern int cvFindContours(ref CvSeq image, ref CvMemStorage storage, ref IntPtr first_contour, int header_size, int mode, int method, CvPoint offset);
/// <summary>
/// StartFindContours
/// Initializes contour scanning process
/// </summary>
/// <param name="image"></param>
/// <returns></returns>
public static CvContourScanner CvStartFindContours(ref IplImage image, ref CvMemStorage storage, int mode, int method)
{
return cvStartFindContours(ref image, ref storage, mode, method);
}
public static CvContourScanner CvStartFindContours(ref CvMat image, ref CvMemStorage storage, int mode, int method)
{
return cvStartFindContours(ref image, ref storage, mode, method);
}
public static CvContourScanner CvStartFindContours(ref CvSeq image, ref CvMemStorage storage, int mode, int method)
{
return cvStartFindContours(ref image, ref storage, mode, method);
}
[DllImport(CV_LIBRARY)]
private static extern CvContourScanner cvStartFindContours(ref IplImage image, ref CvMemStorage storage, int mode, int method);
[DllImport(CV_LIBRARY)]
private static extern CvContourScanner cvStartFindContours(ref CvMat image, ref CvMemStorage storage, int mode, int method);
[DllImport(CV_LIBRARY)]
private static extern CvContourScanner cvStartFindContours(ref CvSeq image, ref CvMemStorage storage, int mode, int method);
/// <summary>
/// FindNextContour
/// Finds next contour in the image
/// </summary>
/// <param name="scanner"></param>
/// <returns></returns>
public static CvSeq CvFindNextContour(CvContourScanner scanner)
{
IntPtr p = cvFindNextContour(scanner);
CvSeq i = (CvSeq)Marshal.PtrToStructure(p, typeof(CvSeq));
i.ptr = p;
return i;
}
[DllImport(CV_LIBRARY)]
private static extern IntPtr cvFindNextContour(CvContourScanner scanner);
/// <summary>
/// SubstituteContour
/// Replaces retrieved contour
/// </summary>
/// <param name="scanner"></param>
/// <returns></returns>
public static void CvSubstituteContour(CvContourScanner scanner, ref CvSeq new_contour)
{
cvSubstituteContour(scanner, ref new_contour);
}
[DllImport(CV_LIBRARY)]
private static extern void cvSubstituteContour(CvContourScanner scanner, ref CvSeq new_contour);
/// <summary>
/// EndFindContours
/// Finishes scanning process
/// </summary>
/// <param name="scanner"></param>
/// <returns></returns>
public static CvSeq CvEndFindContours(ref CvContourScanner scanner)
{
IntPtr p = cvEndFindContours(ref scanner);
CvSeq i = (CvSeq)Marshal.PtrToStructure(p, typeof(CvSeq));
i.ptr = p;
return i;
}
[DllImport(CV_LIBRARY)]
private static extern IntPtr cvEndFindContours(ref CvContourScanner scanner);
/// <summary>
/// PyrSegmentation
/// Does image segmentation by pyramids
/// </summary>
/// <param name="src"></param>
/// <returns></returns>
public static void CvPyrSegmentation(ref IplImage src, ref IplImage dst, ref CvMemStorage storage, ref CvSeq comp, int level, double threshold1, double threshold2)
{
cvPyrSegmentation(ref src, ref dst, ref storage, ref comp.ptr, level, threshold1, threshold2);
}
[DllImport(CV_LIBRARY)]
private static extern void cvPyrSegmentation(ref IplImage src, ref IplImage dst, ref CvMemStorage storage, ref IntPtr comp, int level, double threshold1, double threshold2);
/// <summary>
/// PyrMeanShiftFiltering
/// Does meanshift image segmentation
/// </summary>
/// <param name="src"></param>
/// <returns></returns>
public static void CvPyrMeanShiftFiltering(ref IplImage src, ref IplImage dst, double sp, double sr, int max_level)
{
cvPyrMeanShiftFiltering(ref src, ref dst, sp, sr, max_level);
}
public static void CvPyrMeanShiftFiltering(ref CvMat src, ref CvMat dst, double sp, double sr, int max_level)
{
cvPyrMeanShiftFiltering(ref src, ref dst, sp, sr, max_level);
}
public static void CvPyrMeanShiftFiltering(ref CvSeq src, ref CvSeq dst, double sp, double sr, int max_level)
{
cvPyrMeanShiftFiltering(ref src, ref dst, sp, sr, max_level);
}
[DllImport(CV_LIBRARY)]
private static extern void cvPyrMeanShiftFiltering(ref IplImage src, ref IplImage dst, double sp, double sr, int max_level);
[DllImport(CV_LIBRARY)]
private static extern void cvPyrMeanShiftFiltering(ref CvMat src, ref CvMat dst, double sp, double sr, int max_level);
[DllImport(CV_LIBRARY)]
private static extern void cvPyrMeanShiftFiltering(ref CvSeq src, ref CvSeq dst, double sp, double sr, int max_level);
/// <summary>
/// Watershed
/// Does watershed segmentation
/// </summary>
/// <param name="image"></param>
/// <returns></returns>
public static void CvWatershed(ref IplImage image, ref IplImage markers)
{
cvWatershed(ref image, ref markers);
}
public static void CvWatershed(ref CvMat image, ref CvMat markers)
{
cvWatershed(ref image, ref markers);
}
public static void CvWatershed(ref CvSeq image, ref CvSeq markers)
{
cvWatershed(ref image, ref markers);
}
[DllImport(CV_LIBRARY)]
private static extern void cvWatershed(ref IplImage image, ref IplImage markers);
[DllImport(CV_LIBRARY)]
private static extern void cvWatershed(ref CvMat image, ref CvMat markers);
[DllImport(CV_LIBRARY)]
private static extern void cvWatershed(ref CvSeq image, ref CvSeq markers);
/// <summary>
/// Moments
/// Calculates all moments up to third order of a polygon or rasterized shape
/// </summary>
/// <param name="arr"></param>
/// <returns></returns>
public static void CvMoments(ref IplImage arr, ref CvMoments moments, int binary)
{
cvMoments(ref arr, ref moments, binary);
}
public static void CvMoments(ref CvMat arr, ref CvMoments moments, int binary)
{
cvMoments(ref arr, ref moments, binary);
}
public static void CvMoments(ref CvSeq arr, ref CvMoments moments, int binary)
{
cvMoments(ref arr, ref moments, binary);
}
[DllImport(CV_LIBRARY)]
private static extern void cvMoments(ref IplImage arr, ref CvMoments moments, int binary);
[DllImport(CV_LIBRARY)]
private static extern void cvMoments(ref CvMat arr, ref CvMoments moments, int binary);
[DllImport(CV_LIBRARY)]
private static extern void cvMoments(ref CvSeq arr, ref CvMoments moments, int binary);
/// <summary>
/// GetSpatialMoment
/// Retrieves spatial moment from moment state structure
/// </summary>
/// <param name="moments"></param>
/// <returns></returns>
public static double CvGetSpatialMoment(ref CvMoments moments, int x_order, int y_order)
{
return cvGetSpatialMoment(ref moments, x_order, y_order);
}
[DllImport(CV_LIBRARY)]
private static extern double cvGetSpatialMoment(ref CvMoments moments, int x_order, int y_order);
/// <summary>
/// GetCentralMoment
/// Retrieves central moment from moment state structure
/// </summary>
/// <param name="moments"></param>
/// <returns></returns>
public static double CvGetCentralMoment(ref CvMoments moments, int x_order, int y_order)
{
return cvGetCentralMoment(ref moments, x_order, y_order);
}
[DllImport(CV_LIBRARY)]
private static extern double cvGetCentralMoment(ref CvMoments moments, int x_order, int y_order);
/// <summary>
/// GetNormalizedCentralMoment
/// Retrieves normalized central moment from moment state structure
/// </summary>
/// <param name="moments"></param>
/// <returns></returns>
public static double CvGetNormalizedCentralMoment(ref CvMoments moments, int x_order, int y_order)
{
return cvGetNormalizedCentralMoment(ref moments, x_order, y_order);
}
[DllImport(CV_LIBRARY)]
private static extern double cvGetNormalizedCentralMoment(ref CvMoments moments, int x_order, int y_order);
/// <summary>
/// GetHuMoments
/// Calculates seven Hu invariants
/// </summary>
/// <param name="moments"></param>
/// <returns></returns>
public static void CvGetHuMoments(ref CvMoments moments, ref CvHuMoments hu_moments)
{
cvGetHuMoments(ref moments, ref hu_moments);
}
[DllImport(CV_LIBRARY)]
private static extern void cvGetHuMoments(ref CvMoments moments, ref CvHuMoments hu_moments);
/// <summary>
/// HoughLines2
/// Finds lines in binary image using Hough transform
/// </summary>
/// <param name="image"></param>
/// <returns></returns>
public static CvSeq CvHoughLines2(ref IplImage image, IntPtr line_storage, int method, double rho, double theta, int threshold, double param1, double param2)
{
IntPtr p = cvHoughLines2(ref image, line_storage, method, rho, theta, threshold, param1, param2);
CvSeq i = (CvSeq)Marshal.PtrToStructure(p, typeof(CvSeq));
i.ptr = p;
return i;
}
public static CvSeq CvHoughLines2(ref CvMat image, IntPtr line_storage, int method, double rho, double theta, int threshold, double param1, double param2)
{
IntPtr p = cvHoughLines2(ref image, line_storage, method, rho, theta, threshold, param1, param2);
CvSeq i = (CvSeq)Marshal.PtrToStructure(p, typeof(CvSeq));
i.ptr = p;
return i;
}
public static CvSeq CvHoughLines2(ref CvSeq image, IntPtr line_storage, int method, double rho, double theta, int threshold, double param1, double param2)
{
IntPtr p = cvHoughLines2(ref image, line_storage, method, rho, theta, threshold, param1, param2);
CvSeq i = (CvSeq)Marshal.PtrToStructure(p, typeof(CvSeq));
i.ptr = p;
return i;
}
[DllImport(CV_LIBRARY)]
private static extern IntPtr cvHoughLines2(ref IplImage image, IntPtr line_storage, int method, double rho, double theta, int threshold, double param1, double param2);
[DllImport(CV_LIBRARY)]
private static extern IntPtr cvHoughLines2(ref CvMat image, IntPtr line_storage, int method, double rho, double theta, int threshold, double param1, double param2);
[DllImport(CV_LIBRARY)]
private static extern IntPtr cvHoughLines2(ref CvSeq image, IntPtr line_storage, int method, double rho, double theta, int threshold, double param1, double param2);
/// <summary>
/// HoughCircles
/// Finds circles in grayscale image using Hough transform
/// </summary>
/// <param name="image"></param>
/// <returns></returns>
public static CvSeq CvHoughCircles(ref IplImage image, IntPtr circle_storage, int method, double dp, double min_dist, double param1, double param2, int min_radius, int max_radius)
{
IntPtr p = cvHoughCircles(ref image, circle_storage, method, dp, min_dist, param1, param2, min_radius, max_radius);
CvSeq i = (CvSeq)Marshal.PtrToStructure(p, typeof(CvSeq));
i.ptr = p;
return i;
}
public static CvSeq CvHoughCircles(ref CvMat image, IntPtr circle_storage, int method, double dp, double min_dist, double param1, double param2, int min_radius, int max_radius)
{
IntPtr p = cvHoughCircles(ref image, circle_storage, method, dp, min_dist, param1, param2, min_radius, max_radius);
CvSeq i = (CvSeq)Marshal.PtrToStructure(p, typeof(CvSeq));
i.ptr = p;
return i;
}
public static CvSeq CvHoughCircles(ref CvSeq image, IntPtr circle_storage, int method, double dp, double min_dist, double param1, double param2, int min_radius, int max_radius)
{
IntPtr p = cvHoughCircles(ref image, circle_storage, method, dp, min_dist, param1, param2, min_radius, max_radius);
CvSeq i = (CvSeq)Marshal.PtrToStructure(p, typeof(CvSeq));
i.ptr = p;
return i;
}
[DllImport(CV_LIBRARY)]
private static extern IntPtr cvHoughCircles(ref IplImage image, IntPtr circle_storage, int method, double dp, double min_dist, double param1, double param2, int min_radius, int max_radius);
[DllImport(CV_LIBRARY)]
private static extern IntPtr cvHoughCircles(ref CvMat image, IntPtr circle_storage, int method, double dp, double min_dist, double param1, double param2, int min_radius, int max_radius);
[DllImport(CV_LIBRARY)]
private static extern IntPtr cvHoughCircles(ref CvSeq image, IntPtr circle_storage, int method, double dp, double min_dist, double param1, double param2, int min_radius, int max_radius);
/// <summary>
/// DistTransform
/// Calculates distance to closest zero pixel for all non-zero pixels of source
/// image
/// </summary>
/// <param name="src"></param>
/// <returns></returns>
public static void CvDistTransform(ref IplImage src, ref IplImage dst, int distance_type, int mask_size, float[] mask, ref IplImage labels)
{
cvDistTransform(ref src, ref dst, distance_type, mask_size, mask, ref labels);
}
public static void CvDistTransform(ref CvMat src, ref CvMat dst, int distance_type, int mask_size, float[] mask, ref CvMat labels)
{
cvDistTransform(ref src, ref dst, distance_type, mask_size, mask, ref labels);
}
public static void CvDistTransform(ref CvSeq src, ref CvSeq dst, int distance_type, int mask_size, float[] mask, ref CvSeq labels)
{
cvDistTransform(ref src, ref dst, distance_type, mask_size, mask, ref labels);
}
[DllImport(CV_LIBRARY)]
private static extern void cvDistTransform(ref IplImage src, ref IplImage dst, int distance_type, int mask_size, float[] mask, ref IplImage labels);
[DllImport(CV_LIBRARY)]
private static extern void cvDistTransform(ref CvMat src, ref CvMat dst, int distance_type, int mask_size, float[] mask, ref CvMat labels);
[DllImport(CV_LIBRARY)]
private static extern void cvDistTransform(ref CvSeq src, ref CvSeq dst, int distance_type, int mask_size, float[] mask, ref CvSeq labels);
/// <summary>
/// Inpaint
/// Inpaints the selected region in the image
/// </summary>
/// <param name="src"></param>
/// <returns></returns>
public static void CvInpaint(ref IplImage src, ref IplImage mask, ref IplImage dst, int flags, double inpaintRadius)
{
cvInpaint(ref src, ref mask, ref dst, flags, inpaintRadius);
}
public static void CvInpaint(ref CvMat src, ref CvMat mask, ref CvMat dst, int flags, double inpaintRadius)
{
cvInpaint(ref src, ref mask, ref dst, flags, inpaintRadius);
}
public static void CvInpaint(ref CvSeq src, ref CvSeq mask, ref CvSeq dst, int flags, double inpaintRadius)
{
cvInpaint(ref src, ref mask, ref dst, flags, inpaintRadius);
}
[DllImport(CV_LIBRARY)]
private static extern void cvInpaint(ref IplImage src, ref IplImage mask, ref IplImage dst, int flags, double inpaintRadius);
[DllImport(CV_LIBRARY)]
private static extern void cvInpaint(ref CvMat src, ref CvMat mask, ref CvMat dst, int flags, double inpaintRadius);
[DllImport(CV_LIBRARY)]
private static extern void cvInpaint(ref CvSeq src, ref CvSeq mask, ref CvSeq dst, int flags, double inpaintRadius);
/// <summary>
/// CvHistogram
/// Muti-dimensional histogram
/// </summary>
/// <param name="dims"></param>
/// <returns></returns>
public static CvHistogram CvCreateHist(int dims, int[] sizes, int type, IntPtr ranges, int uniform)
{
IntPtr p = cvCreateHist(dims, sizes, type, ranges, uniform);
CvHistogram i = (CvHistogram)Marshal.PtrToStructure(p, typeof(CvHistogram));
i.ptr = p;
return i;
}
[DllImport(CV_LIBRARY)]
private static extern IntPtr cvCreateHist(int dims, int[] sizes, int type, IntPtr ranges, int uniform);
/// <summary>
/// SetHistBinRanges
/// Sets bounds of histogram bins
/// </summary>
/// <param name="hist"></param>
/// <returns></returns>
public static void CvSetHistBinRanges(ref CvHistogram hist, IntPtr ranges, int uniform)
{
cvSetHistBinRanges(ref hist, ranges, uniform);
}
[DllImport(CV_LIBRARY)]
private static extern void cvSetHistBinRanges(ref CvHistogram hist, IntPtr ranges, int uniform);
/// <summary>
/// ReleaseHist
/// Releases histogram
/// </summary>
/// <param name="hist"></param>
/// <returns></returns>
public static void CvReleaseHist(ref CvHistogram hist)
{
cvReleaseHist(ref hist.ptr);
}
[DllImport(CV_LIBRARY)]
private static extern void cvReleaseHist(ref IntPtr hist);
/// <summary>
/// ClearHist
/// Clears histogram
/// </summary>
/// <param name="hist"></param>
/// <returns></returns>
public static void CvClearHist(ref CvHistogram hist)
{
cvClearHist(ref hist);
}
[DllImport(CV_LIBRARY)]
private static extern void cvClearHist(ref CvHistogram hist);
/// <summary>
/// MakeHistHeaderForArray
/// Makes a histogram out of array
/// </summary>
/// <param name="dims"></param>
/// <returns></returns>
public static CvHistogram CvMakeHistHeaderForArray(int dims, int[] sizes, ref CvHistogram hist, float[] data, IntPtr ranges, int uniform)
{
IntPtr p = cvMakeHistHeaderForArray(dims, sizes, ref hist, data, ranges, uniform);
CvHistogram i = (CvHistogram)Marshal.PtrToStructure(p, typeof(CvHistogram));
i.ptr = p;
return i;
}
[DllImport(CV_LIBRARY)]
private static extern IntPtr cvMakeHistHeaderForArray(int dims, int[] sizes, ref CvHistogram hist, float[] data, IntPtr ranges, int uniform);
/// <summary>
/// QueryHistValue_*D
/// Queries value of histogram bin
/// </summary>
/// <param name="hist"></param>
/// <returns></returns>
/// <summary>
/// GetHistValue_*D
/// Returns pointer to histogram bin
/// </summary>
/// <param name="hist"></param>
/// <returns></returns>
/// <summary>
/// GetMinMaxHistValue
/// Finds minimum and maximum histogram bins
/// </summary>
/// <param name="hist"></param>
/// <returns></returns>
public static void CvGetMinMaxHistValue(ref CvHistogram hist, ref float min_value, ref float max_value, ref int min_idx, ref int max_idx)
{
cvGetMinMaxHistValue(ref hist, ref min_value, ref max_value, ref min_idx, ref max_idx);
}
[DllImport(CV_LIBRARY)]
private static extern void cvGetMinMaxHistValue(ref CvHistogram hist, ref float min_value, ref float max_value, ref int min_idx, ref int max_idx);
/// <summary>
/// NormalizeHist
/// Normalizes histogram
/// </summary>
/// <param name="hist"></param>
/// <returns></returns>
public static void CvNormalizeHist(ref CvHistogram hist, double factor)
{
cvNormalizeHist(ref hist, factor);
}
[DllImport(CV_LIBRARY)]
private static extern void cvNormalizeHist(ref CvHistogram hist, double factor);
/// <summary>
/// ThreshHist
/// Thresholds histogram
/// </summary>
/// <param name="hist"></param>
/// <returns></returns>
public static void CvThreshHist(ref CvHistogram hist, double threshold)
{
cvThreshHist(ref hist, threshold);
}
[DllImport(CV_LIBRARY)]
private static extern void cvThreshHist(ref CvHistogram hist, double threshold);
/// <summary>
/// CompareHist
/// Compares two dense histograms
/// </summary>
/// <param name="hist1"></param>
/// <returns></returns>
public static double CvCompareHist(ref CvHistogram hist1, ref CvHistogram hist2, int method)
{
return cvCompareHist(ref hist1, ref hist2, method);
}
[DllImport(CV_LIBRARY)]
private static extern double cvCompareHist(ref CvHistogram hist1, ref CvHistogram hist2, int method);
/// <summary>
/// CopyHist
/// Copies histogram
/// </summary>
/// <param name="src"></param>
/// <returns></returns>
public static void CvCopyHist(ref CvHistogram src, ref CvHistogram dst)
{
cvCopyHist(ref src, ref dst.ptr);
}
[DllImport(CV_LIBRARY)]
private static extern void cvCopyHist(ref CvHistogram src, ref IntPtr dst);
/// <summary>
/// CalcHist
/// Calculates histogram of image(s)
/// </summary>
/// <param name="image"></param>
/// <returns></returns>
public static void CvCalcHist(IntPtr[] images, ref CvHistogram hist, int accumulate, ref IplImage mask)
{
cvCalcArrHist(images, ref hist, accumulate, ref mask);
}
public static void CvCalcHist(IntPtr[] images, ref CvHistogram hist, int accumulate, ref CvMat mask)
{
cvCalcArrHist(images, ref hist, accumulate, ref mask);
}
public static void CvCalcHist(IntPtr[] images, ref CvHistogram hist, int accumulate, ref CvSeq mask)
{
cvCalcArrHist(images, ref hist, accumulate, ref mask);
}
public static void CvCalcHist(IntPtr[] images, ref CvHistogram hist, int accumulate)
{
cvCalcArrHist(images, ref hist, accumulate, IntPtr.Zero);
}
[DllImport(CV_LIBRARY)]
private static extern void cvCalcArrHist(IntPtr[] images, ref CvHistogram hist, int do_not_clear, ref IplImage mask);
[DllImport(CV_LIBRARY)]
private static extern void cvCalcArrHist(IntPtr[] images, ref CvHistogram hist, int do_not_clear, ref CvMat mask);
[DllImport(CV_LIBRARY)]
private static extern void cvCalcArrHist(IntPtr[] images, ref CvHistogram hist, int do_not_clear, ref CvSeq mask);
[DllImport(CV_LIBRARY)]
private static extern void cvCalcArrHist(IntPtr[] images, ref CvHistogram hist, int do_not_clear, IntPtr mask);
/// <summary>
/// CalcBackProject
/// Calculates back projection
/// </summary>
/// <param name="image"></param>
/// <returns></returns>
public static void CvCalcBackProject(ref IplImage image, ref IplImage back_project, ref CvHistogram hist)
{
CvCalcArrBackProject(ref image, ref back_project, ref hist);
}
public static void CvCalcBackProject(ref IplImage image, ref CvMat back_project, ref CvHistogram hist)
{
CvCalcArrBackProject(ref image, ref back_project, ref hist);
}
public static void CvCalcBackProject(ref IplImage image, ref CvSeq back_project, ref CvHistogram hist)
{
CvCalcArrBackProject(ref image, ref back_project, ref hist);
}
/// <summary>
/// CalcBackProject
/// Calculates back projection
/// </summary>
/// <param name="image"></param>
/// <returns></returns>
public static void CvCalcArrBackProject(ref IplImage image, ref IplImage back_project, ref CvHistogram hist)
{
cvCalcArrBackProject(ref image.ptr, ref back_project, ref hist);
}
public static void CvCalcArrBackProject(ref IplImage image, ref CvMat back_project, ref CvHistogram hist)
{
cvCalcArrBackProject(ref image.ptr, ref back_project, ref hist);
}
public static void CvCalcArrBackProject(ref IplImage image, ref CvSeq back_project, ref CvHistogram hist)
{
cvCalcArrBackProject(ref image.ptr, ref back_project, ref hist);
}
[DllImport(CV_LIBRARY)]
private static extern void cvCalcArrBackProject(ref IntPtr image, ref IplImage back_project, ref CvHistogram hist);
[DllImport(CV_LIBRARY)]
private static extern void cvCalcArrBackProject(ref IntPtr image, ref CvMat back_project, ref CvHistogram hist);
[DllImport(CV_LIBRARY)]
private static extern void cvCalcArrBackProject(ref IntPtr image, ref CvSeq back_project, ref CvHistogram hist);
/// <summary>
/// CalcBackProjectPatch
/// Locates a template within image by histogram comparison
/// </summary>
/// <param name="images"></param>
/// <returns></returns>
public static void CvCalcBackProjectPatch(ref IplImage images, ref IplImage dst, CvSize patch_size, ref CvHistogram hist, int method, float factor)
{
cvCalcBackProjectPatch(ref images.ptr, ref dst, patch_size, ref hist, method, factor);
}
public static void CvCalcBackProjectPatch(ref IplImage images, ref CvMat dst, CvSize patch_size, ref CvHistogram hist, int method, float factor)
{
cvCalcBackProjectPatch(ref images.ptr, ref dst, patch_size, ref hist, method, factor);
}
public static void CvCalcBackProjectPatch(ref IplImage images, ref CvSeq dst, CvSize patch_size, ref CvHistogram hist, int method, float factor)
{
cvCalcBackProjectPatch(ref images.ptr, ref dst, patch_size, ref hist, method, factor);
}
[DllImport(CV_LIBRARY)]
private static extern void cvCalcBackProjectPatch(ref IntPtr images, ref IplImage dst, CvSize patch_size, ref CvHistogram hist, int method, float factor);
[DllImport(CV_LIBRARY)]
private static extern void cvCalcBackProjectPatch(ref IntPtr images, ref CvMat dst, CvSize patch_size, ref CvHistogram hist, int method, float factor);
[DllImport(CV_LIBRARY)]
private static extern void cvCalcBackProjectPatch(ref IntPtr images, ref CvSeq dst, CvSize patch_size, ref CvHistogram hist, int method, float factor);
/// <summary>
/// CalcProbDensity
/// Divides one histogram by another
/// </summary>
/// <param name="hist1"></param>
/// <returns></returns>
public static void CvCalcProbDensity(ref CvHistogram hist1, ref CvHistogram hist2, ref CvHistogram dst_hist, double scale)
{
cvCalcProbDensity(ref hist1, ref hist2, ref dst_hist, scale);
}
[DllImport(CV_LIBRARY)]
private static extern void cvCalcProbDensity(ref CvHistogram hist1, ref CvHistogram hist2, ref CvHistogram dst_hist, double scale);
/// <summary>
/// EqualizeHist
/// Equalizes histogram of grayscale image
/// </summary>
/// <param name="src"></param>
/// <returns></returns>
public static void CvEqualizeHist(ref IplImage src, ref IplImage dst)
{
cvEqualizeHist(ref src, ref dst);
}
public static void CvEqualizeHist(ref CvMat src, ref CvMat dst)
{
cvEqualizeHist(ref src, ref dst);
}
public static void CvEqualizeHist(ref CvSeq src, ref CvSeq dst)
{
cvEqualizeHist(ref src, ref dst);
}
[DllImport(CV_LIBRARY)]
private static extern void cvEqualizeHist(ref IplImage src, ref IplImage dst);
[DllImport(CV_LIBRARY)]
private static extern void cvEqualizeHist(ref CvMat src, ref CvMat dst);
[DllImport(CV_LIBRARY)]
private static extern void cvEqualizeHist(ref CvSeq src, ref CvSeq dst);
/// <summary>
/// MatchTemplate
/// Compares template against overlapped image regions
/// </summary>
/// <param name="image"></param>
/// <returns></returns>
public static void CvMatchTemplate(ref IplImage image, ref IplImage templ, ref IplImage result, int method)
{
cvMatchTemplate(ref image, ref templ, ref result, method);
}
public static void CvMatchTemplate(ref CvMat image, ref CvMat templ, ref CvMat result, int method)
{
cvMatchTemplate(ref image, ref templ, ref result, method);
}
public static void CvMatchTemplate(ref CvSeq image, ref CvSeq templ, ref CvSeq result, int method)
{
cvMatchTemplate(ref image, ref templ, ref result, method);
}
[DllImport(CV_LIBRARY)]
private static extern void cvMatchTemplate(ref IplImage image, ref IplImage templ, ref IplImage result, int method);
[DllImport(CV_LIBRARY)]
private static extern void cvMatchTemplate(ref CvMat image, ref CvMat templ, ref CvMat result, int method);
[DllImport(CV_LIBRARY)]
private static extern void cvMatchTemplate(ref CvSeq image, ref CvSeq templ, ref CvSeq result, int method);
/// <summary>
/// MatchShapes
/// Compares two shapes
/// </summary>
/// <param name="object1"></param>
/// <returns></returns>
public static double CvMatchShapes(IntPtr object1, IntPtr object2, int method, double parameter)
{
return cvMatchShapes(object1, object2, method, parameter);
}
[DllImport(CV_LIBRARY)]
private static extern double cvMatchShapes(IntPtr object1, IntPtr object2, int method, double parameter);
/// <summary>
/// CalcEMD2
/// Computes minimal work distance between two weighted point configurations
/// </summary>
/// <param name="signature1"></param>
/// <returns></returns>
public static float CvCalcEMD2(ref IplImage signature1, ref IplImage signature2, int distance_type, IntPtr distance_func, ref IplImage cost_matrix, ref IplImage flow, float[] lower_bound, IntPtr userdata)
{
return cvCalcEMD2(ref signature1, ref signature2, distance_type, distance_func, ref cost_matrix, ref flow, lower_bound, userdata);
}
public static float CvCalcEMD2(ref CvMat signature1, ref CvMat signature2, int distance_type, IntPtr distance_func, ref CvMat cost_matrix, ref CvMat flow, float[] lower_bound, IntPtr userdata)
{
return cvCalcEMD2(ref signature1, ref signature2, distance_type, distance_func, ref cost_matrix, ref flow, lower_bound, userdata);
}
public static float CvCalcEMD2(ref CvSeq signature1, ref CvSeq signature2, int distance_type, IntPtr distance_func, ref CvSeq cost_matrix, ref CvSeq flow, float[] lower_bound, IntPtr userdata)
{
return cvCalcEMD2(ref signature1, ref signature2, distance_type, distance_func, ref cost_matrix, ref flow, lower_bound, userdata);
}
[DllImport(CV_LIBRARY)]
private static extern float cvCalcEMD2(ref IplImage signature1, ref IplImage signature2, int distance_type, IntPtr distance_func, ref IplImage cost_matrix, ref IplImage flow, float[] lower_bound, IntPtr userdata);
[DllImport(CV_LIBRARY)]
private static extern float cvCalcEMD2(ref CvMat signature1, ref CvMat signature2, int distance_type, IntPtr distance_func, ref CvMat cost_matrix, ref CvMat flow, float[] lower_bound, IntPtr userdata);
[DllImport(CV_LIBRARY)]
private static extern float cvCalcEMD2(ref CvSeq signature1, ref CvSeq signature2, int distance_type, IntPtr distance_func, ref CvSeq cost_matrix, ref CvSeq flow, float[] lower_bound, IntPtr userdata);
/// <summary>
/// ApproxChains
/// Approximates Freeman chain(s) with polygonal curve
/// </summary>
/// <param name="src_seq"></param>
/// <returns></returns>
public static CvSeq CvApproxChains(ref CvSeq src_seq, ref CvMemStorage storage, int method, double parameter, int minimal_perimeter, int recursive)
{
IntPtr p = cvApproxChains(ref src_seq, ref storage, method, parameter, minimal_perimeter, recursive);
CvSeq i = (CvSeq)Marshal.PtrToStructure(p, typeof(CvSeq));
i.ptr = p;
return i;
}
[DllImport(CV_LIBRARY)]
private static extern IntPtr cvApproxChains(ref CvSeq src_seq, ref CvMemStorage storage, int method, double parameter, int minimal_perimeter, int recursive);
/// <summary>
/// StartReadChainPoints
/// Initializes chain reader
/// </summary>
/// <param name="reader"></param>
/// <returns></returns>
public static void CvStartReadChainPoints(ref CvChain chain, ref CvChainPtReader reader)
{
cvStartReadChainPoints(ref chain, ref reader);
}
[DllImport(CV_LIBRARY)]
private static extern void cvStartReadChainPoints(ref CvChain chain, ref CvChainPtReader reader);
/// <summary>
/// ApproxPoly
/// Approximates polygonal curve(s) with desired precision
/// </summary>
/// <param name="src_seq"></param>
/// <returns></returns>
public static CvSeq CvApproxPoly(IntPtr src_seq, int header_size, ref CvMemStorage storage, int method, double parameter, int parameter2)
{
IntPtr p = cvApproxPoly(src_seq, header_size, ref storage, method, parameter, parameter2);
CvSeq i = (CvSeq)Marshal.PtrToStructure(p, typeof(CvSeq));
i.ptr = p;
return i;
}
[DllImport(CV_LIBRARY)]
private static extern IntPtr cvApproxPoly(IntPtr src_seq, int header_size, ref CvMemStorage storage, int method, double parameter, int parameter2);
/// <summary>
/// BoundingRect
/// Calculates up-right bounding rectangle of point set
/// </summary>
/// <param name="points"></param>
/// <returns></returns>
public static CvRect CvBoundingRect(ref IplImage points, int update)
{
return cvBoundingRect(ref points, update);
}
public static CvRect CvBoundingRect(ref CvMat points, int update)
{
return cvBoundingRect(ref points, update);
}
public static CvRect CvBoundingRect(ref CvSeq points, int update)
{
return cvBoundingRect(ref points, update);
}
[DllImport(CV_LIBRARY)]
private static extern CvRect cvBoundingRect(ref IplImage points, int update);
[DllImport(CV_LIBRARY)]
private static extern CvRect cvBoundingRect(ref CvMat points, int update);
[DllImport(CV_LIBRARY)]
private static extern CvRect cvBoundingRect(ref CvSeq points, int update);
/// <summary>
/// ContourArea
/// Calculates area of the whole contour or contour section
/// </summary>
/// <param name="contour"></param>
/// <returns></returns>
public static double CvContourArea(ref IplImage contour, CvSlice slice)
{
return cvContourArea(ref contour, slice);
}
public static double CvContourArea(ref CvMat contour, CvSlice slice)
{
return cvContourArea(ref contour, slice);
}
public static double CvContourArea(ref CvSeq contour, CvSlice slice)
{
return cvContourArea(ref contour, slice);
}
[DllImport(CV_LIBRARY)]
private static extern double cvContourArea(ref IplImage contour, CvSlice slice);
[DllImport(CV_LIBRARY)]
private static extern double cvContourArea(ref CvMat contour, CvSlice slice);
[DllImport(CV_LIBRARY)]
private static extern double cvContourArea(ref CvSeq contour, CvSlice slice);
/// <summary>
/// ArcLength
/// Calculates contour perimeter or curve length
/// </summary>
/// <param name="curve"></param>
/// <returns></returns>
public static double CvArcLength(IntPtr curve, CvSlice slice, int is_closed)
{
return cvArcLength(curve, slice, is_closed);
}
[DllImport(CV_LIBRARY)]
private static extern double cvArcLength(IntPtr curve, CvSlice slice, int is_closed);
/// <summary>
/// CreateContourTree
/// Creates hierarchical representation of contour
/// </summary>
/// <param name="contour"></param>
/// <returns></returns>
public static CvContourTree CvCreateContourTree(ref CvSeq contour, ref CvMemStorage storage, double threshold)
{
IntPtr p = cvCreateContourTree(ref contour, ref storage, threshold);
CvContourTree i = (CvContourTree)Marshal.PtrToStructure(p, typeof(CvContourTree));
i.ptr = p;
return i;
}
[DllImport(CV_LIBRARY)]
private static extern IntPtr cvCreateContourTree(ref CvSeq contour, ref CvMemStorage storage, double threshold);
/// <summary>
/// ContourFromContourTree
/// Restores contour from tree
/// </summary>
/// <param name="tree"></param>
/// <returns></returns>
public static CvSeq CvContourFromContourTree(ref CvContourTree tree, ref CvMemStorage storage, CvTermCriteria criteria)
{
IntPtr p = cvContourFromContourTree(ref tree, ref storage, criteria);
CvSeq i = (CvSeq)Marshal.PtrToStructure(p, typeof(CvSeq));
i.ptr = p;
return i;
}
[DllImport(CV_LIBRARY)]
private static extern IntPtr cvContourFromContourTree(ref CvContourTree tree, ref CvMemStorage storage, CvTermCriteria criteria);
/// <summary>
/// MatchContourTrees
/// Compares two contours using their tree representations
/// </summary>
/// <param name="tree1"></param>
/// <returns></returns>
public static double CvMatchContourTrees(ref CvContourTree tree1, ref CvContourTree tree2, int method, double threshold)
{
return cvMatchContourTrees(ref tree1, ref tree2, method, threshold);
}
[DllImport(CV_LIBRARY)]
private static extern double cvMatchContourTrees(ref CvContourTree tree1, ref CvContourTree tree2, int method, double threshold);
/// <summary>
/// MaxRect
/// Finds bounding rectangle for two given rectangles
/// </summary>
/// <param name="rect1"></param>
/// <returns></returns>
public static CvRect CvMaxRect(ref CvRect rect1, ref CvRect rect2)
{
return cvMaxRect(ref rect1, ref rect2);
}
[DllImport(CV_LIBRARY)]
private static extern CvRect cvMaxRect(ref CvRect rect1, ref CvRect rect2);
/// <summary>
/// CvBox2D
/// Rotated 2D box
/// </summary>
/// <param name="seq_kind"></param>
/// <returns></returns>
public static CvSeq CvPointSeqFromMat(int seq_kind, ref IplImage mat, ref CvContour contour_header, ref CvSeqBlock block)
{
IntPtr p = cvPointSeqFromMat(seq_kind, ref mat, ref contour_header, ref block);
CvSeq i = (CvSeq)Marshal.PtrToStructure(p, typeof(CvSeq));
i.ptr = p;
return i;
}
public static CvSeq CvPointSeqFromMat(int seq_kind, ref CvMat mat, ref CvContour contour_header, ref CvSeqBlock block)
{
IntPtr p = cvPointSeqFromMat(seq_kind, ref mat, ref contour_header, ref block);
CvSeq i = (CvSeq)Marshal.PtrToStructure(p, typeof(CvSeq));
i.ptr = p;
return i;
}
public static CvSeq CvPointSeqFromMat(int seq_kind, ref CvSeq mat, ref CvContour contour_header, ref CvSeqBlock block)
{
IntPtr p = cvPointSeqFromMat(seq_kind, ref mat, ref contour_header, ref block);
CvSeq i = (CvSeq)Marshal.PtrToStructure(p, typeof(CvSeq));
i.ptr = p;
return i;
}
[DllImport(CV_LIBRARY)]
private static extern IntPtr cvPointSeqFromMat(int seq_kind, ref IplImage mat, ref CvContour contour_header, ref CvSeqBlock block);
[DllImport(CV_LIBRARY)]
private static extern IntPtr cvPointSeqFromMat(int seq_kind, ref CvMat mat, ref CvContour contour_header, ref CvSeqBlock block);
[DllImport(CV_LIBRARY)]
private static extern IntPtr cvPointSeqFromMat(int seq_kind, ref CvSeq mat, ref CvContour contour_header, ref CvSeqBlock block);
/// <summary>
/// BoxPoints
/// Finds box vertices
/// </summary>
/// <param name="box"></param>
/// <returns></returns>
public static void CvBoxPoints(CvBox2D box, CvPoint2D32f pt)
{
cvBoxPoints(box, pt);
}
[DllImport(CV_LIBRARY)]
private static extern void cvBoxPoints(CvBox2D box, CvPoint2D32f pt);
/// <summary>
/// FitEllipse
/// Fits ellipse to set of 2D points
/// </summary>
/// <param name="points"></param>
/// <returns></returns>
public static CvBox2D CvFitEllipse2(ref IplImage points)
{
return cvFitEllipse2(ref points);
}
public static CvBox2D CvFitEllipse2(ref CvMat points)
{
return cvFitEllipse2(ref points);
}
public static CvBox2D CvFitEllipse2(ref CvSeq points)
{
return cvFitEllipse2(ref points);
}
[DllImport(CV_LIBRARY)]
private static extern CvBox2D cvFitEllipse2(ref IplImage points);
[DllImport(CV_LIBRARY)]
private static extern CvBox2D cvFitEllipse2(ref CvMat points);
[DllImport(CV_LIBRARY)]
private static extern CvBox2D cvFitEllipse2(ref CvSeq points);
/// <summary>
/// FitLine
/// Fits line to 2D or 3D point set
/// </summary>
/// <param name="points"></param>
/// <returns></returns>
public static void CvFitLine(ref IplImage points, int dist_type, double param, double reps, double aeps, float[] line)
{
cvFitLine(ref points, dist_type, param, reps, aeps, line);
}
public static void CvFitLine(ref CvMat points, int dist_type, double param, double reps, double aeps, float[] line)
{
cvFitLine(ref points, dist_type, param, reps, aeps, line);
}
public static void CvFitLine(ref CvSeq points, int dist_type, double param, double reps, double aeps, float[] line)
{
cvFitLine(ref points, dist_type, param, reps, aeps, line);
}
[DllImport(CV_LIBRARY)]
private static extern void cvFitLine(ref IplImage points, int dist_type, double param, double reps, double aeps, float[] line);
[DllImport(CV_LIBRARY)]
private static extern void cvFitLine(ref CvMat points, int dist_type, double param, double reps, double aeps, float[] line);
[DllImport(CV_LIBRARY)]
private static extern void cvFitLine(ref CvSeq points, int dist_type, double param, double reps, double aeps, float[] line);
/// <summary>
/// ConvexHull2
/// Finds convex hull of point set
/// </summary>
/// <param name="points"></param>
/// <returns></returns>
public static CvSeq CvConvexHull2(ref IplImage input, IntPtr hull_storage, int orientation, int return_points)
{
IntPtr p = cvConvexHull2(ref input, hull_storage, orientation, return_points);
CvSeq i = (CvSeq)Marshal.PtrToStructure(p, typeof(CvSeq));
i.ptr = p;
return i;
}
public static CvSeq CvConvexHull2(ref CvMat input, IntPtr hull_storage, int orientation, int return_points)
{
IntPtr p = cvConvexHull2(ref input, hull_storage, orientation, return_points);
CvSeq i = (CvSeq)Marshal.PtrToStructure(p, typeof(CvSeq));
i.ptr = p;
return i;
}
public static CvSeq CvConvexHull2(ref CvSeq input, IntPtr hull_storage, int orientation, int return_points)
{
IntPtr p = cvConvexHull2(ref input, hull_storage, orientation, return_points);
CvSeq i = (CvSeq)Marshal.PtrToStructure(p, typeof(CvSeq));
i.ptr = p;
return i;
}
[DllImport(CV_LIBRARY)]
private static extern IntPtr cvConvexHull2(ref IplImage input, IntPtr hull_storage, int orientation, int return_points);
[DllImport(CV_LIBRARY)]
private static extern IntPtr cvConvexHull2(ref CvMat input, IntPtr hull_storage, int orientation, int return_points);
[DllImport(CV_LIBRARY)]
private static extern IntPtr cvConvexHull2(ref CvSeq input, IntPtr hull_storage, int orientation, int return_points);
/// <summary>
/// CheckContourConvexity
/// Tests contour convex
/// </summary>
/// <param name="contour"></param>
/// <returns></returns>
public static int CvCheckContourConvexity(ref IplImage contour)
{
return cvCheckContourConvexity(ref contour);
}
public static int CvCheckContourConvexity(ref CvMat contour)
{
return cvCheckContourConvexity(ref contour);
}
public static int CvCheckContourConvexity(ref CvSeq contour)
{
return cvCheckContourConvexity(ref contour);
}
[DllImport(CV_LIBRARY)]
private static extern int cvCheckContourConvexity(ref IplImage contour);
[DllImport(CV_LIBRARY)]
private static extern int cvCheckContourConvexity(ref CvMat contour);
[DllImport(CV_LIBRARY)]
private static extern int cvCheckContourConvexity(ref CvSeq contour);
/// <summary>
/// CvConvexityDefect
/// Structure describing a single contour convexity detect
/// </summary>
/// <param name="contour"></param>
/// <returns></returns>
public static CvSeq CvConvexityDefects(ref IplImage contour, ref IplImage convexhull, ref CvMemStorage storage)
{
IntPtr p = cvConvexityDefects(ref contour, ref convexhull, ref storage);
CvSeq i = (CvSeq)Marshal.PtrToStructure(p, typeof(CvSeq));
i.ptr = p;
return i;
}
public static CvSeq CvConvexityDefects(ref CvMat contour, ref CvMat convexhull, ref CvMemStorage storage)
{
IntPtr p = cvConvexityDefects(ref contour, ref convexhull, ref storage);
CvSeq i = (CvSeq)Marshal.PtrToStructure(p, typeof(CvSeq));
i.ptr = p;
return i;
}
public static CvSeq CvConvexityDefects(ref CvSeq contour, ref CvSeq convexhull, ref CvMemStorage storage)
{
IntPtr p = cvConvexityDefects(ref contour, ref convexhull, ref storage);
CvSeq i = (CvSeq)Marshal.PtrToStructure(p, typeof(CvSeq));
i.ptr = p;
return i;
}
[DllImport(CV_LIBRARY)]
private static extern IntPtr cvConvexityDefects(ref IplImage contour, ref IplImage convexhull, ref CvMemStorage storage);
[DllImport(CV_LIBRARY)]
private static extern IntPtr cvConvexityDefects(ref CvMat contour, ref CvMat convexhull, ref CvMemStorage storage);
[DllImport(CV_LIBRARY)]
private static extern IntPtr cvConvexityDefects(ref CvSeq contour, ref CvSeq convexhull, ref CvMemStorage storage);
/// <summary>
/// PointPolygonTest
/// Point in contour test
/// </summary>
/// <param name="contour"></param>
/// <returns></returns>
public static double CvPointPolygonTest(ref IplImage contour, CvPoint2D32f pt, int measure_dist)
{
return cvPointPolygonTest(ref contour, pt, measure_dist);
}
public static double CvPointPolygonTest(ref CvMat contour, CvPoint2D32f pt, int measure_dist)
{
return cvPointPolygonTest(ref contour, pt, measure_dist);
}
public static double CvPointPolygonTest(ref CvSeq contour, CvPoint2D32f pt, int measure_dist)
{
return cvPointPolygonTest(ref contour, pt, measure_dist);
}
[DllImport(CV_LIBRARY)]
private static extern double cvPointPolygonTest(ref IplImage contour, CvPoint2D32f pt, int measure_dist);
[DllImport(CV_LIBRARY)]
private static extern double cvPointPolygonTest(ref CvMat contour, CvPoint2D32f pt, int measure_dist);
[DllImport(CV_LIBRARY)]
private static extern double cvPointPolygonTest(ref CvSeq contour, CvPoint2D32f pt, int measure_dist);
/// <summary>
/// MinAreaRect2
/// Finds circumscribed rectangle of minimal area for given 2D point set
/// </summary>
/// <param name="points"></param>
/// <returns></returns>
public static CvBox2D CvMinAreaRect2(ref IplImage points, ref CvMemStorage storage)
{
return cvMinAreaRect2(ref points, ref storage);
}
public static CvBox2D CvMinAreaRect2(ref CvMat points, ref CvMemStorage storage)
{
return cvMinAreaRect2(ref points, ref storage);
}
public static CvBox2D CvMinAreaRect2(ref CvSeq points, ref CvMemStorage storage)
{
return cvMinAreaRect2(ref points, ref storage);
}
[DllImport(CV_LIBRARY)]
private static extern CvBox2D cvMinAreaRect2(ref IplImage points, ref CvMemStorage storage);
[DllImport(CV_LIBRARY)]
private static extern CvBox2D cvMinAreaRect2(ref CvMat points, ref CvMemStorage storage);
[DllImport(CV_LIBRARY)]
private static extern CvBox2D cvMinAreaRect2(ref CvSeq points, ref CvMemStorage storage);
/// <summary>
/// MinEnclosingCircle
/// Finds circumscribed circle of minimal area for given 2D point set
/// </summary>
/// <param name="points"></param>
/// <returns></returns>
public static int CvMinEnclosingCircle(ref IplImage points, ref CvPoint2D32f center, float[] radius)
{
return cvMinEnclosingCircle(ref points, ref center, radius);
}
public static int CvMinEnclosingCircle(ref CvMat points, ref CvPoint2D32f center, float[] radius)
{
return cvMinEnclosingCircle(ref points, ref center, radius);
}
public static int CvMinEnclosingCircle(ref CvSeq points, ref CvPoint2D32f center, float[] radius)
{
return cvMinEnclosingCircle(ref points, ref center, radius);
}
[DllImport(CV_LIBRARY)]
private static extern int cvMinEnclosingCircle(ref IplImage points, ref CvPoint2D32f center, float[] radius);
[DllImport(CV_LIBRARY)]
private static extern int cvMinEnclosingCircle(ref CvMat points, ref CvPoint2D32f center, float[] radius);
[DllImport(CV_LIBRARY)]
private static extern int cvMinEnclosingCircle(ref CvSeq points, ref CvPoint2D32f center, float[] radius);
/// <summary>
/// CalcPGH
/// Calculates pair-wise geometrical histogram for contour
/// </summary>
/// <param name="contour"></param>
/// <returns></returns>
public static void CvCalcPGH(ref CvSeq contour, ref CvHistogram hist)
{
cvCalcPGH(ref contour, ref hist);
}
[DllImport(CV_LIBRARY)]
private static extern void cvCalcPGH(ref CvSeq contour, ref CvHistogram hist);
/// <summary>
/// CvSubdiv2D
/// Planar subdivision
/// </summary>
/// <param name="edge"></param>
/// <returns></returns>
/// <summary>
/// Subdiv2DRotateEdge
/// Returns another edge of the same quad-edge
/// </summary>
/// <param name="edge"></param>
/// <returns></returns>
public static uint CvSubdiv2DRotateEdge(uint edge, int rotate)
{
return cvSubdiv2DRotateEdge(edge, rotate);
}
[DllImport(CV_LIBRARY)]
private static extern uint cvSubdiv2DRotateEdge(uint edge, int rotate);
/// <summary>
/// Subdiv2DEdgeOrg
/// Returns edge origin
/// </summary>
/// <param name="edge"></param>
/// <returns></returns>
public static CvSubdiv2DPoint UintOrg(uint edge)
{
IntPtr p = uintOrg(edge);
CvSubdiv2DPoint i = (CvSubdiv2DPoint)Marshal.PtrToStructure(p, typeof(CvSubdiv2DPoint));
i.ptr = p;
return i;
}
[DllImport(CV_LIBRARY)]
private static extern IntPtr uintOrg(uint edge);
/// <summary>
/// Subdiv2DEdgeDst
/// Returns edge destination
/// </summary>
/// <param name="edge"></param>
/// <returns></returns>
public static CvSubdiv2DPoint UintDst(uint edge)
{
IntPtr p = uintDst(edge);
CvSubdiv2DPoint i = (CvSubdiv2DPoint)Marshal.PtrToStructure(p, typeof(CvSubdiv2DPoint));
i.ptr = p;
return i;
}
[DllImport(CV_LIBRARY)]
private static extern IntPtr uintDst(uint edge);
/// <summary>
/// CreateSubdivDelaunay2D
/// Creates empty Delaunay triangulation
/// </summary>
/// <param name="rect"></param>
/// <returns></returns>
public static CvSubdiv2D CvCreateSubdivDelaunay2D(CvRect rect, ref CvMemStorage storage)
{
IntPtr p = cvCreateSubdivDelaunay2D(rect, ref storage);
CvSubdiv2D i = (CvSubdiv2D)Marshal.PtrToStructure(p, typeof(CvSubdiv2D));
i.ptr = p;
return i;
}
[DllImport(CV_LIBRARY)]
private static extern IntPtr cvCreateSubdivDelaunay2D(CvRect rect, ref CvMemStorage storage);
/// <summary>
/// SubdivDelaunay2DInsert
/// Inserts a single point to Delaunay triangulation
/// </summary>
/// <param name="subdiv"></param>
/// <returns></returns>
public static CvSubdiv2DPoint CvSubdivDelaunay2DInsert(ref CvSubdiv2D subdiv, CvPoint2D32f pt)
{
IntPtr p = cvSubdivDelaunay2DInsert(ref subdiv, pt);
CvSubdiv2DPoint i = (CvSubdiv2DPoint)Marshal.PtrToStructure(p, typeof(CvSubdiv2DPoint));
i.ptr = p;
return i;
}
[DllImport(CV_LIBRARY)]
private static extern IntPtr cvSubdivDelaunay2DInsert(ref CvSubdiv2D subdiv, CvPoint2D32f pt);
/// <summary>
/// Subdiv2DLocate
/// Inserts a single point to Delaunay triangulation
/// </summary>
/// <param name="subdiv"></param>
/// <returns></returns>
public static CvSubdiv2DPointLocation CvSubdiv2DLocate(ref CvSubdiv2D subdiv, CvPoint2D32f pt, ref uint edge, ref CvSubdiv2DPoint vertex)
{
return cvSubdiv2DLocate(ref subdiv, pt, ref edge, ref vertex.ptr);
}
[DllImport(CV_LIBRARY)]
private static extern CvSubdiv2DPointLocation cvSubdiv2DLocate(ref CvSubdiv2D subdiv, CvPoint2D32f pt, ref uint edge, ref IntPtr vertex);
/// <summary>
/// FindNearestPoint2D
/// Finds the closest subdivision vertex to given point
/// </summary>
/// <param name="subdiv"></param>
/// <returns></returns>
public static CvSubdiv2DPoint CvFindNearestPoint2D(ref CvSubdiv2D subdiv, CvPoint2D32f pt)
{
IntPtr p = cvFindNearestPoint2D(ref subdiv, pt);
CvSubdiv2DPoint i = (CvSubdiv2DPoint)Marshal.PtrToStructure(p, typeof(CvSubdiv2DPoint));
i.ptr = p;
return i;
}
[DllImport(CV_LIBRARY)]
private static extern IntPtr cvFindNearestPoint2D(ref CvSubdiv2D subdiv, CvPoint2D32f pt);
/// <summary>
/// CalcSubdivVoronoi2D
/// Calculates coordinates of Voronoi diagram cells
/// </summary>
/// <param name="subdiv"></param>
/// <returns></returns>
public static void CvCalcSubdivVoronoi2D(ref CvSubdiv2D subdiv)
{
cvCalcSubdivVoronoi2D(ref subdiv);
}
[DllImport(CV_LIBRARY)]
private static extern void cvCalcSubdivVoronoi2D(ref CvSubdiv2D subdiv);
/// <summary>
/// ClearSubdivVoronoi2D
/// Removes all virtual points
/// </summary>
/// <param name="subdiv"></param>
/// <returns></returns>
public static void CvClearSubdivVoronoi2D(ref CvSubdiv2D subdiv)
{
cvClearSubdivVoronoi2D(ref subdiv);
}
[DllImport(CV_LIBRARY)]
private static extern void cvClearSubdivVoronoi2D(ref CvSubdiv2D subdiv);
/// <summary>
/// Acc
/// Adds frame to accumulator
/// </summary>
/// <param name="image"></param>
/// <returns></returns>
public static void CvAcc(ref IplImage image, ref IplImage sum, ref IplImage mask)
{
cvAcc(ref image, ref sum, ref mask);
}
public static void CvAcc(ref CvMat image, ref CvMat sum, ref CvMat mask)
{
cvAcc(ref image, ref sum, ref mask);
}
public static void CvAcc(ref CvSeq image, ref CvSeq sum, ref CvSeq mask)
{
cvAcc(ref image, ref sum, ref mask);
}
[DllImport(CV_LIBRARY)]
private static extern void cvAcc(ref IplImage image, ref IplImage sum, ref IplImage mask);
[DllImport(CV_LIBRARY)]
private static extern void cvAcc(ref CvMat image, ref CvMat sum, ref CvMat mask);
[DllImport(CV_LIBRARY)]
private static extern void cvAcc(ref CvSeq image, ref CvSeq sum, ref CvSeq mask);
/// <summary>
/// SquareAcc
/// Adds the square of source image to accumulator
/// </summary>
/// <param name="image"></param>
/// <returns></returns>
public static void CvSquareAcc(ref IplImage image, ref IplImage sqsum, ref IplImage mask)
{
cvSquareAcc(ref image, ref sqsum, ref mask);
}
public static void CvSquareAcc(ref CvMat image, ref CvMat sqsum, ref CvMat mask)
{
cvSquareAcc(ref image, ref sqsum, ref mask);
}
public static void CvSquareAcc(ref CvSeq image, ref CvSeq sqsum, ref CvSeq mask)
{
cvSquareAcc(ref image, ref sqsum, ref mask);
}
[DllImport(CV_LIBRARY)]
private static extern void cvSquareAcc(ref IplImage image, ref IplImage sqsum, ref IplImage mask);
[DllImport(CV_LIBRARY)]
private static extern void cvSquareAcc(ref CvMat image, ref CvMat sqsum, ref CvMat mask);
[DllImport(CV_LIBRARY)]
private static extern void cvSquareAcc(ref CvSeq image, ref CvSeq sqsum, ref CvSeq mask);
/// <summary>
/// MultiplyAcc
/// Adds product of two input images to accumulator
/// </summary>
/// <param name="image1"></param>
/// <returns></returns>
public static void CvMultiplyAcc(ref IplImage image1, ref IplImage image2, ref IplImage acc, ref IplImage mask)
{
cvMultiplyAcc(ref image1, ref image2, ref acc, ref mask);
}
public static void CvMultiplyAcc(ref CvMat image1, ref CvMat image2, ref CvMat acc, ref CvMat mask)
{
cvMultiplyAcc(ref image1, ref image2, ref acc, ref mask);
}
public static void CvMultiplyAcc(ref CvSeq image1, ref CvSeq image2, ref CvSeq acc, ref CvSeq mask)
{
cvMultiplyAcc(ref image1, ref image2, ref acc, ref mask);
}
[DllImport(CV_LIBRARY)]
private static extern void cvMultiplyAcc(ref IplImage image1, ref IplImage image2, ref IplImage acc, ref IplImage mask);
[DllImport(CV_LIBRARY)]
private static extern void cvMultiplyAcc(ref CvMat image1, ref CvMat image2, ref CvMat acc, ref CvMat mask);
[DllImport(CV_LIBRARY)]
private static extern void cvMultiplyAcc(ref CvSeq image1, ref CvSeq image2, ref CvSeq acc, ref CvSeq mask);
/// <summary>
/// RunningAvg
/// Updates running average
/// </summary>
/// <param name="image"></param>
/// <returns></returns>
public static void CvRunningAvg(ref IplImage image, ref IplImage acc, double alpha, ref IplImage mask)
{
cvRunningAvg(ref image, ref acc, alpha, ref mask);
}
public static void CvRunningAvg(ref CvMat image, ref CvMat acc, double alpha, ref CvMat mask)
{
cvRunningAvg(ref image, ref acc, alpha, ref mask);
}
public static void CvRunningAvg(ref CvSeq image, ref CvSeq acc, double alpha, ref CvSeq mask)
{
cvRunningAvg(ref image, ref acc, alpha, ref mask);
}
[DllImport(CV_LIBRARY)]
private static extern void cvRunningAvg(ref IplImage image, ref IplImage acc, double alpha, ref IplImage mask);
[DllImport(CV_LIBRARY)]
private static extern void cvRunningAvg(ref CvMat image, ref CvMat acc, double alpha, ref CvMat mask);
[DllImport(CV_LIBRARY)]
private static extern void cvRunningAvg(ref CvSeq image, ref CvSeq acc, double alpha, ref CvSeq mask);
/// <summary>
/// UpdateMotionHistory
/// Updates motion history image by moving silhouette
/// </summary>
/// <param name="silhouette"></param>
/// <returns></returns>
public static void CvUpdateMotionHistory(ref IplImage silhouette, ref IplImage mhi, double timestamp, double duration)
{
cvUpdateMotionHistory(ref silhouette, ref mhi, timestamp, duration);
}
public static void CvUpdateMotionHistory(ref CvMat silhouette, ref CvMat mhi, double timestamp, double duration)
{
cvUpdateMotionHistory(ref silhouette, ref mhi, timestamp, duration);
}
public static void CvUpdateMotionHistory(ref CvSeq silhouette, ref CvSeq mhi, double timestamp, double duration)
{
cvUpdateMotionHistory(ref silhouette, ref mhi, timestamp, duration);
}
[DllImport(CV_LIBRARY)]
private static extern void cvUpdateMotionHistory(ref IplImage silhouette, ref IplImage mhi, double timestamp, double duration);
[DllImport(CV_LIBRARY)]
private static extern void cvUpdateMotionHistory(ref CvMat silhouette, ref CvMat mhi, double timestamp, double duration);
[DllImport(CV_LIBRARY)]
private static extern void cvUpdateMotionHistory(ref CvSeq silhouette, ref CvSeq mhi, double timestamp, double duration);
/// <summary>
/// CalcMotionGradient
/// Calculates gradient orientation of motion history image
/// </summary>
/// <param name="mhi"></param>
/// <returns></returns>
public static void CvCalcMotionGradient(ref IplImage mhi, ref IplImage mask, ref IplImage orientation, double delta1, double delta2, int aperture_size)
{
cvCalcMotionGradient(ref mhi, ref mask, ref orientation, delta1, delta2, aperture_size);
}
public static void CvCalcMotionGradient(ref CvMat mhi, ref CvMat mask, ref CvMat orientation, double delta1, double delta2, int aperture_size)
{
cvCalcMotionGradient(ref mhi, ref mask, ref orientation, delta1, delta2, aperture_size);
}
public static void CvCalcMotionGradient(ref CvSeq mhi, ref CvSeq mask, ref CvSeq orientation, double delta1, double delta2, int aperture_size)
{
cvCalcMotionGradient(ref mhi, ref mask, ref orientation, delta1, delta2, aperture_size);
}
[DllImport(CV_LIBRARY)]
private static extern void cvCalcMotionGradient(ref IplImage mhi, ref IplImage mask, ref IplImage orientation, double delta1, double delta2, int aperture_size);
[DllImport(CV_LIBRARY)]
private static extern void cvCalcMotionGradient(ref CvMat mhi, ref CvMat mask, ref CvMat orientation, double delta1, double delta2, int aperture_size);
[DllImport(CV_LIBRARY)]
private static extern void cvCalcMotionGradient(ref CvSeq mhi, ref CvSeq mask, ref CvSeq orientation, double delta1, double delta2, int aperture_size);
/// <summary>
/// CalcGlobalOrientation
/// Calculates global motion orientation of some selected region
/// </summary>
/// <param name="orientation"></param>
/// <returns></returns>
public static double CvCalcGlobalOrientation(ref IplImage orientation, ref IplImage mask, ref IplImage mhi, double timestamp, double duration)
{
return cvCalcGlobalOrientation(ref orientation, ref mask, ref mhi, timestamp, duration);
}
public static double CvCalcGlobalOrientation(ref CvMat orientation, ref CvMat mask, ref CvMat mhi, double timestamp, double duration)
{
return cvCalcGlobalOrientation(ref orientation, ref mask, ref mhi, timestamp, duration);
}
public static double CvCalcGlobalOrientation(ref CvSeq orientation, ref CvSeq mask, ref CvSeq mhi, double timestamp, double duration)
{
return cvCalcGlobalOrientation(ref orientation, ref mask, ref mhi, timestamp, duration);
}
[DllImport(CV_LIBRARY)]
private static extern double cvCalcGlobalOrientation(ref IplImage orientation, ref IplImage mask, ref IplImage mhi, double timestamp, double duration);
[DllImport(CV_LIBRARY)]
private static extern double cvCalcGlobalOrientation(ref CvMat orientation, ref CvMat mask, ref CvMat mhi, double timestamp, double duration);
[DllImport(CV_LIBRARY)]
private static extern double cvCalcGlobalOrientation(ref CvSeq orientation, ref CvSeq mask, ref CvSeq mhi, double timestamp, double duration);
/// <summary>
/// SegmentMotion
/// Segments whole motion into separate moving parts
/// </summary>
/// <param name="mhi"></param>
/// <returns></returns>
public static CvSeq CvSegmentMotion(ref IplImage mhi, ref IplImage seg_mask, ref CvMemStorage storage, double timestamp, double seg_thresh)
{
IntPtr p = cvSegmentMotion(ref mhi, ref seg_mask, ref storage, timestamp, seg_thresh);
CvSeq i = (CvSeq)Marshal.PtrToStructure(p, typeof(CvSeq));
i.ptr = p;
return i;
}
public static CvSeq CvSegmentMotion(ref CvMat mhi, ref CvMat seg_mask, ref CvMemStorage storage, double timestamp, double seg_thresh)
{
IntPtr p = cvSegmentMotion(ref mhi, ref seg_mask, ref storage, timestamp, seg_thresh);
CvSeq i = (CvSeq)Marshal.PtrToStructure(p, typeof(CvSeq));
i.ptr = p;
return i;
}
public static CvSeq CvSegmentMotion(ref CvSeq mhi, ref CvSeq seg_mask, ref CvMemStorage storage, double timestamp, double seg_thresh)
{
IntPtr p = cvSegmentMotion(ref mhi, ref seg_mask, ref storage, timestamp, seg_thresh);
CvSeq i = (CvSeq)Marshal.PtrToStructure(p, typeof(CvSeq));
i.ptr = p;
return i;
}
[DllImport(CV_LIBRARY)]
private static extern IntPtr cvSegmentMotion(ref IplImage mhi, ref IplImage seg_mask, ref CvMemStorage storage, double timestamp, double seg_thresh);
[DllImport(CV_LIBRARY)]
private static extern IntPtr cvSegmentMotion(ref CvMat mhi, ref CvMat seg_mask, ref CvMemStorage storage, double timestamp, double seg_thresh);
[DllImport(CV_LIBRARY)]
private static extern IntPtr cvSegmentMotion(ref CvSeq mhi, ref CvSeq seg_mask, ref CvMemStorage storage, double timestamp, double seg_thresh);
/// <summary>
/// MeanShift
/// Finds object center on back projection
/// </summary>
/// <param name="prob_image"></param>
/// <returns></returns>
public static int CvMeanShift(ref IplImage prob_image, CvRect window, CvTermCriteria criteria, ref CvConnectedComp comp)
{
return cvMeanShift(ref prob_image, window, criteria, ref comp);
}
public static int CvMeanShift(ref CvMat prob_image, CvRect window, CvTermCriteria criteria, ref CvConnectedComp comp)
{
return cvMeanShift(ref prob_image, window, criteria, ref comp);
}
public static int CvMeanShift(ref CvSeq prob_image, CvRect window, CvTermCriteria criteria, ref CvConnectedComp comp)
{
return cvMeanShift(ref prob_image, window, criteria, ref comp);
}
[DllImport(CV_LIBRARY)]
private static extern int cvMeanShift(ref IplImage prob_image, CvRect window, CvTermCriteria criteria, ref CvConnectedComp comp);
[DllImport(CV_LIBRARY)]
private static extern int cvMeanShift(ref CvMat prob_image, CvRect window, CvTermCriteria criteria, ref CvConnectedComp comp);
[DllImport(CV_LIBRARY)]
private static extern int cvMeanShift(ref CvSeq prob_image, CvRect window, CvTermCriteria criteria, ref CvConnectedComp comp);
/// <summary>
/// CamShift
/// Finds object center, size, and orientation
/// </summary>
/// <param name="prob_image"></param>
/// <returns></returns>
public static int CvCamShift(ref IplImage prob_image, CvRect window, CvTermCriteria criteria, ref CvConnectedComp comp, ref CvBox2D box)
{
return cvCamShift(ref prob_image, window, criteria, ref comp, ref box);
}
public static int CvCamShift(ref CvMat prob_image, CvRect window, CvTermCriteria criteria, ref CvConnectedComp comp, ref CvBox2D box)
{
return cvCamShift(ref prob_image, window, criteria, ref comp, ref box);
}
public static int CvCamShift(ref CvSeq prob_image, CvRect window, CvTermCriteria criteria, ref CvConnectedComp comp, ref CvBox2D box)
{
return cvCamShift(ref prob_image, window, criteria, ref comp, ref box);
}
[DllImport(CV_LIBRARY)]
private static extern int cvCamShift(ref IplImage prob_image, CvRect window, CvTermCriteria criteria, ref CvConnectedComp comp, ref CvBox2D box);
[DllImport(CV_LIBRARY)]
private static extern int cvCamShift(ref CvMat prob_image, CvRect window, CvTermCriteria criteria, ref CvConnectedComp comp, ref CvBox2D box);
[DllImport(CV_LIBRARY)]
private static extern int cvCamShift(ref CvSeq prob_image, CvRect window, CvTermCriteria criteria, ref CvConnectedComp comp, ref CvBox2D box);
/// <summary>
/// SnakeImage
/// Changes contour position to minimize its energy
/// </summary>
/// <param name="image"></param>
/// <returns></returns>
public static void CvSnakeImage(ref IplImage image, IntPtr points, int length, float[] alpha, float[] beta, float[] gamma, int coeff_usage, CvSize win, CvTermCriteria criteria, int calc_gradient)
{
cvSnakeImage(ref image, points, length, alpha, beta, gamma, coeff_usage, win, criteria, calc_gradient);
}
[DllImport(CV_LIBRARY)]
private static extern void cvSnakeImage(ref IplImage image, IntPtr points, int length, float[] alpha, float[] beta, float[] gamma, int coeff_usage, CvSize win, CvTermCriteria criteria, int calc_gradient);
/// <summary>
/// CalcOpticalFlowHS
/// Calculates optical flow for two images
/// </summary>
/// <param name="prev"></param>
/// <returns></returns>
public static void CvCalcOpticalFlowHS(ref IplImage prev, ref IplImage curr, int use_previous, ref IplImage velx, ref IplImage vely, double lambda, CvTermCriteria criteria)
{
cvCalcOpticalFlowHS(ref prev, ref curr, use_previous, ref velx, ref vely, lambda, criteria);
}
public static void CvCalcOpticalFlowHS(ref CvMat prev, ref CvMat curr, int use_previous, ref CvMat velx, ref CvMat vely, double lambda, CvTermCriteria criteria)
{
cvCalcOpticalFlowHS(ref prev, ref curr, use_previous, ref velx, ref vely, lambda, criteria);
}
public static void CvCalcOpticalFlowHS(ref CvSeq prev, ref CvSeq curr, int use_previous, ref CvSeq velx, ref CvSeq vely, double lambda, CvTermCriteria criteria)
{
cvCalcOpticalFlowHS(ref prev, ref curr, use_previous, ref velx, ref vely, lambda, criteria);
}
[DllImport(CV_LIBRARY)]
private static extern void cvCalcOpticalFlowHS(ref IplImage prev, ref IplImage curr, int use_previous, ref IplImage velx, ref IplImage vely, double lambda, CvTermCriteria criteria);
[DllImport(CV_LIBRARY)]
private static extern void cvCalcOpticalFlowHS(ref CvMat prev, ref CvMat curr, int use_previous, ref CvMat velx, ref CvMat vely, double lambda, CvTermCriteria criteria);
[DllImport(CV_LIBRARY)]
private static extern void cvCalcOpticalFlowHS(ref CvSeq prev, ref CvSeq curr, int use_previous, ref CvSeq velx, ref CvSeq vely, double lambda, CvTermCriteria criteria);
/// <summary>
/// CalcOpticalFlowLK
/// Calculates optical flow for two images
/// </summary>
/// <param name="prev"></param>
/// <returns></returns>
public static void CvCalcOpticalFlowLK(ref IplImage prev, ref IplImage curr, CvSize win_size, ref IplImage velx, ref IplImage vely)
{
cvCalcOpticalFlowLK(ref prev, ref curr, win_size, ref velx, ref vely);
}
public static void CvCalcOpticalFlowLK(ref CvMat prev, ref CvMat curr, CvSize win_size, ref CvMat velx, ref CvMat vely)
{
cvCalcOpticalFlowLK(ref prev, ref curr, win_size, ref velx, ref vely);
}
public static void CvCalcOpticalFlowLK(ref CvSeq prev, ref CvSeq curr, CvSize win_size, ref CvSeq velx, ref CvSeq vely)
{
cvCalcOpticalFlowLK(ref prev, ref curr, win_size, ref velx, ref vely);
}
[DllImport(CV_LIBRARY)]
private static extern void cvCalcOpticalFlowLK(ref IplImage prev, ref IplImage curr, CvSize win_size, ref IplImage velx, ref IplImage vely);
[DllImport(CV_LIBRARY)]
private static extern void cvCalcOpticalFlowLK(ref CvMat prev, ref CvMat curr, CvSize win_size, ref CvMat velx, ref CvMat vely);
[DllImport(CV_LIBRARY)]
private static extern void cvCalcOpticalFlowLK(ref CvSeq prev, ref CvSeq curr, CvSize win_size, ref CvSeq velx, ref CvSeq vely);
/// <summary>
/// CalcOpticalFlowBM
/// Calculates optical flow for two images by block matching method
/// </summary>
/// <param name="prev"></param>
/// <returns></returns>
public static void CvCalcOpticalFlowBM(ref IplImage prev, ref IplImage curr, CvSize block_size, CvSize shift_size, CvSize max_range, int use_previous, ref IplImage velx, ref IplImage vely)
{
cvCalcOpticalFlowBM(ref prev, ref curr, block_size, shift_size, max_range, use_previous, ref velx, ref vely);
}
public static void CvCalcOpticalFlowBM(ref CvMat prev, ref CvMat curr, CvSize block_size, CvSize shift_size, CvSize max_range, int use_previous, ref CvMat velx, ref CvMat vely)
{
cvCalcOpticalFlowBM(ref prev, ref curr, block_size, shift_size, max_range, use_previous, ref velx, ref vely);
}
public static void CvCalcOpticalFlowBM(ref CvSeq prev, ref CvSeq curr, CvSize block_size, CvSize shift_size, CvSize max_range, int use_previous, ref CvSeq velx, ref CvSeq vely)
{
cvCalcOpticalFlowBM(ref prev, ref curr, block_size, shift_size, max_range, use_previous, ref velx, ref vely);
}
[DllImport(CV_LIBRARY)]
private static extern void cvCalcOpticalFlowBM(ref IplImage prev, ref IplImage curr, CvSize block_size, CvSize shift_size, CvSize max_range, int use_previous, ref IplImage velx, ref IplImage vely);
[DllImport(CV_LIBRARY)]
private static extern void cvCalcOpticalFlowBM(ref CvMat prev, ref CvMat curr, CvSize block_size, CvSize shift_size, CvSize max_range, int use_previous, ref CvMat velx, ref CvMat vely);
[DllImport(CV_LIBRARY)]
private static extern void cvCalcOpticalFlowBM(ref CvSeq prev, ref CvSeq curr, CvSize block_size, CvSize shift_size, CvSize max_range, int use_previous, ref CvSeq velx, ref CvSeq vely);
/// <summary>
/// CalcOpticalFlowPyrLK
/// Calculates optical flow for a sparse feature set using iterative Lucas-Kanade method in
/// pyramids
/// </summary>
/// <param name="prev"></param>
/// <returns></returns>
public static void CvCalcOpticalFlowPyrLK(ref IplImage prev, ref IplImage curr, ref IplImage prev_pyr, ref IplImage curr_pyr, IntPtr prev_features, IntPtr curr_features, int count, CvSize win_size, int level, byte[] status, float[] track_error, CvTermCriteria criteria, int flags)
{
cvCalcOpticalFlowPyrLK(ref prev, ref curr, ref prev_pyr, ref curr_pyr, prev_features, curr_features, count, win_size, level, status, track_error, criteria, flags);
}
public static void CvCalcOpticalFlowPyrLK(ref CvMat prev, ref CvMat curr, ref CvMat prev_pyr, ref CvMat curr_pyr, IntPtr prev_features, IntPtr curr_features, int count, CvSize win_size, int level, byte[] status, float[] track_error, CvTermCriteria criteria, int flags)
{
cvCalcOpticalFlowPyrLK(ref prev, ref curr, ref prev_pyr, ref curr_pyr, prev_features, curr_features, count, win_size, level, status, track_error, criteria, flags);
}
public static void CvCalcOpticalFlowPyrLK(ref CvSeq prev, ref CvSeq curr, ref CvSeq prev_pyr, ref CvSeq curr_pyr, IntPtr prev_features, IntPtr curr_features, int count, CvSize win_size, int level, byte[] status, float[] track_error, CvTermCriteria criteria, int flags)
{
cvCalcOpticalFlowPyrLK(ref prev, ref curr, ref prev_pyr, ref curr_pyr, prev_features, curr_features, count, win_size, level, status, track_error, criteria, flags);
}
[DllImport(CV_LIBRARY)]
private static extern void cvCalcOpticalFlowPyrLK(ref IplImage prev, ref IplImage curr, ref IplImage prev_pyr, ref IplImage curr_pyr, IntPtr prev_features, IntPtr curr_features, int count, CvSize win_size, int level, byte[] status, float[] track_error, CvTermCriteria criteria, int flags);
[DllImport(CV_LIBRARY)]
private static extern void cvCalcOpticalFlowPyrLK(ref CvMat prev, ref CvMat curr, ref CvMat prev_pyr, ref CvMat curr_pyr, IntPtr prev_features, IntPtr curr_features, int count, CvSize win_size, int level, byte[] status, float[] track_error, CvTermCriteria criteria, int flags);
[DllImport(CV_LIBRARY)]
private static extern void cvCalcOpticalFlowPyrLK(ref CvSeq prev, ref CvSeq curr, ref CvSeq prev_pyr, ref CvSeq curr_pyr, IntPtr prev_features, IntPtr curr_features, int count, CvSize win_size, int level, byte[] status, float[] track_error, CvTermCriteria criteria, int flags);
/// <summary>
/// CvKalman
/// Kalman filter state
/// </summary>
/// <param name="dynam_params"></param>
/// <returns></returns>
/// <summary>
/// ReleaseKalman
/// Deallocates Kalman filter structure
/// </summary>
/// <param name="kalman"></param>
/// <returns></returns>
public static void CvReleaseKalman(ref CvKalman kalman)
{
cvReleaseKalman(ref kalman.ptr);
}
[DllImport(CV_LIBRARY)]
private static extern void cvReleaseKalman(ref IntPtr kalman);
/// <summary>
/// KalmanPredict
/// Estimates subsequent model state
/// </summary>
/// <param name="kalman"></param>
/// <returns></returns>
public static CvMat CvKalmanPredict(ref CvKalman kalman, ref CvMat control)
{
IntPtr p = cvKalmanPredict(ref kalman, ref control);
CvMat i = (CvMat)Marshal.PtrToStructure(p, typeof(CvMat));
i.ptr = p;
return i;
}
[DllImport(CV_LIBRARY)]
private static extern IntPtr cvKalmanPredict(ref CvKalman kalman, ref CvMat control);
/// <summary>
/// KalmanCorrect
/// Adjusts model state
/// </summary>
/// <param name="kalman"></param>
/// <returns></returns>
public static CvMat CvKalmanCorrect(ref CvKalman kalman, ref CvMat measurement)
{
IntPtr p = cvKalmanCorrect(ref kalman, ref measurement);
CvMat i = (CvMat)Marshal.PtrToStructure(p, typeof(CvMat));
i.ptr = p;
return i;
}
[DllImport(CV_LIBRARY)]
private static extern IntPtr cvKalmanCorrect(ref CvKalman kalman, ref CvMat measurement);
/// <summary>
/// CvConDensation
/// ConDenstation state
/// </summary>
/// <param name="dynam_params"></param>
/// <returns></returns>
public static CvConDensation CvCreateConDensation( int dynam_params, int measure_params, int sample_count )
{
IntPtr p = cvCreateConDensation(dynam_params, measure_params, sample_count );
CvConDensation i = (CvConDensation)Marshal.PtrToStructure(p, typeof(CvConDensation));
i.ptr = p;
return i;
}
[DllImport(CV_LIBRARY)]
private static extern IntPtr cvCreateConDensation( int dynam_params, int measure_params, int sample_count );
/// <summary>
/// ReleaseConDensation
/// Deallocates ConDensation filter structure
/// </summary>
/// <param name="condens"></param>
/// <returns></returns>
public static void CvReleaseConDensation(ref CvConDensation condens)
{
cvReleaseConDensation(ref condens.ptr);
}
[DllImport(CV_LIBRARY)]
private static extern void cvReleaseConDensation(ref IntPtr condens);
/// <summary>
/// ConDensInitSampleSet
/// Initializes sample set for ConDensation algorithm
/// </summary>
/// <param name="condens"></param>
/// <returns></returns>
public static void CvConDensInitSampleSet(ref CvConDensation condens, ref CvMat lower_bound, ref CvMat upper_bound)
{
cvConDensInitSampleSet(ref condens, ref lower_bound, ref upper_bound);
}
[DllImport(CV_LIBRARY)]
private static extern void cvConDensInitSampleSet(ref CvConDensation condens, ref CvMat lower_bound, ref CvMat upper_bound);
/// <summary>
/// ConDensUpdateByTime
/// Estimates subsequent model state
/// </summary>
/// <param name="condens"></param>
/// <returns></returns>
public static void CvConDensUpdateByTime(ref CvConDensation condens)
{
cvConDensUpdateByTime(ref condens);
}
[DllImport(CV_LIBRARY)]
private static extern void cvConDensUpdateByTime(ref CvConDensation condens);
/// <summary>
/// cvReleaseHaarClassifierCascade
/// Releases haar classifier cascade
/// </summary>
/// <param name="cascade"></param>
/// <returns></returns>
public static void CvReleaseHaarClassifierCascade(ref CvHaarClassifierCascade cascade)
{
cvReleaseHaarClassifierCascade(ref cascade.ptr);
}
[DllImport(CV_LIBRARY)]
private static extern void cvReleaseHaarClassifierCascade(ref IntPtr cascade);
/// <summary>
/// cvHaarDetectObjects
/// Detects objects in the image
/// </summary>
/// <param name="image"></param>
/// <returns></returns>
/// <summary>
/// cvHaarDetectObjects
/// Detects objects in the image
/// </summary>
/// <param name="image"></param>
/// <returns></returns>
public static CvSeq CvHaarDetectObjects(ref IplImage image,
ref CvHaarClassifierCascade cascade, ref CvMemStorage storage,
double scale_factor, int min_neighbors, int flag, CvSize min_size)
{
IntPtr p = cvHaarDetectObjects(ref image, ref cascade, ref storage,
scale_factor, min_neighbors, flag, min_size);
CvSeq i = (CvSeq)Marshal.PtrToStructure(p, typeof(CvSeq));
i.ptr = p;
return i;
}
[DllImport(CV_LIBRARY)]
private static extern IntPtr cvHaarDetectObjects(ref IplImage image,
ref CvHaarClassifierCascade cascade, ref CvMemStorage storage,
double scale_factor, int min_neighbors, int flags, CvSize min_size);
/// <summary>
/// cvSetImagesForHaarClassifierCascade
/// Assigns images to the hidden cascade
/// </summary>
/// <param name="cascade"></param>
/// <returns></returns>
public static void CvSetImagesForHaarClassifierCascade(ref CvHaarClassifierCascade cascade, ref IplImage sum, ref IplImage sqsum, ref IplImage tilted_sum, double scale)
{
cvSetImagesForHaarClassifierCascade(ref cascade, ref sum, ref sqsum, ref tilted_sum, scale);
}
public static void CvSetImagesForHaarClassifierCascade(ref CvHaarClassifierCascade cascade, ref CvMat sum, ref CvMat sqsum, ref CvMat tilted_sum, double scale)
{
cvSetImagesForHaarClassifierCascade(ref cascade, ref sum, ref sqsum, ref tilted_sum, scale);
}
public static void CvSetImagesForHaarClassifierCascade(ref CvHaarClassifierCascade cascade, ref CvSeq sum, ref CvSeq sqsum, ref CvSeq tilted_sum, double scale)
{
cvSetImagesForHaarClassifierCascade(ref cascade, ref sum, ref sqsum, ref tilted_sum, scale);
}
[DllImport(CV_LIBRARY)]
private static extern void cvSetImagesForHaarClassifierCascade(ref CvHaarClassifierCascade cascade, ref IplImage sum, ref IplImage sqsum, ref IplImage tilted_sum, double scale);
[DllImport(CV_LIBRARY)]
private static extern void cvSetImagesForHaarClassifierCascade(ref CvHaarClassifierCascade cascade, ref CvMat sum, ref CvMat sqsum, ref CvMat tilted_sum, double scale);
[DllImport(CV_LIBRARY)]
private static extern void cvSetImagesForHaarClassifierCascade(ref CvHaarClassifierCascade cascade, ref CvSeq sum, ref CvSeq sqsum, ref CvSeq tilted_sum, double scale);
/// <summary>
/// ProjectPoints2
/// Projects 3D points to image plane
/// </summary>
/// <param name="object_points"></param>
/// <returns></returns>
public static void CvProjectPoints2(ref CvMat object_points, ref CvMat rotation_vector,
ref CvMat translation_vector, ref CvMat intrinsic_matrix,
ref CvMat distortion_coeffs, ref CvMat image_points,
ref CvMat dpdrot, ref CvMat dpdt, ref CvMat dpdf,
ref CvMat dpdc, ref CvMat dpddist)
{
cvProjectPoints2(ref object_points, ref rotation_vector,
ref translation_vector, ref intrinsic_matrix,
ref distortion_coeffs, ref image_points,
ref dpdrot, ref dpdt, ref dpdf,
ref dpdc, ref dpddist);
}
public static void CvProjectPoints2(ref CvMat object_points, ref CvMat rotation_vector,
ref CvMat translation_vector, ref CvMat intrinsic_matrix,
ref CvMat distortion_coeffs, ref CvMat image_points)
{
cvProjectPoints2(ref object_points, ref rotation_vector,
ref translation_vector, ref intrinsic_matrix,
ref distortion_coeffs, ref image_points,
IntPtr.Zero, IntPtr.Zero, IntPtr.Zero,
IntPtr.Zero, IntPtr.Zero);
}
[DllImport(CV_LIBRARY)]
private static extern void cvProjectPoints2(ref CvMat object_points, ref CvMat rotation_vector,
ref CvMat translation_vector, ref CvMat intrinsic_matrix,
ref CvMat distortion_coeffs, ref CvMat image_points,
ref CvMat dpdrot, ref CvMat dpdt, ref CvMat dpdf,
ref CvMat dpdc, ref CvMat dpddist);
[DllImport(CV_LIBRARY)]
private static extern void cvProjectPoints2(ref CvMat object_points, ref CvMat rotation_vector,
ref CvMat translation_vector, ref CvMat intrinsic_matrix,
ref CvMat distortion_coeffs, ref CvMat image_points,
IntPtr dpdrot, IntPtr dpdt, IntPtr dpdf,
IntPtr dpdc, IntPtr dpddist);
/// <summary>
/// FindHomography
/// Finds perspective transformation between two planes
/// </summary>
/// <param name="src_points"></param>
/// <returns></returns>
public static void CvFindHomography(ref CvMat src_points, ref CvMat dst_points, ref CvMat homography)
{
cvFindHomography(ref src_points, ref dst_points, ref homography);
}
[DllImport(CV_LIBRARY)]
private static extern void cvFindHomography(ref CvMat src_points, ref CvMat dst_points, ref CvMat homography);
/// <summary>
/// CalibrateCamera2
/// Finds intrinsic and extrinsic camera parameters using calibration pattern
/// </summary>
/// <param name="object_points"></param>
/// <returns></returns>
public static void CvCalibrateCamera2(ref CvMat object_points, ref CvMat image_points,
ref CvMat point_counts, CvSize image_size, ref CvMat intrinsic_matrix, ref CvMat distortion_coeffs,
ref CvMat rotation_vectors, ref CvMat translation_vectors, int flags)
{
cvCalibrateCamera2(ref object_points, ref image_points, ref point_counts,
image_size, ref intrinsic_matrix, ref distortion_coeffs, ref rotation_vectors,
ref translation_vectors, flags);
}
[DllImport(CV_LIBRARY)]
private static extern void cvCalibrateCamera2(ref CvMat object_points, ref CvMat image_points,
ref CvMat point_counts, CvSize image_size, ref CvMat intrinsic_matrix, ref CvMat distortion_coeffs,
ref CvMat rotation_vectors, ref CvMat translation_vectors, int flags);
/// <summary>
/// FindExtrinsicCameraParams2
/// Finds extrinsic camera parameters for particular view
/// </summary>
/// <param name="object_points"></param>
/// <returns></returns>
public static void CvFindExtrinsicCameraParams2(ref CvMat object_points, ref CvMat image_points, ref CvMat intrinsic_matrix, ref CvMat distortion_coeffs, ref CvMat rotation_vector, ref CvMat translation_vector)
{
cvFindExtrinsicCameraParams2(ref object_points, ref image_points, ref intrinsic_matrix, ref distortion_coeffs, ref rotation_vector, ref translation_vector);
}
[DllImport(CV_LIBRARY)]
private static extern void cvFindExtrinsicCameraParams2(ref CvMat object_points, ref CvMat image_points, ref CvMat intrinsic_matrix, ref CvMat distortion_coeffs, ref CvMat rotation_vector, ref CvMat translation_vector);
/// <summary>
/// Rodrigues2
/// Converts rotation matrix to rotation vector or vice versa
/// </summary>
/// <param name="src"></param>
/// <returns></returns>
public static int CvRodrigues2(ref CvMat src, ref CvMat dst, ref CvMat jacobian)
{
return cvRodrigues2(ref src, ref dst, ref jacobian);
}
[DllImport(CV_LIBRARY)]
private static extern int cvRodrigues2(ref CvMat src, ref CvMat dst, ref CvMat jacobian);
/// <summary>
/// Undistort2
/// Transforms image to compensate lens distortion
/// </summary>
/// <param name="src"></param>
/// <returns></returns>
public static void CvUndistort2(ref IplImage src, ref IplImage dst, ref CvMat intrinsic_matrix, ref CvMat distortion_coeffs)
{
cvUndistort2(ref src, ref dst, ref intrinsic_matrix, ref distortion_coeffs);
}
public static void CvUndistort2(ref CvMat src, ref CvMat dst, ref CvMat intrinsic_matrix, ref CvMat distortion_coeffs)
{
cvUndistort2(ref src, ref dst, ref intrinsic_matrix, ref distortion_coeffs);
}
public static void CvUndistort2(ref CvSeq src, ref CvSeq dst, ref CvMat intrinsic_matrix, ref CvMat distortion_coeffs)
{
cvUndistort2(ref src, ref dst, ref intrinsic_matrix, ref distortion_coeffs);
}
[DllImport(CV_LIBRARY)]
private static extern void cvUndistort2(ref IplImage src, ref IplImage dst, ref CvMat intrinsic_matrix, ref CvMat distortion_coeffs);
[DllImport(CV_LIBRARY)]
private static extern void cvUndistort2(ref CvMat src, ref CvMat dst, ref CvMat intrinsic_matrix, ref CvMat distortion_coeffs);
[DllImport(CV_LIBRARY)]
private static extern void cvUndistort2(ref CvSeq src, ref CvSeq dst, ref CvMat intrinsic_matrix, ref CvMat distortion_coeffs);
/// <summary>
/// InitUndistortMap
/// Computes undistorion map
/// </summary>
/// <param name="intrinsic_matrix"></param>
/// <returns></returns>
public static void CvInitUndistortMap(ref CvMat intrinsic_matrix, ref CvMat distortion_coeffs, ref IplImage mapx, ref IplImage mapy)
{
cvInitUndistortMap(ref intrinsic_matrix, ref distortion_coeffs, ref mapx, ref mapy);
}
public static void CvInitUndistortMap(ref CvMat intrinsic_matrix, ref CvMat distortion_coeffs, ref CvMat mapx, ref CvMat mapy)
{
cvInitUndistortMap(ref intrinsic_matrix, ref distortion_coeffs, ref mapx, ref mapy);
}
public static void CvInitUndistortMap(ref CvMat intrinsic_matrix, ref CvMat distortion_coeffs, ref CvSeq mapx, ref CvSeq mapy)
{
cvInitUndistortMap(ref intrinsic_matrix, ref distortion_coeffs, ref mapx, ref mapy);
}
[DllImport(CV_LIBRARY)]
private static extern void cvInitUndistortMap(ref CvMat intrinsic_matrix, ref CvMat distortion_coeffs, ref IplImage mapx, ref IplImage mapy);
[DllImport(CV_LIBRARY)]
private static extern void cvInitUndistortMap(ref CvMat intrinsic_matrix, ref CvMat distortion_coeffs, ref CvMat mapx, ref CvMat mapy);
[DllImport(CV_LIBRARY)]
private static extern void cvInitUndistortMap(ref CvMat intrinsic_matrix, ref CvMat distortion_coeffs, ref CvSeq mapx, ref CvSeq mapy);
/// <summary>
/// FindChessboardCorners
/// Finds positions of internal corners of the chessboard
/// </summary>
/// <param name="image"></param>
/// <returns></returns>
public static int CvFindChessboardCorners(ref IplImage image, CvSize pattern_size, IntPtr corners, ref int corner_count, int flags)
{
return cvFindChessboardCorners(ref image, pattern_size, corners, ref corner_count, flags);
}
[DllImport(CV_LIBRARY)]
private static extern int cvFindChessboardCorners(ref IplImage image, CvSize pattern_size, IntPtr corners, ref int corner_count, int flags);
/// <summary>
/// DrawChessBoardCorners
/// Renders the detected chessboard corners
/// </summary>
/// <param name="image"></param>
/// <returns></returns>
public static void CvDrawChessboardCorners(ref IplImage image, CvSize pattern_size, IntPtr corners, int count, int pattern_was_found)
{
cvDrawChessboardCorners(ref image, pattern_size, corners, count, pattern_was_found);
}
[DllImport(CV_LIBRARY)]
private static extern void cvDrawChessboardCorners(ref IplImage image, CvSize pattern_size, IntPtr corners, int count, int pattern_was_found);
/// <summary>
/// CreatePOSITObject
/// Initializes structure containing object information
/// </summary>
/// <param name="points"></param>
/// <returns></returns>
public static CvPOSITObject CvCreatePOSITObject(ref CvPoint3D32f points, int point_count)
{
IntPtr p = cvCreatePOSITObject(ref points, point_count);
CvPOSITObject i = (CvPOSITObject)Marshal.PtrToStructure(p, typeof(CvPOSITObject));
i.ptr = p;
return i;
}
[DllImport(CV_LIBRARY)]
private static extern IntPtr cvCreatePOSITObject(ref CvPoint3D32f points, int point_count);
/// <summary>
/// POSIT
/// Implements POSIT algorithm
/// </summary>
/// <param name="posit_object"></param>
/// <returns></returns>
public static void CvPOSIT(ref CvPOSITObject posit_object, ref CvPoint2D32f image_points, double focal_length, CvTermCriteria criteria, float[] rotation_matrix, float[] translation_vector)
{
cvPOSIT(ref posit_object, ref image_points, focal_length, criteria, rotation_matrix, translation_vector);
}
[DllImport(CV_LIBRARY)]
private static extern void cvPOSIT(ref CvPOSITObject posit_object, ref CvPoint2D32f image_points, double focal_length, CvTermCriteria criteria, float[] rotation_matrix, float[] translation_vector);
/// <summary>
/// ReleasePOSITObject
/// Deallocates 3D object structure
/// </summary>
/// <param name="posit_object"></param>
/// <returns></returns>
public static void CvReleasePOSITObject(ref CvPOSITObject posit_object)
{
cvReleasePOSITObject(ref posit_object.ptr);
}
[DllImport(CV_LIBRARY)]
private static extern void cvReleasePOSITObject(ref IntPtr posit_object);
/// <summary>
/// CalcImageHomography
/// Calculates homography matrix for oblong planar object (e g arm)
/// </summary>
/// <param name="line"></param>
/// <returns></returns>
public static void CvCalcImageHomography(float[] line, ref CvPoint3D32f center, float[] intrinsic, float[] homography)
{
cvCalcImageHomography(line, ref center, intrinsic, homography);
}
[DllImport(CV_LIBRARY)]
private static extern void cvCalcImageHomography(float[] line, ref CvPoint3D32f center, float[] intrinsic, float[] homography);
/// <summary>
/// FindFundamentalMat
/// Calculates fundamental matrix from corresponding points in two images
/// </summary>
/// <param name="points1"></param>
/// <returns></returns>
public static int CvFindFundamentalMat(ref CvMat points1, ref CvMat points2, ref CvMat fundamental_matrix, int method, double param1, double param2, ref CvMat status)
{
return cvFindFundamentalMat(ref points1, ref points2, ref fundamental_matrix, method, param1, param2, ref status);
}
[DllImport(CV_LIBRARY)]
private static extern int cvFindFundamentalMat(ref CvMat points1, ref CvMat points2, ref CvMat fundamental_matrix, int method, double param1, double param2, ref CvMat status);
/// <summary>
/// </summary>
/// <returns></returns>
public static void CvComputeCorrespondEpilines(ref CvMat points, int which_image, ref CvMat fundamental_matrix, ref CvMat correspondent_lines)
{
cvComputeCorrespondEpilines(ref points, which_image, ref fundamental_matrix, ref correspondent_lines);
}
[DllImport(CV_LIBRARY)]
private static extern void cvComputeCorrespondEpilines(ref CvMat points, int which_image, ref CvMat fundamental_matrix, ref CvMat correspondent_lines);
}
}
Submit an article or tip