opencv_legacy (JavaCPP Presets for OpenCV 2.4.9-0.8 API)

java.lang.Object
- org.bytedeco.javacpp.presets.opencv_legacy
- - org.bytedeco.javacpp.helper.opencv_legacy
  - - org.bytedeco.javacpp.opencv_legacy

All Implemented Interfaces:: InfoMapper

public class opencv_legacy
extends opencv_legacy

Nested Class Summary

Nested Classes
Modifier and Type	Class and Description
`static class`	`opencv_legacy.BaseKeypoint` \ Calonder Classifier * \
`static class`	`opencv_legacy.Cv3dTracker2dTrackedObject` \ 3D Tracker * \
`static class`	`opencv_legacy.Cv3dTrackerCameraInfo`
`static class`	`opencv_legacy.Cv3dTrackerCameraIntrinsics`
`static class`	`opencv_legacy.Cv3dTrackerTrackedObject`
`static class`	`opencv_legacy.CvAffinePose` \ One-Way Descriptor * \
`static class`	`opencv_legacy.CvBGCodeBookElem`
`static class`	`opencv_legacy.CvBGCodeBookModel`
`static class`	`opencv_legacy.CvBGPixelCCStatTable`
`static class`	`opencv_legacy.CvBGPixelCStatTable`
`static class`	`opencv_legacy.CvBGPixelStat`
`static class`	`opencv_legacy.CvBGStatModel`
`static class`	`opencv_legacy.CvBlob`
`static class`	`opencv_legacy.CvBlobDetector`
`static class`	`opencv_legacy.CvBlobSeq`
`static class`	`opencv_legacy.CvBlobTrack`
`static class`	`opencv_legacy.CvBlobTrackAnalysis`
`static class`	`opencv_legacy.CvBlobTrackAnalysisHeight`
`static class`	`opencv_legacy.CvBlobTrackAnalysisOne`
`static class`	`opencv_legacy.CvBlobTrackAnalysisOne_Create`
`static class`	`opencv_legacy.CvBlobTracker`
`static class`	`opencv_legacy.CvBlobTrackerAuto`
`static class`	`opencv_legacy.CvBlobTrackerAutoParam1`
`static class`	`opencv_legacy.CvBlobTrackerOne`
`static class`	`opencv_legacy.CvBlobTrackerOne_Create`
`static class`	`opencv_legacy.CvBlobTrackerParamLH`
`static class`	`opencv_legacy.CvBlobTrackerParamMS`
`static class`	`opencv_legacy.CvBlobTrackFVGen`
`static class`	`opencv_legacy.CvBlobTrackGen`
`static class`	`opencv_legacy.CvBlobTrackPostProc`
`static class`	`opencv_legacy.CvBlobTrackPostProcOne`
`static class`	`opencv_legacy.CvBlobTrackPostProcOne_Create`
`static class`	`opencv_legacy.CvBlobTrackPredictor`
`static class`	`opencv_legacy.CvBlobTrackSeq`
`static class`	`opencv_legacy.CvCalibFilter`
`static class`	`opencv_legacy.CvCallback` \ Eigen objects * \
`static class`	`opencv_legacy.CvCamera`
`static class`	`opencv_legacy.CvCamShiftTracker` \ CamShiftTracker * \
`static class`	`opencv_legacy.CvCliqueFinder` Stereo correspondence
`static class`	`opencv_legacy.CvConDensation`
`static class`	`opencv_legacy.CvContourOrientation`
`static class`	`opencv_legacy.CvContourTree` \ Contour Tree * \
`static class`	`opencv_legacy.CvDefParam`
`static class`	`opencv_legacy.CvDetectedBlob`
`static class`	`opencv_legacy.CvDrawShape`
`static class`	`opencv_legacy.CvEHMM`
`static class`	`opencv_legacy.CvEHMMState`
`static class`	`opencv_legacy.CvEM`
`static class`	`opencv_legacy.CvEMParams` \ Expectation - Maximization * \
`static class`	`opencv_legacy.CvFaceData`
`static class`	`opencv_legacy.CvFaceTracker` \ Face eyes&mouth tracking * \
`static class`	`opencv_legacy.CvFGDetector`
`static class`	`opencv_legacy.CvFGDStatModel`
`static class`	`opencv_legacy.CvFGDStatModelParams`
`static class`	`opencv_legacy.CvGaussBGModel`
`static class`	`opencv_legacy.CvGaussBGPoint`
`static class`	`opencv_legacy.CvGaussBGStatModelParams`
`static class`	`opencv_legacy.CvGaussBGValues`
`static class`	`opencv_legacy.CvGLCM`
`static class`	`opencv_legacy.CvGraphWeightedEdge`
`static class`	`opencv_legacy.CvGraphWeightedVtx`
`static class`	`opencv_legacy.CvImage`
`static class`	`opencv_legacy.CvImgObsInfo` \ 1D/2D HMM * \
`static class`	`opencv_legacy.CvInput`
`static class`	`opencv_legacy.CvLCMEdge` Linear-Contour Model
`static class`	`opencv_legacy.CvLCMNode`
`static class`	`opencv_legacy.CvLSHOperations`
`static class`	`opencv_legacy.CvMatrix`
`static class`	`opencv_legacy.CvMatrix3` View Morphing Functions
`static class`	`opencv_legacy.CvMSERParams` Maximal Stable Regions Parameters
`static class`	`opencv_legacy.CvObjectDetector`
`static class`	`opencv_legacy.CvPixelPosition32f`
`static class`	`opencv_legacy.CvPixelPosition8s`
`static class`	`opencv_legacy.CvPixelPosition8u` \ Pixel Access Macros * \
`static class`	`opencv_legacy.CvProb`
`static class`	`opencv_legacy.CvRandState`
`static class`	`opencv_legacy.CvReleaseBGStatModel`
`static class`	`opencv_legacy.CvStarDetectorParams`
`static class`	`opencv_legacy.CvStarKeypoint`
`static class`	`opencv_legacy.CvStereoCamera`
`static class`	`opencv_legacy.CvStereoGCState`
`static class`	`opencv_legacy.CvStereoLineCoeff` Epiline functions
`static class`	`opencv_legacy.CvSURFParams`
`static class`	`opencv_legacy.CvSURFPoint`
`static class`	`opencv_legacy.CvTestSeq`
`static class`	`opencv_legacy.CvTracksTimePos`
`static class`	`opencv_legacy.CvUpdateBGStatModel`
`static class`	`opencv_legacy.CvVoronoiDiagram2D`
`static class`	`opencv_legacy.CvVoronoiEdge2D`
`static class`	`opencv_legacy.CvVoronoiNode2D`
`static class`	`opencv_legacy.CvVoronoiSite2D`
`static class`	`opencv_legacy.CvVSModule`
`static class`	`opencv_legacy.FernClassifier`
`static class`	`opencv_legacy.FernDescriptorMatcher`
`static class`	`opencv_legacy.LDetector`
`static class`	`opencv_legacy.lsh_hash`
`static class`	`opencv_legacy.OneWayDescriptor`
`static class`	`opencv_legacy.OneWayDescriptorBase`
`static class`	`opencv_legacy.OneWayDescriptorMatcher`
`static class`	`opencv_legacy.OneWayDescriptorObject`
`static class`	`opencv_legacy.PatchGenerator` The Patch Generator class
`static class`	`opencv_legacy.PlanarObjectDetector` \ Planar Object Detection * \
`static class`	`opencv_legacy.RandomizedTree`
`static class`	`opencv_legacy.RTreeClassifier`
`static class`	`opencv_legacy.RTreeNode`

Nested classes/interfaces inherited from class org.bytedeco.javacpp.helper.opencv_legacy
opencv_legacy.AbstractCvBGCodeBookModel, opencv_legacy.AbstractCvBGStatModel, opencv_legacy.AbstractCvConDensation, opencv_legacy.AbstractCvEHMM, opencv_legacy.AbstractCvFaceTracker, opencv_legacy.AbstractCvGLCM, opencv_legacy.AbstractCvImgObsInfo

Field Summary

Fields
Modifier and Type	Field and Description
`static int`	`CLIQUE_END`
`static int`	`CLIQUE_FOUND`
`static int`	`CLIQUE_TIME_OFF`
`static int`	`CV_ARRAY`
`static int`	`CV_BG_MODEL_FGD` \ Background/foreground segmentation * \
`static int`	`CV_BG_MODEL_FGD_SIMPLE`
`static int`	`CV_BG_MODEL_MOG`
`static double`	`CV_BGFG_FGD_ALPHA_1`
`static double`	`CV_BGFG_FGD_ALPHA_2`
`static double`	`CV_BGFG_FGD_ALPHA_3`
`static double`	`CV_BGFG_FGD_BG_UPDATE_TRESH`
`static int`	`CV_BGFG_FGD_DELTA`
`static int`	`CV_BGFG_FGD_LC`
`static int`	`CV_BGFG_FGD_LCC`
`static double`	`CV_BGFG_FGD_MINAREA`
`static int`	`CV_BGFG_FGD_N1C`
`static int`	`CV_BGFG_FGD_N1CC`
`static int`	`CV_BGFG_FGD_N2C`
`static int`	`CV_BGFG_FGD_N2CC`
`static double`	`CV_BGFG_FGD_T`
`static double`	`CV_BGFG_MOG_BACKGROUND_THRESHOLD`
`static int`	`CV_BGFG_MOG_MAX_NGAUSSIANS`
`static double`	`CV_BGFG_MOG_MINAREA`
`static int`	`CV_BGFG_MOG_NCOLORS`
`static int`	`CV_BGFG_MOG_NGAUSSIANS`
`static int`	`CV_BGFG_MOG_SIGMA_INIT`
`static double`	`CV_BGFG_MOG_STD_THRESHOLD`
`static double`	`CV_BGFG_MOG_WEIGHT_INIT`
`static int`	`CV_BGFG_MOG_WINDOW_SIZE`
`static int`	`CV_BLOB_MINH`
`static int`	`CV_BLOB_MINW`
`static int`	`CV_BT_HIST_TYPE_H`
`static int`	`CV_BT_HIST_TYPE_MG`
`static int`	`CV_BT_HIST_TYPE_MG2`
`static int`	`CV_BT_HIST_TYPE_S`
`static int`	`CV_CALIB_ETALON_CHECKERBOARD` enum CvCalibEtalonType
`static int`	`CV_CALIB_ETALON_CHESSBOARD` enum CvCalibEtalonType
`static int`	`CV_CALIB_ETALON_USER` enum CvCalibEtalonType
`static int`	`CV_CAMERA_TO_WARP`
`static int`	`CV_CONTOUR_TREES_MATCH_I1` enum
`static int`	`CV_DISPARITY_BIRCHFIELD`
`static int`	`CV_DOMINANT_IPAN`
`static int`	`CV_EIGOBJ_BOTH_CALLBACK`
`static int`	`CV_EIGOBJ_INPUT_CALLBACK`
`static int`	`CV_EIGOBJ_NO_CALLBACK`
`static int`	`CV_EIGOBJ_OUTPUT_CALLBACK`
`static int`	`CV_FACE_LEFT_EYE` enum CV_FACE_ELEMENTS
`static int`	`CV_FACE_MOUTH` enum CV_FACE_ELEMENTS
`static int`	`CV_FACE_RIGHT_EYE` enum CV_FACE_ELEMENTS
`static int`	`CV_GLCM_ALL`
`static int`	`CV_GLCM_DESC`
`static int`	`CV_GLCM_GLCM`
`static int`	`CV_GLCM_OPTIMIZATION_HISTOGRAM`
`static int`	`CV_GLCM_OPTIMIZATION_LUT`
`static int`	`CV_GLCM_OPTIMIZATION_NONE` \ Texture Descriptors * \
`static int`	`CV_GLCMDESC_CLUSTERSHADE`
`static int`	`CV_GLCMDESC_CLUSTERTENDENCY`
`static int`	`CV_GLCMDESC_CONTRAST`
`static int`	`CV_GLCMDESC_CORRELATION`
`static int`	`CV_GLCMDESC_CORRELATIONINFO1`
`static int`	`CV_GLCMDESC_CORRELATIONINFO2`
`static int`	`CV_GLCMDESC_ENERGY`
`static int`	`CV_GLCMDESC_ENTROPY`
`static int`	`CV_GLCMDESC_HOMOGENITY`
`static int`	`CV_GLCMDESC_MAXIMUMPROBABILITY`
`static int`	`CV_GLCMDESC_OPTIMIZATION_ALLOWDOUBLENEST`
`static int`	`CV_GLCMDESC_OPTIMIZATION_ALLOWTRIPLENEST`
`static int`	`CV_GLCMDESC_OPTIMIZATION_HISTOGRAM`
`static int`	`CV_IDP_BIRCHFIELD_PARAM1`
`static int`	`CV_IDP_BIRCHFIELD_PARAM2`
`static int`	`CV_IDP_BIRCHFIELD_PARAM3`
`static int`	`CV_IDP_BIRCHFIELD_PARAM4`
`static int`	`CV_IDP_BIRCHFIELD_PARAM5`
`static int`	`CV_LEE_AUTO` enum CvLeeParameters
`static int`	`CV_LEE_DOUBLE` enum CvLeeParameters
`static int`	`CV_LEE_ERODE` enum CvLeeParameters
`static int`	`CV_LEE_FLOAT` enum CvLeeParameters
`static int`	`CV_LEE_INT` enum CvLeeParameters
`static int`	`CV_LEE_NON` enum CvLeeParameters
`static int`	`CV_LEE_ZOOM` enum CvLeeParameters
`static int`	`CV_MAT32F` enum
`static int`	`CV_MAT3x1_32F` enum
`static int`	`CV_MAT3x1_64D` enum
`static int`	`CV_MAT3x3_32F` enum
`static int`	`CV_MAT3x3_64D` enum
`static int`	`CV_MAT4x1_32F` enum
`static int`	`CV_MAT4x1_64D` enum
`static int`	`CV_MAT4x4_32F` enum
`static int`	`CV_MAT4x4_64D` enum
`static int`	`CV_MAT64D` enum
`static int`	`CV_NOISE_GAUSSIAN`
`static int`	`CV_NOISE_NONE`
`static int`	`CV_NOISE_SALT_AND_PEPPER`
`static int`	`CV_NOISE_SPECKLE`
`static int`	`CV_NOISE_UNIFORM`
`static int`	`CV_NOT_WEIGHTED` enum CvGraphWeightType
`static int`	`CV_NUM_FACE_ELEMENTS`
`static int`	`CV_RODRIGUES_M2V` enum
`static int`	`CV_RODRIGUES_V2M` enum
`static int`	`CV_SHIFT_DOWN` enum
`static int`	`CV_SHIFT_LD` enum
`static int`	`CV_SHIFT_LEFT` enum
`static int`	`CV_SHIFT_LU` enum
`static int`	`CV_SHIFT_NONE` enum
`static int`	`CV_SHIFT_RD` enum
`static int`	`CV_SHIFT_RIGHT` enum
`static int`	`CV_SHIFT_RU` enum
`static int`	`CV_SHIFT_UP` enum
`static int`	`CV_STEREO_GC_OCCLUDED`
`static int`	`CV_UNDEF_SC_PARAM`
`static int`	`CV_VALUE` \ Active Contours * \
`static int`	`CV_WARP_TO_CAMERA`
`static int`	`CV_WEIGHTED_ALL` enum CvGraphWeightType
`static int`	`CV_WEIGHTED_EDGE` enum CvGraphWeightType
`static int`	`CV_WEIGHTED_VTX` enum CvGraphWeightType
`static int`	`IPL_GAUSSIAN_5x5` enum
`static int`	`PROFILE_DOG`
`static int`	`PROFILE_EPANECHNIKOV`

Constructor Summary

Constructors
Constructor and Description

opencv_legacy()

Constructors
Constructor and Description
`opencv_legacy()`

Method Summary

Methods
Modifier and Type	Method and Description
`static boolean`	`CV_IS_SET_ELEM_EXISTS(opencv_core.CvSetElem arg1)`
`static int`	`CV_STEREO_GC_OCCLUDED()`
`static opencv_legacy.Cv3dTracker2dTrackedObject`	`cv3dTracker2dTrackedObject(int id, float[] p)`
`static opencv_legacy.Cv3dTracker2dTrackedObject`	`cv3dTracker2dTrackedObject(int id, FloatBuffer p)`
`static opencv_legacy.Cv3dTracker2dTrackedObject`	`cv3dTracker2dTrackedObject(int id, opencv_core.CvPoint2D32f p)`
`static byte`	`cv3dTrackerCalibrateCameras(int num_cameras, opencv_legacy.Cv3dTrackerCameraIntrinsics camera_intrinsics, opencv_core.CvSize etalon_size, float square_size, opencv_core.IplImage samples, opencv_legacy.Cv3dTrackerCameraInfo camera_info)`
`static byte`	`cv3dTrackerCalibrateCameras(int num_cameras, opencv_legacy.Cv3dTrackerCameraIntrinsics camera_intrinsics, opencv_core.CvSize etalon_size, float square_size, PointerPointer samples, opencv_legacy.Cv3dTrackerCameraInfo camera_info)`
`static int`	`cv3dTrackerLocateObjects(int num_cameras, int num_objects, opencv_legacy.Cv3dTrackerCameraInfo camera_info, opencv_legacy.Cv3dTracker2dTrackedObject tracking_info, opencv_legacy.Cv3dTrackerTrackedObject tracked_objects)`
`static opencv_legacy.Cv3dTrackerTrackedObject`	`cv3dTrackerTrackedObject(int id, float[] p)`
`static opencv_legacy.Cv3dTrackerTrackedObject`	`cv3dTrackerTrackedObject(int id, FloatBuffer p)`
`static opencv_legacy.Cv3dTrackerTrackedObject`	`cv3dTrackerTrackedObject(int id, opencv_core.CvPoint3D32f p)`
`static void`	`cvAccMask(opencv_core.CvArr arg1, opencv_core.CvArr arg2, opencv_core.CvArr arg3)`
`static void`	`cvbCartToPolar(float[] y, float[] x, float[] magnitude, float[] angle, int len)`
`static void`	`cvbCartToPolar(FloatBuffer y, FloatBuffer x, FloatBuffer magnitude, FloatBuffer angle, int len)`
`static void`	`cvbCartToPolar(FloatPointer y, FloatPointer x, FloatPointer magnitude, FloatPointer angle, int len)`
`static void`	`cvbFastArctan(float[] y, float[] x, float[] angle, int len)`
`static void`	`cvbFastArctan(FloatBuffer y, FloatBuffer x, FloatBuffer angle, int len)`
`static void`	`cvbFastArctan(FloatPointer y, FloatPointer x, FloatPointer angle, int len)`
`static void`	`cvbFastExp(float[] x, double[] y, int len)`
`static void`	`cvbFastExp(FloatBuffer x, DoubleBuffer y, int len)`
`static void`	`cvbFastExp(FloatPointer x, DoublePointer y, int len)`
`static void`	`cvbFastLog(double[] x, float[] y, int len)`
`static void`	`cvbFastLog(DoubleBuffer x, FloatBuffer y, int len)`
`static void`	`cvbFastLog(DoublePointer x, FloatPointer y, int len)`
`static void`	`cvBGCodeBookClearStale(opencv_legacy.CvBGCodeBookModel model, int staleThresh)`
`static void`	`cvBGCodeBookClearStale(opencv_legacy.CvBGCodeBookModel model, int staleThresh, opencv_core.CvRect roi, opencv_core.CvArr mask)`
`static int`	`cvBGCodeBookDiff(opencv_legacy.CvBGCodeBookModel model, opencv_core.CvArr image, opencv_core.CvArr fgmask)`
`static int`	`cvBGCodeBookDiff(opencv_legacy.CvBGCodeBookModel model, opencv_core.CvArr image, opencv_core.CvArr fgmask, opencv_core.CvRect roi)`
`static void`	`cvBGCodeBookUpdate(opencv_legacy.CvBGCodeBookModel model, opencv_core.CvArr image)`
`static void`	`cvBGCodeBookUpdate(opencv_legacy.CvBGCodeBookModel model, opencv_core.CvArr image, opencv_core.CvRect roi, opencv_core.CvArr mask)`
`static void`	`cvbInvSqrt(float[] x, float[] y, int len)`
`static void`	`cvbInvSqrt(FloatBuffer x, FloatBuffer y, int len)`
`static void`	`cvbInvSqrt(FloatPointer x, FloatPointer y, int len)`
`static opencv_legacy.CvBlob`	`cvBlob(float x, float y, float w, float h)`
`static void`	`cvbRand(opencv_legacy.CvRandState state, float[] dst, int len)`
`static void`	`cvbRand(opencv_legacy.CvRandState state, FloatBuffer dst, int len)`
`static void`	`cvbRand(opencv_legacy.CvRandState state, FloatPointer dst, int len)`
`static void`	`cvbReciprocal(float[] x, float[] y, int len)`
`static void`	`cvbReciprocal(FloatBuffer x, FloatBuffer y, int len)`
`static void`	`cvbReciprocal(FloatPointer x, FloatPointer y, int len)`
`static void`	`cvbSqrt(float[] x, float[] y, int len)`
`static void`	`cvbSqrt(FloatBuffer x, FloatBuffer y, int len)`
`static void`	`cvbSqrt(FloatPointer x, FloatPointer y, int len)`
`static void`	`cvCalcCovarMatrixEx(int nObjects, Pointer input, int ioFlags, int ioBufSize, byte[] buffer, Pointer userData, opencv_core.IplImage avg, float[] covarMatrix)`
`static void`	`cvCalcCovarMatrixEx(int nObjects, Pointer input, int ioFlags, int ioBufSize, ByteBuffer buffer, Pointer userData, opencv_core.IplImage avg, FloatBuffer covarMatrix)`
`static void`	`cvCalcCovarMatrixEx(int nObjects, Pointer input, int ioFlags, int ioBufSize, BytePointer buffer, Pointer userData, opencv_core.IplImage avg, FloatPointer covarMatrix)`
`static double`	`cvCalcDecompCoeff(opencv_core.IplImage obj, opencv_core.IplImage eigObj, opencv_core.IplImage avg)`
`static void`	`cvCalcEigenObjects(int nObjects, Pointer input, Pointer output, int ioFlags, int ioBufSize, Pointer userData, opencv_core.CvTermCriteria calcLimit, opencv_core.IplImage avg, float[] eigVals)`
`static void`	`cvCalcEigenObjects(int nObjects, Pointer input, Pointer output, int ioFlags, int ioBufSize, Pointer userData, opencv_core.CvTermCriteria calcLimit, opencv_core.IplImage avg, FloatBuffer eigVals)`
`static void`	`cvCalcEigenObjects(int nObjects, Pointer input, Pointer output, int ioFlags, int ioBufSize, Pointer userData, opencv_core.CvTermCriteria calcLimit, opencv_core.IplImage avg, FloatPointer eigVals)`
`static float`	`cvCalcEMD(float[] signature1, int size1, float[] signature2, int size2, int dims)`
`static float`	`cvCalcEMD(float[] signature1, int size1, float[] signature2, int size2, int dims, int dist_type, opencv_imgproc.CvDistanceFunction dist_func, float[] lower_bound, Pointer user_param)`
`static float`	`cvCalcEMD(FloatBuffer signature1, int size1, FloatBuffer signature2, int size2, int dims)`
`static float`	`cvCalcEMD(FloatBuffer signature1, int size1, FloatBuffer signature2, int size2, int dims, int dist_type, opencv_imgproc.CvDistanceFunction dist_func, FloatBuffer lower_bound, Pointer user_param)`
`static float`	`cvCalcEMD(FloatPointer signature1, int size1, FloatPointer signature2, int size2, int dims)`
`static float`	`cvCalcEMD(FloatPointer signature1, int size1, FloatPointer signature2, int size2, int dims, int dist_type, opencv_imgproc.CvDistanceFunction dist_func, FloatPointer lower_bound, Pointer user_param)`
`static void`	`cvCalcHistMask(opencv_core.IplImage img, opencv_core.CvArr mask, opencv_core.CvHistogram hist, int doNotClear)`
`static void`	`cvCalcHistMask(PointerPointer img, opencv_core.CvArr mask, opencv_core.CvHistogram hist, int doNotClear)`
`static void`	`cvCalcImageHomography(float[] line, float[] center, float[] intrinsic, float[] homography)`
`static void`	`cvCalcImageHomography(FloatBuffer line, FloatBuffer center, FloatBuffer intrinsic, FloatBuffer homography)`
`static void`	`cvCalcImageHomography(FloatPointer line, opencv_core.CvPoint3D32f center, FloatPointer intrinsic, FloatPointer homography)`
`static void`	`cvCalcOpticalFlowBM(opencv_core.CvArr prev, opencv_core.CvArr curr, opencv_core.CvSize block_size, opencv_core.CvSize shift_size, opencv_core.CvSize max_range, int use_previous, opencv_core.CvArr velx, opencv_core.CvArr vely)`
`static void`	`cvCalcOpticalFlowHS(opencv_core.CvArr prev, opencv_core.CvArr curr, int use_previous, opencv_core.CvArr velx, opencv_core.CvArr vely, double lambda, opencv_core.CvTermCriteria criteria)`
`static void`	`cvCalcOpticalFlowLK(opencv_core.CvArr prev, opencv_core.CvArr curr, opencv_core.CvSize win_size, opencv_core.CvArr velx, opencv_core.CvArr vely)`
`static void`	`cvCalcPGH(opencv_core.CvSeq contour, opencv_core.CvHistogram hist)`
`static void`	`cvCalcSubdivVoronoi2D(opencv_imgproc.CvSubdiv2D subdiv)`
`static void`	`cvCalibrateCamera_64d(int image_count, int[] _point_counts, opencv_core.CvSize image_size, double[] _image_points, double[] _object_points, double[] _distortion_coeffs, double[] _camera_matrix, double[] _translation_vectors, double[] _rotation_matrices, int flags)`
`static void`	`cvCalibrateCamera_64d(int image_count, IntBuffer _point_counts, opencv_core.CvSize image_size, DoubleBuffer _image_points, DoubleBuffer _object_points, DoubleBuffer _distortion_coeffs, DoubleBuffer _camera_matrix, DoubleBuffer _translation_vectors, DoubleBuffer _rotation_matrices, int flags)`
`static void`	`cvCalibrateCamera_64d(int image_count, IntPointer _point_counts, opencv_core.CvSize image_size, opencv_core.CvPoint2D64f _image_points, opencv_core.CvPoint3D64f _object_points, DoublePointer _distortion_coeffs, DoublePointer _camera_matrix, DoublePointer _translation_vectors, DoublePointer _rotation_matrices, int flags)`
`static void`	`cvCalibrateCamera(int image_count, int[] _point_counts, opencv_core.CvSize image_size, float[] _image_points, float[] _object_points, float[] _distortion_coeffs, float[] _camera_matrix, float[] _translation_vectors, float[] _rotation_matrices, int flags)`
`static void`	`cvCalibrateCamera(int image_count, IntBuffer _point_counts, opencv_core.CvSize image_size, FloatBuffer _image_points, FloatBuffer _object_points, FloatBuffer _distortion_coeffs, FloatBuffer _camera_matrix, FloatBuffer _translation_vectors, FloatBuffer _rotation_matrices, int flags)`
`static void`	`cvCalibrateCamera(int image_count, IntPointer _point_counts, opencv_core.CvSize image_size, opencv_core.CvPoint2D32f _image_points, opencv_core.CvPoint3D32f _object_points, FloatPointer _distortion_coeffs, FloatPointer _camera_matrix, FloatPointer _translation_vectors, FloatPointer _rotation_matrices, int flags)`
`static int`	`cvChangeDetection(opencv_core.IplImage prev_frame, opencv_core.IplImage curr_frame, opencv_core.IplImage change_mask)`
`static void`	`cvCircleAA(opencv_core.CvArr img, int[] center, int radius, double color)`
`static void`	`cvCircleAA(opencv_core.CvArr img, int[] center, int radius, double color, int scale)`
`static void`	`cvCircleAA(opencv_core.CvArr img, IntBuffer center, int radius, double color)`
`static void`	`cvCircleAA(opencv_core.CvArr img, IntBuffer center, int radius, double color, int scale)`
`static void`	`cvCircleAA(opencv_core.CvArr img, opencv_core.CvPoint center, int radius, double color)`
`static void`	`cvCircleAA(opencv_core.CvArr img, opencv_core.CvPoint center, int radius, double color, int scale)`
`static void`	`cvClearSubdivVoronoi2D(opencv_imgproc.CvSubdiv2D subdiv)`
`static void`	`cvComputePerspectiveMap(double[] coeffs, opencv_core.CvArr rectMapX, opencv_core.CvArr rectMapY)`
`static void`	`cvComputePerspectiveMap(DoubleBuffer coeffs, opencv_core.CvArr rectMapX, opencv_core.CvArr rectMapY)`
`static void`	`cvComputePerspectiveMap(DoublePointer coeffs, opencv_core.CvArr rectMapX, opencv_core.CvArr rectMapY)`
`static void`	`cvConDensInitSampleSet(opencv_legacy.CvConDensation condens, opencv_core.CvMat lower_bound, opencv_core.CvMat upper_bound)`
`static void`	`cvConDensUpdateByTime(opencv_legacy.CvConDensation condens)`
`static opencv_core.CvRect`	`cvContourBoundingRect(Pointer point_set)`
`static opencv_core.CvRect`	`cvContourBoundingRect(Pointer point_set, int update)`
`static opencv_core.CvSeq`	`cvContourFromContourTree(opencv_legacy.CvContourTree tree, opencv_core.CvMemStorage storage, opencv_core.CvTermCriteria criteria)`
`static void`	`cvContourMoments(opencv_core.CvArr contour, opencv_imgproc.CvMoments moments)`
`static void`	`cvConvertPointsHomogenious(opencv_core.CvMat arg1, opencv_core.CvMat arg2)`
`static void`	`cvConvexHull(int[] points, int num_points, opencv_core.CvRect bound_rect, int orientation, int[] hull, int[] hullsize)`
`static void`	`cvConvexHull(IntBuffer points, int num_points, opencv_core.CvRect bound_rect, int orientation, IntBuffer hull, IntBuffer hullsize)`
`static void`	`cvConvexHull(opencv_core.CvPoint points, int num_points, opencv_core.CvRect bound_rect, int orientation, IntPointer hull, IntPointer hullsize)`
`static void`	`cvCopyImage(opencv_core.CvArr src, opencv_core.CvArr dst)`
`static opencv_legacy.CvEHMM`	`cvCreate2DHMM(int[] stateNumber, int[] numMix, int obsSize)`
`static opencv_legacy.CvEHMM`	`cvCreate2DHMM(IntBuffer stateNumber, IntBuffer numMix, int obsSize)`
`static opencv_legacy.CvEHMM`	`cvCreate2DHMM(IntPointer stateNumber, IntPointer numMix, int obsSize)` Embedded HMMs
`static opencv_legacy.CvBGCodeBookModel`	`cvCreateBGCodeBookModel()`
`static opencv_legacy.CvBlobDetector`	`cvCreateBlobDetectorCC()`
`static opencv_legacy.CvBlobDetector`	`cvCreateBlobDetectorSimple()`
`static opencv_legacy.CvBlobTrackAnalysis`	`cvCreateBlobTrackAnalysisList(opencv_legacy.CvBlobTrackAnalysisOne_Create create)`
`static opencv_legacy.CvBlobTrackerAuto`	`cvCreateBlobTrackerAuto(int type, Pointer param)`
`static opencv_legacy.CvBlobTrackerAuto`	`cvCreateBlobTrackerAuto1()`
`static opencv_legacy.CvBlobTrackerAuto`	`cvCreateBlobTrackerAuto1(opencv_legacy.CvBlobTrackerAutoParam1 param)`
`static opencv_legacy.CvBlobTracker`	`cvCreateBlobTrackerCC()`
`static opencv_legacy.CvBlobTracker`	`cvCreateBlobTrackerCCMSPF()`
`static opencv_legacy.CvBlobTracker`	`cvCreateBlobTrackerList(opencv_legacy.CvBlobTrackerOne_Create create)`
`static opencv_legacy.CvBlobTracker`	`cvCreateBlobTrackerMS()`
`static opencv_legacy.CvBlobTracker`	`cvCreateBlobTrackerMSFG()`
`static opencv_legacy.CvBlobTracker`	`cvCreateBlobTrackerMSFGS()`
`static opencv_legacy.CvBlobTracker`	`cvCreateBlobTrackerMSPF()`
`static opencv_legacy.CvBlobTrackPostProc`	`cvCreateBlobTrackPostProcList(opencv_legacy.CvBlobTrackPostProcOne_Create create)`
`static opencv_legacy.CvConDensation`	`cvCreateConDensation(int dynam_params, int measure_params, int sample_count)`
`static opencv_legacy.CvContourTree`	`cvCreateContourTree(opencv_core.CvSeq contour, opencv_core.CvMemStorage storage, double threshold)`
`static opencv_legacy.CvFGDetector`	`cvCreateFGDetectorBase(int type, Pointer param)`
`static opencv_legacy.CvBGStatModel`	`cvCreateFGDStatModel(opencv_core.IplImage first_frame)`
`static opencv_legacy.CvBGStatModel`	`cvCreateFGDStatModel(opencv_core.IplImage first_frame, opencv_legacy.CvFGDStatModelParams parameters)`
`static opencv_legacy.CvBGStatModel`	`cvCreateGaussianBGModel(opencv_core.IplImage first_frame)`
`static opencv_legacy.CvBGStatModel`	`cvCreateGaussianBGModel(opencv_core.IplImage first_frame, opencv_legacy.CvGaussBGStatModelParams parameters)`
`static opencv_legacy.CvGLCM`	`cvCreateGLCM(opencv_core.IplImage srcImage, int stepMagnitude)`
`static opencv_legacy.CvGLCM`	`cvCreateGLCM(opencv_core.IplImage srcImage, int stepMagnitude, int[] stepDirections, int numStepDirections, int optimizationType)`
`static opencv_legacy.CvGLCM`	`cvCreateGLCM(opencv_core.IplImage srcImage, int stepMagnitude, IntBuffer stepDirections, int numStepDirections, int optimizationType)`
`static opencv_legacy.CvGLCM`	`cvCreateGLCM(opencv_core.IplImage srcImage, int stepMagnitude, IntPointer stepDirections, int numStepDirections, int optimizationType)`
`static void`	`cvCreateGLCMDescriptors(opencv_legacy.CvGLCM destGLCM)`
`static void`	`cvCreateGLCMDescriptors(opencv_legacy.CvGLCM destGLCM, int descriptorOptimizationType)`
`static opencv_core.IplImage`	`cvCreateGLCMImage(opencv_legacy.CvGLCM GLCM, int step)`
`static void`	`cvCreateHandMask(opencv_core.CvSeq hand_points, opencv_core.IplImage img_mask, opencv_core.CvRect roi)` \ A few functions from old stereo gesture recognition demosions * \
`static void`	`cvCreateImageData(opencv_core.CvArr arg1)`
`static opencv_imgproc.CvFeatureTree`	`cvCreateKDTree(opencv_core.CvMat desc)`
`static opencv_imgproc.CvLSH`	`cvCreateLSH(opencv_legacy.CvLSHOperations ops, int d)`
`static opencv_imgproc.CvLSH`	`cvCreateLSH(opencv_legacy.CvLSHOperations ops, int d, int L, int k, int type, double r, long seed)`
`static opencv_imgproc.CvLSH`	`cvCreateMemoryLSH(int d, int n)`
`static opencv_imgproc.CvLSH`	`cvCreateMemoryLSH(int d, int n, int L, int k, int type, double r, long seed)`
`static opencv_legacy.CvBlobTrackAnalysis`	`cvCreateModuleBlobTrackAnalysisHistP()`
`static opencv_legacy.CvBlobTrackAnalysis`	`cvCreateModuleBlobTrackAnalysisHistPV()`
`static opencv_legacy.CvBlobTrackAnalysis`	`cvCreateModuleBlobTrackAnalysisHistPVS()`
`static opencv_legacy.CvBlobTrackAnalysis`	`cvCreateModuleBlobTrackAnalysisHistSS()`
`static opencv_legacy.CvBlobTrackAnalysis`	`cvCreateModuleBlobTrackAnalysisIOR()`
`static opencv_legacy.CvBlobTrackAnalysis`	`cvCreateModuleBlobTrackAnalysisTrackDist()`
`static opencv_legacy.CvBlobTrackGen`	`cvCreateModuleBlobTrackGen1()`
`static opencv_legacy.CvBlobTrackGen`	`cvCreateModuleBlobTrackGenYML()`
`static opencv_legacy.CvBlobTrackPostProc`	`cvCreateModuleBlobTrackPostProcKalman()`
`static opencv_legacy.CvBlobTrackPostProc`	`cvCreateModuleBlobTrackPostProcTimeAverExp()`
`static opencv_legacy.CvBlobTrackPostProc`	`cvCreateModuleBlobTrackPostProcTimeAverRect()`
`static opencv_legacy.CvBlobTrackPredictor`	`cvCreateModuleBlobTrackPredictKalman()`
`static opencv_legacy.CvImgObsInfo`	`cvCreateObsInfo(opencv_core.CvSize numObs, int obsSize)`
`static opencv_imgproc.CvFeatureTree`	`cvCreateSpillTree(opencv_core.CvMat raw_data)`
`static opencv_imgproc.CvFeatureTree`	`cvCreateSpillTree(opencv_core.CvMat raw_data, int naive, double rho, double tau)`
`static opencv_legacy.CvStereoGCState`	`cvCreateStereoGCState(int numberOfDisparities, int maxIters)`
`static opencv_imgproc.CvSubdiv2D`	`cvCreateSubdiv2D(int subdiv_type, int header_size, int vtx_size, int quadedge_size, opencv_core.CvMemStorage storage)`
`static opencv_imgproc.CvSubdiv2D`	`cvCreateSubdivDelaunay2D(opencv_core.CvRect rect, opencv_core.CvMemStorage storage)` high-level subdivision functions
`static opencv_legacy.CvTestSeq`	`cvCreateTestSeq(byte[] pConfigfile, byte[] videos, int numvideo)`
`static opencv_legacy.CvTestSeq`	`cvCreateTestSeq(byte[] pConfigfile, byte[] videos, int numvideo, float Scale, int noise_type, double noise_ampl)`
`static opencv_legacy.CvTestSeq`	`cvCreateTestSeq(ByteBuffer pConfigfile, ByteBuffer videos, int numvideo)`
`static opencv_legacy.CvTestSeq`	`cvCreateTestSeq(ByteBuffer pConfigfile, ByteBuffer videos, int numvideo, float Scale, int noise_type, double noise_ampl)`
`static opencv_legacy.CvTestSeq`	`cvCreateTestSeq(BytePointer pConfigfile, BytePointer videos, int numvideo)`
`static opencv_legacy.CvTestSeq`	`cvCreateTestSeq(BytePointer pConfigfile, BytePointer videos, int numvideo, float Scale, int noise_type, double noise_ampl)`
`static opencv_legacy.CvTestSeq`	`cvCreateTestSeq(BytePointer pConfigfile, PointerPointer videos, int numvideo, float Scale, int noise_type, double noise_ampl)`
`static void`	`cvCvtPixToPlane(opencv_core.CvArr arg1, opencv_core.CvArr arg2, opencv_core.CvArr arg3, opencv_core.CvArr arg4, opencv_core.CvArr arg5)`
`static void`	`cvCvtPlaneToPix(opencv_core.CvArr arg1, opencv_core.CvArr arg2, opencv_core.CvArr arg3, opencv_core.CvArr arg4, opencv_core.CvArr arg5)`
`static void`	`cvDeInterlace(opencv_core.CvArr frame, opencv_core.CvArr fieldEven, opencv_core.CvArr fieldOdd)`
`static void`	`cvDeleteMoire(opencv_core.IplImage img)`
`static opencv_legacy.CvDetectedBlob`	`cvDetectedBlob(float x, float y, float w, float h)`
`static opencv_legacy.CvDetectedBlob`	`cvDetectedBlob(float x, float y, float w, float h, int ID, float response)`
`static void`	`cvDynamicCorrespondMulti(int line_count, int[] first, int[] first_runs, int[] second, int[] second_runs, int[] first_corr, int[] second_corr)`
`static void`	`cvDynamicCorrespondMulti(int line_count, IntBuffer first, IntBuffer first_runs, IntBuffer second, IntBuffer second_runs, IntBuffer first_corr, IntBuffer second_corr)`
`static void`	`cvDynamicCorrespondMulti(int line_count, IntPointer first, IntPointer first_runs, IntPointer second, IntPointer second_runs, IntPointer first_corr, IntPointer second_corr)`
`static void`	`cvEigenDecomposite(opencv_core.IplImage obj, int nEigObjs, Pointer eigInput, int ioFlags, Pointer userData, opencv_core.IplImage avg, float[] coeffs)`
`static void`	`cvEigenDecomposite(opencv_core.IplImage obj, int nEigObjs, Pointer eigInput, int ioFlags, Pointer userData, opencv_core.IplImage avg, FloatBuffer coeffs)`
`static void`	`cvEigenDecomposite(opencv_core.IplImage obj, int nEigObjs, Pointer eigInput, int ioFlags, Pointer userData, opencv_core.IplImage avg, FloatPointer coeffs)`
`static void`	`cvEigenProjection(Pointer eigInput, int nEigObjs, int ioFlags, Pointer userData, float[] coeffs, opencv_core.IplImage avg, opencv_core.IplImage proj)`
`static void`	`cvEigenProjection(Pointer eigInput, int nEigObjs, int ioFlags, Pointer userData, FloatBuffer coeffs, opencv_core.IplImage avg, opencv_core.IplImage proj)`
`static void`	`cvEigenProjection(Pointer eigInput, int nEigObjs, int ioFlags, Pointer userData, FloatPointer coeffs, opencv_core.IplImage avg, opencv_core.IplImage proj)`
`static void`	`cvEllipseAA(opencv_core.CvArr img, int[] center, opencv_core.CvSize axes, double angle, double start_angle, double end_angle, double color)`
`static void`	`cvEllipseAA(opencv_core.CvArr img, int[] center, opencv_core.CvSize axes, double angle, double start_angle, double end_angle, double color, int scale)`
`static void`	`cvEllipseAA(opencv_core.CvArr img, IntBuffer center, opencv_core.CvSize axes, double angle, double start_angle, double end_angle, double color)`
`static void`	`cvEllipseAA(opencv_core.CvArr img, IntBuffer center, opencv_core.CvSize axes, double angle, double start_angle, double end_angle, double color, int scale)`
`static void`	`cvEllipseAA(opencv_core.CvArr img, opencv_core.CvPoint center, opencv_core.CvSize axes, double angle, double start_angle, double end_angle, double color)`
`static void`	`cvEllipseAA(opencv_core.CvArr img, opencv_core.CvPoint center, opencv_core.CvSize axes, double angle, double start_angle, double end_angle, double color, int scale)`
`static void`	`cvEndScanGraph(opencv_core.CvGraphScanner scanner)`
`static void`	`cvEstimateHMMStateParams(opencv_legacy.CvImgObsInfo obs_info_array, int num_img, opencv_legacy.CvEHMM hmm)`
`static void`	`cvEstimateHMMStateParams(PointerPointer obs_info_array, int num_img, opencv_legacy.CvEHMM hmm)`
`static void`	`cvEstimateObsProb(opencv_legacy.CvImgObsInfo obs_info, opencv_legacy.CvEHMM hmm)`
`static void`	`cvEstimateTransProb(opencv_legacy.CvImgObsInfo obs_info_array, int num_img, opencv_legacy.CvEHMM hmm)`
`static void`	`cvEstimateTransProb(PointerPointer obs_info_array, int num_img, opencv_legacy.CvEHMM hmm)`
`static float`	`cvEViterbi(opencv_legacy.CvImgObsInfo obs_info, opencv_legacy.CvEHMM hmm)`
`static void`	`cvExtractSURF(opencv_core.CvArr img, opencv_core.CvArr mask, opencv_core.CvSeq keypoints, opencv_core.CvSeq descriptors, opencv_core.CvMemStorage storage, opencv_legacy.CvSURFParams params)`
`static void`	`cvExtractSURF(opencv_core.CvArr img, opencv_core.CvArr mask, opencv_core.CvSeq keypoints, opencv_core.CvSeq descriptors, opencv_core.CvMemStorage storage, opencv_legacy.CvSURFParams params, int useProvidedKeyPts)`
`static void`	`cvExtractSURF(opencv_core.CvArr img, opencv_core.CvArr mask, PointerPointer keypoints, PointerPointer descriptors, opencv_core.CvMemStorage storage, opencv_legacy.CvSURFParams params, int useProvidedKeyPts)`
`static void`	`cvFillImage(opencv_core.CvArr mat, double color)`
`static int`	`cvFindChessBoardCornerGuesses(Pointer arr, Pointer thresharr, opencv_core.CvMemStorage storage, opencv_core.CvSize pattern_size, float[] corners, int[] corner_count)`
`static int`	`cvFindChessBoardCornerGuesses(Pointer arr, Pointer thresharr, opencv_core.CvMemStorage storage, opencv_core.CvSize pattern_size, FloatBuffer corners, IntBuffer corner_count)`
`static int`	`cvFindChessBoardCornerGuesses(Pointer arr, Pointer thresharr, opencv_core.CvMemStorage storage, opencv_core.CvSize pattern_size, opencv_core.CvPoint2D32f corners, IntPointer corner_count)`
`static opencv_core.CvSeq`	`cvFindDominantPoints(opencv_core.CvSeq contour, opencv_core.CvMemStorage storage)`
`static opencv_core.CvSeq`	`cvFindDominantPoints(opencv_core.CvSeq contour, opencv_core.CvMemStorage storage, int method, double parameter1, double parameter2, double parameter3, double parameter4)`
`static void`	`cvFindExtrinsicCameraParams_64d(int point_count, opencv_core.CvSize image_size, double[] _image_points, double[] _object_points, double[] focal_length, double[] principal_point, double[] _distortion_coeffs, double[] _rotation_vector, double[] _translation_vector)`
`static void`	`cvFindExtrinsicCameraParams_64d(int point_count, opencv_core.CvSize image_size, DoubleBuffer _image_points, DoubleBuffer _object_points, DoubleBuffer focal_length, DoubleBuffer principal_point, DoubleBuffer _distortion_coeffs, DoubleBuffer _rotation_vector, DoubleBuffer _translation_vector)`
`static void`	`cvFindExtrinsicCameraParams_64d(int point_count, opencv_core.CvSize image_size, opencv_core.CvPoint2D64f _image_points, opencv_core.CvPoint3D64f _object_points, DoublePointer focal_length, opencv_core.CvPoint2D64f principal_point, DoublePointer _distortion_coeffs, DoublePointer _rotation_vector, DoublePointer _translation_vector)`
`static void`	`cvFindExtrinsicCameraParams(int point_count, opencv_core.CvSize image_size, float[] _image_points, float[] _object_points, float[] focal_length, float[] principal_point, float[] _distortion_coeffs, float[] _rotation_vector, float[] _translation_vector)`
`static void`	`cvFindExtrinsicCameraParams(int point_count, opencv_core.CvSize image_size, FloatBuffer _image_points, FloatBuffer _object_points, FloatBuffer focal_length, FloatBuffer principal_point, FloatBuffer _distortion_coeffs, FloatBuffer _rotation_vector, FloatBuffer _translation_vector)`
`static void`	`cvFindExtrinsicCameraParams(int point_count, opencv_core.CvSize image_size, opencv_core.CvPoint2D32f _image_points, opencv_core.CvPoint3D32f _object_points, FloatPointer focal_length, opencv_core.CvPoint2D32f principal_point, FloatPointer _distortion_coeffs, FloatPointer _rotation_vector, FloatPointer _translation_vector)`
`static void`	`cvFindFeatures(opencv_imgproc.CvFeatureTree tr, opencv_core.CvMat query_points, opencv_core.CvMat indices, opencv_core.CvMat dist, int k)`
`static void`	`cvFindFeatures(opencv_imgproc.CvFeatureTree tr, opencv_core.CvMat query_points, opencv_core.CvMat indices, opencv_core.CvMat dist, int k, int emax)`
`static int`	`cvFindFeaturesBoxed(opencv_imgproc.CvFeatureTree tr, opencv_core.CvMat bounds_min, opencv_core.CvMat bounds_max, opencv_core.CvMat out_indices)`
`static void`	`cvFindFundamentalMatrix(int[] points1, int[] points2, int numpoints, int method, float[] matrix)`
`static void`	`cvFindFundamentalMatrix(IntBuffer points1, IntBuffer points2, int numpoints, int method, FloatBuffer matrix)`
`static void`	`cvFindFundamentalMatrix(IntPointer points1, IntPointer points2, int numpoints, int method, FloatPointer matrix)`
`static void`	`cvFindHandRegion(float[] points, int count, opencv_core.CvSeq indexs, float[] line, opencv_core.CvSize2D32f size, int flag, float[] center, opencv_core.CvMemStorage storage, opencv_core.CvSeq numbers)`
`static void`	`cvFindHandRegion(FloatBuffer points, int count, opencv_core.CvSeq indexs, FloatBuffer line, opencv_core.CvSize2D32f size, int flag, FloatBuffer center, opencv_core.CvMemStorage storage, opencv_core.CvSeq numbers)`
`static void`	`cvFindHandRegion(opencv_core.CvPoint3D32f points, int count, opencv_core.CvSeq indexs, FloatPointer line, opencv_core.CvSize2D32f size, int flag, opencv_core.CvPoint3D32f center, opencv_core.CvMemStorage storage, opencv_core.CvSeq numbers)`
`static void`	`cvFindHandRegion(opencv_core.CvPoint3D32f points, int count, opencv_core.CvSeq indexs, FloatPointer line, opencv_core.CvSize2D32f size, int flag, opencv_core.CvPoint3D32f center, opencv_core.CvMemStorage storage, PointerPointer numbers)`
`static void`	`cvFindHandRegionA(float[] points, int count, opencv_core.CvSeq indexs, float[] line, opencv_core.CvSize2D32f size, int jc, float[] center, opencv_core.CvMemStorage storage, opencv_core.CvSeq numbers)`
`static void`	`cvFindHandRegionA(FloatBuffer points, int count, opencv_core.CvSeq indexs, FloatBuffer line, opencv_core.CvSize2D32f size, int jc, FloatBuffer center, opencv_core.CvMemStorage storage, opencv_core.CvSeq numbers)`
`static void`	`cvFindHandRegionA(opencv_core.CvPoint3D32f points, int count, opencv_core.CvSeq indexs, FloatPointer line, opencv_core.CvSize2D32f size, int jc, opencv_core.CvPoint3D32f center, opencv_core.CvMemStorage storage, opencv_core.CvSeq numbers)`
`static void`	`cvFindHandRegionA(opencv_core.CvPoint3D32f points, int count, opencv_core.CvSeq indexs, FloatPointer line, opencv_core.CvSize2D32f size, int jc, opencv_core.CvPoint3D32f center, opencv_core.CvMemStorage storage, PointerPointer numbers)`
`static opencv_imgproc.CvSubdiv2DPoint`	`cvFindNearestPoint2D(opencv_imgproc.CvSubdiv2D subdiv, float[] pt)`
`static opencv_imgproc.CvSubdiv2DPoint`	`cvFindNearestPoint2D(opencv_imgproc.CvSubdiv2D subdiv, FloatBuffer pt)`
`static opencv_imgproc.CvSubdiv2DPoint`	`cvFindNearestPoint2D(opencv_imgproc.CvSubdiv2D subdiv, opencv_core.CvPoint2D32f pt)`
`static void`	`cvFindRuns(int line_count, byte[] prewarp1, byte[] prewarp2, int[] line_lengths1, int[] line_lengths2, int[] runs1, int[] runs2, int[] num_runs1, int[] num_runs2)`
`static void`	`cvFindRuns(int line_count, ByteBuffer prewarp1, ByteBuffer prewarp2, IntBuffer line_lengths1, IntBuffer line_lengths2, IntBuffer runs1, IntBuffer runs2, IntBuffer num_runs1, IntBuffer num_runs2)`
`static void`	`cvFindRuns(int line_count, BytePointer prewarp1, BytePointer prewarp2, IntPointer line_lengths1, IntPointer line_lengths2, IntPointer runs1, IntPointer runs2, IntPointer num_runs1, IntPointer num_runs2)`
`static void`	`cvFindStereoCorrespondence(opencv_core.CvArr leftImage, opencv_core.CvArr rightImage, int mode, opencv_core.CvArr dispImage, int maxDisparity)`
`static void`	`cvFindStereoCorrespondence(opencv_core.CvArr leftImage, opencv_core.CvArr rightImage, int mode, opencv_core.CvArr dispImage, int maxDisparity, double param1, double param2, double param3, double param4, double param5)`
`static void`	`cvFindStereoCorrespondenceGC(opencv_core.CvArr left, opencv_core.CvArr right, opencv_core.CvArr disparityLeft, opencv_core.CvArr disparityRight, opencv_legacy.CvStereoGCState state)`
`static void`	`cvFindStereoCorrespondenceGC(opencv_core.CvArr left, opencv_core.CvArr right, opencv_core.CvArr disparityLeft, opencv_core.CvArr disparityRight, opencv_legacy.CvStereoGCState state, int useDisparityGuess)`
`static void`	`cvFitEllipse(float[] points, int count, opencv_core.CvBox2D box)`
`static void`	`cvFitEllipse(FloatBuffer points, int count, opencv_core.CvBox2D box)`
`static void`	`cvFitEllipse(opencv_core.CvPoint2D32f points, int count, opencv_core.CvBox2D box)`
`static void`	`cvFitLine2D(float[] points, int count, int dist, Pointer param, float reps, float aeps, float[] line)`
`static void`	`cvFitLine2D(FloatBuffer points, int count, int dist, Pointer param, float reps, float aeps, FloatBuffer line)`
`static void`	`cvFitLine2D(opencv_core.CvPoint2D32f points, int count, int dist, Pointer param, float reps, float aeps, FloatPointer line)`
`static void`	`cvFitLine3D(float[] points, int count, int dist, Pointer param, float reps, float aeps, float[] line)`
`static void`	`cvFitLine3D(FloatBuffer points, int count, int dist, Pointer param, float reps, float aeps, FloatBuffer line)`
`static void`	`cvFitLine3D(opencv_core.CvPoint3D32f points, int count, int dist, Pointer param, float reps, float aeps, FloatPointer line)`
`static opencv_core.CvScalar`	`cvGetAt(opencv_core.CvArr arg1, int arg2, int arg3)`
`static double`	`cvGetGLCMDescriptor(opencv_legacy.CvGLCM GLCM, int step, int descriptor)`
`static void`	`cvGetGLCMDescriptorStatistics(opencv_legacy.CvGLCM GLCM, int descriptor, double[] average, double[] standardDeviation)`
`static void`	`cvGetGLCMDescriptorStatistics(opencv_legacy.CvGLCM GLCM, int descriptor, DoubleBuffer average, DoubleBuffer standardDeviation)`
`static void`	`cvGetGLCMDescriptorStatistics(opencv_legacy.CvGLCM GLCM, int descriptor, DoublePointer average, DoublePointer standardDeviation)`
`static Pointer`	`cvGetHistValue_1D(opencv_core.CvHistogram hist, int idx0)`
`static Pointer`	`cvGetHistValue_2D(opencv_core.CvHistogram hist, int idx0, int idx1)`
`static Pointer`	`cvGetHistValue_3D(opencv_core.CvHistogram hist, int idx0, int idx1, int idx2)`
`static Pointer`	`cvGetHistValue_nD(opencv_core.CvHistogram hist, int[] idx)`
`static Pointer`	`cvGetHistValue_nD(opencv_core.CvHistogram hist, IntBuffer idx)`
`static Pointer`	`cvGetHistValue_nD(opencv_core.CvHistogram hist, IntPointer idx)`
`static void`	`cvGetImageRawData(opencv_core.CvArr arg1, byte[] arg2, int[] arg3, opencv_core.CvSize arg4)`
`static void`	`cvGetImageRawData(opencv_core.CvArr arg1, ByteBuffer arg2, IntBuffer arg3, opencv_core.CvSize arg4)`
`static void`	`cvGetImageRawData(opencv_core.CvArr arg1, BytePointer arg2, IntPointer arg3, opencv_core.CvSize arg4)`
`static void`	`cvGetImageRawData(opencv_core.CvArr arg1, PointerPointer arg2, IntPointer arg3, opencv_core.CvSize arg4)`
`static Pointer`	`cvGetPtrAt(opencv_core.CvArr arg1, int arg2, int arg3)`
`static opencv_core.CvSeq`	`cvGetStarKeypoints(opencv_core.CvArr img, opencv_core.CvMemStorage storage)`
`static opencv_core.CvSeq`	`cvGetStarKeypoints(opencv_core.CvArr img, opencv_core.CvMemStorage storage, opencv_legacy.CvStarDetectorParams params)`
`static int`	`cvHoughLines(opencv_core.CvArr image, double rho, double theta, int threshold, float[] lines, int linesNumber)`
`static int`	`cvHoughLines(opencv_core.CvArr image, double rho, double theta, int threshold, FloatBuffer lines, int linesNumber)`
`static int`	`cvHoughLines(opencv_core.CvArr image, double rho, double theta, int threshold, FloatPointer lines, int linesNumber)`
`static int`	`cvHoughLinesP(opencv_core.CvArr image, double rho, double theta, int threshold, int lineLength, int lineGap, int[] lines, int linesNumber)`
`static int`	`cvHoughLinesP(opencv_core.CvArr image, double rho, double theta, int threshold, int lineLength, int lineGap, IntBuffer lines, int linesNumber)`
`static int`	`cvHoughLinesP(opencv_core.CvArr image, double rho, double theta, int threshold, int lineLength, int lineGap, IntPointer lines, int linesNumber)`
`static int`	`cvHoughLinesSDiv(opencv_core.CvArr image, double rho, int srn, double theta, int stn, int threshold, float[] lines, int linesNumber)`
`static int`	`cvHoughLinesSDiv(opencv_core.CvArr image, double rho, int srn, double theta, int stn, int threshold, FloatBuffer lines, int linesNumber)`
`static int`	`cvHoughLinesSDiv(opencv_core.CvArr image, double rho, int srn, double theta, int stn, int threshold, FloatPointer lines, int linesNumber)`
`static void`	`cvImgToObs_DCT(opencv_core.CvArr arr, float[] obs, opencv_core.CvSize dctSize, opencv_core.CvSize obsSize, opencv_core.CvSize delta)`
`static void`	`cvImgToObs_DCT(opencv_core.CvArr arr, FloatBuffer obs, opencv_core.CvSize dctSize, opencv_core.CvSize obsSize, opencv_core.CvSize delta)`
`static void`	`cvImgToObs_DCT(opencv_core.CvArr arr, FloatPointer obs, opencv_core.CvSize dctSize, opencv_core.CvSize obsSize, opencv_core.CvSize delta)`
`static opencv_legacy.CvFaceTracker`	`cvInitFaceTracker(opencv_legacy.CvFaceTracker pFaceTracking, opencv_core.IplImage imgGray, opencv_core.CvRect pRects, int nRects)`
`static void`	`cvInitMixSegm(opencv_legacy.CvImgObsInfo obs_info_array, int num_img, opencv_legacy.CvEHMM hmm)`
`static void`	`cvInitMixSegm(PointerPointer obs_info_array, int num_img, opencv_legacy.CvEHMM hmm)`
`static void`	`cvInitPerspectiveTransform(opencv_core.CvSize size, float[] vertex, double[] matrix, opencv_core.CvArr rectMap)`
`static void`	`cvInitPerspectiveTransform(opencv_core.CvSize size, FloatBuffer vertex, DoubleBuffer matrix, opencv_core.CvArr rectMap)`
`static void`	`cvInitPerspectiveTransform(opencv_core.CvSize size, opencv_core.CvPoint2D32f vertex, DoublePointer matrix, opencv_core.CvArr rectMap)`
`static void`	`cvInitSubdivDelaunay2D(opencv_imgproc.CvSubdiv2D subdiv, opencv_core.CvRect rect)` \ Planar subdivisions * \
`static void`	`cvIntegralImage(opencv_core.CvArr arg1, opencv_core.CvArr arg2, opencv_core.CvArr arg3, opencv_core.CvArr arg4)`
`static void`	`cvKMeans(int num_clusters, float[] samples, int num_samples, int vec_size, opencv_core.CvTermCriteria termcrit, int[] cluster_idx)`
`static void`	`cvKMeans(int num_clusters, FloatBuffer samples, int num_samples, int vec_size, opencv_core.CvTermCriteria termcrit, IntBuffer cluster_idx)`
`static void`	`cvKMeans(int num_clusters, FloatPointer samples, int num_samples, int vec_size, opencv_core.CvTermCriteria termcrit, IntPointer cluster_idx)`
`static void`	`cvKMeans(int num_clusters, PointerPointer samples, int num_samples, int vec_size, opencv_core.CvTermCriteria termcrit, IntPointer cluster_idx)`
`static void`	`cvLineAA(opencv_core.CvArr img, int[] pt1, int[] pt2, double color)`
`static void`	`cvLineAA(opencv_core.CvArr img, int[] pt1, int[] pt2, double color, int scale)`
`static void`	`cvLineAA(opencv_core.CvArr img, IntBuffer pt1, IntBuffer pt2, double color)`
`static void`	`cvLineAA(opencv_core.CvArr img, IntBuffer pt1, IntBuffer pt2, double color, int scale)`
`static void`	`cvLineAA(opencv_core.CvArr img, opencv_core.CvPoint pt1, opencv_core.CvPoint pt2, double color)`
`static void`	`cvLineAA(opencv_core.CvArr img, opencv_core.CvPoint pt1, opencv_core.CvPoint pt2, double color, int scale)`
`static opencv_core.CvGraph`	`cvLinearContorModelFromVoronoiDiagram(opencv_legacy.CvVoronoiDiagram2D VoronoiDiagram, float maxWidth)`
`static void`	`cvLSHAdd(opencv_imgproc.CvLSH lsh, opencv_core.CvMat data)`
`static void`	`cvLSHAdd(opencv_imgproc.CvLSH lsh, opencv_core.CvMat data, opencv_core.CvMat indices)`
`static void`	`cvLSHQuery(opencv_imgproc.CvLSH lsh, opencv_core.CvMat query_points, opencv_core.CvMat indices, opencv_core.CvMat dist, int k, int emax)`
`static void`	`cvLSHRemove(opencv_imgproc.CvLSH lsh, opencv_core.CvMat indices)`
`static void`	`cvMake2DPoints(opencv_core.CvMat arg1, opencv_core.CvMat arg2)`
`static void`	`cvMake3DPoints(opencv_core.CvMat arg1, opencv_core.CvMat arg2)`
`static void`	`cvMakeAlphaScanlines(int[] scanlines1, int[] scanlines2, int[] scanlinesA, int[] lengths, int line_count, float alpha)`
`static void`	`cvMakeAlphaScanlines(IntBuffer scanlines1, IntBuffer scanlines2, IntBuffer scanlinesA, IntBuffer lengths, int line_count, float alpha)`
`static void`	`cvMakeAlphaScanlines(IntPointer scanlines1, IntPointer scanlines2, IntPointer scanlinesA, IntPointer lengths, int line_count, float alpha)`
`static void`	`cvMakeScanlines(opencv_legacy.CvMatrix3 matrix, opencv_core.CvSize img_size, int[] scanlines1, int[] scanlines2, int[] lengths1, int[] lengths2, int[] line_count)`
`static void`	`cvMakeScanlines(opencv_legacy.CvMatrix3 matrix, opencv_core.CvSize img_size, IntBuffer scanlines1, IntBuffer scanlines2, IntBuffer lengths1, IntBuffer lengths2, IntBuffer line_count)`
`static void`	`cvMakeScanlines(opencv_legacy.CvMatrix3 matrix, opencv_core.CvSize img_size, IntPointer scanlines1, IntPointer scanlines2, IntPointer lengths1, IntPointer lengths2, IntPointer line_count)`
`static void`	`cvmAlloc(opencv_core.CvArr arg1)`
`static void`	`cvmAllocArray(opencv_core.CvArr arg1)`
`static opencv_core.CvMat`	`cvMatArray(int rows, int cols, int type, int count)`
`static opencv_core.CvMat`	`cvMatArray(int rows, int cols, int type, int count, Pointer data)`
`static double`	`cvMatchContours(Pointer arg1, Pointer arg2, int arg3, double arg4)`
`static double`	`cvMatchContourTrees(opencv_legacy.CvContourTree tree1, opencv_legacy.CvContourTree tree2, int method, double threshold)`
`static void`	`cvMean_StdDev(opencv_core.CvArr image, double[] mean, double[] sdv)`
`static void`	`cvMean_StdDev(opencv_core.CvArr image, double[] mean, double[] sdv, opencv_core.CvArr mask)`
`static void`	`cvMean_StdDev(opencv_core.CvArr image, DoubleBuffer mean, DoubleBuffer sdv)`
`static void`	`cvMean_StdDev(opencv_core.CvArr image, DoubleBuffer mean, DoubleBuffer sdv, opencv_core.CvArr mask)`
`static void`	`cvMean_StdDev(opencv_core.CvArr image, DoublePointer mean, DoublePointer sdv)`
`static void`	`cvMean_StdDev(opencv_core.CvArr image, DoublePointer mean, DoublePointer sdv, opencv_core.CvArr mask)`
`static void`	`cvMean_StdDevMask(opencv_core.CvArr img, opencv_core.CvArr mask, double[] mean, double[] sdv)`
`static void`	`cvMean_StdDevMask(opencv_core.CvArr img, opencv_core.CvArr mask, DoubleBuffer mean, DoubleBuffer sdv)`
`static void`	`cvMean_StdDevMask(opencv_core.CvArr img, opencv_core.CvArr mask, DoublePointer mean, DoublePointer sdv)`
`static double`	`cvMean(opencv_core.CvArr image)`
`static double`	`cvMean(opencv_core.CvArr image, opencv_core.CvArr mask)`
`static double`	`cvMeanMask(opencv_core.CvArr arg1, opencv_core.CvArr arg2)`
`static void`	`cvmFree(opencv_core.CvArr arg1)`
`static void`	`cvmFreeArray(opencv_core.CvArr arg1)`
`static void`	`cvMinAreaRect(int[] points, int n, int left, int bottom, int right, int top, float[] anchor, float[] vect1, float[] vect2)`
`static void`	`cvMinAreaRect(IntBuffer points, int n, int left, int bottom, int right, int top, FloatBuffer anchor, FloatBuffer vect1, FloatBuffer vect2)`
`static void`	`cvMinAreaRect(opencv_core.CvPoint points, int n, int left, int bottom, int right, int top, opencv_core.CvPoint2D32f anchor, opencv_core.CvPoint2D32f vect1, opencv_core.CvPoint2D32f vect2)`
`static void`	`cvMixSegmL2(opencv_legacy.CvImgObsInfo obs_info_array, int num_img, opencv_legacy.CvEHMM hmm)`
`static void`	`cvMixSegmL2(PointerPointer obs_info_array, int num_img, opencv_legacy.CvEHMM hmm)`
`static void`	`cvMorphEpilinesMulti(int line_count, byte[] first_pix, int[] first_num, byte[] second_pix, int[] second_num, byte[] dst_pix, int[] dst_num, float alpha, int[] first, int[] first_runs, int[] second, int[] second_runs, int[] first_corr, int[] second_corr)`
`static void`	`cvMorphEpilinesMulti(int line_count, ByteBuffer first_pix, IntBuffer first_num, ByteBuffer second_pix, IntBuffer second_num, ByteBuffer dst_pix, IntBuffer dst_num, float alpha, IntBuffer first, IntBuffer first_runs, IntBuffer second, IntBuffer second_runs, IntBuffer first_corr, IntBuffer second_corr)`
`static void`	`cvMorphEpilinesMulti(int line_count, BytePointer first_pix, IntPointer first_num, BytePointer second_pix, IntPointer second_num, BytePointer dst_pix, IntPointer dst_num, float alpha, IntPointer first, IntPointer first_runs, IntPointer second, IntPointer second_runs, IntPointer first_corr, IntPointer second_corr)`
`static void`	`cvmPerspectiveProject(opencv_core.CvMat mat, opencv_core.CvArr src, opencv_core.CvArr dst)`
`static void`	`cvMultiplyAccMask(opencv_core.CvArr arg1, opencv_core.CvArr arg2, opencv_core.CvArr arg3, opencv_core.CvArr arg4)`
`static double`	`cvNormMask(opencv_core.CvArr imgA, opencv_core.CvArr imgB, opencv_core.CvArr mask, int normType)`
`static void`	`cvPolyLineAA(opencv_core.CvArr img, int[] pts, int[] npts, int contours, int is_closed, double color)`
`static void`	`cvPolyLineAA(opencv_core.CvArr img, int[] pts, int[] npts, int contours, int is_closed, double color, int scale)`
`static void`	`cvPolyLineAA(opencv_core.CvArr img, IntBuffer pts, IntBuffer npts, int contours, int is_closed, double color)`
`static void`	`cvPolyLineAA(opencv_core.CvArr img, IntBuffer pts, IntBuffer npts, int contours, int is_closed, double color, int scale)`
`static void`	`cvPolyLineAA(opencv_core.CvArr img, opencv_core.CvPoint pts, IntPointer npts, int contours, int is_closed, double color)`
`static void`	`cvPolyLineAA(opencv_core.CvArr img, opencv_core.CvPoint pts, IntPointer npts, int contours, int is_closed, double color, int scale)`
`static void`	`cvPolyLineAA(opencv_core.CvArr img, PointerPointer pts, IntPointer npts, int contours, int is_closed, double color, int scale)`
`static void`	`cvPostWarpImage(int line_count, byte[] src, int[] src_nums, opencv_core.IplImage img, int[] scanlines)`
`static void`	`cvPostWarpImage(int line_count, ByteBuffer src, IntBuffer src_nums, opencv_core.IplImage img, IntBuffer scanlines)`
`static void`	`cvPostWarpImage(int line_count, BytePointer src, IntPointer src_nums, opencv_core.IplImage img, IntPointer scanlines)`
`static void`	`cvPreWarpImage(int line_count, opencv_core.IplImage img, byte[] dst, int[] dst_nums, int[] scanlines)`
`static void`	`cvPreWarpImage(int line_count, opencv_core.IplImage img, ByteBuffer dst, IntBuffer dst_nums, IntBuffer scanlines)`
`static void`	`cvPreWarpImage(int line_count, opencv_core.IplImage img, BytePointer dst, IntPointer dst_nums, IntPointer scanlines)`
`static void`	`cvProject3D(float[] points3D, int count, float[] points2D)`
`static void`	`cvProject3D(float[] points3D, int count, float[] points2D, int xIndx, int yIndx)`
`static void`	`cvProject3D(FloatBuffer points3D, int count, FloatBuffer points2D)`
`static void`	`cvProject3D(FloatBuffer points3D, int count, FloatBuffer points2D, int xIndx, int yIndx)`
`static void`	`cvProject3D(opencv_core.CvPoint3D32f points3D, int count, opencv_core.CvPoint2D32f points2D)`
`static void`	`cvProject3D(opencv_core.CvPoint3D32f points3D, int count, opencv_core.CvPoint2D32f points2D, int xIndx, int yIndx)`
`static void`	`cvProjectPoints(int point_count, double[] _object_points, double[] _rotation_vector, double[] _translation_vector, double[] focal_length, double[] principal_point, double[] _distortion, double[] _image_points, double[] _deriv_points_rotation_matrix, double[] _deriv_points_translation_vect, double[] _deriv_points_focal, double[] _deriv_points_principal_point, double[] _deriv_points_distortion_coeffs)`
`static void`	`cvProjectPoints(int point_count, DoubleBuffer _object_points, DoubleBuffer _rotation_vector, DoubleBuffer _translation_vector, DoubleBuffer focal_length, DoubleBuffer principal_point, DoubleBuffer _distortion, DoubleBuffer _image_points, DoubleBuffer _deriv_points_rotation_matrix, DoubleBuffer _deriv_points_translation_vect, DoubleBuffer _deriv_points_focal, DoubleBuffer _deriv_points_principal_point, DoubleBuffer _deriv_points_distortion_coeffs)`
`static void`	cvProjectPoints(int point_count, opencv_core.CvPoint3D64f _object_points, DoublePointer _rotation_vector, DoublePointer _translation_vector, DoublePointer focal_length, opencv_core.CvPoint2D64f principal_point, DoublePointer _distortion, opencv_core.CvPoint2D64f _image_points, DoublePointer _deriv_points_rotation_matrix, DoublePointer _deriv_points_translation_vect, DoublePointer _deriv_points_focal, DoublePointer _deriv_points_principal_point, DoublePointer _deriv_points_distortion_coeffs)
`static void`	`cvProjectPointsSimple(int point_count, double[] _object_points, double[] _rotation_matrix, double[] _translation_vector, double[] _camera_matrix, double[] _distortion, double[] _image_points)`
`static void`	`cvProjectPointsSimple(int point_count, DoubleBuffer _object_points, DoubleBuffer _rotation_matrix, DoubleBuffer _translation_vector, DoubleBuffer _camera_matrix, DoubleBuffer _distortion, DoubleBuffer _image_points)`
`static void`	`cvProjectPointsSimple(int point_count, opencv_core.CvPoint3D64f _object_points, DoublePointer _rotation_matrix, DoublePointer _translation_vector, DoublePointer _camera_matrix, DoublePointer _distortion, opencv_core.CvPoint2D64f _image_points)`
`static double`	`cvPseudoInv(opencv_core.CvArr arg1, opencv_core.CvArr arg2)`
`static double`	`cvPseudoInverse(opencv_core.CvArr src, opencv_core.CvArr dst)`
`static void`	`cvPyrSegmentation(opencv_core.IplImage src, opencv_core.IplImage dst, opencv_core.CvMemStorage storage, opencv_core.CvSeq comp, int level, double threshold1, double threshold2)`
`static void`	`cvPyrSegmentation(opencv_core.IplImage src, opencv_core.IplImage dst, opencv_core.CvMemStorage storage, PointerPointer comp, int level, double threshold1, double threshold2)`
`static float`	`cvQueryHistValue_1D(opencv_core.CvHistogram hist, int idx0)`
`static float`	`cvQueryHistValue_2D(opencv_core.CvHistogram hist, int idx0, int idx1)`
`static float`	`cvQueryHistValue_3D(opencv_core.CvHistogram hist, int idx0, int idx1, int idx2)`
`static float`	`cvQueryHistValue_nD(opencv_core.CvHistogram hist, int[] idx)`
`static float`	`cvQueryHistValue_nD(opencv_core.CvHistogram hist, IntBuffer idx)`
`static float`	`cvQueryHistValue_nD(opencv_core.CvHistogram hist, IntPointer idx)`
`static void`	`cvRand(opencv_legacy.CvRandState state, opencv_core.CvArr arr)`
`static void`	`cvRandInit(opencv_legacy.CvRandState state, double param1, double param2, int seed)`
`static void`	`cvRandInit(opencv_legacy.CvRandState state, double param1, double param2, int seed, int disttype)`
`static void`	`cvRandSetRange(opencv_legacy.CvRandState state, double param1, double param2)`
`static void`	`cvRandSetRange(opencv_legacy.CvRandState state, double param1, double param2, int index)`
`static void`	`cvReadStructByName(opencv_core.CvFileStorage fs, opencv_core.CvFileNode node, BytePointer name, Pointer addr, BytePointer desc)`
`static void`	`cvReadStructByName(opencv_core.CvFileStorage fs, opencv_core.CvFileNode node, String name, Pointer addr, String desc)`
`static opencv_core.CvRect`	`cvRectIntersection(opencv_core.CvRect r1, opencv_core.CvRect r2)`
`static void`	`cvRefineForegroundMaskBySegm(opencv_core.CvSeq segments, opencv_legacy.CvBGStatModel bg_model)`
`static void`	`cvRelease2DHMM(opencv_legacy.CvEHMM hmm)`
`static void`	`cvRelease2DHMM(PointerPointer hmm)`
`static void`	`cvReleaseBGCodeBookModel(opencv_legacy.CvBGCodeBookModel model)`
`static void`	`cvReleaseBGCodeBookModel(PointerPointer model)`
`static void`	`cvReleaseBGStatModel(opencv_legacy.CvBGStatModel bg_model)`
`static void`	`cvReleaseBGStatModel(PointerPointer bg_model)`
`static void`	`cvReleaseBlobDetector(opencv_legacy.CvBlobDetector ppBD)`
`static void`	`cvReleaseBlobDetector(PointerPointer ppBD)`
`static void`	`cvReleaseBlobTrackAnalysis(opencv_legacy.CvBlobTrackAnalysis pBTPP)`
`static void`	`cvReleaseBlobTrackAnalysis(PointerPointer pBTPP)`
`static void`	`cvReleaseBlobTracker(opencv_legacy.CvBlobTracker ppT)`
`static void`	`cvReleaseBlobTracker(PointerPointer ppT)`
`static void`	`cvReleaseBlobTrackerAuto(opencv_legacy.CvBlobTrackerAuto ppT)`
`static void`	`cvReleaseBlobTrackerAuto(PointerPointer ppT)`
`static void`	`cvReleaseBlobTrackerOne(opencv_legacy.CvBlobTrackerOne ppT)`
`static void`	`cvReleaseBlobTrackerOne(PointerPointer ppT)`
`static void`	`cvReleaseBlobTrackGen(opencv_legacy.CvBlobTrackGen pBTGen)`
`static void`	`cvReleaseBlobTrackGen(PointerPointer pBTGen)`
`static void`	`cvReleaseBlobTrackPostProc(opencv_legacy.CvBlobTrackPostProc pBTPP)`
`static void`	`cvReleaseBlobTrackPostProc(PointerPointer pBTPP)`
`static void`	`cvReleaseConDensation(opencv_legacy.CvConDensation condens)`
`static void`	`cvReleaseConDensation(PointerPointer condens)`
`static void`	`cvReleaseFaceTracker(opencv_legacy.CvFaceTracker ppFaceTracker)`
`static void`	`cvReleaseFaceTracker(PointerPointer ppFaceTracker)`
`static void`	`cvReleaseFeatureTree(opencv_imgproc.CvFeatureTree tr)`
`static void`	`cvReleaseFGDetector(opencv_legacy.CvFGDetector ppT)`
`static void`	`cvReleaseFGDetector(PointerPointer ppT)`
`static void`	`cvReleaseGLCM(opencv_legacy.CvGLCM GLCM)`
`static void`	`cvReleaseGLCM(opencv_legacy.CvGLCM GLCM, int flag)`
`static void`	`cvReleaseGLCM(PointerPointer GLCM, int flag)`
`static void`	`cvReleaseImageData(opencv_core.CvArr arg1)`
`static int`	`cvReleaseLinearContorModelStorage(opencv_core.CvGraph Graph)`
`static int`	`cvReleaseLinearContorModelStorage(PointerPointer Graph)`
`static void`	`cvReleaseLSH(opencv_imgproc.CvLSH lsh)`
`static void`	`cvReleaseLSH(PointerPointer lsh)`
`static void`	`cvReleaseMatHeader(opencv_core.CvMat arg1)`
`static void`	`cvReleaseMatHeader(PointerPointer arg1)`
`static void`	`cvReleaseObsInfo(opencv_legacy.CvImgObsInfo obs_info)`
`static void`	`cvReleaseObsInfo(PointerPointer obs_info)`
`static void`	`cvReleaseProb(opencv_legacy.CvProb ppProb)`
`static void`	`cvReleaseProb(PointerPointer ppProb)`
`static void`	`cvReleaseStereoGCState(opencv_legacy.CvStereoGCState state)`
`static void`	`cvReleaseStereoGCState(PointerPointer state)`
`static void`	`cvReleaseTestSeq(opencv_legacy.CvTestSeq ppTestSeq)`
`static void`	`cvReleaseTestSeq(PointerPointer ppTestSeq)`
`static void`	`cvReleaseVoronoiStorage(opencv_legacy.CvVoronoiDiagram2D VoronoiDiagram, opencv_core.CvMemStorage pVoronoiStorage)`
`static void`	`cvReleaseVoronoiStorage(opencv_legacy.CvVoronoiDiagram2D VoronoiDiagram, PointerPointer pVoronoiStorage)`
`static void`	`cvRemoveMemoryManager(opencv_core.CvAllocFunc arg1, opencv_core.CvFreeFunc arg2, Pointer arg3)`
`static void`	`cvRodrigues(opencv_core.CvMat rotation_matrix, opencv_core.CvMat rotation_vector, opencv_core.CvMat jacobian, int conv_type)`
`static void`	`cvRunningAvgMask(opencv_core.CvArr imgY, opencv_core.CvArr imgU, opencv_core.CvArr mask, double alpha)`
`static opencv_core.CvSeq`	`cvSegmentFGMask(opencv_core.CvArr fgmask)`
`static opencv_core.CvSeq`	`cvSegmentFGMask(opencv_core.CvArr fgmask, int poly1Hull0, float perimScale, opencv_core.CvMemStorage storage, int[] offset)`
`static opencv_core.CvSeq`	`cvSegmentFGMask(opencv_core.CvArr fgmask, int poly1Hull0, float perimScale, opencv_core.CvMemStorage storage, IntBuffer offset)`
`static opencv_core.CvSeq`	`cvSegmentFGMask(opencv_core.CvArr fgmask, int poly1Hull0, float perimScale, opencv_core.CvMemStorage storage, opencv_core.CvPoint offset)`
`static opencv_core.CvSeq`	`cvSegmentImage(opencv_core.CvArr srcarr, opencv_core.CvArr dstarr, double canny_threshold, double ffill_threshold, opencv_core.CvMemStorage storage)`
`static void`	`cvSetAt(opencv_core.CvArr arr, opencv_core.CvScalar val, int y, int x)`
`static void`	`cvSetHistThresh(opencv_core.CvHistogram arg1, float[] arg2, int arg3)`
`static void`	`cvSetHistThresh(opencv_core.CvHistogram arg1, FloatBuffer arg2, int arg3)`
`static void`	`cvSetHistThresh(opencv_core.CvHistogram arg1, FloatPointer arg2, int arg3)`
`static void`	`cvSetHistThresh(opencv_core.CvHistogram arg1, PointerPointer arg2, int arg3)`
`static void`	`cvSetImageData(opencv_core.CvArr arg1, Pointer arg2, int arg3)`
`static void`	`cvSnakeImage(opencv_core.IplImage image, int[] points, int length, float[] alpha, float[] beta, float[] gamma, int coeff_usage, opencv_core.CvSize win, opencv_core.CvTermCriteria criteria)`
`static void`	`cvSnakeImage(opencv_core.IplImage image, int[] points, int length, float[] alpha, float[] beta, float[] gamma, int coeff_usage, opencv_core.CvSize win, opencv_core.CvTermCriteria criteria, int calc_gradient)`
`static void`	`cvSnakeImage(opencv_core.IplImage image, IntBuffer points, int length, FloatBuffer alpha, FloatBuffer beta, FloatBuffer gamma, int coeff_usage, opencv_core.CvSize win, opencv_core.CvTermCriteria criteria)`
`static void`	`cvSnakeImage(opencv_core.IplImage image, IntBuffer points, int length, FloatBuffer alpha, FloatBuffer beta, FloatBuffer gamma, int coeff_usage, opencv_core.CvSize win, opencv_core.CvTermCriteria criteria, int calc_gradient)`
`static void`	`cvSnakeImage(opencv_core.IplImage image, opencv_core.CvPoint points, int length, FloatPointer alpha, FloatPointer beta, FloatPointer gamma, int coeff_usage, opencv_core.CvSize win, opencv_core.CvTermCriteria criteria)`
`static void`	`cvSnakeImage(opencv_core.IplImage image, opencv_core.CvPoint points, int length, FloatPointer alpha, FloatPointer beta, FloatPointer gamma, int coeff_usage, opencv_core.CvSize win, opencv_core.CvTermCriteria criteria, int calc_gradient)`
`static void`	`cvSquareAccMask(opencv_core.CvArr arg1, opencv_core.CvArr arg2, opencv_core.CvArr arg3)`
`static opencv_legacy.CvStarDetectorParams`	`cvStarDetectorParams()`
`static opencv_legacy.CvStarDetectorParams`	`cvStarDetectorParams(int maxSize, int responseThreshold, int lineThresholdProjected, int lineThresholdBinarized, int suppressNonmaxSize)`
`static opencv_legacy.CvStarKeypoint`	`cvStarKeypoint(int[] pt, int size, float response)`
`static opencv_legacy.CvStarKeypoint`	`cvStarKeypoint(IntBuffer pt, int size, float response)`
`static opencv_legacy.CvStarKeypoint`	`cvStarKeypoint(opencv_core.CvPoint pt, int size, float response)`
`static void`	`cvStartScanGraph(opencv_core.CvGraph graph, opencv_core.CvGraphScanner scanner)`
`static void`	`cvStartScanGraph(opencv_core.CvGraph graph, opencv_core.CvGraphScanner scanner, opencv_core.CvGraphVtx vtx, int mask)`
`static opencv_imgproc.CvSubdiv2DPoint`	`cvSubdiv2DEdgeDst(long edge)`
`static opencv_imgproc.CvSubdiv2DPoint`	`cvSubdiv2DEdgeOrg(long edge)`
`static long`	`cvSubdiv2DGetEdge(long edge, int type)`
`static int`	`cvSubdiv2DLocate(opencv_imgproc.CvSubdiv2D subdiv, float[] pt, SizeTPointer edge)`
`static int`	`cvSubdiv2DLocate(opencv_imgproc.CvSubdiv2D subdiv, float[] pt, SizeTPointer edge, opencv_imgproc.CvSubdiv2DPoint vertex)`
`static int`	`cvSubdiv2DLocate(opencv_imgproc.CvSubdiv2D subdiv, FloatBuffer pt, SizeTPointer edge)`
`static int`	`cvSubdiv2DLocate(opencv_imgproc.CvSubdiv2D subdiv, FloatBuffer pt, SizeTPointer edge, opencv_imgproc.CvSubdiv2DPoint vertex)`
`static int`	`cvSubdiv2DLocate(opencv_imgproc.CvSubdiv2D subdiv, opencv_core.CvPoint2D32f pt, SizeTPointer edge)`
`static int`	`cvSubdiv2DLocate(opencv_imgproc.CvSubdiv2D subdiv, opencv_core.CvPoint2D32f pt, SizeTPointer edge, opencv_imgproc.CvSubdiv2DPoint vertex)`
`static int`	`cvSubdiv2DLocate(opencv_imgproc.CvSubdiv2D subdiv, opencv_core.CvPoint2D32f pt, SizeTPointer edge, PointerPointer vertex)`
`static long`	`cvSubdiv2DNextEdge(long edge)` Basic quad-edge navigation and operations
`static long`	`cvSubdiv2DRotateEdge(long edge, int rotate)`
`static long`	`cvSubdiv2DSymEdge(long edge)`
`static opencv_imgproc.CvSubdiv2DPoint`	`cvSubdivDelaunay2DInsert(opencv_imgproc.CvSubdiv2D subdiv, float[] pt)`
`static opencv_imgproc.CvSubdiv2DPoint`	`cvSubdivDelaunay2DInsert(opencv_imgproc.CvSubdiv2D subdiv, FloatBuffer pt)`
`static opencv_imgproc.CvSubdiv2DPoint`	`cvSubdivDelaunay2DInsert(opencv_imgproc.CvSubdiv2D subdiv, opencv_core.CvPoint2D32f pt)`
`static double`	`cvSumPixels(opencv_core.CvArr image)`
`static opencv_legacy.CvSURFParams`	`cvSURFParams(double hessianThreshold)`
`static opencv_legacy.CvSURFParams`	`cvSURFParams(double hessianThreshold, int extended)`
`static opencv_legacy.CvSURFPoint`	`cvSURFPoint(float[] pt, int laplacian, int size)`
`static opencv_legacy.CvSURFPoint`	`cvSURFPoint(float[] pt, int laplacian, int size, float dir, float hessian)`
`static opencv_legacy.CvSURFPoint`	`cvSURFPoint(FloatBuffer pt, int laplacian, int size)`
`static opencv_legacy.CvSURFPoint`	`cvSURFPoint(FloatBuffer pt, int laplacian, int size, float dir, float hessian)`
`static opencv_legacy.CvSURFPoint`	`cvSURFPoint(opencv_core.CvPoint2D32f pt, int laplacian, int size)`
`static opencv_legacy.CvSURFPoint`	`cvSURFPoint(opencv_core.CvPoint2D32f pt, int laplacian, int size, float dir, float hessian)`
`static void`	`cvTestSeqAddIntensityVariation(opencv_legacy.CvTestSeq pTestSeq, float DI_per_frame, float MinI, float MaxI)`
`static void`	`cvTestSeqAddNoise(opencv_legacy.CvTestSeq pTestSeq)`
`static void`	`cvTestSeqAddNoise(opencv_legacy.CvTestSeq pTestSeq, int noise_type, double noise_ampl)`
`static int`	`cvTestSeqFrameNum(opencv_legacy.CvTestSeq pTestSeq)`
`static opencv_core.IplImage`	`cvTestSeqGetFGMask(opencv_legacy.CvTestSeq pTestSeq)`
`static opencv_core.IplImage`	`cvTestSeqGetImage(opencv_legacy.CvTestSeq pTestSeq)`
`static opencv_core.CvSize`	`cvTestSeqGetImageSize(opencv_legacy.CvTestSeq pTestSeq)`
`static int`	`cvTestSeqGetObjectNum(opencv_legacy.CvTestSeq pTestSeq)`
`static int`	`cvTestSeqGetObjectPos(opencv_legacy.CvTestSeq pTestSeq, int ObjIndex, float[] pPos)`
`static int`	`cvTestSeqGetObjectPos(opencv_legacy.CvTestSeq pTestSeq, int ObjIndex, FloatBuffer pPos)`
`static int`	`cvTestSeqGetObjectPos(opencv_legacy.CvTestSeq pTestSeq, int ObjIndex, opencv_core.CvPoint2D32f pPos)`
`static int`	`cvTestSeqGetObjectSize(opencv_legacy.CvTestSeq pTestSeq, int ObjIndex, float[] pSize)`
`static int`	`cvTestSeqGetObjectSize(opencv_legacy.CvTestSeq pTestSeq, int ObjIndex, FloatBuffer pSize)`
`static int`	`cvTestSeqGetObjectSize(opencv_legacy.CvTestSeq pTestSeq, int ObjIndex, opencv_core.CvPoint2D32f pSize)`
`static opencv_core.IplImage`	`cvTestSeqQueryFrame(opencv_legacy.CvTestSeq pTestSeq)`
`static void`	`cvTestSeqSetFrame(opencv_legacy.CvTestSeq pTestSeq, int n)`
`static int`	`cvTrackFace(opencv_legacy.CvFaceTracker pFaceTracker, opencv_core.IplImage imgGray, opencv_core.CvRect pRects, int nRects, int[] ptRotate, double[] dbAngleRotate)`
`static int`	`cvTrackFace(opencv_legacy.CvFaceTracker pFaceTracker, opencv_core.IplImage imgGray, opencv_core.CvRect pRects, int nRects, IntBuffer ptRotate, DoubleBuffer dbAngleRotate)`
`static int`	`cvTrackFace(opencv_legacy.CvFaceTracker pFaceTracker, opencv_core.IplImage imgGray, opencv_core.CvRect pRects, int nRects, opencv_core.CvPoint ptRotate, DoublePointer dbAngleRotate)`
`static double`	`cvTriangleArea(float[] a, float[] b, float[] c)`
`static double`	`cvTriangleArea(FloatBuffer a, FloatBuffer b, FloatBuffer c)`
`static double`	`cvTriangleArea(opencv_core.CvPoint2D32f a, opencv_core.CvPoint2D32f b, opencv_core.CvPoint2D32f c)`
`static void`	`cvUnDistort(opencv_core.CvArr src, opencv_core.CvArr dst, opencv_core.CvArr undistortion_map, int interpolate)`
`static void`	`cvUnDistortInit(opencv_core.CvArr src, opencv_core.CvArr undistortion_map, float[] A, float[] k, int interpolate)`
`static void`	`cvUnDistortInit(opencv_core.CvArr src, opencv_core.CvArr undistortion_map, FloatBuffer A, FloatBuffer k, int interpolate)`
`static void`	`cvUnDistortInit(opencv_core.CvArr src, opencv_core.CvArr undistortion_map, FloatPointer A, FloatPointer k, int interpolate)`
`static void`	`cvUnDistortOnce(opencv_core.CvArr src, opencv_core.CvArr dst, float[] intrinsic_matrix, float[] distortion_coeffs, int interpolate)`
`static void`	`cvUnDistortOnce(opencv_core.CvArr src, opencv_core.CvArr dst, FloatBuffer intrinsic_matrix, FloatBuffer distortion_coeffs, int interpolate)`
`static void`	`cvUnDistortOnce(opencv_core.CvArr src, opencv_core.CvArr dst, FloatPointer intrinsic_matrix, FloatPointer distortion_coeffs, int interpolate)`
`static void`	`cvUniformImgSegm(opencv_legacy.CvImgObsInfo obs_info, opencv_legacy.CvEHMM ehmm)`
`static int`	`cvUpdateBGStatModel(opencv_core.IplImage current_frame, opencv_legacy.CvBGStatModel bg_model)`
`static int`	`cvUpdateBGStatModel(opencv_core.IplImage current_frame, opencv_legacy.CvBGStatModel bg_model, double learningRate)`
`static void`	`cvUpdateMHIByTime(opencv_core.CvArr arg1, opencv_core.CvArr arg2, double arg3, double arg4)`
`static int`	`cvVoronoiDiagramFromContour(opencv_core.CvSeq ContourSeq, opencv_legacy.CvVoronoiDiagram2D VoronoiDiagram, opencv_core.CvMemStorage VoronoiStorage)`
`static int`	`cvVoronoiDiagramFromContour(opencv_core.CvSeq ContourSeq, opencv_legacy.CvVoronoiDiagram2D VoronoiDiagram, opencv_core.CvMemStorage VoronoiStorage, int contour_type, int contour_orientation, int attempt_number)`
`static int`	`cvVoronoiDiagramFromContour(opencv_core.CvSeq ContourSeq, PointerPointer VoronoiDiagram, opencv_core.CvMemStorage VoronoiStorage, int contour_type, int contour_orientation, int attempt_number)`
`static int`	`cvVoronoiDiagramFromImage(opencv_core.IplImage pImage, opencv_core.CvSeq ContourSeq, opencv_legacy.CvVoronoiDiagram2D VoronoiDiagram, opencv_core.CvMemStorage VoronoiStorage)`
`static int`	`cvVoronoiDiagramFromImage(opencv_core.IplImage pImage, opencv_core.CvSeq ContourSeq, opencv_legacy.CvVoronoiDiagram2D VoronoiDiagram, opencv_core.CvMemStorage VoronoiStorage, int regularization_method, float approx_precision)`
`static int`	`cvVoronoiDiagramFromImage(opencv_core.IplImage pImage, PointerPointer ContourSeq, PointerPointer VoronoiDiagram, opencv_core.CvMemStorage VoronoiStorage, int regularization_method, float approx_precision)`
`static opencv_core.CvMat`	`cvWarpPerspectiveQMatrix(float[] arg1, float[] arg2, opencv_core.CvMat arg3)`
`static opencv_core.CvMat`	`cvWarpPerspectiveQMatrix(FloatBuffer arg1, FloatBuffer arg2, opencv_core.CvMat arg3)`
`static opencv_core.CvMat`	`cvWarpPerspectiveQMatrix(opencv_core.CvPoint2D32f arg1, opencv_core.CvPoint2D32f arg2, opencv_core.CvMat arg3)`
`static void`	`cvWriteStruct(opencv_core.CvFileStorage fs, BytePointer name, Pointer addr, BytePointer desc)`
`static void`	`cvWriteStruct(opencv_core.CvFileStorage fs, BytePointer name, Pointer addr, BytePointer desc, int num)`
`static void`	`cvWriteStruct(opencv_core.CvFileStorage fs, String name, Pointer addr, String desc)`
`static void`	`cvWriteStruct(opencv_core.CvFileStorage fs, String name, Pointer addr, String desc, int num)`
`static BytePointer`	`getData(opencv_core.IplImage image)`
`static int`	`icvComCoeffForLine(double[] point1, double[] point2, double[] point3, double[] point4, double[] camMatr1, double[] rotMatr1, double[] transVect1, double[] camMatr2, double[] rotMatr2, double[] transVect2, opencv_legacy.CvStereoLineCoeff coeffs, int[] needSwapCameras)`
`static int`	`icvComCoeffForLine(DoubleBuffer point1, DoubleBuffer point2, DoubleBuffer point3, DoubleBuffer point4, DoubleBuffer camMatr1, DoubleBuffer rotMatr1, DoubleBuffer transVect1, DoubleBuffer camMatr2, DoubleBuffer rotMatr2, DoubleBuffer transVect2, opencv_legacy.CvStereoLineCoeff coeffs, IntBuffer needSwapCameras)`
`static int`	`icvComCoeffForLine(opencv_core.CvPoint2D64f point1, opencv_core.CvPoint2D64f point2, opencv_core.CvPoint2D64f point3, opencv_core.CvPoint2D64f point4, DoublePointer camMatr1, DoublePointer rotMatr1, DoublePointer transVect1, DoublePointer camMatr2, DoublePointer rotMatr2, DoublePointer transVect2, opencv_legacy.CvStereoLineCoeff coeffs, IntPointer needSwapCameras)`
`static int`	`icvCompute3DPoint(double alpha, double betta, opencv_legacy.CvStereoLineCoeff coeffs, double[] point)`
`static int`	`icvCompute3DPoint(double alpha, double betta, opencv_legacy.CvStereoLineCoeff coeffs, DoubleBuffer point)`
`static int`	`icvCompute3DPoint(double alpha, double betta, opencv_legacy.CvStereoLineCoeff coeffs, opencv_core.CvPoint3D64f point)`
`static int`	`icvComputeCoeffForStereo(opencv_legacy.CvStereoCamera stereoCamera)`
`static void`	`icvComputeeInfiniteProject1(double[] rotMatr, double[] camMatr1, double[] camMatr2, float[] point1, float[] point2)`
`static void`	`icvComputeeInfiniteProject1(DoubleBuffer rotMatr, DoubleBuffer camMatr1, DoubleBuffer camMatr2, FloatBuffer point1, FloatBuffer point2)`
`static void`	`icvComputeeInfiniteProject1(DoublePointer rotMatr, DoublePointer camMatr1, DoublePointer camMatr2, opencv_core.CvPoint2D32f point1, opencv_core.CvPoint2D32f point2)`
`static void`	`icvComputeeInfiniteProject2(double[] rotMatr, double[] camMatr1, double[] camMatr2, float[] point1, float[] point2)`
`static void`	`icvComputeeInfiniteProject2(DoubleBuffer rotMatr, DoubleBuffer camMatr1, DoubleBuffer camMatr2, FloatBuffer point1, FloatBuffer point2)`
`static void`	`icvComputeeInfiniteProject2(DoublePointer rotMatr, DoublePointer camMatr1, DoublePointer camMatr2, opencv_core.CvPoint2D32f point1, opencv_core.CvPoint2D32f point2)`
`static int`	`icvComputeRestStereoParams(opencv_legacy.CvStereoCamera stereoparams)`
`static int`	`icvComputeStereoLineCoeffs(double[] pointA, double[] pointB, double[] pointCam1, double gamma, opencv_legacy.CvStereoLineCoeff coeffs)`
`static int`	`icvComputeStereoLineCoeffs(DoubleBuffer pointA, DoubleBuffer pointB, DoubleBuffer pointCam1, double gamma, opencv_legacy.CvStereoLineCoeff coeffs)`
`static int`	`icvComputeStereoLineCoeffs(opencv_core.CvPoint3D64f pointA, opencv_core.CvPoint3D64f pointB, opencv_core.CvPoint3D64f pointCam1, double gamma, opencv_legacy.CvStereoLineCoeff coeffs)`
`static void`	`icvComputeStereoParamsForCameras(opencv_legacy.CvStereoCamera stereoCamera)`
`static int`	`icvConvertPointSystem(double[] M2, double[] M1, double[] rotMatr, double[] transVect)`
`static int`	`icvConvertPointSystem(DoubleBuffer M2, DoubleBuffer M1, DoubleBuffer rotMatr, DoubleBuffer transVect)`
`static int`	`icvConvertPointSystem(opencv_core.CvPoint3D64f M2, opencv_core.CvPoint3D64f M1, DoublePointer rotMatr, DoublePointer transVect)`
`static int`	`icvConvertWarpCoordinates(double[] coeffs, float[] cameraPoint, float[] warpPoint, int direction)`
`static int`	`icvConvertWarpCoordinates(DoubleBuffer coeffs, FloatBuffer cameraPoint, FloatBuffer warpPoint, int direction)`
`static int`	`icvConvertWarpCoordinates(DoublePointer coeffs, opencv_core.CvPoint2D32f cameraPoint, opencv_core.CvPoint2D32f warpPoint, int direction)`
`static int`	`icvCreateConvertMatrVect(double[] rotMatr1, double[] transVect1, double[] rotMatr2, double[] transVect2, double[] convRotMatr, double[] convTransVect)`
`static int`	`icvCreateConvertMatrVect(DoubleBuffer rotMatr1, DoubleBuffer transVect1, DoubleBuffer rotMatr2, DoubleBuffer transVect2, DoubleBuffer convRotMatr, DoubleBuffer convTransVect)`
`static int`	`icvCreateConvertMatrVect(DoublePointer rotMatr1, DoublePointer transVect1, DoublePointer rotMatr2, DoublePointer transVect2, DoublePointer convRotMatr, DoublePointer convTransVect)`
`static opencv_core.IplImage`	`icvCreateIsometricImage(opencv_core.IplImage src, opencv_core.IplImage dst, int desired_depth, int desired_num_channels)`
`static float`	`icvDefinePointPosition(float[] point1, float[] point2, float[] point)`
`static float`	`icvDefinePointPosition(FloatBuffer point1, FloatBuffer point2, FloatBuffer point)`
`static float`	`icvDefinePointPosition(opencv_core.CvPoint2D32f point1, opencv_core.CvPoint2D32f point2, opencv_core.CvPoint2D32f point)`
`static void`	`icvDrawMosaic(opencv_imgproc.CvSubdiv2D subdiv, opencv_core.IplImage src, opencv_core.IplImage dst)` \ Additional operations on Subdivisions * \
`static int`	`icvGetAngleLine(double[] startPoint, opencv_core.CvSize imageSize, double[] point1, double[] point2)`
`static int`	`icvGetAngleLine(DoubleBuffer startPoint, opencv_core.CvSize imageSize, DoubleBuffer point1, DoubleBuffer point2)`
`static int`	`icvGetAngleLine(opencv_core.CvPoint2D64f startPoint, opencv_core.CvSize imageSize, opencv_core.CvPoint2D64f point1, opencv_core.CvPoint2D64f point2)`
`static void`	`icvGetCoefForPiece(double[] p_start, double[] p_end, double[] a, double[] b, double[] c, int[] result)`
`static void`	`icvGetCoefForPiece(DoubleBuffer p_start, DoubleBuffer p_end, DoubleBuffer a, DoubleBuffer b, DoubleBuffer c, IntBuffer result)`
`static void`	`icvGetCoefForPiece(opencv_core.CvPoint2D64f p_start, opencv_core.CvPoint2D64f p_end, DoublePointer a, DoublePointer b, DoublePointer c, IntPointer result)`
`static void`	`icvGetCrossDirectDirect(double[] direct1, double[] direct2, double[] cross, int[] result)`
`static void`	`icvGetCrossDirectDirect(DoubleBuffer direct1, DoubleBuffer direct2, DoubleBuffer cross, IntBuffer result)`
`static void`	`icvGetCrossDirectDirect(DoublePointer direct1, DoublePointer direct2, opencv_core.CvPoint2D64f cross, IntPointer result)`
`static int`	`icvGetCrossLineDirect(float[] p1, float[] p2, float a, float b, float c, float[] cross)`
`static int`	`icvGetCrossLineDirect(FloatBuffer p1, FloatBuffer p2, float a, float b, float c, FloatBuffer cross)`
`static int`	`icvGetCrossLineDirect(opencv_core.CvPoint2D32f p1, opencv_core.CvPoint2D32f p2, float a, float b, float c, opencv_core.CvPoint2D32f cross)`
`static int`	`icvGetCrossLines(double[] point11, double[] point12, double[] point21, double[] point22, double[] midPoint)`
`static int`	`icvGetCrossLines(DoubleBuffer point11, DoubleBuffer point12, DoubleBuffer point21, DoubleBuffer point22, DoubleBuffer midPoint)`
`static int`	`icvGetCrossLines(opencv_core.CvPoint3D64f point11, opencv_core.CvPoint3D64f point12, opencv_core.CvPoint3D64f point21, opencv_core.CvPoint3D64f point22, opencv_core.CvPoint3D64f midPoint)`
`static void`	`icvGetCrossPieceDirect(double[] p_start, double[] p_end, double a, double b, double c, double[] cross, int[] result)`
`static void`	`icvGetCrossPieceDirect(DoubleBuffer p_start, DoubleBuffer p_end, double a, double b, double c, DoubleBuffer cross, IntBuffer result)`
`static void`	`icvGetCrossPieceDirect(opencv_core.CvPoint2D64f p_start, opencv_core.CvPoint2D64f p_end, double a, double b, double c, opencv_core.CvPoint2D64f cross, IntPointer result)`
`static void`	`icvGetCrossPiecePiece(double[] p1_start, double[] p1_end, double[] p2_start, double[] p2_end, double[] cross, int[] result)`
`static void`	`icvGetCrossPiecePiece(DoubleBuffer p1_start, DoubleBuffer p1_end, DoubleBuffer p2_start, DoubleBuffer p2_end, DoubleBuffer cross, IntBuffer result)`
`static void`	`icvGetCrossPiecePiece(opencv_core.CvPoint2D64f p1_start, opencv_core.CvPoint2D64f p1_end, opencv_core.CvPoint2D64f p2_start, opencv_core.CvPoint2D64f p2_end, opencv_core.CvPoint2D64f cross, IntPointer result)`
`static int`	`icvGetCrossPieceVector(float[] p1_start, float[] p1_end, float[] v2_start, float[] v2_end, float[] cross)`
`static int`	`icvGetCrossPieceVector(FloatBuffer p1_start, FloatBuffer p1_end, FloatBuffer v2_start, FloatBuffer v2_end, FloatBuffer cross)`
`static int`	`icvGetCrossPieceVector(opencv_core.CvPoint2D32f p1_start, opencv_core.CvPoint2D32f p1_end, opencv_core.CvPoint2D32f v2_start, opencv_core.CvPoint2D32f v2_end, opencv_core.CvPoint2D32f cross)`
`static void`	`icvGetCrossRectDirect(opencv_core.CvSize imageSize, double a, double b, double c, double[] start, double[] end, int[] result)`
`static void`	`icvGetCrossRectDirect(opencv_core.CvSize imageSize, double a, double b, double c, DoubleBuffer start, DoubleBuffer end, IntBuffer result)`
`static void`	`icvGetCrossRectDirect(opencv_core.CvSize imageSize, double a, double b, double c, opencv_core.CvPoint2D64f start, opencv_core.CvPoint2D64f end, IntPointer result)`
`static void`	`icvGetCutPiece(double[] areaLineCoef1, double[] areaLineCoef2, double[] epipole, opencv_core.CvSize imageSize, double[] point11, double[] point12, double[] point21, double[] point22, int[] result)`
`static void`	`icvGetCutPiece(DoubleBuffer areaLineCoef1, DoubleBuffer areaLineCoef2, DoubleBuffer epipole, opencv_core.CvSize imageSize, DoubleBuffer point11, DoubleBuffer point12, DoubleBuffer point21, DoubleBuffer point22, IntBuffer result)`
`static void`	`icvGetCutPiece(DoublePointer areaLineCoef1, DoublePointer areaLineCoef2, opencv_core.CvPoint2D64f epipole, opencv_core.CvSize imageSize, opencv_core.CvPoint2D64f point11, opencv_core.CvPoint2D64f point12, opencv_core.CvPoint2D64f point21, opencv_core.CvPoint2D64f point22, IntPointer result)`
`static int`	`icvGetDirectionForPoint(double[] point, double[] camMatr, double[] direct)`
`static int`	`icvGetDirectionForPoint(DoubleBuffer point, DoubleBuffer camMatr, DoubleBuffer direct)`
`static int`	`icvGetDirectionForPoint(opencv_core.CvPoint2D64f point, DoublePointer camMatr, opencv_core.CvPoint3D64f direct)`
`static void`	`icvGetDistanceFromPointToDirect(double[] point, double[] lineCoef, double[] dist)`
`static void`	`icvGetDistanceFromPointToDirect(DoubleBuffer point, DoubleBuffer lineCoef, DoubleBuffer dist)`
`static void`	`icvGetDistanceFromPointToDirect(opencv_core.CvPoint2D64f point, DoublePointer lineCoef, DoublePointer dist)`
`static void`	`icvGetMiddleAnglePoint(double[] basePoint, double[] point1, double[] point2, double[] midPoint)`
`static void`	`icvGetMiddleAnglePoint(DoubleBuffer basePoint, DoubleBuffer point1, DoubleBuffer point2, DoubleBuffer midPoint)`
`static void`	`icvGetMiddleAnglePoint(opencv_core.CvPoint2D64f basePoint, opencv_core.CvPoint2D64f point1, opencv_core.CvPoint2D64f point2, opencv_core.CvPoint2D64f midPoint)`
`static void`	`icvGetNormalDirect(double[] direct, double[] point, double[] normDirect)`
`static void`	`icvGetNormalDirect(DoubleBuffer direct, DoubleBuffer point, DoubleBuffer normDirect)`
`static void`	`icvGetNormalDirect(DoublePointer direct, opencv_core.CvPoint2D64f point, DoublePointer normDirect)`
`static void`	`icvGetPieceLength(double[] point1, double[] point2, double[] dist)`
`static void`	`icvGetPieceLength(DoubleBuffer point1, DoubleBuffer point2, DoubleBuffer dist)`
`static void`	`icvGetPieceLength(opencv_core.CvPoint2D64f point1, opencv_core.CvPoint2D64f point2, DoublePointer dist)`
`static void`	`icvGetPieceLength3D(double[] point1, double[] point2, double[] dist)`
`static void`	`icvGetPieceLength3D(DoubleBuffer point1, DoubleBuffer point2, DoubleBuffer dist)`
`static void`	`icvGetPieceLength3D(opencv_core.CvPoint3D64f point1, opencv_core.CvPoint3D64f point2, DoublePointer dist)`
`static void`	`icvGetQuadsTransform(opencv_core.CvSize imageSize, double[] camMatr1, double[] rotMatr1, double[] transVect1, double[] camMatr2, double[] rotMatr2, double[] transVect2, opencv_core.CvSize warpSize, double[] quad1, double[] quad2, double[] fundMatr, double[] epipole1, double[] epipole2)`
`static void`	`icvGetQuadsTransform(opencv_core.CvSize imageSize, DoubleBuffer camMatr1, DoubleBuffer rotMatr1, DoubleBuffer transVect1, DoubleBuffer camMatr2, DoubleBuffer rotMatr2, DoubleBuffer transVect2, opencv_core.CvSize warpSize, DoubleBuffer quad1, DoubleBuffer quad2, DoubleBuffer fundMatr, DoubleBuffer epipole1, DoubleBuffer epipole2)`
`static void`	`icvGetQuadsTransform(opencv_core.CvSize imageSize, DoublePointer camMatr1, DoublePointer rotMatr1, DoublePointer transVect1, DoublePointer camMatr2, DoublePointer rotMatr2, DoublePointer transVect2, opencv_core.CvSize warpSize, DoublePointer quad1, DoublePointer quad2, DoublePointer fundMatr, opencv_core.CvPoint3D64f epipole1, opencv_core.CvPoint3D64f epipole2)`
`static void`	`icvGetQuadsTransformStruct(opencv_legacy.CvStereoCamera stereoCamera)`
`static int`	`icvGetSymPoint3D(double[] pointCorner, double[] point1, double[] point2, double[] pointSym2)`
`static int`	`icvGetSymPoint3D(DoubleBuffer pointCorner, DoubleBuffer point1, DoubleBuffer point2, DoubleBuffer pointSym2)`
`static int`	`icvGetSymPoint3D(opencv_core.CvPoint3D64f pointCorner, opencv_core.CvPoint3D64f point1, opencv_core.CvPoint3D64f point2, opencv_core.CvPoint3D64f pointSym2)`
`static double`	`icvGetVect(double[] basePoint, double[] point1, double[] point2)`
`static double`	`icvGetVect(DoubleBuffer basePoint, DoubleBuffer point1, DoubleBuffer point2)`
`static double`	`icvGetVect(opencv_core.CvPoint2D64f basePoint, opencv_core.CvPoint2D64f point1, opencv_core.CvPoint2D64f point2)`
`static void`	`icvProjectPointToDirect(double[] point, double[] lineCoeff, double[] projectPoint)`
`static void`	`icvProjectPointToDirect(DoubleBuffer point, DoubleBuffer lineCoeff, DoubleBuffer projectPoint)`
`static void`	`icvProjectPointToDirect(opencv_core.CvPoint2D64f point, DoublePointer lineCoeff, opencv_core.CvPoint2D64f projectPoint)`
`static void`	`icvProjectPointToImage(double[] point, double[] camMatr, double[] rotMatr, double[] transVect, double[] projPoint)`
`static void`	`icvProjectPointToImage(DoubleBuffer point, DoubleBuffer camMatr, DoubleBuffer rotMatr, DoubleBuffer transVect, DoubleBuffer projPoint)`
`static void`	`icvProjectPointToImage(opencv_core.CvPoint3D64f point, DoublePointer camMatr, DoublePointer rotMatr, DoublePointer transVect, opencv_core.CvPoint2D64f projPoint)`
`static double`	`icvSqDist2D32f(float[] pt1, float[] pt2)`
`static double`	`icvSqDist2D32f(FloatBuffer pt1, FloatBuffer pt2)`
`static double`	`icvSqDist2D32f(opencv_core.CvPoint2D32f pt1, opencv_core.CvPoint2D32f pt2)`
`static int`	`icvStereoCalibration(int numImages, int[] nums, opencv_core.CvSize imageSize, float[] imagePoints1, float[] imagePoints2, float[] objectPoints, opencv_legacy.CvStereoCamera stereoparams)`
`static int`	`icvStereoCalibration(int numImages, IntBuffer nums, opencv_core.CvSize imageSize, FloatBuffer imagePoints1, FloatBuffer imagePoints2, FloatBuffer objectPoints, opencv_legacy.CvStereoCamera stereoparams)`
`static int`	`icvStereoCalibration(int numImages, IntPointer nums, opencv_core.CvSize imageSize, opencv_core.CvPoint2D32f imagePoints1, opencv_core.CvPoint2D32f imagePoints2, opencv_core.CvPoint3D32f objectPoints, opencv_legacy.CvStereoCamera stereoparams)`
`static int`	`icvSubdiv2DCheck(opencv_imgproc.CvSubdiv2D subdiv)`
`static int`	`iplHeight(opencv_core.IplImage img)`
`static int`	`iplWidth(opencv_core.IplImage img)`
`static int`	`LSHSize(opencv_imgproc.CvLSH lsh)`

Methods inherited from class org.bytedeco.javacpp.helper.opencv_legacy
cvCalcCovarMatrixEx, cvCalcCovarMatrixEx, cvCalcEigenObjects, cvCalcEigenObjects, cvEigenDecomposite, cvEigenDecomposite, cvEigenProjection, cvEigenProjection

Methods inherited from class org.bytedeco.javacpp.presets.opencv_legacy
map

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Field Detail
- CV_BLOB_MINW
```
public static final int CV_BLOB_MINW
```
  See Also:
  Constant Field Values
- CV_BLOB_MINH
```
public static final int CV_BLOB_MINH
```
  See Also:
  Constant Field Values
- PROFILE_EPANECHNIKOV
```
public static final int PROFILE_EPANECHNIKOV
```
  See Also:
  Constant Field Values
- PROFILE_DOG
```
public static final int PROFILE_DOG
```
  See Also:
  Constant Field Values
- CV_BT_HIST_TYPE_S
```
public static final int CV_BT_HIST_TYPE_S
```
  See Also:
  Constant Field Values
- CV_BT_HIST_TYPE_MG
```
public static final int CV_BT_HIST_TYPE_MG
```
  See Also:
  Constant Field Values
- CV_BT_HIST_TYPE_MG2
```
public static final int CV_BT_HIST_TYPE_MG2
```
  See Also:
  Constant Field Values
- CV_BT_HIST_TYPE_H
```
public static final int CV_BT_HIST_TYPE_H
```
  See Also:
  Constant Field Values
- CV_NOISE_NONE
```
public static final int CV_NOISE_NONE
```
  See Also:
  Constant Field Values
- CV_NOISE_GAUSSIAN
```
public static final int CV_NOISE_GAUSSIAN
```
  See Also:
  Constant Field Values
- CV_NOISE_UNIFORM
```
public static final int CV_NOISE_UNIFORM
```
  See Also:
  Constant Field Values
- CV_NOISE_SPECKLE
```
public static final int CV_NOISE_SPECKLE
```
  See Also:
  Constant Field Values
- CV_NOISE_SALT_AND_PEPPER
```
public static final int CV_NOISE_SALT_AND_PEPPER
```
  See Also:
  Constant Field Values
- CV_MAT32F
```
public static final int CV_MAT32F
```
  enum
- CV_MAT3x1_32F
```
public static final int CV_MAT3x1_32F
```
  enum
- CV_MAT4x1_32F
```
public static final int CV_MAT4x1_32F
```
  enum
- CV_MAT3x3_32F
```
public static final int CV_MAT3x3_32F
```
  enum
- CV_MAT4x4_32F
```
public static final int CV_MAT4x4_32F
```
  enum
- CV_MAT64D
```
public static final int CV_MAT64D
```
  enum
- CV_MAT3x1_64D
```
public static final int CV_MAT3x1_64D
```
  enum
- CV_MAT4x1_64D
```
public static final int CV_MAT4x1_64D
```
  enum
- CV_MAT3x3_64D
```
public static final int CV_MAT3x3_64D
```
  enum
- CV_MAT4x4_64D
```
public static final int CV_MAT4x4_64D
```
  enum
- IPL_GAUSSIAN_5x5
```
public static final int IPL_GAUSSIAN_5x5
```
  enum
  
  See Also:
  Constant Field Values
- CV_SHIFT_NONE
```
public static final int CV_SHIFT_NONE
```
  enum
  
  See Also:
  Constant Field Values
- CV_SHIFT_LEFT
```
public static final int CV_SHIFT_LEFT
```
  enum
  
  See Also:
  Constant Field Values
- CV_SHIFT_RIGHT
```
public static final int CV_SHIFT_RIGHT
```
  enum
  
  See Also:
  Constant Field Values
- CV_SHIFT_UP
```
public static final int CV_SHIFT_UP
```
  enum
  
  See Also:
  Constant Field Values
- CV_SHIFT_DOWN
```
public static final int CV_SHIFT_DOWN
```
  enum
  
  See Also:
  Constant Field Values
- CV_SHIFT_LU
```
public static final int CV_SHIFT_LU
```
  enum
  
  See Also:
  Constant Field Values
- CV_SHIFT_RU
```
public static final int CV_SHIFT_RU
```
  enum
  
  See Also:
  Constant Field Values
- CV_SHIFT_LD
```
public static final int CV_SHIFT_LD
```
  enum
  
  See Also:
  Constant Field Values
- CV_SHIFT_RD
```
public static final int CV_SHIFT_RD
```
  enum
  
  See Also:
  Constant Field Values
- CV_RODRIGUES_M2V
```
public static final int CV_RODRIGUES_M2V
```
  enum
  
  See Also:
  Constant Field Values
- CV_RODRIGUES_V2M
```
public static final int CV_RODRIGUES_V2M
```
  enum
  
  See Also:
  Constant Field Values
- CV_EIGOBJ_NO_CALLBACK
```
public static final int CV_EIGOBJ_NO_CALLBACK
```
  See Also:
  Constant Field Values
- CV_EIGOBJ_INPUT_CALLBACK
```
public static final int CV_EIGOBJ_INPUT_CALLBACK
```
  See Also:
  Constant Field Values
- CV_EIGOBJ_OUTPUT_CALLBACK
```
public static final int CV_EIGOBJ_OUTPUT_CALLBACK
```
  See Also:
  Constant Field Values
- CV_EIGOBJ_BOTH_CALLBACK
```
public static final int CV_EIGOBJ_BOTH_CALLBACK
```
  See Also:
  Constant Field Values
- CV_NOT_WEIGHTED
```
public static final int CV_NOT_WEIGHTED
```
  enum CvGraphWeightType
  
  See Also:
  Constant Field Values
- CV_WEIGHTED_VTX
```
public static final int CV_WEIGHTED_VTX
```
  enum CvGraphWeightType
  
  See Also:
  Constant Field Values
- CV_WEIGHTED_EDGE
```
public static final int CV_WEIGHTED_EDGE
```
  enum CvGraphWeightType
  
  See Also:
  Constant Field Values
- CV_WEIGHTED_ALL
```
public static final int CV_WEIGHTED_ALL
```
  enum CvGraphWeightType
  
  See Also:
  Constant Field Values
- CV_DOMINANT_IPAN
```
public static final int CV_DOMINANT_IPAN
```
  See Also:
  Constant Field Values
- CLIQUE_TIME_OFF
```
public static final int CLIQUE_TIME_OFF
```
  See Also:
  Constant Field Values
- CLIQUE_FOUND
```
public static final int CLIQUE_FOUND
```
  See Also:
  Constant Field Values
- CLIQUE_END
```
public static final int CLIQUE_END
```
  See Also:
  Constant Field Values
- CV_UNDEF_SC_PARAM
```
public static final int CV_UNDEF_SC_PARAM
```
  See Also:
  Constant Field Values
- CV_IDP_BIRCHFIELD_PARAM1
```
public static final int CV_IDP_BIRCHFIELD_PARAM1
```
  See Also:
  Constant Field Values
- CV_IDP_BIRCHFIELD_PARAM2
```
public static final int CV_IDP_BIRCHFIELD_PARAM2
```
  See Also:
  Constant Field Values
- CV_IDP_BIRCHFIELD_PARAM3
```
public static final int CV_IDP_BIRCHFIELD_PARAM3
```
  See Also:
  Constant Field Values
- CV_IDP_BIRCHFIELD_PARAM4
```
public static final int CV_IDP_BIRCHFIELD_PARAM4
```
  See Also:
  Constant Field Values
- CV_IDP_BIRCHFIELD_PARAM5
```
public static final int CV_IDP_BIRCHFIELD_PARAM5
```
  See Also:
  Constant Field Values
- CV_DISPARITY_BIRCHFIELD
```
public static final int CV_DISPARITY_BIRCHFIELD
```
  See Also:
  Constant Field Values
- CV_CAMERA_TO_WARP
```
public static final int CV_CAMERA_TO_WARP
```
  See Also:
  Constant Field Values
- CV_WARP_TO_CAMERA
```
public static final int CV_WARP_TO_CAMERA
```
  See Also:
  Constant Field Values
- CV_CONTOUR_TREES_MATCH_I1
```
public static final int CV_CONTOUR_TREES_MATCH_I1
```
  enum
  
  See Also:
  Constant Field Values
- CV_VALUE
```
public static final int CV_VALUE
```
  \ Active Contours * \
  
  See Also:
  Constant Field Values
- CV_ARRAY
```
public static final int CV_ARRAY
```
  See Also:
  Constant Field Values
- CV_GLCM_OPTIMIZATION_NONE
```
public static final int CV_GLCM_OPTIMIZATION_NONE
```
  \ Texture Descriptors * \
  
  See Also:
  Constant Field Values
- CV_GLCM_OPTIMIZATION_LUT
```
public static final int CV_GLCM_OPTIMIZATION_LUT
```
  See Also:
  Constant Field Values
- CV_GLCM_OPTIMIZATION_HISTOGRAM
```
public static final int CV_GLCM_OPTIMIZATION_HISTOGRAM
```
  See Also:
  Constant Field Values
- CV_GLCMDESC_OPTIMIZATION_ALLOWDOUBLENEST
```
public static final int CV_GLCMDESC_OPTIMIZATION_ALLOWDOUBLENEST
```
  See Also:
  Constant Field Values
- CV_GLCMDESC_OPTIMIZATION_ALLOWTRIPLENEST
```
public static final int CV_GLCMDESC_OPTIMIZATION_ALLOWTRIPLENEST
```
  See Also:
  Constant Field Values
- CV_GLCMDESC_OPTIMIZATION_HISTOGRAM
```
public static final int CV_GLCMDESC_OPTIMIZATION_HISTOGRAM
```
  See Also:
  Constant Field Values
- CV_GLCMDESC_ENTROPY
```
public static final int CV_GLCMDESC_ENTROPY
```
  See Also:
  Constant Field Values
- CV_GLCMDESC_ENERGY
```
public static final int CV_GLCMDESC_ENERGY
```
  See Also:
  Constant Field Values
- CV_GLCMDESC_HOMOGENITY
```
public static final int CV_GLCMDESC_HOMOGENITY
```
  See Also:
  Constant Field Values
- CV_GLCMDESC_CONTRAST
```
public static final int CV_GLCMDESC_CONTRAST
```
  See Also:
  Constant Field Values
- CV_GLCMDESC_CLUSTERTENDENCY
```
public static final int CV_GLCMDESC_CLUSTERTENDENCY
```
  See Also:
  Constant Field Values
- CV_GLCMDESC_CLUSTERSHADE
```
public static final int CV_GLCMDESC_CLUSTERSHADE
```
  See Also:
  Constant Field Values
- CV_GLCMDESC_CORRELATION
```
public static final int CV_GLCMDESC_CORRELATION
```
  See Also:
  Constant Field Values
- CV_GLCMDESC_CORRELATIONINFO1
```
public static final int CV_GLCMDESC_CORRELATIONINFO1
```
  See Also:
  Constant Field Values
- CV_GLCMDESC_CORRELATIONINFO2
```
public static final int CV_GLCMDESC_CORRELATIONINFO2
```
  See Also:
  Constant Field Values
- CV_GLCMDESC_MAXIMUMPROBABILITY
```
public static final int CV_GLCMDESC_MAXIMUMPROBABILITY
```
  See Also:
  Constant Field Values
- CV_GLCM_ALL
```
public static final int CV_GLCM_ALL
```
  See Also:
  Constant Field Values
- CV_GLCM_GLCM
```
public static final int CV_GLCM_GLCM
```
  See Also:
  Constant Field Values
- CV_GLCM_DESC
```
public static final int CV_GLCM_DESC
```
  See Also:
  Constant Field Values
- CV_NUM_FACE_ELEMENTS
```
public static final int CV_NUM_FACE_ELEMENTS
```
  See Also:
  Constant Field Values
- CV_FACE_MOUTH
```
public static final int CV_FACE_MOUTH
```
  enum CV_FACE_ELEMENTS
  
  See Also:
  Constant Field Values
- CV_FACE_LEFT_EYE
```
public static final int CV_FACE_LEFT_EYE
```
  enum CV_FACE_ELEMENTS
  
  See Also:
  Constant Field Values
- CV_FACE_RIGHT_EYE
```
public static final int CV_FACE_RIGHT_EYE
```
  enum CV_FACE_ELEMENTS
  
  See Also:
  Constant Field Values
- CV_LEE_INT
```
public static final int CV_LEE_INT
```
  enum CvLeeParameters
  
  See Also:
  Constant Field Values
- CV_LEE_FLOAT
```
public static final int CV_LEE_FLOAT
```
  enum CvLeeParameters
  
  See Also:
  Constant Field Values
- CV_LEE_DOUBLE
```
public static final int CV_LEE_DOUBLE
```
  enum CvLeeParameters
  
  See Also:
  Constant Field Values
- CV_LEE_AUTO
```
public static final int CV_LEE_AUTO
```
  enum CvLeeParameters
  
  See Also:
  Constant Field Values
- CV_LEE_ERODE
```
public static final int CV_LEE_ERODE
```
  enum CvLeeParameters
  
  See Also:
  Constant Field Values
- CV_LEE_ZOOM
```
public static final int CV_LEE_ZOOM
```
  enum CvLeeParameters
  
  See Also:
  Constant Field Values
- CV_LEE_NON
```
public static final int CV_LEE_NON
```
  enum CvLeeParameters
  
  See Also:
  Constant Field Values
- CV_CALIB_ETALON_USER
```
public static final int CV_CALIB_ETALON_USER
```
  enum CvCalibEtalonType
  
  See Also:
  Constant Field Values
- CV_CALIB_ETALON_CHESSBOARD
```
public static final int CV_CALIB_ETALON_CHESSBOARD
```
  enum CvCalibEtalonType
  
  See Also:
  Constant Field Values
- CV_CALIB_ETALON_CHECKERBOARD
```
public static final int CV_CALIB_ETALON_CHECKERBOARD
```
  enum CvCalibEtalonType
  
  See Also:
  Constant Field Values
- CV_STEREO_GC_OCCLUDED
```
public static final int CV_STEREO_GC_OCCLUDED
```
- CV_BG_MODEL_FGD
```
public static final int CV_BG_MODEL_FGD
```
  \ Background/foreground segmentation * \
  
  See Also:
  Constant Field Values
- CV_BG_MODEL_MOG
```
public static final int CV_BG_MODEL_MOG
```
  See Also:
  Constant Field Values
- CV_BG_MODEL_FGD_SIMPLE
```
public static final int CV_BG_MODEL_FGD_SIMPLE
```
  See Also:
  Constant Field Values
- CV_BGFG_FGD_LC
```
public static final int CV_BGFG_FGD_LC
```
  See Also:
  Constant Field Values
- CV_BGFG_FGD_N1C
```
public static final int CV_BGFG_FGD_N1C
```
  See Also:
  Constant Field Values
- CV_BGFG_FGD_N2C
```
public static final int CV_BGFG_FGD_N2C
```
  See Also:
  Constant Field Values
- CV_BGFG_FGD_LCC
```
public static final int CV_BGFG_FGD_LCC
```
  See Also:
  Constant Field Values
- CV_BGFG_FGD_N1CC
```
public static final int CV_BGFG_FGD_N1CC
```
  See Also:
  Constant Field Values
- CV_BGFG_FGD_N2CC
```
public static final int CV_BGFG_FGD_N2CC
```
  See Also:
  Constant Field Values
- CV_BGFG_FGD_ALPHA_1
```
public static final double CV_BGFG_FGD_ALPHA_1
```
  See Also:
  Constant Field Values
- CV_BGFG_FGD_ALPHA_2
```
public static final double CV_BGFG_FGD_ALPHA_2
```
  See Also:
  Constant Field Values
- CV_BGFG_FGD_ALPHA_3
```
public static final double CV_BGFG_FGD_ALPHA_3
```
  See Also:
  Constant Field Values
- CV_BGFG_FGD_DELTA
```
public static final int CV_BGFG_FGD_DELTA
```
  See Also:
  Constant Field Values
- CV_BGFG_FGD_T
```
public static final double CV_BGFG_FGD_T
```
  See Also:
  Constant Field Values
- CV_BGFG_FGD_MINAREA
```
public static final double CV_BGFG_FGD_MINAREA
```
  See Also:
  Constant Field Values
- CV_BGFG_FGD_BG_UPDATE_TRESH
```
public static final double CV_BGFG_FGD_BG_UPDATE_TRESH
```
  See Also:
  Constant Field Values
- CV_BGFG_MOG_MAX_NGAUSSIANS
```
public static final int CV_BGFG_MOG_MAX_NGAUSSIANS
```
  See Also:
  Constant Field Values
- CV_BGFG_MOG_BACKGROUND_THRESHOLD
```
public static final double CV_BGFG_MOG_BACKGROUND_THRESHOLD
```
  See Also:
  Constant Field Values
- CV_BGFG_MOG_STD_THRESHOLD
```
public static final double CV_BGFG_MOG_STD_THRESHOLD
```
  See Also:
  Constant Field Values
- CV_BGFG_MOG_WINDOW_SIZE
```
public static final int CV_BGFG_MOG_WINDOW_SIZE
```
  See Also:
  Constant Field Values
- CV_BGFG_MOG_NGAUSSIANS
```
public static final int CV_BGFG_MOG_NGAUSSIANS
```
  See Also:
  Constant Field Values
- CV_BGFG_MOG_WEIGHT_INIT
```
public static final double CV_BGFG_MOG_WEIGHT_INIT
```
  See Also:
  Constant Field Values
- CV_BGFG_MOG_SIGMA_INIT
```
public static final int CV_BGFG_MOG_SIGMA_INIT
```
  See Also:
  Constant Field Values
- CV_BGFG_MOG_MINAREA
```
public static final double CV_BGFG_MOG_MINAREA
```
  See Also:
  Constant Field Values
- CV_BGFG_MOG_NCOLORS
```
public static final int CV_BGFG_MOG_NCOLORS
```
  See Also:
  Constant Field Values

Constructor Detail
- opencv_legacy
```
public opencv_legacy()
```

Method Detail

cvWriteStruct

public static void cvWriteStruct(opencv_core.CvFileStorage fs,
                 BytePointer name,
                 Pointer addr,
                 BytePointer desc,
                 int num)

cvWriteStruct

public static void cvWriteStruct(opencv_core.CvFileStorage fs,
                 BytePointer name,
                 Pointer addr,
                 BytePointer desc)

cvWriteStruct

public static void cvWriteStruct(opencv_core.CvFileStorage fs,
                 String name,
                 Pointer addr,
                 String desc,
                 int num)

cvWriteStruct

public static void cvWriteStruct(opencv_core.CvFileStorage fs,
                 String name,
                 Pointer addr,
                 String desc)

cvReadStructByName

public static void cvReadStructByName(opencv_core.CvFileStorage fs,
                      opencv_core.CvFileNode node,
                      BytePointer name,
                      Pointer addr,
                      BytePointer desc)

cvReadStructByName

public static void cvReadStructByName(opencv_core.CvFileStorage fs,
                      opencv_core.CvFileNode node,
                      String name,
                      Pointer addr,
                      String desc)

cvReleaseFGDetector

public static void cvReleaseFGDetector(PointerPointer ppT)

cvReleaseFGDetector

public static void cvReleaseFGDetector(opencv_legacy.CvFGDetector ppT)

cvCreateFGDetectorBase

public static opencv_legacy.CvFGDetector cvCreateFGDetectorBase(int type,
                                                Pointer param)

cvBlob

public static opencv_legacy.CvBlob cvBlob(float x,
                          float y,
                          float w,
                          float h)

cvReleaseBlobDetector

public static void cvReleaseBlobDetector(PointerPointer ppBD)

cvReleaseBlobDetector

public static void cvReleaseBlobDetector(opencv_legacy.CvBlobDetector ppBD)

cvCreateBlobDetectorSimple

public static opencv_legacy.CvBlobDetector cvCreateBlobDetectorSimple()

cvCreateBlobDetectorCC

public static opencv_legacy.CvBlobDetector cvCreateBlobDetectorCC()

cvDetectedBlob

public static opencv_legacy.CvDetectedBlob cvDetectedBlob(float x,
                                          float y,
                                          float w,
                                          float h,
                                          int ID,
                                          float response)

cvDetectedBlob

public static opencv_legacy.CvDetectedBlob cvDetectedBlob(float x,
                                          float y,
                                          float w,
                                          float h)

cvRectIntersection

public static opencv_core.CvRect cvRectIntersection(opencv_core.CvRect r1,
                                    opencv_core.CvRect r2)

cvReleaseBlobTrackGen

public static void cvReleaseBlobTrackGen(PointerPointer pBTGen)

cvReleaseBlobTrackGen

public static void cvReleaseBlobTrackGen(opencv_legacy.CvBlobTrackGen pBTGen)

cvCreateModuleBlobTrackGen1

public static opencv_legacy.CvBlobTrackGen cvCreateModuleBlobTrackGen1()

cvCreateModuleBlobTrackGenYML

public static opencv_legacy.CvBlobTrackGen cvCreateModuleBlobTrackGenYML()

cvReleaseBlobTracker

public static void cvReleaseBlobTracker(PointerPointer ppT)

cvReleaseBlobTracker

public static void cvReleaseBlobTracker(opencv_legacy.CvBlobTracker ppT)

cvReleaseBlobTrackerOne

public static void cvReleaseBlobTrackerOne(PointerPointer ppT)

cvReleaseBlobTrackerOne

public static void cvReleaseBlobTrackerOne(opencv_legacy.CvBlobTrackerOne ppT)

cvCreateBlobTrackerList

public static opencv_legacy.CvBlobTracker cvCreateBlobTrackerList(opencv_legacy.CvBlobTrackerOne_Create create)

cvCreateBlobTrackerCC

public static opencv_legacy.CvBlobTracker cvCreateBlobTrackerCC()

cvCreateBlobTrackerCCMSPF

public static opencv_legacy.CvBlobTracker cvCreateBlobTrackerCCMSPF()

cvCreateBlobTrackerMSFG

public static opencv_legacy.CvBlobTracker cvCreateBlobTrackerMSFG()

cvCreateBlobTrackerMSFGS

public static opencv_legacy.CvBlobTracker cvCreateBlobTrackerMSFGS()

cvCreateBlobTrackerMS

public static opencv_legacy.CvBlobTracker cvCreateBlobTrackerMS()

cvCreateBlobTrackerMSPF

public static opencv_legacy.CvBlobTracker cvCreateBlobTrackerMSPF()

cvReleaseBlobTrackPostProc

public static void cvReleaseBlobTrackPostProc(PointerPointer pBTPP)

cvReleaseBlobTrackPostProc

public static void cvReleaseBlobTrackPostProc(opencv_legacy.CvBlobTrackPostProc pBTPP)

cvCreateBlobTrackPostProcList

public static opencv_legacy.CvBlobTrackPostProc cvCreateBlobTrackPostProcList(opencv_legacy.CvBlobTrackPostProcOne_Create create)

cvCreateModuleBlobTrackPostProcKalman

public static opencv_legacy.CvBlobTrackPostProc cvCreateModuleBlobTrackPostProcKalman()

cvCreateModuleBlobTrackPostProcTimeAverRect

public static opencv_legacy.CvBlobTrackPostProc cvCreateModuleBlobTrackPostProcTimeAverRect()

cvCreateModuleBlobTrackPostProcTimeAverExp

public static opencv_legacy.CvBlobTrackPostProc cvCreateModuleBlobTrackPostProcTimeAverExp()

cvCreateModuleBlobTrackPredictKalman

public static opencv_legacy.CvBlobTrackPredictor cvCreateModuleBlobTrackPredictKalman()

cvReleaseBlobTrackAnalysis

public static void cvReleaseBlobTrackAnalysis(PointerPointer pBTPP)

cvReleaseBlobTrackAnalysis

public static void cvReleaseBlobTrackAnalysis(opencv_legacy.CvBlobTrackAnalysis pBTPP)

cvCreateBlobTrackAnalysisList

public static opencv_legacy.CvBlobTrackAnalysis cvCreateBlobTrackAnalysisList(opencv_legacy.CvBlobTrackAnalysisOne_Create create)

cvCreateModuleBlobTrackAnalysisHistP

public static opencv_legacy.CvBlobTrackAnalysis cvCreateModuleBlobTrackAnalysisHistP()

cvCreateModuleBlobTrackAnalysisHistPV

public static opencv_legacy.CvBlobTrackAnalysis cvCreateModuleBlobTrackAnalysisHistPV()

cvCreateModuleBlobTrackAnalysisHistPVS

public static opencv_legacy.CvBlobTrackAnalysis cvCreateModuleBlobTrackAnalysisHistPVS()

cvCreateModuleBlobTrackAnalysisHistSS

public static opencv_legacy.CvBlobTrackAnalysis cvCreateModuleBlobTrackAnalysisHistSS()

cvCreateModuleBlobTrackAnalysisTrackDist

public static opencv_legacy.CvBlobTrackAnalysis cvCreateModuleBlobTrackAnalysisTrackDist()

cvCreateModuleBlobTrackAnalysisIOR

public static opencv_legacy.CvBlobTrackAnalysis cvCreateModuleBlobTrackAnalysisIOR()

cvReleaseBlobTrackerAuto

public static void cvReleaseBlobTrackerAuto(PointerPointer ppT)

cvReleaseBlobTrackerAuto

public static void cvReleaseBlobTrackerAuto(opencv_legacy.CvBlobTrackerAuto ppT)

cvCreateBlobTrackerAuto1

public static opencv_legacy.CvBlobTrackerAuto cvCreateBlobTrackerAuto1(opencv_legacy.CvBlobTrackerAutoParam1 param)

cvCreateBlobTrackerAuto1

public static opencv_legacy.CvBlobTrackerAuto cvCreateBlobTrackerAuto1()

cvCreateBlobTrackerAuto

public static opencv_legacy.CvBlobTrackerAuto cvCreateBlobTrackerAuto(int type,
                                                      Pointer param)

cvReleaseProb

public static void cvReleaseProb(PointerPointer ppProb)

cvReleaseProb

public static void cvReleaseProb(opencv_legacy.CvProb ppProb)

cvCreateTestSeq

public static opencv_legacy.CvTestSeq cvCreateTestSeq(BytePointer pConfigfile,
                                      PointerPointer videos,
                                      int numvideo,
                                      float Scale,
                                      int noise_type,
                                      double noise_ampl)

cvCreateTestSeq

public static opencv_legacy.CvTestSeq cvCreateTestSeq(BytePointer pConfigfile,
                                      BytePointer videos,
                                      int numvideo)

cvCreateTestSeq

public static opencv_legacy.CvTestSeq cvCreateTestSeq(BytePointer pConfigfile,
                                      BytePointer videos,
                                      int numvideo,
                                      float Scale,
                                      int noise_type,
                                      double noise_ampl)

cvCreateTestSeq

public static opencv_legacy.CvTestSeq cvCreateTestSeq(ByteBuffer pConfigfile,
                                      ByteBuffer videos,
                                      int numvideo,
                                      float Scale,
                                      int noise_type,
                                      double noise_ampl)

cvCreateTestSeq

public static opencv_legacy.CvTestSeq cvCreateTestSeq(ByteBuffer pConfigfile,
                                      ByteBuffer videos,
                                      int numvideo)

cvCreateTestSeq

public static opencv_legacy.CvTestSeq cvCreateTestSeq(byte[] pConfigfile,
                                      byte[] videos,
                                      int numvideo,
                                      float Scale,
                                      int noise_type,
                                      double noise_ampl)

cvCreateTestSeq

public static opencv_legacy.CvTestSeq cvCreateTestSeq(byte[] pConfigfile,
                                      byte[] videos,
                                      int numvideo)

cvReleaseTestSeq

public static void cvReleaseTestSeq(PointerPointer ppTestSeq)

cvReleaseTestSeq

public static void cvReleaseTestSeq(opencv_legacy.CvTestSeq ppTestSeq)

cvTestSeqQueryFrame

public static opencv_core.IplImage cvTestSeqQueryFrame(opencv_legacy.CvTestSeq pTestSeq)

cvTestSeqGetFGMask

public static opencv_core.IplImage cvTestSeqGetFGMask(opencv_legacy.CvTestSeq pTestSeq)

cvTestSeqGetImage

public static opencv_core.IplImage cvTestSeqGetImage(opencv_legacy.CvTestSeq pTestSeq)

cvTestSeqGetImageSize

public static opencv_core.CvSize cvTestSeqGetImageSize(opencv_legacy.CvTestSeq pTestSeq)

cvTestSeqFrameNum

public static int cvTestSeqFrameNum(opencv_legacy.CvTestSeq pTestSeq)

cvTestSeqGetObjectNum

public static int cvTestSeqGetObjectNum(opencv_legacy.CvTestSeq pTestSeq)

cvTestSeqGetObjectPos

public static int cvTestSeqGetObjectPos(opencv_legacy.CvTestSeq pTestSeq,
                        int ObjIndex,
                        opencv_core.CvPoint2D32f pPos)

cvTestSeqGetObjectPos

public static int cvTestSeqGetObjectPos(opencv_legacy.CvTestSeq pTestSeq,
                        int ObjIndex,
                        FloatBuffer pPos)

cvTestSeqGetObjectPos

public static int cvTestSeqGetObjectPos(opencv_legacy.CvTestSeq pTestSeq,
                        int ObjIndex,
                        float[] pPos)

cvTestSeqGetObjectSize

public static int cvTestSeqGetObjectSize(opencv_legacy.CvTestSeq pTestSeq,
                         int ObjIndex,
                         opencv_core.CvPoint2D32f pSize)

cvTestSeqGetObjectSize

public static int cvTestSeqGetObjectSize(opencv_legacy.CvTestSeq pTestSeq,
                         int ObjIndex,
                         FloatBuffer pSize)

cvTestSeqGetObjectSize

public static int cvTestSeqGetObjectSize(opencv_legacy.CvTestSeq pTestSeq,
                         int ObjIndex,
                         float[] pSize)

cvTestSeqAddNoise

public static void cvTestSeqAddNoise(opencv_legacy.CvTestSeq pTestSeq,
                     int noise_type,
                     double noise_ampl)

cvTestSeqAddNoise

public static void cvTestSeqAddNoise(opencv_legacy.CvTestSeq pTestSeq)

cvTestSeqAddIntensityVariation

public static void cvTestSeqAddIntensityVariation(opencv_legacy.CvTestSeq pTestSeq,
                                  float DI_per_frame,
                                  float MinI,
                                  float MaxI)

cvTestSeqSetFrame

public static void cvTestSeqSetFrame(opencv_legacy.CvTestSeq pTestSeq,
                     int n)

cvCreateImageData

public static void cvCreateImageData(opencv_core.CvArr arg1)

cvReleaseImageData

public static void cvReleaseImageData(opencv_core.CvArr arg1)

cvSetImageData

public static void cvSetImageData(opencv_core.CvArr arg1,
                  Pointer arg2,
                  int arg3)

cvGetImageRawData

public static void cvGetImageRawData(opencv_core.CvArr arg1,
                     PointerPointer arg2,
                     IntPointer arg3,
                     opencv_core.CvSize arg4)

cvGetImageRawData

public static void cvGetImageRawData(opencv_core.CvArr arg1,
                     BytePointer arg2,
                     IntPointer arg3,
                     opencv_core.CvSize arg4)

cvGetImageRawData

public static void cvGetImageRawData(opencv_core.CvArr arg1,
                     ByteBuffer arg2,
                     IntBuffer arg3,
                     opencv_core.CvSize arg4)

cvGetImageRawData

public static void cvGetImageRawData(opencv_core.CvArr arg1,
                     byte[] arg2,
                     int[] arg3,
                     opencv_core.CvSize arg4)

cvmAlloc

public static void cvmAlloc(opencv_core.CvArr arg1)

cvmFree

public static void cvmFree(opencv_core.CvArr arg1)

cvmAllocArray

public static void cvmAllocArray(opencv_core.CvArr arg1)

cvmFreeArray

public static void cvmFreeArray(opencv_core.CvArr arg1)

cvIntegralImage

public static void cvIntegralImage(opencv_core.CvArr arg1,
                   opencv_core.CvArr arg2,
                   opencv_core.CvArr arg3,
                   opencv_core.CvArr arg4)

cvMatchContours

public static double cvMatchContours(Pointer arg1,
                     Pointer arg2,
                     int arg3,
                     double arg4)

cvMatArray

public static opencv_core.CvMat cvMatArray(int rows,
                           int cols,
                           int type,
                           int count,
                           Pointer data)

cvMatArray

public static opencv_core.CvMat cvMatArray(int rows,
                           int cols,
                           int type,
                           int count)

cvUpdateMHIByTime

public static void cvUpdateMHIByTime(opencv_core.CvArr arg1,
                     opencv_core.CvArr arg2,
                     double arg3,
                     double arg4)

cvAccMask

public static void cvAccMask(opencv_core.CvArr arg1,
             opencv_core.CvArr arg2,
             opencv_core.CvArr arg3)

cvSquareAccMask

public static void cvSquareAccMask(opencv_core.CvArr arg1,
                   opencv_core.CvArr arg2,
                   opencv_core.CvArr arg3)

cvMultiplyAccMask

public static void cvMultiplyAccMask(opencv_core.CvArr arg1,
                     opencv_core.CvArr arg2,
                     opencv_core.CvArr arg3,
                     opencv_core.CvArr arg4)

cvRunningAvgMask

public static void cvRunningAvgMask(opencv_core.CvArr imgY,
                    opencv_core.CvArr imgU,
                    opencv_core.CvArr mask,
                    double alpha)

cvSetHistThresh

public static void cvSetHistThresh(opencv_core.CvHistogram arg1,
                   PointerPointer arg2,
                   int arg3)

cvSetHistThresh

public static void cvSetHistThresh(opencv_core.CvHistogram arg1,
                   FloatPointer arg2,
                   int arg3)

cvSetHistThresh

public static void cvSetHistThresh(opencv_core.CvHistogram arg1,
                   FloatBuffer arg2,
                   int arg3)

cvSetHistThresh

public static void cvSetHistThresh(opencv_core.CvHistogram arg1,
                   float[] arg2,
                   int arg3)

cvCalcHistMask

public static void cvCalcHistMask(PointerPointer img,
                  opencv_core.CvArr mask,
                  opencv_core.CvHistogram hist,
                  int doNotClear)

cvCalcHistMask

public static void cvCalcHistMask(opencv_core.IplImage img,
                  opencv_core.CvArr mask,
                  opencv_core.CvHistogram hist,
                  int doNotClear)

cvMean

public static double cvMean(opencv_core.CvArr image,
            opencv_core.CvArr mask)

cvMean

public static double cvMean(opencv_core.CvArr image)

cvSumPixels

public static double cvSumPixels(opencv_core.CvArr image)

cvMean_StdDev

public static void cvMean_StdDev(opencv_core.CvArr image,
                 DoublePointer mean,
                 DoublePointer sdv,
                 opencv_core.CvArr mask)

cvMean_StdDev

public static void cvMean_StdDev(opencv_core.CvArr image,
                 DoublePointer mean,
                 DoublePointer sdv)

cvMean_StdDev

public static void cvMean_StdDev(opencv_core.CvArr image,
                 DoubleBuffer mean,
                 DoubleBuffer sdv,
                 opencv_core.CvArr mask)

cvMean_StdDev

public static void cvMean_StdDev(opencv_core.CvArr image,
                 DoubleBuffer mean,
                 DoubleBuffer sdv)

cvMean_StdDev

public static void cvMean_StdDev(opencv_core.CvArr image,
                 double[] mean,
                 double[] sdv,
                 opencv_core.CvArr mask)

cvMean_StdDev

public static void cvMean_StdDev(opencv_core.CvArr image,
                 double[] mean,
                 double[] sdv)

cvmPerspectiveProject

public static void cvmPerspectiveProject(opencv_core.CvMat mat,
                         opencv_core.CvArr src,
                         opencv_core.CvArr dst)

cvFillImage

public static void cvFillImage(opencv_core.CvArr mat,
               double color)

cvCvtPixToPlane

public static void cvCvtPixToPlane(opencv_core.CvArr arg1,
                   opencv_core.CvArr arg2,
                   opencv_core.CvArr arg3,
                   opencv_core.CvArr arg4,
                   opencv_core.CvArr arg5)

cvCvtPlaneToPix

public static void cvCvtPlaneToPix(opencv_core.CvArr arg1,
                   opencv_core.CvArr arg2,
                   opencv_core.CvArr arg3,
                   opencv_core.CvArr arg4,
                   opencv_core.CvArr arg5)

cvRandSetRange

public static void cvRandSetRange(opencv_legacy.CvRandState state,
                  double param1,
                  double param2,
                  int index)

cvRandSetRange

public static void cvRandSetRange(opencv_legacy.CvRandState state,
                  double param1,
                  double param2)

cvRandInit

public static void cvRandInit(opencv_legacy.CvRandState state,
              double param1,
              double param2,
              int seed,
              int disttype)

cvRandInit

public static void cvRandInit(opencv_legacy.CvRandState state,
              double param1,
              double param2,
              int seed)

cvRand

public static void cvRand(opencv_legacy.CvRandState state,
          opencv_core.CvArr arr)

cvbRand

public static void cvbRand(opencv_legacy.CvRandState state,
           FloatPointer dst,
           int len)

cvbRand

public static void cvbRand(opencv_legacy.CvRandState state,
           FloatBuffer dst,
           int len)

cvbRand

public static void cvbRand(opencv_legacy.CvRandState state,
           float[] dst,
           int len)

cvbCartToPolar

public static void cvbCartToPolar(FloatPointer y,
                  FloatPointer x,
                  FloatPointer magnitude,
                  FloatPointer angle,
                  int len)

cvbCartToPolar

public static void cvbCartToPolar(FloatBuffer y,
                  FloatBuffer x,
                  FloatBuffer magnitude,
                  FloatBuffer angle,
                  int len)

cvbCartToPolar

public static void cvbCartToPolar(float[] y,
                  float[] x,
                  float[] magnitude,
                  float[] angle,
                  int len)

cvbFastArctan

public static void cvbFastArctan(FloatPointer y,
                 FloatPointer x,
                 FloatPointer angle,
                 int len)

cvbFastArctan

public static void cvbFastArctan(FloatBuffer y,
                 FloatBuffer x,
                 FloatBuffer angle,
                 int len)

cvbFastArctan

public static void cvbFastArctan(float[] y,
                 float[] x,
                 float[] angle,
                 int len)

cvbSqrt

public static void cvbSqrt(FloatPointer x,
           FloatPointer y,
           int len)

cvbSqrt

public static void cvbSqrt(FloatBuffer x,
           FloatBuffer y,
           int len)

cvbSqrt

public static void cvbSqrt(float[] x,
           float[] y,
           int len)

cvbInvSqrt

public static void cvbInvSqrt(FloatPointer x,
              FloatPointer y,
              int len)

cvbInvSqrt

public static void cvbInvSqrt(FloatBuffer x,
              FloatBuffer y,
              int len)

cvbInvSqrt

public static void cvbInvSqrt(float[] x,
              float[] y,
              int len)

cvbReciprocal

public static void cvbReciprocal(FloatPointer x,
                 FloatPointer y,
                 int len)

cvbReciprocal

public static void cvbReciprocal(FloatBuffer x,
                 FloatBuffer y,
                 int len)

cvbReciprocal

public static void cvbReciprocal(float[] x,
                 float[] y,
                 int len)

cvbFastExp

public static void cvbFastExp(FloatPointer x,
              DoublePointer y,
              int len)

cvbFastExp

public static void cvbFastExp(FloatBuffer x,
              DoubleBuffer y,
              int len)

cvbFastExp

public static void cvbFastExp(float[] x,
              double[] y,
              int len)

cvbFastLog

public static void cvbFastLog(DoublePointer x,
              FloatPointer y,
              int len)

cvbFastLog

public static void cvbFastLog(DoubleBuffer x,
              FloatBuffer y,
              int len)

cvbFastLog

public static void cvbFastLog(double[] x,
              float[] y,
              int len)

cvContourBoundingRect

public static opencv_core.CvRect cvContourBoundingRect(Pointer point_set,
                                       int update)

cvContourBoundingRect

public static opencv_core.CvRect cvContourBoundingRect(Pointer point_set)

cvPseudoInverse

public static double cvPseudoInverse(opencv_core.CvArr src,
                     opencv_core.CvArr dst)

cvPseudoInv

public static double cvPseudoInv(opencv_core.CvArr arg1,
                 opencv_core.CvArr arg2)

cvContourMoments

public static void cvContourMoments(opencv_core.CvArr contour,
                    opencv_imgproc.CvMoments moments)

cvGetPtrAt

public static Pointer cvGetPtrAt(opencv_core.CvArr arg1,
                 int arg2,
                 int arg3)

cvGetAt

public static opencv_core.CvScalar cvGetAt(opencv_core.CvArr arg1,
                           int arg2,
                           int arg3)

cvSetAt

public static void cvSetAt(opencv_core.CvArr arr,
           opencv_core.CvScalar val,
           int y,
           int x)

cvMeanMask

public static double cvMeanMask(opencv_core.CvArr arg1,
                opencv_core.CvArr arg2)

cvMean_StdDevMask

public static void cvMean_StdDevMask(opencv_core.CvArr img,
                     opencv_core.CvArr mask,
                     DoublePointer mean,
                     DoublePointer sdv)

cvMean_StdDevMask

public static void cvMean_StdDevMask(opencv_core.CvArr img,
                     opencv_core.CvArr mask,
                     DoubleBuffer mean,
                     DoubleBuffer sdv)

cvMean_StdDevMask

public static void cvMean_StdDevMask(opencv_core.CvArr img,
                     opencv_core.CvArr mask,
                     double[] mean,
                     double[] sdv)

cvNormMask

public static double cvNormMask(opencv_core.CvArr imgA,
                opencv_core.CvArr imgB,
                opencv_core.CvArr mask,
                int normType)

cvRemoveMemoryManager

public static void cvRemoveMemoryManager(opencv_core.CvAllocFunc arg1,
                         opencv_core.CvFreeFunc arg2,
                         Pointer arg3)

cvCopyImage

public static void cvCopyImage(opencv_core.CvArr src,
               opencv_core.CvArr dst)

cvReleaseMatHeader

public static void cvReleaseMatHeader(PointerPointer arg1)

cvReleaseMatHeader

public static void cvReleaseMatHeader(opencv_core.CvMat arg1)

cvConvexHull

public static void cvConvexHull(opencv_core.CvPoint points,
                int num_points,
                opencv_core.CvRect bound_rect,
                int orientation,
                IntPointer hull,
                IntPointer hullsize)

cvConvexHull

public static void cvConvexHull(IntBuffer points,
                int num_points,
                opencv_core.CvRect bound_rect,
                int orientation,
                IntBuffer hull,
                IntBuffer hullsize)

cvConvexHull

public static void cvConvexHull(int[] points,
                int num_points,
                opencv_core.CvRect bound_rect,
                int orientation,
                int[] hull,
                int[] hullsize)

cvMinAreaRect

public static void cvMinAreaRect(opencv_core.CvPoint points,
                 int n,
                 int left,
                 int bottom,
                 int right,
                 int top,
                 opencv_core.CvPoint2D32f anchor,
                 opencv_core.CvPoint2D32f vect1,
                 opencv_core.CvPoint2D32f vect2)

cvMinAreaRect

public static void cvMinAreaRect(IntBuffer points,
                 int n,
                 int left,
                 int bottom,
                 int right,
                 int top,
                 FloatBuffer anchor,
                 FloatBuffer vect1,
                 FloatBuffer vect2)

cvMinAreaRect

public static void cvMinAreaRect(int[] points,
                 int n,
                 int left,
                 int bottom,
                 int right,
                 int top,
                 float[] anchor,
                 float[] vect1,
                 float[] vect2)

cvFitLine3D

public static void cvFitLine3D(opencv_core.CvPoint3D32f points,
               int count,
               int dist,
               Pointer param,
               float reps,
               float aeps,
               FloatPointer line)

cvFitLine3D

public static void cvFitLine3D(FloatBuffer points,
               int count,
               int dist,
               Pointer param,
               float reps,
               float aeps,
               FloatBuffer line)

cvFitLine3D

public static void cvFitLine3D(float[] points,
               int count,
               int dist,
               Pointer param,
               float reps,
               float aeps,
               float[] line)

cvFitLine2D

public static void cvFitLine2D(opencv_core.CvPoint2D32f points,
               int count,
               int dist,
               Pointer param,
               float reps,
               float aeps,
               FloatPointer line)

cvFitLine2D

public static void cvFitLine2D(FloatBuffer points,
               int count,
               int dist,
               Pointer param,
               float reps,
               float aeps,
               FloatBuffer line)

cvFitLine2D

public static void cvFitLine2D(float[] points,
               int count,
               int dist,
               Pointer param,
               float reps,
               float aeps,
               float[] line)

cvFitEllipse

public static void cvFitEllipse(opencv_core.CvPoint2D32f points,
                int count,
                opencv_core.CvBox2D box)

cvFitEllipse

public static void cvFitEllipse(FloatBuffer points,
                int count,
                opencv_core.CvBox2D box)

cvFitEllipse

public static void cvFitEllipse(float[] points,
                int count,
                opencv_core.CvBox2D box)

cvProject3D

public static void cvProject3D(opencv_core.CvPoint3D32f points3D,
               int count,
               opencv_core.CvPoint2D32f points2D,
               int xIndx,
               int yIndx)

cvProject3D

public static void cvProject3D(opencv_core.CvPoint3D32f points3D,
               int count,
               opencv_core.CvPoint2D32f points2D)

cvProject3D

public static void cvProject3D(FloatBuffer points3D,
               int count,
               FloatBuffer points2D,
               int xIndx,
               int yIndx)

cvProject3D

public static void cvProject3D(FloatBuffer points3D,
               int count,
               FloatBuffer points2D)

cvProject3D

public static void cvProject3D(float[] points3D,
               int count,
               float[] points2D,
               int xIndx,
               int yIndx)

cvProject3D

public static void cvProject3D(float[] points3D,
               int count,
               float[] points2D)

cvQueryHistValue_1D

public static float cvQueryHistValue_1D(opencv_core.CvHistogram hist,
                        int idx0)

cvQueryHistValue_2D

public static float cvQueryHistValue_2D(opencv_core.CvHistogram hist,
                        int idx0,
                        int idx1)

cvQueryHistValue_3D

public static float cvQueryHistValue_3D(opencv_core.CvHistogram hist,
                        int idx0,
                        int idx1,
                        int idx2)

cvQueryHistValue_nD

public static float cvQueryHistValue_nD(opencv_core.CvHistogram hist,
                        IntPointer idx)

cvQueryHistValue_nD

public static float cvQueryHistValue_nD(opencv_core.CvHistogram hist,
                        IntBuffer idx)

cvQueryHistValue_nD

public static float cvQueryHistValue_nD(opencv_core.CvHistogram hist,
                        int[] idx)

cvGetHistValue_1D

public static Pointer cvGetHistValue_1D(opencv_core.CvHistogram hist,
                        int idx0)

cvGetHistValue_2D

public static Pointer cvGetHistValue_2D(opencv_core.CvHistogram hist,
                        int idx0,
                        int idx1)

cvGetHistValue_3D

public static Pointer cvGetHistValue_3D(opencv_core.CvHistogram hist,
                        int idx0,
                        int idx1,
                        int idx2)

cvGetHistValue_nD

public static Pointer cvGetHistValue_nD(opencv_core.CvHistogram hist,
                        IntPointer idx)

cvGetHistValue_nD

public static Pointer cvGetHistValue_nD(opencv_core.CvHistogram hist,
                        IntBuffer idx)

cvGetHistValue_nD

public static Pointer cvGetHistValue_nD(opencv_core.CvHistogram hist,
                        int[] idx)

CV_IS_SET_ELEM_EXISTS

public static boolean CV_IS_SET_ELEM_EXISTS(opencv_core.CvSetElem arg1)

cvHoughLines

public static int cvHoughLines(opencv_core.CvArr image,
               double rho,
               double theta,
               int threshold,
               FloatPointer lines,
               int linesNumber)

cvHoughLines

public static int cvHoughLines(opencv_core.CvArr image,
               double rho,
               double theta,
               int threshold,
               FloatBuffer lines,
               int linesNumber)

cvHoughLines

public static int cvHoughLines(opencv_core.CvArr image,
               double rho,
               double theta,
               int threshold,
               float[] lines,
               int linesNumber)

cvHoughLinesP

public static int cvHoughLinesP(opencv_core.CvArr image,
                double rho,
                double theta,
                int threshold,
                int lineLength,
                int lineGap,
                IntPointer lines,
                int linesNumber)

cvHoughLinesP

public static int cvHoughLinesP(opencv_core.CvArr image,
                double rho,
                double theta,
                int threshold,
                int lineLength,
                int lineGap,
                IntBuffer lines,
                int linesNumber)

cvHoughLinesP

public static int cvHoughLinesP(opencv_core.CvArr image,
                double rho,
                double theta,
                int threshold,
                int lineLength,
                int lineGap,
                int[] lines,
                int linesNumber)

cvHoughLinesSDiv

public static int cvHoughLinesSDiv(opencv_core.CvArr image,
                   double rho,
                   int srn,
                   double theta,
                   int stn,
                   int threshold,
                   FloatPointer lines,
                   int linesNumber)

cvHoughLinesSDiv

public static int cvHoughLinesSDiv(opencv_core.CvArr image,
                   double rho,
                   int srn,
                   double theta,
                   int stn,
                   int threshold,
                   FloatBuffer lines,
                   int linesNumber)

cvHoughLinesSDiv

public static int cvHoughLinesSDiv(opencv_core.CvArr image,
                   double rho,
                   int srn,
                   double theta,
                   int stn,
                   int threshold,
                   float[] lines,
                   int linesNumber)

cvCalcEMD

public static float cvCalcEMD(FloatPointer signature1,
              int size1,
              FloatPointer signature2,
              int size2,
              int dims,
              int dist_type,
              opencv_imgproc.CvDistanceFunction dist_func,
              FloatPointer lower_bound,
              Pointer user_param)

cvCalcEMD

public static float cvCalcEMD(FloatPointer signature1,
              int size1,
              FloatPointer signature2,
              int size2,
              int dims)

cvCalcEMD

public static float cvCalcEMD(FloatBuffer signature1,
              int size1,
              FloatBuffer signature2,
              int size2,
              int dims,
              int dist_type,
              opencv_imgproc.CvDistanceFunction dist_func,
              FloatBuffer lower_bound,
              Pointer user_param)

cvCalcEMD

public static float cvCalcEMD(FloatBuffer signature1,
              int size1,
              FloatBuffer signature2,
              int size2,
              int dims)

cvCalcEMD

public static float cvCalcEMD(float[] signature1,
              int size1,
              float[] signature2,
              int size2,
              int dims,
              int dist_type,
              opencv_imgproc.CvDistanceFunction dist_func,
              float[] lower_bound,
              Pointer user_param)

cvCalcEMD

public static float cvCalcEMD(float[] signature1,
              int size1,
              float[] signature2,
              int size2,
              int dims)

cvKMeans

public static void cvKMeans(int num_clusters,
            PointerPointer samples,
            int num_samples,
            int vec_size,
            opencv_core.CvTermCriteria termcrit,
            IntPointer cluster_idx)

cvKMeans

public static void cvKMeans(int num_clusters,
            FloatPointer samples,
            int num_samples,
            int vec_size,
            opencv_core.CvTermCriteria termcrit,
            IntPointer cluster_idx)

cvKMeans

public static void cvKMeans(int num_clusters,
            FloatBuffer samples,
            int num_samples,
            int vec_size,
            opencv_core.CvTermCriteria termcrit,
            IntBuffer cluster_idx)

cvKMeans

public static void cvKMeans(int num_clusters,
            float[] samples,
            int num_samples,
            int vec_size,
            opencv_core.CvTermCriteria termcrit,
            int[] cluster_idx)

cvStartScanGraph

public static void cvStartScanGraph(opencv_core.CvGraph graph,
                    opencv_core.CvGraphScanner scanner,
                    opencv_core.CvGraphVtx vtx,
                    int mask)

cvStartScanGraph

public static void cvStartScanGraph(opencv_core.CvGraph graph,
                    opencv_core.CvGraphScanner scanner)

cvEndScanGraph

public static void cvEndScanGraph(opencv_core.CvGraphScanner scanner)

cvLineAA

public static void cvLineAA(opencv_core.CvArr img,
            opencv_core.CvPoint pt1,
            opencv_core.CvPoint pt2,
            double color,
            int scale)

cvLineAA

public static void cvLineAA(opencv_core.CvArr img,
            opencv_core.CvPoint pt1,
            opencv_core.CvPoint pt2,
            double color)

cvLineAA

public static void cvLineAA(opencv_core.CvArr img,
            IntBuffer pt1,
            IntBuffer pt2,
            double color,
            int scale)

cvLineAA

public static void cvLineAA(opencv_core.CvArr img,
            IntBuffer pt1,
            IntBuffer pt2,
            double color)

cvLineAA

public static void cvLineAA(opencv_core.CvArr img,
            int[] pt1,
            int[] pt2,
            double color,
            int scale)

cvLineAA

public static void cvLineAA(opencv_core.CvArr img,
            int[] pt1,
            int[] pt2,
            double color)

cvCircleAA

public static void cvCircleAA(opencv_core.CvArr img,
              opencv_core.CvPoint center,
              int radius,
              double color,
              int scale)

cvCircleAA

public static void cvCircleAA(opencv_core.CvArr img,
              opencv_core.CvPoint center,
              int radius,
              double color)

cvCircleAA

public static void cvCircleAA(opencv_core.CvArr img,
              IntBuffer center,
              int radius,
              double color,
              int scale)

cvCircleAA

public static void cvCircleAA(opencv_core.CvArr img,
              IntBuffer center,
              int radius,
              double color)

cvCircleAA

public static void cvCircleAA(opencv_core.CvArr img,
              int[] center,
              int radius,
              double color,
              int scale)

cvCircleAA

public static void cvCircleAA(opencv_core.CvArr img,
              int[] center,
              int radius,
              double color)

cvEllipseAA

public static void cvEllipseAA(opencv_core.CvArr img,
               opencv_core.CvPoint center,
               opencv_core.CvSize axes,
               double angle,
               double start_angle,
               double end_angle,
               double color,
               int scale)

cvEllipseAA

public static void cvEllipseAA(opencv_core.CvArr img,
               opencv_core.CvPoint center,
               opencv_core.CvSize axes,
               double angle,
               double start_angle,
               double end_angle,
               double color)

cvEllipseAA

public static void cvEllipseAA(opencv_core.CvArr img,
               IntBuffer center,
               opencv_core.CvSize axes,
               double angle,
               double start_angle,
               double end_angle,
               double color,
               int scale)

cvEllipseAA

public static void cvEllipseAA(opencv_core.CvArr img,
               IntBuffer center,
               opencv_core.CvSize axes,
               double angle,
               double start_angle,
               double end_angle,
               double color)

cvEllipseAA

public static void cvEllipseAA(opencv_core.CvArr img,
               int[] center,
               opencv_core.CvSize axes,
               double angle,
               double start_angle,
               double end_angle,
               double color,
               int scale)

cvEllipseAA

public static void cvEllipseAA(opencv_core.CvArr img,
               int[] center,
               opencv_core.CvSize axes,
               double angle,
               double start_angle,
               double end_angle,
               double color)

cvPolyLineAA

public static void cvPolyLineAA(opencv_core.CvArr img,
                PointerPointer pts,
                IntPointer npts,
                int contours,
                int is_closed,
                double color,
                int scale)

cvPolyLineAA

public static void cvPolyLineAA(opencv_core.CvArr img,
                opencv_core.CvPoint pts,
                IntPointer npts,
                int contours,
                int is_closed,
                double color)

cvPolyLineAA

public static void cvPolyLineAA(opencv_core.CvArr img,
                opencv_core.CvPoint pts,
                IntPointer npts,
                int contours,
                int is_closed,
                double color,
                int scale)

cvPolyLineAA

public static void cvPolyLineAA(opencv_core.CvArr img,
                IntBuffer pts,
                IntBuffer npts,
                int contours,
                int is_closed,
                double color,
                int scale)

cvPolyLineAA

public static void cvPolyLineAA(opencv_core.CvArr img,
                IntBuffer pts,
                IntBuffer npts,
                int contours,
                int is_closed,
                double color)

cvPolyLineAA

public static void cvPolyLineAA(opencv_core.CvArr img,
                int[] pts,
                int[] npts,
                int contours,
                int is_closed,
                double color,
                int scale)

cvPolyLineAA

public static void cvPolyLineAA(opencv_core.CvArr img,
                int[] pts,
                int[] npts,
                int contours,
                int is_closed,
                double color)

cvUnDistortOnce

public static void cvUnDistortOnce(opencv_core.CvArr src,
                   opencv_core.CvArr dst,
                   FloatPointer intrinsic_matrix,
                   FloatPointer distortion_coeffs,
                   int interpolate)

cvUnDistortOnce

public static void cvUnDistortOnce(opencv_core.CvArr src,
                   opencv_core.CvArr dst,
                   FloatBuffer intrinsic_matrix,
                   FloatBuffer distortion_coeffs,
                   int interpolate)

cvUnDistortOnce

public static void cvUnDistortOnce(opencv_core.CvArr src,
                   opencv_core.CvArr dst,
                   float[] intrinsic_matrix,
                   float[] distortion_coeffs,
                   int interpolate)

cvUnDistortInit

public static void cvUnDistortInit(opencv_core.CvArr src,
                   opencv_core.CvArr undistortion_map,
                   FloatPointer A,
                   FloatPointer k,
                   int interpolate)

cvUnDistortInit

public static void cvUnDistortInit(opencv_core.CvArr src,
                   opencv_core.CvArr undistortion_map,
                   FloatBuffer A,
                   FloatBuffer k,
                   int interpolate)

cvUnDistortInit

public static void cvUnDistortInit(opencv_core.CvArr src,
                   opencv_core.CvArr undistortion_map,
                   float[] A,
                   float[] k,
                   int interpolate)

cvUnDistort

public static void cvUnDistort(opencv_core.CvArr src,
               opencv_core.CvArr dst,
               opencv_core.CvArr undistortion_map,
               int interpolate)

cvFindFundamentalMatrix

public static void cvFindFundamentalMatrix(IntPointer points1,
                           IntPointer points2,
                           int numpoints,
                           int method,
                           FloatPointer matrix)

cvFindFundamentalMatrix

public static void cvFindFundamentalMatrix(IntBuffer points1,
                           IntBuffer points2,
                           int numpoints,
                           int method,
                           FloatBuffer matrix)

cvFindFundamentalMatrix

public static void cvFindFundamentalMatrix(int[] points1,
                           int[] points2,
                           int numpoints,
                           int method,
                           float[] matrix)

cvFindChessBoardCornerGuesses

public static int cvFindChessBoardCornerGuesses(Pointer arr,
                                Pointer thresharr,
                                opencv_core.CvMemStorage storage,
                                opencv_core.CvSize pattern_size,
                                opencv_core.CvPoint2D32f corners,
                                IntPointer corner_count)

cvFindChessBoardCornerGuesses

public static int cvFindChessBoardCornerGuesses(Pointer arr,
                                Pointer thresharr,
                                opencv_core.CvMemStorage storage,
                                opencv_core.CvSize pattern_size,
                                FloatBuffer corners,
                                IntBuffer corner_count)

cvFindChessBoardCornerGuesses

public static int cvFindChessBoardCornerGuesses(Pointer arr,
                                Pointer thresharr,
                                opencv_core.CvMemStorage storage,
                                opencv_core.CvSize pattern_size,
                                float[] corners,
                                int[] corner_count)

cvCalibrateCamera

public static void cvCalibrateCamera(int image_count,
                     IntPointer _point_counts,
                     opencv_core.CvSize image_size,
                     opencv_core.CvPoint2D32f _image_points,
                     opencv_core.CvPoint3D32f _object_points,
                     FloatPointer _distortion_coeffs,
                     FloatPointer _camera_matrix,
                     FloatPointer _translation_vectors,
                     FloatPointer _rotation_matrices,
                     int flags)

cvCalibrateCamera

public static void cvCalibrateCamera(int image_count,
                     IntBuffer _point_counts,
                     opencv_core.CvSize image_size,
                     FloatBuffer _image_points,
                     FloatBuffer _object_points,
                     FloatBuffer _distortion_coeffs,
                     FloatBuffer _camera_matrix,
                     FloatBuffer _translation_vectors,
                     FloatBuffer _rotation_matrices,
                     int flags)

cvCalibrateCamera

public static void cvCalibrateCamera(int image_count,
                     int[] _point_counts,
                     opencv_core.CvSize image_size,
                     float[] _image_points,
                     float[] _object_points,
                     float[] _distortion_coeffs,
                     float[] _camera_matrix,
                     float[] _translation_vectors,
                     float[] _rotation_matrices,
                     int flags)

cvCalibrateCamera_64d

public static void cvCalibrateCamera_64d(int image_count,
                         IntPointer _point_counts,
                         opencv_core.CvSize image_size,
                         opencv_core.CvPoint2D64f _image_points,
                         opencv_core.CvPoint3D64f _object_points,
                         DoublePointer _distortion_coeffs,
                         DoublePointer _camera_matrix,
                         DoublePointer _translation_vectors,
                         DoublePointer _rotation_matrices,
                         int flags)

cvCalibrateCamera_64d

public static void cvCalibrateCamera_64d(int image_count,
                         IntBuffer _point_counts,
                         opencv_core.CvSize image_size,
                         DoubleBuffer _image_points,
                         DoubleBuffer _object_points,
                         DoubleBuffer _distortion_coeffs,
                         DoubleBuffer _camera_matrix,
                         DoubleBuffer _translation_vectors,
                         DoubleBuffer _rotation_matrices,
                         int flags)

cvCalibrateCamera_64d

public static void cvCalibrateCamera_64d(int image_count,
                         int[] _point_counts,
                         opencv_core.CvSize image_size,
                         double[] _image_points,
                         double[] _object_points,
                         double[] _distortion_coeffs,
                         double[] _camera_matrix,
                         double[] _translation_vectors,
                         double[] _rotation_matrices,
                         int flags)

cvFindExtrinsicCameraParams

public static void cvFindExtrinsicCameraParams(int point_count,
                               opencv_core.CvSize image_size,
                               opencv_core.CvPoint2D32f _image_points,
                               opencv_core.CvPoint3D32f _object_points,
                               FloatPointer focal_length,
                               opencv_core.CvPoint2D32f principal_point,
                               FloatPointer _distortion_coeffs,
                               FloatPointer _rotation_vector,
                               FloatPointer _translation_vector)

cvFindExtrinsicCameraParams

public static void cvFindExtrinsicCameraParams(int point_count,
                               opencv_core.CvSize image_size,
                               FloatBuffer _image_points,
                               FloatBuffer _object_points,
                               FloatBuffer focal_length,
                               FloatBuffer principal_point,
                               FloatBuffer _distortion_coeffs,
                               FloatBuffer _rotation_vector,
                               FloatBuffer _translation_vector)

cvFindExtrinsicCameraParams

public static void cvFindExtrinsicCameraParams(int point_count,
                               opencv_core.CvSize image_size,
                               float[] _image_points,
                               float[] _object_points,
                               float[] focal_length,
                               float[] principal_point,
                               float[] _distortion_coeffs,
                               float[] _rotation_vector,
                               float[] _translation_vector)

cvFindExtrinsicCameraParams_64d

public static void cvFindExtrinsicCameraParams_64d(int point_count,
                                   opencv_core.CvSize image_size,
                                   opencv_core.CvPoint2D64f _image_points,
                                   opencv_core.CvPoint3D64f _object_points,
                                   DoublePointer focal_length,
                                   opencv_core.CvPoint2D64f principal_point,
                                   DoublePointer _distortion_coeffs,
                                   DoublePointer _rotation_vector,
                                   DoublePointer _translation_vector)

cvFindExtrinsicCameraParams_64d

public static void cvFindExtrinsicCameraParams_64d(int point_count,
                                   opencv_core.CvSize image_size,
                                   DoubleBuffer _image_points,
                                   DoubleBuffer _object_points,
                                   DoubleBuffer focal_length,
                                   DoubleBuffer principal_point,
                                   DoubleBuffer _distortion_coeffs,
                                   DoubleBuffer _rotation_vector,
                                   DoubleBuffer _translation_vector)

cvFindExtrinsicCameraParams_64d

public static void cvFindExtrinsicCameraParams_64d(int point_count,
                                   opencv_core.CvSize image_size,
                                   double[] _image_points,
                                   double[] _object_points,
                                   double[] focal_length,
                                   double[] principal_point,
                                   double[] _distortion_coeffs,
                                   double[] _rotation_vector,
                                   double[] _translation_vector)

cvRodrigues

public static void cvRodrigues(opencv_core.CvMat rotation_matrix,
               opencv_core.CvMat rotation_vector,
               opencv_core.CvMat jacobian,
               int conv_type)

cvProjectPoints

public static void cvProjectPoints(int point_count,
                   opencv_core.CvPoint3D64f _object_points,
                   DoublePointer _rotation_vector,
                   DoublePointer _translation_vector,
                   DoublePointer focal_length,
                   opencv_core.CvPoint2D64f principal_point,
                   DoublePointer _distortion,
                   opencv_core.CvPoint2D64f _image_points,
                   DoublePointer _deriv_points_rotation_matrix,
                   DoublePointer _deriv_points_translation_vect,
                   DoublePointer _deriv_points_focal,
                   DoublePointer _deriv_points_principal_point,
                   DoublePointer _deriv_points_distortion_coeffs)

cvProjectPoints

public static void cvProjectPoints(int point_count,
                   DoubleBuffer _object_points,
                   DoubleBuffer _rotation_vector,
                   DoubleBuffer _translation_vector,
                   DoubleBuffer focal_length,
                   DoubleBuffer principal_point,
                   DoubleBuffer _distortion,
                   DoubleBuffer _image_points,
                   DoubleBuffer _deriv_points_rotation_matrix,
                   DoubleBuffer _deriv_points_translation_vect,
                   DoubleBuffer _deriv_points_focal,
                   DoubleBuffer _deriv_points_principal_point,
                   DoubleBuffer _deriv_points_distortion_coeffs)

cvProjectPoints

public static void cvProjectPoints(int point_count,
                   double[] _object_points,
                   double[] _rotation_vector,
                   double[] _translation_vector,
                   double[] focal_length,
                   double[] principal_point,
                   double[] _distortion,
                   double[] _image_points,
                   double[] _deriv_points_rotation_matrix,
                   double[] _deriv_points_translation_vect,
                   double[] _deriv_points_focal,
                   double[] _deriv_points_principal_point,
                   double[] _deriv_points_distortion_coeffs)

cvProjectPointsSimple

public static void cvProjectPointsSimple(int point_count,
                         opencv_core.CvPoint3D64f _object_points,
                         DoublePointer _rotation_matrix,
                         DoublePointer _translation_vector,
                         DoublePointer _camera_matrix,
                         DoublePointer _distortion,
                         opencv_core.CvPoint2D64f _image_points)

cvProjectPointsSimple

public static void cvProjectPointsSimple(int point_count,
                         DoubleBuffer _object_points,
                         DoubleBuffer _rotation_matrix,
                         DoubleBuffer _translation_vector,
                         DoubleBuffer _camera_matrix,
                         DoubleBuffer _distortion,
                         DoubleBuffer _image_points)

cvProjectPointsSimple

public static void cvProjectPointsSimple(int point_count,
                         double[] _object_points,
                         double[] _rotation_matrix,
                         double[] _translation_vector,
                         double[] _camera_matrix,
                         double[] _distortion,
                         double[] _image_points)

cvMake2DPoints

public static void cvMake2DPoints(opencv_core.CvMat arg1,
                  opencv_core.CvMat arg2)

cvMake3DPoints

public static void cvMake3DPoints(opencv_core.CvMat arg1,
                  opencv_core.CvMat arg2)

cvWarpPerspectiveQMatrix

public static opencv_core.CvMat cvWarpPerspectiveQMatrix(opencv_core.CvPoint2D32f arg1,
                                         opencv_core.CvPoint2D32f arg2,
                                         opencv_core.CvMat arg3)

cvWarpPerspectiveQMatrix

public static opencv_core.CvMat cvWarpPerspectiveQMatrix(FloatBuffer arg1,
                                         FloatBuffer arg2,
                                         opencv_core.CvMat arg3)

cvWarpPerspectiveQMatrix

public static opencv_core.CvMat cvWarpPerspectiveQMatrix(float[] arg1,
                                         float[] arg2,
                                         opencv_core.CvMat arg3)

cvConvertPointsHomogenious

public static void cvConvertPointsHomogenious(opencv_core.CvMat arg1,
                              opencv_core.CvMat arg2)

cvSURFPoint

public static opencv_legacy.CvSURFPoint cvSURFPoint(opencv_core.CvPoint2D32f pt,
                                    int laplacian,
                                    int size,
                                    float dir,
                                    float hessian)

cvSURFPoint

public static opencv_legacy.CvSURFPoint cvSURFPoint(opencv_core.CvPoint2D32f pt,
                                    int laplacian,
                                    int size)

cvSURFPoint

public static opencv_legacy.CvSURFPoint cvSURFPoint(FloatBuffer pt,
                                    int laplacian,
                                    int size,
                                    float dir,
                                    float hessian)

cvSURFPoint

public static opencv_legacy.CvSURFPoint cvSURFPoint(FloatBuffer pt,
                                    int laplacian,
                                    int size)

cvSURFPoint

public static opencv_legacy.CvSURFPoint cvSURFPoint(float[] pt,
                                    int laplacian,
                                    int size,
                                    float dir,
                                    float hessian)

cvSURFPoint

public static opencv_legacy.CvSURFPoint cvSURFPoint(float[] pt,
                                    int laplacian,
                                    int size)

cvSURFParams

public static opencv_legacy.CvSURFParams cvSURFParams(double hessianThreshold,
                                      int extended)

cvSURFParams

public static opencv_legacy.CvSURFParams cvSURFParams(double hessianThreshold)

cvExtractSURF

public static void cvExtractSURF(opencv_core.CvArr img,
                 opencv_core.CvArr mask,
                 PointerPointer keypoints,
                 PointerPointer descriptors,
                 opencv_core.CvMemStorage storage,
                 opencv_legacy.CvSURFParams params,
                 int useProvidedKeyPts)

cvExtractSURF

public static void cvExtractSURF(opencv_core.CvArr img,
                 opencv_core.CvArr mask,
                 opencv_core.CvSeq keypoints,
                 opencv_core.CvSeq descriptors,
                 opencv_core.CvMemStorage storage,
                 opencv_legacy.CvSURFParams params)

cvExtractSURF

public static void cvExtractSURF(opencv_core.CvArr img,
                 opencv_core.CvArr mask,
                 opencv_core.CvSeq keypoints,
                 opencv_core.CvSeq descriptors,
                 opencv_core.CvMemStorage storage,
                 opencv_legacy.CvSURFParams params,
                 int useProvidedKeyPts)

cvStarKeypoint

public static opencv_legacy.CvStarKeypoint cvStarKeypoint(opencv_core.CvPoint pt,
                                          int size,
                                          float response)

cvStarKeypoint

public static opencv_legacy.CvStarKeypoint cvStarKeypoint(IntBuffer pt,
                                          int size,
                                          float response)

cvStarKeypoint

public static opencv_legacy.CvStarKeypoint cvStarKeypoint(int[] pt,
                                          int size,
                                          float response)

cvStarDetectorParams

public static opencv_legacy.CvStarDetectorParams cvStarDetectorParams(int maxSize,
                                                      int responseThreshold,
                                                      int lineThresholdProjected,
                                                      int lineThresholdBinarized,
                                                      int suppressNonmaxSize)

cvStarDetectorParams

public static opencv_legacy.CvStarDetectorParams cvStarDetectorParams()

cvGetStarKeypoints

public static opencv_core.CvSeq cvGetStarKeypoints(opencv_core.CvArr img,
                                   opencv_core.CvMemStorage storage,
                                   opencv_legacy.CvStarDetectorParams params)

cvGetStarKeypoints

public static opencv_core.CvSeq cvGetStarKeypoints(opencv_core.CvArr img,
                                   opencv_core.CvMemStorage storage)

cvSegmentImage

public static opencv_core.CvSeq cvSegmentImage(opencv_core.CvArr srcarr,
                               opencv_core.CvArr dstarr,
                               double canny_threshold,
                               double ffill_threshold,
                               opencv_core.CvMemStorage storage)

cvCalcCovarMatrixEx

public static void cvCalcCovarMatrixEx(int nObjects,
                       Pointer input,
                       int ioFlags,
                       int ioBufSize,
                       BytePointer buffer,
                       Pointer userData,
                       opencv_core.IplImage avg,
                       FloatPointer covarMatrix)

cvCalcCovarMatrixEx

public static void cvCalcCovarMatrixEx(int nObjects,
                       Pointer input,
                       int ioFlags,
                       int ioBufSize,
                       ByteBuffer buffer,
                       Pointer userData,
                       opencv_core.IplImage avg,
                       FloatBuffer covarMatrix)

cvCalcCovarMatrixEx

public static void cvCalcCovarMatrixEx(int nObjects,
                       Pointer input,
                       int ioFlags,
                       int ioBufSize,
                       byte[] buffer,
                       Pointer userData,
                       opencv_core.IplImage avg,
                       float[] covarMatrix)

cvCalcEigenObjects

public static void cvCalcEigenObjects(int nObjects,
                      Pointer input,
                      Pointer output,
                      int ioFlags,
                      int ioBufSize,
                      Pointer userData,
                      opencv_core.CvTermCriteria calcLimit,
                      opencv_core.IplImage avg,
                      FloatPointer eigVals)

cvCalcEigenObjects

public static void cvCalcEigenObjects(int nObjects,
                      Pointer input,
                      Pointer output,
                      int ioFlags,
                      int ioBufSize,
                      Pointer userData,
                      opencv_core.CvTermCriteria calcLimit,
                      opencv_core.IplImage avg,
                      FloatBuffer eigVals)

cvCalcEigenObjects

public static void cvCalcEigenObjects(int nObjects,
                      Pointer input,
                      Pointer output,
                      int ioFlags,
                      int ioBufSize,
                      Pointer userData,
                      opencv_core.CvTermCriteria calcLimit,
                      opencv_core.IplImage avg,
                      float[] eigVals)

cvCalcDecompCoeff

public static double cvCalcDecompCoeff(opencv_core.IplImage obj,
                       opencv_core.IplImage eigObj,
                       opencv_core.IplImage avg)

cvEigenDecomposite

public static void cvEigenDecomposite(opencv_core.IplImage obj,
                      int nEigObjs,
                      Pointer eigInput,
                      int ioFlags,
                      Pointer userData,
                      opencv_core.IplImage avg,
                      FloatPointer coeffs)

cvEigenDecomposite

public static void cvEigenDecomposite(opencv_core.IplImage obj,
                      int nEigObjs,
                      Pointer eigInput,
                      int ioFlags,
                      Pointer userData,
                      opencv_core.IplImage avg,
                      FloatBuffer coeffs)

cvEigenDecomposite

public static void cvEigenDecomposite(opencv_core.IplImage obj,
                      int nEigObjs,
                      Pointer eigInput,
                      int ioFlags,
                      Pointer userData,
                      opencv_core.IplImage avg,
                      float[] coeffs)

cvEigenProjection

public static void cvEigenProjection(Pointer eigInput,
                     int nEigObjs,
                     int ioFlags,
                     Pointer userData,
                     FloatPointer coeffs,
                     opencv_core.IplImage avg,
                     opencv_core.IplImage proj)

cvEigenProjection

public static void cvEigenProjection(Pointer eigInput,
                     int nEigObjs,
                     int ioFlags,
                     Pointer userData,
                     FloatBuffer coeffs,
                     opencv_core.IplImage avg,
                     opencv_core.IplImage proj)

cvEigenProjection

public static void cvEigenProjection(Pointer eigInput,
                     int nEigObjs,
                     int ioFlags,
                     Pointer userData,
                     float[] coeffs,
                     opencv_core.IplImage avg,
                     opencv_core.IplImage proj)

cvCreate2DHMM

public static opencv_legacy.CvEHMM cvCreate2DHMM(IntPointer stateNumber,
                                 IntPointer numMix,
                                 int obsSize)

Embedded HMMs

cvCreate2DHMM

public static opencv_legacy.CvEHMM cvCreate2DHMM(IntBuffer stateNumber,
                                 IntBuffer numMix,
                                 int obsSize)

cvCreate2DHMM

public static opencv_legacy.CvEHMM cvCreate2DHMM(int[] stateNumber,
                                 int[] numMix,
                                 int obsSize)

cvRelease2DHMM

public static void cvRelease2DHMM(PointerPointer hmm)

cvRelease2DHMM

public static void cvRelease2DHMM(opencv_legacy.CvEHMM hmm)

cvCreateObsInfo

public static opencv_legacy.CvImgObsInfo cvCreateObsInfo(opencv_core.CvSize numObs,
                                         int obsSize)

cvReleaseObsInfo

public static void cvReleaseObsInfo(PointerPointer obs_info)

cvReleaseObsInfo

public static void cvReleaseObsInfo(opencv_legacy.CvImgObsInfo obs_info)

cvImgToObs_DCT

public static void cvImgToObs_DCT(opencv_core.CvArr arr,
                  FloatPointer obs,
                  opencv_core.CvSize dctSize,
                  opencv_core.CvSize obsSize,
                  opencv_core.CvSize delta)

cvImgToObs_DCT

public static void cvImgToObs_DCT(opencv_core.CvArr arr,
                  FloatBuffer obs,
                  opencv_core.CvSize dctSize,
                  opencv_core.CvSize obsSize,
                  opencv_core.CvSize delta)

cvImgToObs_DCT

public static void cvImgToObs_DCT(opencv_core.CvArr arr,
                  float[] obs,
                  opencv_core.CvSize dctSize,
                  opencv_core.CvSize obsSize,
                  opencv_core.CvSize delta)

cvUniformImgSegm

public static void cvUniformImgSegm(opencv_legacy.CvImgObsInfo obs_info,
                    opencv_legacy.CvEHMM ehmm)

cvInitMixSegm

public static void cvInitMixSegm(PointerPointer obs_info_array,
                 int num_img,
                 opencv_legacy.CvEHMM hmm)

cvInitMixSegm

public static void cvInitMixSegm(opencv_legacy.CvImgObsInfo obs_info_array,
                 int num_img,
                 opencv_legacy.CvEHMM hmm)

cvEstimateHMMStateParams

public static void cvEstimateHMMStateParams(PointerPointer obs_info_array,
                            int num_img,
                            opencv_legacy.CvEHMM hmm)

cvEstimateHMMStateParams

public static void cvEstimateHMMStateParams(opencv_legacy.CvImgObsInfo obs_info_array,
                            int num_img,
                            opencv_legacy.CvEHMM hmm)

cvEstimateTransProb

public static void cvEstimateTransProb(PointerPointer obs_info_array,
                       int num_img,
                       opencv_legacy.CvEHMM hmm)

cvEstimateTransProb

public static void cvEstimateTransProb(opencv_legacy.CvImgObsInfo obs_info_array,
                       int num_img,
                       opencv_legacy.CvEHMM hmm)

cvEstimateObsProb

public static void cvEstimateObsProb(opencv_legacy.CvImgObsInfo obs_info,
                     opencv_legacy.CvEHMM hmm)

cvEViterbi

public static float cvEViterbi(opencv_legacy.CvImgObsInfo obs_info,
               opencv_legacy.CvEHMM hmm)

cvMixSegmL2

public static void cvMixSegmL2(PointerPointer obs_info_array,
               int num_img,
               opencv_legacy.CvEHMM hmm)

cvMixSegmL2

public static void cvMixSegmL2(opencv_legacy.CvImgObsInfo obs_info_array,
               int num_img,
               opencv_legacy.CvEHMM hmm)

cvCreateHandMask

public static void cvCreateHandMask(opencv_core.CvSeq hand_points,
                    opencv_core.IplImage img_mask,
                    opencv_core.CvRect roi)

\ A few functions from old stereo gesture recognition demosions * \

cvFindHandRegion

public static void cvFindHandRegion(opencv_core.CvPoint3D32f points,
                    int count,
                    opencv_core.CvSeq indexs,
                    FloatPointer line,
                    opencv_core.CvSize2D32f size,
                    int flag,
                    opencv_core.CvPoint3D32f center,
                    opencv_core.CvMemStorage storage,
                    PointerPointer numbers)

cvFindHandRegion

public static void cvFindHandRegion(opencv_core.CvPoint3D32f points,
                    int count,
                    opencv_core.CvSeq indexs,
                    FloatPointer line,
                    opencv_core.CvSize2D32f size,
                    int flag,
                    opencv_core.CvPoint3D32f center,
                    opencv_core.CvMemStorage storage,
                    opencv_core.CvSeq numbers)

cvFindHandRegion

public static void cvFindHandRegion(FloatBuffer points,
                    int count,
                    opencv_core.CvSeq indexs,
                    FloatBuffer line,
                    opencv_core.CvSize2D32f size,
                    int flag,
                    FloatBuffer center,
                    opencv_core.CvMemStorage storage,
                    opencv_core.CvSeq numbers)

cvFindHandRegion

public static void cvFindHandRegion(float[] points,
                    int count,
                    opencv_core.CvSeq indexs,
                    float[] line,
                    opencv_core.CvSize2D32f size,
                    int flag,
                    float[] center,
                    opencv_core.CvMemStorage storage,
                    opencv_core.CvSeq numbers)

cvFindHandRegionA

public static void cvFindHandRegionA(opencv_core.CvPoint3D32f points,
                     int count,
                     opencv_core.CvSeq indexs,
                     FloatPointer line,
                     opencv_core.CvSize2D32f size,
                     int jc,
                     opencv_core.CvPoint3D32f center,
                     opencv_core.CvMemStorage storage,
                     PointerPointer numbers)

cvFindHandRegionA

public static void cvFindHandRegionA(opencv_core.CvPoint3D32f points,
                     int count,
                     opencv_core.CvSeq indexs,
                     FloatPointer line,
                     opencv_core.CvSize2D32f size,
                     int jc,
                     opencv_core.CvPoint3D32f center,
                     opencv_core.CvMemStorage storage,
                     opencv_core.CvSeq numbers)

cvFindHandRegionA

public static void cvFindHandRegionA(FloatBuffer points,
                     int count,
                     opencv_core.CvSeq indexs,
                     FloatBuffer line,
                     opencv_core.CvSize2D32f size,
                     int jc,
                     FloatBuffer center,
                     opencv_core.CvMemStorage storage,
                     opencv_core.CvSeq numbers)

cvFindHandRegionA

public static void cvFindHandRegionA(float[] points,
                     int count,
                     opencv_core.CvSeq indexs,
                     float[] line,
                     opencv_core.CvSize2D32f size,
                     int jc,
                     float[] center,
                     opencv_core.CvMemStorage storage,
                     opencv_core.CvSeq numbers)

cvCalcImageHomography

public static void cvCalcImageHomography(FloatPointer line,
                         opencv_core.CvPoint3D32f center,
                         FloatPointer intrinsic,
                         FloatPointer homography)

cvCalcImageHomography

public static void cvCalcImageHomography(FloatBuffer line,
                         FloatBuffer center,
                         FloatBuffer intrinsic,
                         FloatBuffer homography)

cvCalcImageHomography

public static void cvCalcImageHomography(float[] line,
                         float[] center,
                         float[] intrinsic,
                         float[] homography)

cvCalcPGH

public static void cvCalcPGH(opencv_core.CvSeq contour,
             opencv_core.CvHistogram hist)

cvFindDominantPoints

public static opencv_core.CvSeq cvFindDominantPoints(opencv_core.CvSeq contour,
                                     opencv_core.CvMemStorage storage,
                                     int method,
                                     double parameter1,
                                     double parameter2,
                                     double parameter3,
                                     double parameter4)

cvFindDominantPoints

public static opencv_core.CvSeq cvFindDominantPoints(opencv_core.CvSeq contour,
                                     opencv_core.CvMemStorage storage)

cvFindStereoCorrespondence

public static void cvFindStereoCorrespondence(opencv_core.CvArr leftImage,
                              opencv_core.CvArr rightImage,
                              int mode,
                              opencv_core.CvArr dispImage,
                              int maxDisparity,
                              double param1,
                              double param2,
                              double param3,
                              double param4,
                              double param5)

cvFindStereoCorrespondence

public static void cvFindStereoCorrespondence(opencv_core.CvArr leftImage,
                              opencv_core.CvArr rightImage,
                              int mode,
                              opencv_core.CvArr dispImage,
                              int maxDisparity)

icvConvertWarpCoordinates

public static int icvConvertWarpCoordinates(DoublePointer coeffs,
                            opencv_core.CvPoint2D32f cameraPoint,
                            opencv_core.CvPoint2D32f warpPoint,
                            int direction)

icvConvertWarpCoordinates

public static int icvConvertWarpCoordinates(DoubleBuffer coeffs,
                            FloatBuffer cameraPoint,
                            FloatBuffer warpPoint,
                            int direction)

icvConvertWarpCoordinates

public static int icvConvertWarpCoordinates(double[] coeffs,
                            float[] cameraPoint,
                            float[] warpPoint,
                            int direction)

icvGetSymPoint3D

public static int icvGetSymPoint3D(opencv_core.CvPoint3D64f pointCorner,
                   opencv_core.CvPoint3D64f point1,
                   opencv_core.CvPoint3D64f point2,
                   opencv_core.CvPoint3D64f pointSym2)

icvGetSymPoint3D

public static int icvGetSymPoint3D(DoubleBuffer pointCorner,
                   DoubleBuffer point1,
                   DoubleBuffer point2,
                   DoubleBuffer pointSym2)

icvGetSymPoint3D

public static int icvGetSymPoint3D(double[] pointCorner,
                   double[] point1,
                   double[] point2,
                   double[] pointSym2)

icvGetPieceLength3D

public static void icvGetPieceLength3D(opencv_core.CvPoint3D64f point1,
                       opencv_core.CvPoint3D64f point2,
                       DoublePointer dist)

icvGetPieceLength3D

public static void icvGetPieceLength3D(DoubleBuffer point1,
                       DoubleBuffer point2,
                       DoubleBuffer dist)

icvGetPieceLength3D

public static void icvGetPieceLength3D(double[] point1,
                       double[] point2,
                       double[] dist)

icvCompute3DPoint

public static int icvCompute3DPoint(double alpha,
                    double betta,
                    opencv_legacy.CvStereoLineCoeff coeffs,
                    opencv_core.CvPoint3D64f point)

icvCompute3DPoint

public static int icvCompute3DPoint(double alpha,
                    double betta,
                    opencv_legacy.CvStereoLineCoeff coeffs,
                    DoubleBuffer point)

icvCompute3DPoint

public static int icvCompute3DPoint(double alpha,
                    double betta,
                    opencv_legacy.CvStereoLineCoeff coeffs,
                    double[] point)

icvCreateConvertMatrVect

public static int icvCreateConvertMatrVect(DoublePointer rotMatr1,
                           DoublePointer transVect1,
                           DoublePointer rotMatr2,
                           DoublePointer transVect2,
                           DoublePointer convRotMatr,
                           DoublePointer convTransVect)

icvCreateConvertMatrVect

public static int icvCreateConvertMatrVect(DoubleBuffer rotMatr1,
                           DoubleBuffer transVect1,
                           DoubleBuffer rotMatr2,
                           DoubleBuffer transVect2,
                           DoubleBuffer convRotMatr,
                           DoubleBuffer convTransVect)

icvCreateConvertMatrVect

public static int icvCreateConvertMatrVect(double[] rotMatr1,
                           double[] transVect1,
                           double[] rotMatr2,
                           double[] transVect2,
                           double[] convRotMatr,
                           double[] convTransVect)

icvConvertPointSystem

public static int icvConvertPointSystem(opencv_core.CvPoint3D64f M2,
                        opencv_core.CvPoint3D64f M1,
                        DoublePointer rotMatr,
                        DoublePointer transVect)

icvConvertPointSystem

public static int icvConvertPointSystem(DoubleBuffer M2,
                        DoubleBuffer M1,
                        DoubleBuffer rotMatr,
                        DoubleBuffer transVect)

icvConvertPointSystem

public static int icvConvertPointSystem(double[] M2,
                        double[] M1,
                        double[] rotMatr,
                        double[] transVect)

icvComputeCoeffForStereo

public static int icvComputeCoeffForStereo(opencv_legacy.CvStereoCamera stereoCamera)

icvGetCrossPieceVector

public static int icvGetCrossPieceVector(opencv_core.CvPoint2D32f p1_start,
                         opencv_core.CvPoint2D32f p1_end,
                         opencv_core.CvPoint2D32f v2_start,
                         opencv_core.CvPoint2D32f v2_end,
                         opencv_core.CvPoint2D32f cross)

icvGetCrossPieceVector

public static int icvGetCrossPieceVector(FloatBuffer p1_start,
                         FloatBuffer p1_end,
                         FloatBuffer v2_start,
                         FloatBuffer v2_end,
                         FloatBuffer cross)

icvGetCrossPieceVector

public static int icvGetCrossPieceVector(float[] p1_start,
                         float[] p1_end,
                         float[] v2_start,
                         float[] v2_end,
                         float[] cross)

icvGetCrossLineDirect

public static int icvGetCrossLineDirect(opencv_core.CvPoint2D32f p1,
                        opencv_core.CvPoint2D32f p2,
                        float a,
                        float b,
                        float c,
                        opencv_core.CvPoint2D32f cross)

icvGetCrossLineDirect

public static int icvGetCrossLineDirect(FloatBuffer p1,
                        FloatBuffer p2,
                        float a,
                        float b,
                        float c,
                        FloatBuffer cross)

icvGetCrossLineDirect

public static int icvGetCrossLineDirect(float[] p1,
                        float[] p2,
                        float a,
                        float b,
                        float c,
                        float[] cross)

icvDefinePointPosition

public static float icvDefinePointPosition(opencv_core.CvPoint2D32f point1,
                           opencv_core.CvPoint2D32f point2,
                           opencv_core.CvPoint2D32f point)

icvDefinePointPosition

public static float icvDefinePointPosition(FloatBuffer point1,
                           FloatBuffer point2,
                           FloatBuffer point)

icvDefinePointPosition

public static float icvDefinePointPosition(float[] point1,
                           float[] point2,
                           float[] point)

icvStereoCalibration

public static int icvStereoCalibration(int numImages,
                       IntPointer nums,
                       opencv_core.CvSize imageSize,
                       opencv_core.CvPoint2D32f imagePoints1,
                       opencv_core.CvPoint2D32f imagePoints2,
                       opencv_core.CvPoint3D32f objectPoints,
                       opencv_legacy.CvStereoCamera stereoparams)

icvStereoCalibration

public static int icvStereoCalibration(int numImages,
                       IntBuffer nums,
                       opencv_core.CvSize imageSize,
                       FloatBuffer imagePoints1,
                       FloatBuffer imagePoints2,
                       FloatBuffer objectPoints,
                       opencv_legacy.CvStereoCamera stereoparams)

icvStereoCalibration

public static int icvStereoCalibration(int numImages,
                       int[] nums,
                       opencv_core.CvSize imageSize,
                       float[] imagePoints1,
                       float[] imagePoints2,
                       float[] objectPoints,
                       opencv_legacy.CvStereoCamera stereoparams)

icvComputeRestStereoParams

public static int icvComputeRestStereoParams(opencv_legacy.CvStereoCamera stereoparams)

cvComputePerspectiveMap

public static void cvComputePerspectiveMap(DoublePointer coeffs,
                           opencv_core.CvArr rectMapX,
                           opencv_core.CvArr rectMapY)

cvComputePerspectiveMap

public static void cvComputePerspectiveMap(DoubleBuffer coeffs,
                           opencv_core.CvArr rectMapX,
                           opencv_core.CvArr rectMapY)

cvComputePerspectiveMap

public static void cvComputePerspectiveMap(double[] coeffs,
                           opencv_core.CvArr rectMapX,
                           opencv_core.CvArr rectMapY)

icvComCoeffForLine

public static int icvComCoeffForLine(opencv_core.CvPoint2D64f point1,
                     opencv_core.CvPoint2D64f point2,
                     opencv_core.CvPoint2D64f point3,
                     opencv_core.CvPoint2D64f point4,
                     DoublePointer camMatr1,
                     DoublePointer rotMatr1,
                     DoublePointer transVect1,
                     DoublePointer camMatr2,
                     DoublePointer rotMatr2,
                     DoublePointer transVect2,
                     opencv_legacy.CvStereoLineCoeff coeffs,
                     IntPointer needSwapCameras)

icvComCoeffForLine

public static int icvComCoeffForLine(DoubleBuffer point1,
                     DoubleBuffer point2,
                     DoubleBuffer point3,
                     DoubleBuffer point4,
                     DoubleBuffer camMatr1,
                     DoubleBuffer rotMatr1,
                     DoubleBuffer transVect1,
                     DoubleBuffer camMatr2,
                     DoubleBuffer rotMatr2,
                     DoubleBuffer transVect2,
                     opencv_legacy.CvStereoLineCoeff coeffs,
                     IntBuffer needSwapCameras)

icvComCoeffForLine

public static int icvComCoeffForLine(double[] point1,
                     double[] point2,
                     double[] point3,
                     double[] point4,
                     double[] camMatr1,
                     double[] rotMatr1,
                     double[] transVect1,
                     double[] camMatr2,
                     double[] rotMatr2,
                     double[] transVect2,
                     opencv_legacy.CvStereoLineCoeff coeffs,
                     int[] needSwapCameras)

icvGetDirectionForPoint

public static int icvGetDirectionForPoint(opencv_core.CvPoint2D64f point,
                          DoublePointer camMatr,
                          opencv_core.CvPoint3D64f direct)

icvGetDirectionForPoint

public static int icvGetDirectionForPoint(DoubleBuffer point,
                          DoubleBuffer camMatr,
                          DoubleBuffer direct)

icvGetDirectionForPoint

public static int icvGetDirectionForPoint(double[] point,
                          double[] camMatr,
                          double[] direct)

icvGetCrossLines

public static int icvGetCrossLines(opencv_core.CvPoint3D64f point11,
                   opencv_core.CvPoint3D64f point12,
                   opencv_core.CvPoint3D64f point21,
                   opencv_core.CvPoint3D64f point22,
                   opencv_core.CvPoint3D64f midPoint)

icvGetCrossLines

public static int icvGetCrossLines(DoubleBuffer point11,
                   DoubleBuffer point12,
                   DoubleBuffer point21,
                   DoubleBuffer point22,
                   DoubleBuffer midPoint)

icvGetCrossLines

public static int icvGetCrossLines(double[] point11,
                   double[] point12,
                   double[] point21,
                   double[] point22,
                   double[] midPoint)

icvComputeStereoLineCoeffs

public static int icvComputeStereoLineCoeffs(opencv_core.CvPoint3D64f pointA,
                             opencv_core.CvPoint3D64f pointB,
                             opencv_core.CvPoint3D64f pointCam1,
                             double gamma,
                             opencv_legacy.CvStereoLineCoeff coeffs)

icvComputeStereoLineCoeffs

public static int icvComputeStereoLineCoeffs(DoubleBuffer pointA,
                             DoubleBuffer pointB,
                             DoubleBuffer pointCam1,
                             double gamma,
                             opencv_legacy.CvStereoLineCoeff coeffs)

icvComputeStereoLineCoeffs

public static int icvComputeStereoLineCoeffs(double[] pointA,
                             double[] pointB,
                             double[] pointCam1,
                             double gamma,
                             opencv_legacy.CvStereoLineCoeff coeffs)

icvGetAngleLine

public static int icvGetAngleLine(opencv_core.CvPoint2D64f startPoint,
                  opencv_core.CvSize imageSize,
                  opencv_core.CvPoint2D64f point1,
                  opencv_core.CvPoint2D64f point2)

icvGetAngleLine

public static int icvGetAngleLine(DoubleBuffer startPoint,
                  opencv_core.CvSize imageSize,
                  DoubleBuffer point1,
                  DoubleBuffer point2)

icvGetAngleLine

public static int icvGetAngleLine(double[] startPoint,
                  opencv_core.CvSize imageSize,
                  double[] point1,
                  double[] point2)

icvGetCoefForPiece

public static void icvGetCoefForPiece(opencv_core.CvPoint2D64f p_start,
                      opencv_core.CvPoint2D64f p_end,
                      DoublePointer a,
                      DoublePointer b,
                      DoublePointer c,
                      IntPointer result)

icvGetCoefForPiece

public static void icvGetCoefForPiece(DoubleBuffer p_start,
                      DoubleBuffer p_end,
                      DoubleBuffer a,
                      DoubleBuffer b,
                      DoubleBuffer c,
                      IntBuffer result)

icvGetCoefForPiece

public static void icvGetCoefForPiece(double[] p_start,
                      double[] p_end,
                      double[] a,
                      double[] b,
                      double[] c,
                      int[] result)

icvComputeeInfiniteProject1

public static void icvComputeeInfiniteProject1(DoublePointer rotMatr,
                               DoublePointer camMatr1,
                               DoublePointer camMatr2,
                               opencv_core.CvPoint2D32f point1,
                               opencv_core.CvPoint2D32f point2)

icvComputeeInfiniteProject1

public static void icvComputeeInfiniteProject1(DoubleBuffer rotMatr,
                               DoubleBuffer camMatr1,
                               DoubleBuffer camMatr2,
                               FloatBuffer point1,
                               FloatBuffer point2)

icvComputeeInfiniteProject1

public static void icvComputeeInfiniteProject1(double[] rotMatr,
                               double[] camMatr1,
                               double[] camMatr2,
                               float[] point1,
                               float[] point2)

icvComputeeInfiniteProject2

public static void icvComputeeInfiniteProject2(DoublePointer rotMatr,
                               DoublePointer camMatr1,
                               DoublePointer camMatr2,
                               opencv_core.CvPoint2D32f point1,
                               opencv_core.CvPoint2D32f point2)

icvComputeeInfiniteProject2

public static void icvComputeeInfiniteProject2(DoubleBuffer rotMatr,
                               DoubleBuffer camMatr1,
                               DoubleBuffer camMatr2,
                               FloatBuffer point1,
                               FloatBuffer point2)

icvComputeeInfiniteProject2

public static void icvComputeeInfiniteProject2(double[] rotMatr,
                               double[] camMatr1,
                               double[] camMatr2,
                               float[] point1,
                               float[] point2)

icvGetCrossDirectDirect

public static void icvGetCrossDirectDirect(DoublePointer direct1,
                           DoublePointer direct2,
                           opencv_core.CvPoint2D64f cross,
                           IntPointer result)

icvGetCrossDirectDirect

public static void icvGetCrossDirectDirect(DoubleBuffer direct1,
                           DoubleBuffer direct2,
                           DoubleBuffer cross,
                           IntBuffer result)

icvGetCrossDirectDirect

public static void icvGetCrossDirectDirect(double[] direct1,
                           double[] direct2,
                           double[] cross,
                           int[] result)

icvGetCrossPieceDirect

public static void icvGetCrossPieceDirect(opencv_core.CvPoint2D64f p_start,
                          opencv_core.CvPoint2D64f p_end,
                          double a,
                          double b,
                          double c,
                          opencv_core.CvPoint2D64f cross,
                          IntPointer result)

icvGetCrossPieceDirect

public static void icvGetCrossPieceDirect(DoubleBuffer p_start,
                          DoubleBuffer p_end,
                          double a,
                          double b,
                          double c,
                          DoubleBuffer cross,
                          IntBuffer result)

icvGetCrossPieceDirect

public static void icvGetCrossPieceDirect(double[] p_start,
                          double[] p_end,
                          double a,
                          double b,
                          double c,
                          double[] cross,
                          int[] result)

icvGetCrossPiecePiece

public static void icvGetCrossPiecePiece(opencv_core.CvPoint2D64f p1_start,
                         opencv_core.CvPoint2D64f p1_end,
                         opencv_core.CvPoint2D64f p2_start,
                         opencv_core.CvPoint2D64f p2_end,
                         opencv_core.CvPoint2D64f cross,
                         IntPointer result)

icvGetCrossPiecePiece

public static void icvGetCrossPiecePiece(DoubleBuffer p1_start,
                         DoubleBuffer p1_end,
                         DoubleBuffer p2_start,
                         DoubleBuffer p2_end,
                         DoubleBuffer cross,
                         IntBuffer result)

icvGetCrossPiecePiece

public static void icvGetCrossPiecePiece(double[] p1_start,
                         double[] p1_end,
                         double[] p2_start,
                         double[] p2_end,
                         double[] cross,
                         int[] result)

icvGetPieceLength

public static void icvGetPieceLength(opencv_core.CvPoint2D64f point1,
                     opencv_core.CvPoint2D64f point2,
                     DoublePointer dist)

icvGetPieceLength

public static void icvGetPieceLength(DoubleBuffer point1,
                     DoubleBuffer point2,
                     DoubleBuffer dist)

icvGetPieceLength

public static void icvGetPieceLength(double[] point1,
                     double[] point2,
                     double[] dist)

icvGetCrossRectDirect

public static void icvGetCrossRectDirect(opencv_core.CvSize imageSize,
                         double a,
                         double b,
                         double c,
                         opencv_core.CvPoint2D64f start,
                         opencv_core.CvPoint2D64f end,
                         IntPointer result)

icvGetCrossRectDirect

public static void icvGetCrossRectDirect(opencv_core.CvSize imageSize,
                         double a,
                         double b,
                         double c,
                         DoubleBuffer start,
                         DoubleBuffer end,
                         IntBuffer result)

icvGetCrossRectDirect

public static void icvGetCrossRectDirect(opencv_core.CvSize imageSize,
                         double a,
                         double b,
                         double c,
                         double[] start,
                         double[] end,
                         int[] result)

icvProjectPointToImage

public static void icvProjectPointToImage(opencv_core.CvPoint3D64f point,
                          DoublePointer camMatr,
                          DoublePointer rotMatr,
                          DoublePointer transVect,
                          opencv_core.CvPoint2D64f projPoint)

icvProjectPointToImage

public static void icvProjectPointToImage(DoubleBuffer point,
                          DoubleBuffer camMatr,
                          DoubleBuffer rotMatr,
                          DoubleBuffer transVect,
                          DoubleBuffer projPoint)

icvProjectPointToImage

public static void icvProjectPointToImage(double[] point,
                          double[] camMatr,
                          double[] rotMatr,
                          double[] transVect,
                          double[] projPoint)

icvGetQuadsTransform

public static void icvGetQuadsTransform(opencv_core.CvSize imageSize,
                        DoublePointer camMatr1,
                        DoublePointer rotMatr1,
                        DoublePointer transVect1,
                        DoublePointer camMatr2,
                        DoublePointer rotMatr2,
                        DoublePointer transVect2,
                        opencv_core.CvSize warpSize,
                        DoublePointer quad1,
                        DoublePointer quad2,
                        DoublePointer fundMatr,
                        opencv_core.CvPoint3D64f epipole1,
                        opencv_core.CvPoint3D64f epipole2)

icvGetQuadsTransform

public static void icvGetQuadsTransform(opencv_core.CvSize imageSize,
                        DoubleBuffer camMatr1,
                        DoubleBuffer rotMatr1,
                        DoubleBuffer transVect1,
                        DoubleBuffer camMatr2,
                        DoubleBuffer rotMatr2,
                        DoubleBuffer transVect2,
                        opencv_core.CvSize warpSize,
                        DoubleBuffer quad1,
                        DoubleBuffer quad2,
                        DoubleBuffer fundMatr,
                        DoubleBuffer epipole1,
                        DoubleBuffer epipole2)

icvGetQuadsTransform

public static void icvGetQuadsTransform(opencv_core.CvSize imageSize,
                        double[] camMatr1,
                        double[] rotMatr1,
                        double[] transVect1,
                        double[] camMatr2,
                        double[] rotMatr2,
                        double[] transVect2,
                        opencv_core.CvSize warpSize,
                        double[] quad1,
                        double[] quad2,
                        double[] fundMatr,
                        double[] epipole1,
                        double[] epipole2)

icvGetQuadsTransformStruct

public static void icvGetQuadsTransformStruct(opencv_legacy.CvStereoCamera stereoCamera)

icvComputeStereoParamsForCameras

public static void icvComputeStereoParamsForCameras(opencv_legacy.CvStereoCamera stereoCamera)

icvGetCutPiece

public static void icvGetCutPiece(DoublePointer areaLineCoef1,
                  DoublePointer areaLineCoef2,
                  opencv_core.CvPoint2D64f epipole,
                  opencv_core.CvSize imageSize,
                  opencv_core.CvPoint2D64f point11,
                  opencv_core.CvPoint2D64f point12,
                  opencv_core.CvPoint2D64f point21,
                  opencv_core.CvPoint2D64f point22,
                  IntPointer result)

icvGetCutPiece

public static void icvGetCutPiece(DoubleBuffer areaLineCoef1,
                  DoubleBuffer areaLineCoef2,
                  DoubleBuffer epipole,
                  opencv_core.CvSize imageSize,
                  DoubleBuffer point11,
                  DoubleBuffer point12,
                  DoubleBuffer point21,
                  DoubleBuffer point22,
                  IntBuffer result)

icvGetCutPiece

public static void icvGetCutPiece(double[] areaLineCoef1,
                  double[] areaLineCoef2,
                  double[] epipole,
                  opencv_core.CvSize imageSize,
                  double[] point11,
                  double[] point12,
                  double[] point21,
                  double[] point22,
                  int[] result)

icvGetMiddleAnglePoint

public static void icvGetMiddleAnglePoint(opencv_core.CvPoint2D64f basePoint,
                          opencv_core.CvPoint2D64f point1,
                          opencv_core.CvPoint2D64f point2,
                          opencv_core.CvPoint2D64f midPoint)

icvGetMiddleAnglePoint

public static void icvGetMiddleAnglePoint(DoubleBuffer basePoint,
                          DoubleBuffer point1,
                          DoubleBuffer point2,
                          DoubleBuffer midPoint)

icvGetMiddleAnglePoint

public static void icvGetMiddleAnglePoint(double[] basePoint,
                          double[] point1,
                          double[] point2,
                          double[] midPoint)

icvGetNormalDirect

public static void icvGetNormalDirect(DoublePointer direct,
                      opencv_core.CvPoint2D64f point,
                      DoublePointer normDirect)

icvGetNormalDirect

public static void icvGetNormalDirect(DoubleBuffer direct,
                      DoubleBuffer point,
                      DoubleBuffer normDirect)

icvGetNormalDirect

public static void icvGetNormalDirect(double[] direct,
                      double[] point,
                      double[] normDirect)

icvGetVect

public static double icvGetVect(opencv_core.CvPoint2D64f basePoint,
                opencv_core.CvPoint2D64f point1,
                opencv_core.CvPoint2D64f point2)

icvGetVect

public static double icvGetVect(DoubleBuffer basePoint,
                DoubleBuffer point1,
                DoubleBuffer point2)

icvGetVect

public static double icvGetVect(double[] basePoint,
                double[] point1,
                double[] point2)

icvProjectPointToDirect

public static void icvProjectPointToDirect(opencv_core.CvPoint2D64f point,
                           DoublePointer lineCoeff,
                           opencv_core.CvPoint2D64f projectPoint)

icvProjectPointToDirect

public static void icvProjectPointToDirect(DoubleBuffer point,
                           DoubleBuffer lineCoeff,
                           DoubleBuffer projectPoint)

icvProjectPointToDirect

public static void icvProjectPointToDirect(double[] point,
                           double[] lineCoeff,
                           double[] projectPoint)

icvGetDistanceFromPointToDirect

public static void icvGetDistanceFromPointToDirect(opencv_core.CvPoint2D64f point,
                                   DoublePointer lineCoef,
                                   DoublePointer dist)

icvGetDistanceFromPointToDirect

public static void icvGetDistanceFromPointToDirect(DoubleBuffer point,
                                   DoubleBuffer lineCoef,
                                   DoubleBuffer dist)

icvGetDistanceFromPointToDirect

public static void icvGetDistanceFromPointToDirect(double[] point,
                                   double[] lineCoef,
                                   double[] dist)

icvCreateIsometricImage

public static opencv_core.IplImage icvCreateIsometricImage(opencv_core.IplImage src,
                                           opencv_core.IplImage dst,
                                           int desired_depth,
                                           int desired_num_channels)

cvDeInterlace

public static void cvDeInterlace(opencv_core.CvArr frame,
                 opencv_core.CvArr fieldEven,
                 opencv_core.CvArr fieldOdd)

cvCreateContourTree

public static opencv_legacy.CvContourTree cvCreateContourTree(opencv_core.CvSeq contour,
                                              opencv_core.CvMemStorage storage,
                                              double threshold)

cvContourFromContourTree

public static opencv_core.CvSeq cvContourFromContourTree(opencv_legacy.CvContourTree tree,
                                         opencv_core.CvMemStorage storage,
                                         opencv_core.CvTermCriteria criteria)

cvMatchContourTrees

public static double cvMatchContourTrees(opencv_legacy.CvContourTree tree1,
                         opencv_legacy.CvContourTree tree2,
                         int method,
                         double threshold)

cvSnakeImage

public static void cvSnakeImage(opencv_core.IplImage image,
                opencv_core.CvPoint points,
                int length,
                FloatPointer alpha,
                FloatPointer beta,
                FloatPointer gamma,
                int coeff_usage,
                opencv_core.CvSize win,
                opencv_core.CvTermCriteria criteria,
                int calc_gradient)

cvSnakeImage

public static void cvSnakeImage(opencv_core.IplImage image,
                opencv_core.CvPoint points,
                int length,
                FloatPointer alpha,
                FloatPointer beta,
                FloatPointer gamma,
                int coeff_usage,
                opencv_core.CvSize win,
                opencv_core.CvTermCriteria criteria)

cvSnakeImage

public static void cvSnakeImage(opencv_core.IplImage image,
                IntBuffer points,
                int length,
                FloatBuffer alpha,
                FloatBuffer beta,
                FloatBuffer gamma,
                int coeff_usage,
                opencv_core.CvSize win,
                opencv_core.CvTermCriteria criteria,
                int calc_gradient)

cvSnakeImage

public static void cvSnakeImage(opencv_core.IplImage image,
                IntBuffer points,
                int length,
                FloatBuffer alpha,
                FloatBuffer beta,
                FloatBuffer gamma,
                int coeff_usage,
                opencv_core.CvSize win,
                opencv_core.CvTermCriteria criteria)

cvSnakeImage

public static void cvSnakeImage(opencv_core.IplImage image,
                int[] points,
                int length,
                float[] alpha,
                float[] beta,
                float[] gamma,
                int coeff_usage,
                opencv_core.CvSize win,
                opencv_core.CvTermCriteria criteria,
                int calc_gradient)

cvSnakeImage

public static void cvSnakeImage(opencv_core.IplImage image,
                int[] points,
                int length,
                float[] alpha,
                float[] beta,
                float[] gamma,
                int coeff_usage,
                opencv_core.CvSize win,
                opencv_core.CvTermCriteria criteria)

cvCreateGLCM

public static opencv_legacy.CvGLCM cvCreateGLCM(opencv_core.IplImage srcImage,
                                int stepMagnitude,
                                IntPointer stepDirections,
                                int numStepDirections,
                                int optimizationType)

cvCreateGLCM

public static opencv_legacy.CvGLCM cvCreateGLCM(opencv_core.IplImage srcImage,
                                int stepMagnitude)

cvCreateGLCM

public static opencv_legacy.CvGLCM cvCreateGLCM(opencv_core.IplImage srcImage,
                                int stepMagnitude,
                                IntBuffer stepDirections,
                                int numStepDirections,
                                int optimizationType)

cvCreateGLCM

public static opencv_legacy.CvGLCM cvCreateGLCM(opencv_core.IplImage srcImage,
                                int stepMagnitude,
                                int[] stepDirections,
                                int numStepDirections,
                                int optimizationType)

cvReleaseGLCM

public static void cvReleaseGLCM(PointerPointer GLCM,
                 int flag)

cvReleaseGLCM

public static void cvReleaseGLCM(opencv_legacy.CvGLCM GLCM)

cvReleaseGLCM

public static void cvReleaseGLCM(opencv_legacy.CvGLCM GLCM,
                 int flag)

cvCreateGLCMDescriptors

public static void cvCreateGLCMDescriptors(opencv_legacy.CvGLCM destGLCM,
                           int descriptorOptimizationType)

cvCreateGLCMDescriptors

public static void cvCreateGLCMDescriptors(opencv_legacy.CvGLCM destGLCM)

cvGetGLCMDescriptor

public static double cvGetGLCMDescriptor(opencv_legacy.CvGLCM GLCM,
                         int step,
                         int descriptor)

cvGetGLCMDescriptorStatistics

public static void cvGetGLCMDescriptorStatistics(opencv_legacy.CvGLCM GLCM,
                                 int descriptor,
                                 DoublePointer average,
                                 DoublePointer standardDeviation)

cvGetGLCMDescriptorStatistics

public static void cvGetGLCMDescriptorStatistics(opencv_legacy.CvGLCM GLCM,
                                 int descriptor,
                                 DoubleBuffer average,
                                 DoubleBuffer standardDeviation)

cvGetGLCMDescriptorStatistics

public static void cvGetGLCMDescriptorStatistics(opencv_legacy.CvGLCM GLCM,
                                 int descriptor,
                                 double[] average,
                                 double[] standardDeviation)

cvCreateGLCMImage

public static opencv_core.IplImage cvCreateGLCMImage(opencv_legacy.CvGLCM GLCM,
                                     int step)

cvInitFaceTracker

public static opencv_legacy.CvFaceTracker cvInitFaceTracker(opencv_legacy.CvFaceTracker pFaceTracking,
                                            opencv_core.IplImage imgGray,
                                            opencv_core.CvRect pRects,
                                            int nRects)

cvTrackFace

public static int cvTrackFace(opencv_legacy.CvFaceTracker pFaceTracker,
              opencv_core.IplImage imgGray,
              opencv_core.CvRect pRects,
              int nRects,
              opencv_core.CvPoint ptRotate,
              DoublePointer dbAngleRotate)

cvTrackFace

public static int cvTrackFace(opencv_legacy.CvFaceTracker pFaceTracker,
              opencv_core.IplImage imgGray,
              opencv_core.CvRect pRects,
              int nRects,
              IntBuffer ptRotate,
              DoubleBuffer dbAngleRotate)

cvTrackFace

public static int cvTrackFace(opencv_legacy.CvFaceTracker pFaceTracker,
              opencv_core.IplImage imgGray,
              opencv_core.CvRect pRects,
              int nRects,
              int[] ptRotate,
              double[] dbAngleRotate)

cvReleaseFaceTracker

public static void cvReleaseFaceTracker(PointerPointer ppFaceTracker)

cvReleaseFaceTracker

public static void cvReleaseFaceTracker(opencv_legacy.CvFaceTracker ppFaceTracker)

cv3dTracker2dTrackedObject

public static opencv_legacy.Cv3dTracker2dTrackedObject cv3dTracker2dTrackedObject(int id,
                                                                  opencv_core.CvPoint2D32f p)

cv3dTracker2dTrackedObject

public static opencv_legacy.Cv3dTracker2dTrackedObject cv3dTracker2dTrackedObject(int id,
                                                                  FloatBuffer p)

cv3dTracker2dTrackedObject

public static opencv_legacy.Cv3dTracker2dTrackedObject cv3dTracker2dTrackedObject(int id,
                                                                  float[] p)

cv3dTrackerTrackedObject

public static opencv_legacy.Cv3dTrackerTrackedObject cv3dTrackerTrackedObject(int id,
                                                              opencv_core.CvPoint3D32f p)

cv3dTrackerTrackedObject

public static opencv_legacy.Cv3dTrackerTrackedObject cv3dTrackerTrackedObject(int id,
                                                              FloatBuffer p)

cv3dTrackerTrackedObject

public static opencv_legacy.Cv3dTrackerTrackedObject cv3dTrackerTrackedObject(int id,
                                                              float[] p)

cv3dTrackerCalibrateCameras

public static byte cv3dTrackerCalibrateCameras(int num_cameras,
                               opencv_legacy.Cv3dTrackerCameraIntrinsics camera_intrinsics,
                               opencv_core.CvSize etalon_size,
                               float square_size,
                               PointerPointer samples,
                               opencv_legacy.Cv3dTrackerCameraInfo camera_info)

cv3dTrackerCalibrateCameras

public static byte cv3dTrackerCalibrateCameras(int num_cameras,
                               opencv_legacy.Cv3dTrackerCameraIntrinsics camera_intrinsics,
                               opencv_core.CvSize etalon_size,
                               float square_size,
                               opencv_core.IplImage samples,
                               opencv_legacy.Cv3dTrackerCameraInfo camera_info)

cv3dTrackerLocateObjects

public static int cv3dTrackerLocateObjects(int num_cameras,
                           int num_objects,
                           opencv_legacy.Cv3dTrackerCameraInfo camera_info,
                           opencv_legacy.Cv3dTracker2dTrackedObject tracking_info,
                           opencv_legacy.Cv3dTrackerTrackedObject tracked_objects)

cvVoronoiDiagramFromContour

public static int cvVoronoiDiagramFromContour(opencv_core.CvSeq ContourSeq,
                              PointerPointer VoronoiDiagram,
                              opencv_core.CvMemStorage VoronoiStorage,
                              int contour_type,
                              int contour_orientation,
                              int attempt_number)

cvVoronoiDiagramFromContour

public static int cvVoronoiDiagramFromContour(opencv_core.CvSeq ContourSeq,
                              opencv_legacy.CvVoronoiDiagram2D VoronoiDiagram,
                              opencv_core.CvMemStorage VoronoiStorage)

cvVoronoiDiagramFromContour

public static int cvVoronoiDiagramFromContour(opencv_core.CvSeq ContourSeq,
                              opencv_legacy.CvVoronoiDiagram2D VoronoiDiagram,
                              opencv_core.CvMemStorage VoronoiStorage,
                              int contour_type,
                              int contour_orientation,
                              int attempt_number)

cvVoronoiDiagramFromImage

public static int cvVoronoiDiagramFromImage(opencv_core.IplImage pImage,
                            PointerPointer ContourSeq,
                            PointerPointer VoronoiDiagram,
                            opencv_core.CvMemStorage VoronoiStorage,
                            int regularization_method,
                            float approx_precision)

cvVoronoiDiagramFromImage

public static int cvVoronoiDiagramFromImage(opencv_core.IplImage pImage,
                            opencv_core.CvSeq ContourSeq,
                            opencv_legacy.CvVoronoiDiagram2D VoronoiDiagram,
                            opencv_core.CvMemStorage VoronoiStorage)

cvVoronoiDiagramFromImage

public static int cvVoronoiDiagramFromImage(opencv_core.IplImage pImage,
                            opencv_core.CvSeq ContourSeq,
                            opencv_legacy.CvVoronoiDiagram2D VoronoiDiagram,
                            opencv_core.CvMemStorage VoronoiStorage,
                            int regularization_method,
                            float approx_precision)

cvReleaseVoronoiStorage

public static void cvReleaseVoronoiStorage(opencv_legacy.CvVoronoiDiagram2D VoronoiDiagram,
                           PointerPointer pVoronoiStorage)

cvReleaseVoronoiStorage

public static void cvReleaseVoronoiStorage(opencv_legacy.CvVoronoiDiagram2D VoronoiDiagram,
                           opencv_core.CvMemStorage pVoronoiStorage)

cvLinearContorModelFromVoronoiDiagram

public static opencv_core.CvGraph cvLinearContorModelFromVoronoiDiagram(opencv_legacy.CvVoronoiDiagram2D VoronoiDiagram,
                                                        float maxWidth)

cvReleaseLinearContorModelStorage

public static int cvReleaseLinearContorModelStorage(PointerPointer Graph)

cvReleaseLinearContorModelStorage

public static int cvReleaseLinearContorModelStorage(opencv_core.CvGraph Graph)

cvInitPerspectiveTransform

public static void cvInitPerspectiveTransform(opencv_core.CvSize size,
                              opencv_core.CvPoint2D32f vertex,
                              DoublePointer matrix,
                              opencv_core.CvArr rectMap)

cvInitPerspectiveTransform

public static void cvInitPerspectiveTransform(opencv_core.CvSize size,
                              FloatBuffer vertex,
                              DoubleBuffer matrix,
                              opencv_core.CvArr rectMap)

cvInitPerspectiveTransform

public static void cvInitPerspectiveTransform(opencv_core.CvSize size,
                              float[] vertex,
                              double[] matrix,
                              opencv_core.CvArr rectMap)

cvMakeScanlines

public static void cvMakeScanlines(opencv_legacy.CvMatrix3 matrix,
                   opencv_core.CvSize img_size,
                   IntPointer scanlines1,
                   IntPointer scanlines2,
                   IntPointer lengths1,
                   IntPointer lengths2,
                   IntPointer line_count)

cvMakeScanlines

public static void cvMakeScanlines(opencv_legacy.CvMatrix3 matrix,
                   opencv_core.CvSize img_size,
                   IntBuffer scanlines1,
                   IntBuffer scanlines2,
                   IntBuffer lengths1,
                   IntBuffer lengths2,
                   IntBuffer line_count)

cvMakeScanlines

public static void cvMakeScanlines(opencv_legacy.CvMatrix3 matrix,
                   opencv_core.CvSize img_size,
                   int[] scanlines1,
                   int[] scanlines2,
                   int[] lengths1,
                   int[] lengths2,
                   int[] line_count)

cvPreWarpImage

public static void cvPreWarpImage(int line_count,
                  opencv_core.IplImage img,
                  BytePointer dst,
                  IntPointer dst_nums,
                  IntPointer scanlines)

cvPreWarpImage

public static void cvPreWarpImage(int line_count,
                  opencv_core.IplImage img,
                  ByteBuffer dst,
                  IntBuffer dst_nums,
                  IntBuffer scanlines)

cvPreWarpImage

public static void cvPreWarpImage(int line_count,
                  opencv_core.IplImage img,
                  byte[] dst,
                  int[] dst_nums,
                  int[] scanlines)

cvFindRuns

public static void cvFindRuns(int line_count,
              BytePointer prewarp1,
              BytePointer prewarp2,
              IntPointer line_lengths1,
              IntPointer line_lengths2,
              IntPointer runs1,
              IntPointer runs2,
              IntPointer num_runs1,
              IntPointer num_runs2)

cvFindRuns

public static void cvFindRuns(int line_count,
              ByteBuffer prewarp1,
              ByteBuffer prewarp2,
              IntBuffer line_lengths1,
              IntBuffer line_lengths2,
              IntBuffer runs1,
              IntBuffer runs2,
              IntBuffer num_runs1,
              IntBuffer num_runs2)

cvFindRuns

public static void cvFindRuns(int line_count,
              byte[] prewarp1,
              byte[] prewarp2,
              int[] line_lengths1,
              int[] line_lengths2,
              int[] runs1,
              int[] runs2,
              int[] num_runs1,
              int[] num_runs2)

cvDynamicCorrespondMulti

public static void cvDynamicCorrespondMulti(int line_count,
                            IntPointer first,
                            IntPointer first_runs,
                            IntPointer second,
                            IntPointer second_runs,
                            IntPointer first_corr,
                            IntPointer second_corr)

cvDynamicCorrespondMulti

public static void cvDynamicCorrespondMulti(int line_count,
                            IntBuffer first,
                            IntBuffer first_runs,
                            IntBuffer second,
                            IntBuffer second_runs,
                            IntBuffer first_corr,
                            IntBuffer second_corr)

cvDynamicCorrespondMulti

public static void cvDynamicCorrespondMulti(int line_count,
                            int[] first,
                            int[] first_runs,
                            int[] second,
                            int[] second_runs,
                            int[] first_corr,
                            int[] second_corr)

cvMakeAlphaScanlines

public static void cvMakeAlphaScanlines(IntPointer scanlines1,
                        IntPointer scanlines2,
                        IntPointer scanlinesA,
                        IntPointer lengths,
                        int line_count,
                        float alpha)

cvMakeAlphaScanlines

public static void cvMakeAlphaScanlines(IntBuffer scanlines1,
                        IntBuffer scanlines2,
                        IntBuffer scanlinesA,
                        IntBuffer lengths,
                        int line_count,
                        float alpha)

cvMakeAlphaScanlines

public static void cvMakeAlphaScanlines(int[] scanlines1,
                        int[] scanlines2,
                        int[] scanlinesA,
                        int[] lengths,
                        int line_count,
                        float alpha)

cvMorphEpilinesMulti

public static void cvMorphEpilinesMulti(int line_count,
                        BytePointer first_pix,
                        IntPointer first_num,
                        BytePointer second_pix,
                        IntPointer second_num,
                        BytePointer dst_pix,
                        IntPointer dst_num,
                        float alpha,
                        IntPointer first,
                        IntPointer first_runs,
                        IntPointer second,
                        IntPointer second_runs,
                        IntPointer first_corr,
                        IntPointer second_corr)

cvMorphEpilinesMulti

public static void cvMorphEpilinesMulti(int line_count,
                        ByteBuffer first_pix,
                        IntBuffer first_num,
                        ByteBuffer second_pix,
                        IntBuffer second_num,
                        ByteBuffer dst_pix,
                        IntBuffer dst_num,
                        float alpha,
                        IntBuffer first,
                        IntBuffer first_runs,
                        IntBuffer second,
                        IntBuffer second_runs,
                        IntBuffer first_corr,
                        IntBuffer second_corr)

cvMorphEpilinesMulti

public static void cvMorphEpilinesMulti(int line_count,
                        byte[] first_pix,
                        int[] first_num,
                        byte[] second_pix,
                        int[] second_num,
                        byte[] dst_pix,
                        int[] dst_num,
                        float alpha,
                        int[] first,
                        int[] first_runs,
                        int[] second,
                        int[] second_runs,
                        int[] first_corr,
                        int[] second_corr)

cvPostWarpImage

public static void cvPostWarpImage(int line_count,
                   BytePointer src,
                   IntPointer src_nums,
                   opencv_core.IplImage img,
                   IntPointer scanlines)

cvPostWarpImage

public static void cvPostWarpImage(int line_count,
                   ByteBuffer src,
                   IntBuffer src_nums,
                   opencv_core.IplImage img,
                   IntBuffer scanlines)

cvPostWarpImage

public static void cvPostWarpImage(int line_count,
                   byte[] src,
                   int[] src_nums,
                   opencv_core.IplImage img,
                   int[] scanlines)

cvDeleteMoire

public static void cvDeleteMoire(opencv_core.IplImage img)

cvCreateConDensation

public static opencv_legacy.CvConDensation cvCreateConDensation(int dynam_params,
                                                int measure_params,
                                                int sample_count)

cvReleaseConDensation

public static void cvReleaseConDensation(PointerPointer condens)

cvReleaseConDensation

public static void cvReleaseConDensation(opencv_legacy.CvConDensation condens)

cvConDensUpdateByTime

public static void cvConDensUpdateByTime(opencv_legacy.CvConDensation condens)

cvConDensInitSampleSet

public static void cvConDensInitSampleSet(opencv_legacy.CvConDensation condens,
                          opencv_core.CvMat lower_bound,
                          opencv_core.CvMat upper_bound)

iplWidth

public static int iplWidth(opencv_core.IplImage img)

iplHeight

public static int iplHeight(opencv_core.IplImage img)

getData

public static BytePointer getData(opencv_core.IplImage image)

cvPyrSegmentation

public static void cvPyrSegmentation(opencv_core.IplImage src,
                     opencv_core.IplImage dst,
                     opencv_core.CvMemStorage storage,
                     PointerPointer comp,
                     int level,
                     double threshold1,
                     double threshold2)

cvPyrSegmentation

public static void cvPyrSegmentation(opencv_core.IplImage src,
                     opencv_core.IplImage dst,
                     opencv_core.CvMemStorage storage,
                     opencv_core.CvSeq comp,
                     int level,
                     double threshold1,
                     double threshold2)

cvInitSubdivDelaunay2D

public static void cvInitSubdivDelaunay2D(opencv_imgproc.CvSubdiv2D subdiv,
                          opencv_core.CvRect rect)

\ Planar subdivisions * \

cvCreateSubdiv2D

public static opencv_imgproc.CvSubdiv2D cvCreateSubdiv2D(int subdiv_type,
                                         int header_size,
                                         int vtx_size,
                                         int quadedge_size,
                                         opencv_core.CvMemStorage storage)

cvCreateSubdivDelaunay2D

public static opencv_imgproc.CvSubdiv2D cvCreateSubdivDelaunay2D(opencv_core.CvRect rect,
                                                 opencv_core.CvMemStorage storage)

high-level subdivision functions

cvSubdivDelaunay2DInsert

public static opencv_imgproc.CvSubdiv2DPoint cvSubdivDelaunay2DInsert(opencv_imgproc.CvSubdiv2D subdiv,
                                                      opencv_core.CvPoint2D32f pt)

cvSubdivDelaunay2DInsert

public static opencv_imgproc.CvSubdiv2DPoint cvSubdivDelaunay2DInsert(opencv_imgproc.CvSubdiv2D subdiv,
                                                      FloatBuffer pt)

cvSubdivDelaunay2DInsert

public static opencv_imgproc.CvSubdiv2DPoint cvSubdivDelaunay2DInsert(opencv_imgproc.CvSubdiv2D subdiv,
                                                      float[] pt)

cvSubdiv2DLocate

public static int cvSubdiv2DLocate(opencv_imgproc.CvSubdiv2D subdiv,
                   opencv_core.CvPoint2D32f pt,
                   SizeTPointer edge,
                   PointerPointer vertex)

cvSubdiv2DLocate

public static int cvSubdiv2DLocate(opencv_imgproc.CvSubdiv2D subdiv,
                   opencv_core.CvPoint2D32f pt,
                   SizeTPointer edge)

cvSubdiv2DLocate

public static int cvSubdiv2DLocate(opencv_imgproc.CvSubdiv2D subdiv,
                   opencv_core.CvPoint2D32f pt,
                   SizeTPointer edge,
                   opencv_imgproc.CvSubdiv2DPoint vertex)

cvSubdiv2DLocate

public static int cvSubdiv2DLocate(opencv_imgproc.CvSubdiv2D subdiv,
                   FloatBuffer pt,
                   SizeTPointer edge,
                   opencv_imgproc.CvSubdiv2DPoint vertex)

cvSubdiv2DLocate

public static int cvSubdiv2DLocate(opencv_imgproc.CvSubdiv2D subdiv,
                   FloatBuffer pt,
                   SizeTPointer edge)

cvSubdiv2DLocate

public static int cvSubdiv2DLocate(opencv_imgproc.CvSubdiv2D subdiv,
                   float[] pt,
                   SizeTPointer edge,
                   opencv_imgproc.CvSubdiv2DPoint vertex)

cvSubdiv2DLocate

public static int cvSubdiv2DLocate(opencv_imgproc.CvSubdiv2D subdiv,
                   float[] pt,
                   SizeTPointer edge)

cvCalcSubdivVoronoi2D

public static void cvCalcSubdivVoronoi2D(opencv_imgproc.CvSubdiv2D subdiv)

cvClearSubdivVoronoi2D

public static void cvClearSubdivVoronoi2D(opencv_imgproc.CvSubdiv2D subdiv)

cvFindNearestPoint2D

public static opencv_imgproc.CvSubdiv2DPoint cvFindNearestPoint2D(opencv_imgproc.CvSubdiv2D subdiv,
                                                  opencv_core.CvPoint2D32f pt)

cvFindNearestPoint2D

public static opencv_imgproc.CvSubdiv2DPoint cvFindNearestPoint2D(opencv_imgproc.CvSubdiv2D subdiv,
                                                  FloatBuffer pt)

cvFindNearestPoint2D

public static opencv_imgproc.CvSubdiv2DPoint cvFindNearestPoint2D(opencv_imgproc.CvSubdiv2D subdiv,
                                                  float[] pt)

cvSubdiv2DNextEdge
```
public static long cvSubdiv2DNextEdge(long edge)
```
Basic quad-edge navigation and operations

cvSubdiv2DRotateEdge

public static long cvSubdiv2DRotateEdge(long edge,
                        int rotate)

cvSubdiv2DSymEdge

public static long cvSubdiv2DSymEdge(long edge)

cvSubdiv2DGetEdge

public static long cvSubdiv2DGetEdge(long edge,
                     int type)

cvSubdiv2DEdgeOrg

public static opencv_imgproc.CvSubdiv2DPoint cvSubdiv2DEdgeOrg(long edge)

cvSubdiv2DEdgeDst

public static opencv_imgproc.CvSubdiv2DPoint cvSubdiv2DEdgeDst(long edge)

icvDrawMosaic

public static void icvDrawMosaic(opencv_imgproc.CvSubdiv2D subdiv,
                 opencv_core.IplImage src,
                 opencv_core.IplImage dst)

\ Additional operations on Subdivisions * \

icvSubdiv2DCheck

public static int icvSubdiv2DCheck(opencv_imgproc.CvSubdiv2D subdiv)

icvSqDist2D32f

public static double icvSqDist2D32f(opencv_core.CvPoint2D32f pt1,
                    opencv_core.CvPoint2D32f pt2)

icvSqDist2D32f

public static double icvSqDist2D32f(FloatBuffer pt1,
                    FloatBuffer pt2)

icvSqDist2D32f

public static double icvSqDist2D32f(float[] pt1,
                    float[] pt2)

cvTriangleArea

public static double cvTriangleArea(opencv_core.CvPoint2D32f a,
                    opencv_core.CvPoint2D32f b,
                    opencv_core.CvPoint2D32f c)

cvTriangleArea

public static double cvTriangleArea(FloatBuffer a,
                    FloatBuffer b,
                    FloatBuffer c)

cvTriangleArea

public static double cvTriangleArea(float[] a,
                    float[] b,
                    float[] c)

cvCreateKDTree

public static opencv_imgproc.CvFeatureTree cvCreateKDTree(opencv_core.CvMat desc)

cvCreateSpillTree

public static opencv_imgproc.CvFeatureTree cvCreateSpillTree(opencv_core.CvMat raw_data,
                                             int naive,
                                             double rho,
                                             double tau)

cvCreateSpillTree

public static opencv_imgproc.CvFeatureTree cvCreateSpillTree(opencv_core.CvMat raw_data)

cvReleaseFeatureTree

public static void cvReleaseFeatureTree(opencv_imgproc.CvFeatureTree tr)

cvFindFeatures

public static void cvFindFeatures(opencv_imgproc.CvFeatureTree tr,
                  opencv_core.CvMat query_points,
                  opencv_core.CvMat indices,
                  opencv_core.CvMat dist,
                  int k,
                  int emax)

cvFindFeatures

public static void cvFindFeatures(opencv_imgproc.CvFeatureTree tr,
                  opencv_core.CvMat query_points,
                  opencv_core.CvMat indices,
                  opencv_core.CvMat dist,
                  int k)

cvFindFeaturesBoxed

public static int cvFindFeaturesBoxed(opencv_imgproc.CvFeatureTree tr,
                      opencv_core.CvMat bounds_min,
                      opencv_core.CvMat bounds_max,
                      opencv_core.CvMat out_indices)

cvCreateLSH

public static opencv_imgproc.CvLSH cvCreateLSH(opencv_legacy.CvLSHOperations ops,
                               int d,
                               int L,
                               int k,
                               int type,
                               double r,
                               long seed)

cvCreateLSH

public static opencv_imgproc.CvLSH cvCreateLSH(opencv_legacy.CvLSHOperations ops,
                               int d)

cvCreateMemoryLSH

public static opencv_imgproc.CvLSH cvCreateMemoryLSH(int d,
                                     int n,
                                     int L,
                                     int k,
                                     int type,
                                     double r,
                                     long seed)

cvCreateMemoryLSH

public static opencv_imgproc.CvLSH cvCreateMemoryLSH(int d,
                                     int n)

cvReleaseLSH

public static void cvReleaseLSH(PointerPointer lsh)

cvReleaseLSH

public static void cvReleaseLSH(opencv_imgproc.CvLSH lsh)

LSHSize

public static int LSHSize(opencv_imgproc.CvLSH lsh)

cvLSHAdd

public static void cvLSHAdd(opencv_imgproc.CvLSH lsh,
            opencv_core.CvMat data,
            opencv_core.CvMat indices)

cvLSHAdd

public static void cvLSHAdd(opencv_imgproc.CvLSH lsh,
            opencv_core.CvMat data)

cvLSHRemove

public static void cvLSHRemove(opencv_imgproc.CvLSH lsh,
               opencv_core.CvMat indices)

cvLSHQuery

public static void cvLSHQuery(opencv_imgproc.CvLSH lsh,
              opencv_core.CvMat query_points,
              opencv_core.CvMat indices,
              opencv_core.CvMat dist,
              int k,
              int emax)

CV_STEREO_GC_OCCLUDED

public static int CV_STEREO_GC_OCCLUDED()

cvCreateStereoGCState

public static opencv_legacy.CvStereoGCState cvCreateStereoGCState(int numberOfDisparities,
                                                  int maxIters)

cvReleaseStereoGCState

public static void cvReleaseStereoGCState(PointerPointer state)

cvReleaseStereoGCState

public static void cvReleaseStereoGCState(opencv_legacy.CvStereoGCState state)

cvFindStereoCorrespondenceGC

public static void cvFindStereoCorrespondenceGC(opencv_core.CvArr left,
                                opencv_core.CvArr right,
                                opencv_core.CvArr disparityLeft,
                                opencv_core.CvArr disparityRight,
                                opencv_legacy.CvStereoGCState state,
                                int useDisparityGuess)

cvFindStereoCorrespondenceGC

public static void cvFindStereoCorrespondenceGC(opencv_core.CvArr left,
                                opencv_core.CvArr right,
                                opencv_core.CvArr disparityLeft,
                                opencv_core.CvArr disparityRight,
                                opencv_legacy.CvStereoGCState state)

cvCalcOpticalFlowLK

public static void cvCalcOpticalFlowLK(opencv_core.CvArr prev,
                       opencv_core.CvArr curr,
                       opencv_core.CvSize win_size,
                       opencv_core.CvArr velx,
                       opencv_core.CvArr vely)

cvCalcOpticalFlowBM

public static void cvCalcOpticalFlowBM(opencv_core.CvArr prev,
                       opencv_core.CvArr curr,
                       opencv_core.CvSize block_size,
                       opencv_core.CvSize shift_size,
                       opencv_core.CvSize max_range,
                       int use_previous,
                       opencv_core.CvArr velx,
                       opencv_core.CvArr vely)

cvCalcOpticalFlowHS

public static void cvCalcOpticalFlowHS(opencv_core.CvArr prev,
                       opencv_core.CvArr curr,
                       int use_previous,
                       opencv_core.CvArr velx,
                       opencv_core.CvArr vely,
                       double lambda,
                       opencv_core.CvTermCriteria criteria)

cvReleaseBGStatModel

public static void cvReleaseBGStatModel(PointerPointer bg_model)

cvReleaseBGStatModel

public static void cvReleaseBGStatModel(opencv_legacy.CvBGStatModel bg_model)

cvUpdateBGStatModel

public static int cvUpdateBGStatModel(opencv_core.IplImage current_frame,
                      opencv_legacy.CvBGStatModel bg_model,
                      double learningRate)

cvUpdateBGStatModel

public static int cvUpdateBGStatModel(opencv_core.IplImage current_frame,
                      opencv_legacy.CvBGStatModel bg_model)

cvRefineForegroundMaskBySegm

public static void cvRefineForegroundMaskBySegm(opencv_core.CvSeq segments,
                                opencv_legacy.CvBGStatModel bg_model)

cvChangeDetection

public static int cvChangeDetection(opencv_core.IplImage prev_frame,
                    opencv_core.IplImage curr_frame,
                    opencv_core.IplImage change_mask)

cvCreateFGDStatModel

public static opencv_legacy.CvBGStatModel cvCreateFGDStatModel(opencv_core.IplImage first_frame,
                                               opencv_legacy.CvFGDStatModelParams parameters)

cvCreateFGDStatModel

public static opencv_legacy.CvBGStatModel cvCreateFGDStatModel(opencv_core.IplImage first_frame)

cvCreateGaussianBGModel

public static opencv_legacy.CvBGStatModel cvCreateGaussianBGModel(opencv_core.IplImage first_frame,
                                                  opencv_legacy.CvGaussBGStatModelParams parameters)

cvCreateGaussianBGModel

public static opencv_legacy.CvBGStatModel cvCreateGaussianBGModel(opencv_core.IplImage first_frame)

cvCreateBGCodeBookModel

public static opencv_legacy.CvBGCodeBookModel cvCreateBGCodeBookModel()

cvReleaseBGCodeBookModel

public static void cvReleaseBGCodeBookModel(PointerPointer model)

cvReleaseBGCodeBookModel

public static void cvReleaseBGCodeBookModel(opencv_legacy.CvBGCodeBookModel model)

cvBGCodeBookUpdate

public static void cvBGCodeBookUpdate(opencv_legacy.CvBGCodeBookModel model,
                      opencv_core.CvArr image,
                      opencv_core.CvRect roi,
                      opencv_core.CvArr mask)

cvBGCodeBookUpdate

public static void cvBGCodeBookUpdate(opencv_legacy.CvBGCodeBookModel model,
                      opencv_core.CvArr image)

cvBGCodeBookDiff

public static int cvBGCodeBookDiff(opencv_legacy.CvBGCodeBookModel model,
                   opencv_core.CvArr image,
                   opencv_core.CvArr fgmask,
                   opencv_core.CvRect roi)

cvBGCodeBookDiff

public static int cvBGCodeBookDiff(opencv_legacy.CvBGCodeBookModel model,
                   opencv_core.CvArr image,
                   opencv_core.CvArr fgmask)

cvBGCodeBookClearStale

public static void cvBGCodeBookClearStale(opencv_legacy.CvBGCodeBookModel model,
                          int staleThresh,
                          opencv_core.CvRect roi,
                          opencv_core.CvArr mask)

cvBGCodeBookClearStale

public static void cvBGCodeBookClearStale(opencv_legacy.CvBGCodeBookModel model,
                          int staleThresh)

cvSegmentFGMask

public static opencv_core.CvSeq cvSegmentFGMask(opencv_core.CvArr fgmask,
                                int poly1Hull0,
                                float perimScale,
                                opencv_core.CvMemStorage storage,
                                opencv_core.CvPoint offset)

cvSegmentFGMask

public static opencv_core.CvSeq cvSegmentFGMask(opencv_core.CvArr fgmask)

cvSegmentFGMask

public static opencv_core.CvSeq cvSegmentFGMask(opencv_core.CvArr fgmask,
                                int poly1Hull0,
                                float perimScale,
                                opencv_core.CvMemStorage storage,
                                IntBuffer offset)

cvSegmentFGMask

public static opencv_core.CvSeq cvSegmentFGMask(opencv_core.CvArr fgmask,
                                int poly1Hull0,
                                float perimScale,
                                opencv_core.CvMemStorage storage,
                                int[] offset)

Class opencv_legacy

Nested Class Summary

Nested classes/interfaces inherited from class org.bytedeco.javacpp.helper.opencv_legacy

Field Summary

Constructor Summary

Method Summary

Methods inherited from class org.bytedeco.javacpp.helper.opencv_legacy

Methods inherited from class org.bytedeco.javacpp.presets.opencv_legacy

Methods inherited from class java.lang.Object

Field Detail

CV_BLOB_MINW

CV_BLOB_MINH

PROFILE_EPANECHNIKOV

PROFILE_DOG

CV_BT_HIST_TYPE_S

CV_BT_HIST_TYPE_MG

CV_BT_HIST_TYPE_MG2

CV_BT_HIST_TYPE_H

CV_NOISE_NONE

CV_NOISE_GAUSSIAN

CV_NOISE_UNIFORM

CV_NOISE_SPECKLE

CV_NOISE_SALT_AND_PEPPER

CV_MAT32F

CV_MAT3x1_32F

CV_MAT4x1_32F

CV_MAT3x3_32F

CV_MAT4x4_32F

CV_MAT64D

CV_MAT3x1_64D

CV_MAT4x1_64D

CV_MAT3x3_64D

CV_MAT4x4_64D

IPL_GAUSSIAN_5x5

CV_SHIFT_NONE

CV_SHIFT_LEFT

CV_SHIFT_RIGHT

CV_SHIFT_UP

CV_SHIFT_DOWN

CV_SHIFT_LU

CV_SHIFT_RU

CV_SHIFT_LD

CV_SHIFT_RD

CV_RODRIGUES_M2V

CV_RODRIGUES_V2M

CV_EIGOBJ_NO_CALLBACK

CV_EIGOBJ_INPUT_CALLBACK

CV_EIGOBJ_OUTPUT_CALLBACK

CV_EIGOBJ_BOTH_CALLBACK

CV_NOT_WEIGHTED

CV_WEIGHTED_VTX

CV_WEIGHTED_EDGE

CV_WEIGHTED_ALL

CV_DOMINANT_IPAN

CLIQUE_TIME_OFF

CLIQUE_FOUND

CLIQUE_END

CV_UNDEF_SC_PARAM

CV_IDP_BIRCHFIELD_PARAM1

CV_IDP_BIRCHFIELD_PARAM2

CV_IDP_BIRCHFIELD_PARAM3

CV_IDP_BIRCHFIELD_PARAM4

CV_IDP_BIRCHFIELD_PARAM5

CV_DISPARITY_BIRCHFIELD

CV_CAMERA_TO_WARP

CV_WARP_TO_CAMERA

CV_CONTOUR_TREES_MATCH_I1

CV_VALUE

CV_ARRAY

CV_GLCM_OPTIMIZATION_NONE

CV_GLCM_OPTIMIZATION_LUT

CV_GLCM_OPTIMIZATION_HISTOGRAM

CV_GLCMDESC_OPTIMIZATION_ALLOWDOUBLENEST

CV_GLCMDESC_OPTIMIZATION_ALLOWTRIPLENEST

CV_GLCMDESC_OPTIMIZATION_HISTOGRAM

CV_GLCMDESC_ENTROPY

CV_GLCMDESC_ENERGY

CV_GLCMDESC_HOMOGENITY

CV_GLCMDESC_CONTRAST

CV_GLCMDESC_CLUSTERTENDENCY