opencv_core (JavaCPP Presets for OpenCV 2.4.10-0.10 API)

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

All Implemented Interfaces:: InfoMapper

public class opencv_core
extends opencv_core

Nested Class Summary

Nested Classes
Modifier and Type	Class and Description
`static class`	`opencv_core.Algorithm` Base class for high-level OpenCV algorithms
`static class`	`opencv_core.AlgorithmInfo`
`static class`	`opencv_core.Arrays`
`static class`	`opencv_core.AutoLock`
`static class`	`opencv_core.BinaryFunc`
`static class`	`opencv_core.Buffer` \namespace cv Namespace where all the C++ OpenCV functionality resides
`static class`	`opencv_core.ByteVectorVector`
`static class`	`opencv_core.ConvertData`
`static class`	`opencv_core.ConvertScaleData`
`static class`	`opencv_core.Cv_iplAllocateImageData`
`static class`	`opencv_core.Cv_iplCloneImage`
`static class`	`opencv_core.Cv_iplCreateImageHeader`
`static class`	`opencv_core.Cv_iplCreateROI`
`static class`	`opencv_core.Cv_iplDeallocate`
`static class`	`opencv_core.Cv32suf`
`static class`	`opencv_core.Cv64suf`
`static class`	`opencv_core.CvAllocFunc`
`static class`	`opencv_core.CvAttrList`
`static class`	`opencv_core.CvBox2D`
`static class`	`opencv_core.CvChain` Chain/Countour
`static class`	`opencv_core.CvCloneFunc`
`static class`	`opencv_core.CvCmpFunc`
`static class`	`opencv_core.CvContour`
`static class`	`opencv_core.CvErrorCallback`
`static class`	`opencv_core.CvFileNode`
`static class`	`opencv_core.CvFileNodeHash`
`static class`	`opencv_core.CvFileStorage` \ Data structures for persistence (a.k.a serialization) functionality * \
`static class`	`opencv_core.CvFont`
`static class`	`opencv_core.CvFreeFunc`
`static class`	`opencv_core.CvGraph`
`static class`	`opencv_core.CvGraphEdge` Graph
`static class`	`opencv_core.CvGraphScanner`
`static class`	`opencv_core.CvGraphVtx`
`static class`	`opencv_core.CvGraphVtx2D`
`static class`	`opencv_core.CvHistogram`
`static class`	`opencv_core.CvIsInstanceFunc`
`static class`	`opencv_core.CvLineIterator`
`static class`	`opencv_core.CvMat`
`static class`	`opencv_core.CvMatND`
`static class`	`opencv_core.CvMemBlock` Memory storage
`static class`	`opencv_core.CvMemStorage`
`static class`	`opencv_core.CvMemStoragePos`
`static class`	`opencv_core.CvModule`
`static class`	`opencv_core.CvModuleInfo`
`static class`	`opencv_core.CvNArrayIterator`
`static class`	`opencv_core.CvPluginFuncInfo` System data types
`static class`	`opencv_core.CvPoint` CvPoint and variants
`static class`	`opencv_core.CvPoint2D32f`
`static class`	`opencv_core.CvPoint2D64f`
`static class`	`opencv_core.CvPoint3D32f`
`static class`	`opencv_core.CvPoint3D64f`
`static class`	`opencv_core.CvReadFunc`
`static class`	`opencv_core.CvRect` CvRect
`static class`	`opencv_core.CvReleaseFunc`
`static class`	`opencv_core.CvScalar` CvScalar
`static class`	`opencv_core.CvSeq`
`static class`	`opencv_core.CvSeqBlock` Sequence
`static class`	`opencv_core.CvSeqReader`
`static class`	`opencv_core.CvSeqWriter`
`static class`	`opencv_core.CvSet`
`static class`	`opencv_core.CvSetElem` Set
`static class`	`opencv_core.CvSize` CvSize's & CvBox
`static class`	`opencv_core.CvSize2D32f`
`static class`	`opencv_core.CvSlice` CvSlice
`static class`	`opencv_core.CvSparseMat`
`static class`	`opencv_core.CvSparseMatIterator`
`static class`	`opencv_core.CvSparseNode` iteration through a sparse array
`static class`	`opencv_core.CvString`
`static class`	`opencv_core.CvStringHashNode`
`static class`	`opencv_core.CvTermCriteria`
`static class`	`opencv_core.CvTreeNodeIterator` Iteration through the sequence tree
`static class`	`opencv_core.CvType`
`static class`	`opencv_core.CvTypeInfo`
`static class`	`opencv_core.CvWriteFunc`
`static class`	`opencv_core.ErrorCallback`
`static class`	`opencv_core.FileNode` File Storage Node class The node is used to store each and every element of the file storage opened for reading - from the primitive objects, such as numbers and text strings, to the complex nodes: sequences, mappings and the registered objects.
`static class`	`opencv_core.FileNodeIterator` File Node Iterator The class is used for iterating sequences (usually) and mappings.
`static class`	`opencv_core.FileStorage` XML/YAML File Storage Class.
`static class`	`opencv_core.Formatted`
`static class`	`opencv_core.Formatter`
`static class`	`opencv_core.GlArrays`
`static class`	`opencv_core.GlBuffer`
`static class`	`opencv_core.GlCamera`
`static class`	`opencv_core.GlTexture`
`static class`	`opencv_core.GpuMat`
`static class`	`opencv_core.IntVectorVector`
`static class`	`opencv_core.IplConvKernel`
`static class`	`opencv_core.IplConvKernelFP`
`static class`	`opencv_core.IplImage`
`static class`	`opencv_core.IplROI`
`static class`	`opencv_core.IplTileInfo`
`static class`	`opencv_core.KDTree` Fast Nearest Neighbor Search Class.
`static class`	`opencv_core.LineIterator` Line iterator class The class is used to iterate over all the pixels on the raster line segment connecting two specified points.
`static class`	`opencv_core.Mat` The n-dimensional matrix class.
`static class`	`opencv_core.MatAllocator` Custom array allocator
`static class`	`opencv_core.MatArg`
`static class`	`opencv_core.MatConstIterator` Template matrix class derived from Mat The class Mat_ is a "thin" template wrapper on top of cv::Mat.
`static class`	`opencv_core.MatExpr`
`static class`	`opencv_core.MatOp`
`static class`	`opencv_core.MatOp_Base`
`static class`	`opencv_core.MatVector`
`static class`	`opencv_core.Mutex`
`static class`	`opencv_core.NAryMatIterator` n-Dimensional Dense Matrix Iterator Class.
`static class`	`opencv_core.ParallelLoopBody` "\nThe CommandLineParser class is designed for command line arguments parsing\n" "Keys map: \n" "Before you start to work with CommandLineParser you have to create a map for keys.\n" " It will look like this\n" " const char* keys =\n" " {\n" " { s\| string\| 123asd \|string parameter}\n" " { d\| digit \| 100 \|digit parameter }\n" " { c\|noCamera\|false \|without camera }\n" " { 1\| \|some text\|help }\n" " { 2\| \|333 \|another help }\n" " };\n" "Usage syntax: \n" " \"{\" - start of parameter string.\n" " \"}\" - end of parameter string\n" " \"\|\" - separator between short name, full name, default value and help\n" "Supported syntax: \n" " --key1=arg1 \n" " -key2=arg2 \n" "Usage: \n" " Imagine that the input parameters are next:\n" " -s=string_value --digit=250 --noCamera lena.jpg 10000\n" " CommandLineParser parser(argc, argv, keys) - create a parser object\n" " parser.get(\"s\" or \"string\") will return you first parameter value\n" " parser.get(\"s\", false or \"string\", false) will return you first parameter value\n" " without spaces in end and begin\n" " parser.get(\"d\" or \"digit\") will return you second parameter value.\n" " It also works with 'unsigned int', 'double', and 'float' types>\n" " parser.get(\"c\" or \"noCamera\") will return you true .\n" " If you enter this key in commandline>\n" " It return you false otherwise.\n" " parser.get(\"1\") will return you the first argument without parameter (lena.jpg) \n" " parser.get(\"2\") will return you the second argument without parameter (10000)\n" " It also works with 'unsigned int', 'double', and 'float' types \n"
`static class`	`opencv_core.Param`
`static class`	`opencv_core.PCA` Principal Component Analysis The class PCA is used to compute the special basis for a set of vectors.
`static class`	`opencv_core.Point` template 2D point class.
`static class`	`opencv_core.Point2d`
`static class`	`opencv_core.Point2dVectorVector`
`static class`	`opencv_core.Point2f`
`static class`	`opencv_core.Point2fVectorVector`
`static class`	`opencv_core.Point3d`
`static class`	`opencv_core.Point3f`
`static class`	`opencv_core.Point3i` template 3D point class.
`static class`	`opencv_core.PointVectorVector`
`static class`	`opencv_core.Range` The 2D range class This is the class used to specify a continuous subsequence, i.e.
`static class`	`opencv_core.Rect` The 2D up-right rectangle class The class represents a 2D rectangle with coordinates of the specified data type.
`static class`	`opencv_core.Rectd`
`static class`	`opencv_core.Rectf`
`static class`	`opencv_core.RectVectorVector`
`static class`	`opencv_core.RNG` Random Number Generator The class implements RNG using Multiply-with-Carry algorithm
`static class`	`opencv_core.RNG_MT19937` Random Number Generator - MT The class implements RNG using the Mersenne Twister algorithm
`static class`	`opencv_core.RotatedRect` The rotated 2D rectangle.
`static class`	`opencv_core.Scalar` The template scalar class.
`static class`	`opencv_core.Size` The 2D size class The class represents the size of a 2D rectangle, image size, matrix size etc.
`static class`	`opencv_core.Size2d`
`static class`	`opencv_core.Size2f`
`static class`	`opencv_core.SparseMat` Sparse matrix class.
`static class`	`opencv_core.SparseMatConstIterator` Read-Only Sparse Matrix Iterator.
`static class`	`opencv_core.SparseMatIterator` Read-write Sparse Matrix Iterator The class is similar to cv::SparseMatConstIterator, but can be used for in-place modification of the matrix elements.
`static class`	`opencv_core.StringVector`
`static class`	`opencv_core.SVD` Singular Value Decomposition class The class is used to compute Singular Value Decomposition of a floating-point matrix and then use it to solve least-square problems, under-determined linear systems, invert matrices, compute condition numbers etc.
`static class`	`opencv_core.TermCriteria` Termination criteria in iterative algorithms
`static class`	`opencv_core.Texture2D`
`static class`	`opencv_core.TLSDataContainer`
`static class`	`opencv_core.WriteStructContext`

Nested classes/interfaces inherited from class org.bytedeco.javacpp.helper.opencv_core
opencv_core.AbstractArray, opencv_core.AbstractCvBox2D, opencv_core.AbstractCvFileStorage, opencv_core.AbstractCvFont, opencv_core.AbstractCvGraph, opencv_core.AbstractCvGraphScanner, opencv_core.AbstractCvMat, opencv_core.AbstractCvMatND, opencv_core.AbstractCvMemStorage, opencv_core.AbstractCvPoint, opencv_core.AbstractCvPoint2D32f, opencv_core.AbstractCvPoint2D64f, opencv_core.AbstractCvPoint3D32f, opencv_core.AbstractCvPoint3D64f, opencv_core.AbstractCvRect, opencv_core.AbstractCvScalar, opencv_core.AbstractCvSeq, opencv_core.AbstractCvSet, opencv_core.AbstractCvSize, opencv_core.AbstractCvSize2D32f, opencv_core.AbstractCvSparseMat, opencv_core.AbstractIplImage, opencv_core.AbstractMat, opencv_core.CvArr, opencv_core.CvArrArray, opencv_core.CvMatArray, opencv_core.CvMatNDArray, opencv_core.IplImageArray

Nested classes/interfaces inherited from class org.bytedeco.javacpp.presets.opencv_core
opencv_core.Ptr

Field Summary

Fields
Modifier and Type	Field and Description
`static int`	`CMP_EQ` enum cv::
`static int`	`CMP_GE` enum cv::
`static int`	`CMP_GT` enum cv::
`static int`	`CMP_LE` enum cv::
`static int`	`CMP_LT` enum cv::
`static int`	`CMP_NE` enum cv::
`static int`	`COVAR_COLS` enum cv::
`static int`	`COVAR_NORMAL` enum cv::
`static int`	`COVAR_ROWS` enum cv::
`static int`	`COVAR_SCALE` enum cv::
`static int`	`COVAR_SCRAMBLED` enum cv::
`static int`	`COVAR_USE_AVG` enum cv::
`static int`	`CV_16S`
`static int`	`CV_16SC1`
`static int`	`CV_16SC2`
`static int`	`CV_16SC3`
`static int`	`CV_16SC4`
`static int`	`CV_16U`
`static int`	`CV_16UC1`
`static int`	`CV_16UC2`
`static int`	`CV_16UC3`
`static int`	`CV_16UC4`
`static int`	`CV_32F`
`static int`	`CV_32FC1`
`static int`	`CV_32FC2`
`static int`	`CV_32FC3`
`static int`	`CV_32FC4`
`static int`	`CV_32S`
`static int`	`CV_32SC1`
`static int`	`CV_32SC2`
`static int`	`CV_32SC3`
`static int`	`CV_32SC4`
`static int`	`CV_64F`
`static int`	`CV_64FC1`
`static int`	`CV_64FC2`
`static int`	`CV_64FC3`
`static int`	`CV_64FC4`
`static int`	`CV_8S`
`static int`	`CV_8SC1`
`static int`	`CV_8SC2`
`static int`	`CV_8SC3`
`static int`	`CV_8SC4`
`static int`	`CV_8U`
`static int`	`CV_8UC1`
`static int`	`CV_8UC2`
`static int`	`CV_8UC3`
`static int`	`CV_8UC4`
`static int`	`CV_AA`
`static int`	`CV_AUTO_STEP`
`static int`	`CV_AUTOSTEP`
`static int`	`CV_BACK`
`static int`	`CV_BadAlign` enum
`static int`	`CV_BadAlphaChannel` enum
`static int`	`CV_BadCallBack` enum
`static int`	`CV_BadCOI` enum
`static int`	`CV_BadDataPtr` enum
`static int`	`CV_BadDepth` enum
`static int`	`CV_BadImageSize` enum
`static int`	`CV_BadModelOrChSeq` enum
`static int`	`CV_BadNumChannel1U` enum
`static int`	`CV_BadNumChannels` enum
`static int`	`CV_BadOffset` enum
`static int`	`CV_BadOrder` enum
`static int`	`CV_BadOrigin` enum
`static int`	`CV_BadROISize` enum
`static int`	`CV_BadStep` enum
`static int`	`CV_BadTileSize` enum
`static int`	`CV_C`
`static int`	`CV_CHECK_QUIET`
`static int`	`CV_CHECK_RANGE`
`static int`	`CV_CHOLESKY`
`static int`	`CV_CMP_EQ`
`static int`	`CV_CMP_GE`
`static int`	`CV_CMP_GT`
`static int`	`CV_CMP_LE`
`static int`	`CV_CMP_LT`
`static int`	`CV_CMP_NE`
`static int`	`CV_CN_MAX` \ Matrix type (CvMat) * \
`static int`	`CV_CN_SHIFT`
`static int`	`CV_COVAR_COLS`
`static int`	`CV_COVAR_NORMAL`
`static int`	`CV_COVAR_ROWS`
`static int`	`CV_COVAR_SCALE`
`static int`	`CV_COVAR_SCRAMBLED`
`static int`	`CV_COVAR_USE_AVG`
`static int`	`CV_CPU_AVX`
`static int`	`CV_CPU_AVX2`
`static int`	`CV_CPU_MMX`
`static int`	`CV_CPU_NONE` CPU capabilities
`static int`	`CV_CPU_POPCNT`
`static int`	`CV_CPU_SSE`
`static int`	`CV_CPU_SSE2`
`static int`	`CV_CPU_SSE3`
`static int`	`CV_CPU_SSE4_1`
`static int`	`CV_CPU_SSE4_2`
`static int`	`CV_CPU_SSSE3`
`static int`	`CV_DEPTH_MAX`
`static int`	`CV_DIFF`
`static int`	`CV_DIFF_C`
`static int`	`CV_DIFF_L1`
`static int`	`CV_DIFF_L2`
`static int`	`CV_DXT_FORWARD` \ Discrete Linear Transforms and Related Functions * \
`static int`	`CV_DXT_INV_SCALE`
`static int`	`CV_DXT_INVERSE`
`static int`	`CV_DXT_INVERSE_SCALE`
`static int`	`CV_DXT_MUL_CONJ`
`static int`	`CV_DXT_ROWS`
`static int`	`CV_DXT_SCALE`
`static int`	`CV_ErrModeLeaf`
`static int`	`CV_ErrModeParent`
`static int`	`CV_ErrModeSilent`
`static int`	`CV_FILLED` \ Drawing functions work with images/matrices of arbitrary type.
`static int`	`CV_FONT_HERSHEY_COMPLEX`
`static int`	`CV_FONT_HERSHEY_COMPLEX_SMALL`
`static int`	`CV_FONT_HERSHEY_DUPLEX`
`static int`	`CV_FONT_HERSHEY_PLAIN`
`static int`	`CV_FONT_HERSHEY_SCRIPT_COMPLEX`
`static int`	`CV_FONT_HERSHEY_SCRIPT_SIMPLEX`
`static int`	`CV_FONT_HERSHEY_SIMPLEX`
`static int`	`CV_FONT_HERSHEY_TRIPLEX`
`static int`	`CV_FONT_ITALIC`
`static int`	`CV_FONT_VECTOR0`
`static int`	`CV_FRONT`
`static int`	`CV_GEMM_A_T`
`static int`	`CV_GEMM_B_T`
`static int`	`CV_GEMM_C_T`
`static int`	`CV_GpuApiCallError` enum
`static int`	`CV_GpuNotSupported` enum
`static int`	`CV_GRAPH`
`static int`	`CV_GRAPH_ALL_ITEMS`
`static int`	`CV_GRAPH_ANY_EDGE`
`static int`	`CV_GRAPH_BACK_EDGE`
`static int`	`CV_GRAPH_BACKTRACKING`
`static int`	`CV_GRAPH_CROSS_EDGE`
`static int`	`CV_GRAPH_FLAG_ORIENTED`
`static int`	`CV_GRAPH_FORWARD_EDGE`
`static int`	`CV_GRAPH_FORWARD_EDGE_FLAG`
`static int`	`CV_GRAPH_ITEM_VISITED_FLAG`
`static int`	`CV_GRAPH_NEW_TREE`
`static int`	`CV_GRAPH_OVER`
`static int`	`CV_GRAPH_SEARCH_TREE_NODE_FLAG`
`static int`	`CV_GRAPH_TREE_EDGE`
`static int`	`CV_GRAPH_VERTEX`
`static int`	`CV_HARDWARE_MAX_FEATURE`
`static int`	`CV_HeaderIsNull` enum
`static int`	`CV_HIST_ARRAY`
`static int`	`CV_HIST_MAGIC_VAL` \ Histogram * \
`static int`	`CV_HIST_RANGES_FLAG`
`static int`	`CV_HIST_SPARSE`
`static int`	`CV_HIST_TREE`
`static int`	`CV_HIST_UNIFORM`
`static int`	`CV_HIST_UNIFORM_FLAG`
`static int`	`CV_KMEANS_USE_INITIAL_LABELS`
`static int`	`CV_L1`
`static int`	`CV_L2`
`static double`	`CV_LOG2`
`static int`	`CV_LU`
`static int`	`CV_MAGIC_MASK`
`static int`	`CV_MaskIsTiled` enum
`static int`	`CV_MAT_CN_MASK`
`static int`	`CV_MAT_CONT_FLAG`
`static int`	`CV_MAT_CONT_FLAG_SHIFT`
`static int`	`CV_MAT_DEPTH_MASK`
`static int`	`CV_MAT_MAGIC_VAL`
`static int`	`CV_MAT_TYPE_MASK`
`static int`	`CV_MATND_MAGIC_VAL` \ Multi-dimensional dense array (CvMatND) * \
`static int`	`CV_MAX_ARR` matrix iterator: used for n-ary operations on dense arrays
`static int`	`CV_MAX_DIM`
`static int`	`CV_MAX_DIM_HEAP`
`static int`	`CV_MINMAX`
`static int`	`CV_NO_CN_CHECK`
`static int`	`CV_NO_DEPTH_CHECK`
`static int`	`CV_NO_SIZE_CHECK`
`static int`	`CV_NODE_EMPTY`
`static int`	`CV_NODE_FLOAT`
`static int`	`CV_NODE_FLOW`
`static int`	`CV_NODE_INT`
`static int`	`CV_NODE_INTEGER`
`static int`	`CV_NODE_MAP`
`static int`	`CV_NODE_NAMED`
`static int`	`CV_NODE_NONE`
`static int`	`CV_NODE_REAL`
`static int`	`CV_NODE_REF`
`static int`	`CV_NODE_SEQ`
`static int`	`CV_NODE_SEQ_SIMPLE`
`static int`	`CV_NODE_STR`
`static int`	`CV_NODE_STRING`
`static int`	`CV_NODE_TYPE_MASK`
`static int`	`CV_NODE_USER`
`static int`	`CV_NORM_MASK`
`static int`	`CV_NORMAL`
`static int`	`CV_OpenCLDoubleNotSupported` enum
`static int`	`CV_OpenCLInitError` enum
`static int`	`CV_OpenCLNoAMDBlasFft` enum
`static int`	`CV_OpenGlApiCallError` enum
`static int`	`CV_OpenGlNotSupported` enum
`static int`	`CV_ORIENTED_GRAPH`
`static int`	`CV_PCA_DATA_AS_COL`
`static int`	`CV_PCA_DATA_AS_ROW`
`static int`	`CV_PCA_USE_AVG`
`static double`	`CV_PI` \ Common macros and inline functions * \
`static int`	`CV_QR`
`static int`	`CV_RAND_NORMAL`
`static int`	`CV_RAND_UNI`
`static int`	`CV_REDUCE_AVG`
`static int`	`CV_REDUCE_MAX`
`static int`	`CV_REDUCE_MIN`
`static int`	`CV_REDUCE_SUM`
`static int`	`CV_RELATIVE`
`static int`	`CV_RELATIVE_C`
`static int`	`CV_RELATIVE_L1`
`static int`	`CV_RELATIVE_L2`
`static long`	`CV_RNG_COEFF` Random number generation
`static int`	`CV_SEQ_CHAIN`
`static int`	`CV_SEQ_CHAIN_CONTOUR`
`static int`	`CV_SEQ_CONNECTED_COMP`
`static int`	`CV_SEQ_CONTOUR`
`static int`	`CV_SEQ_ELTYPE_BITS`
`static int`	`CV_SEQ_ELTYPE_CODE`
`static int`	`CV_SEQ_ELTYPE_CONNECTED_COMP`
`static int`	`CV_SEQ_ELTYPE_GENERIC`
`static int`	`CV_SEQ_ELTYPE_GRAPH_EDGE`
`static int`	`CV_SEQ_ELTYPE_GRAPH_VERTEX`
`static int`	`CV_SEQ_ELTYPE_INDEX`
`static int`	`CV_SEQ_ELTYPE_MASK`
`static int`	`CV_SEQ_ELTYPE_POINT`
`static int`	`CV_SEQ_ELTYPE_POINT3D`
`static int`	`CV_SEQ_ELTYPE_PPOINT`
`static int`	`CV_SEQ_ELTYPE_PTR`
`static int`	`CV_SEQ_ELTYPE_TRIAN_ATR`
`static int`	`CV_SEQ_FLAG_CLOSED`
`static int`	`CV_SEQ_FLAG_CONVEX`
`static int`	`CV_SEQ_FLAG_HOLE`
`static int`	`CV_SEQ_FLAG_SHIFT`
`static int`	`CV_SEQ_FLAG_SIMPLE`
`static int`	`CV_SEQ_INDEX`
`static int`	`CV_SEQ_KIND_BIN_TREE`
`static int`	`CV_SEQ_KIND_BITS`
`static int`	`CV_SEQ_KIND_CURVE`
`static int`	`CV_SEQ_KIND_GENERIC`
`static int`	`CV_SEQ_KIND_GRAPH`
`static int`	`CV_SEQ_KIND_MASK`
`static int`	`CV_SEQ_KIND_SUBDIV2D`
`static int`	`CV_SEQ_MAGIC_VAL` \ Sequence types * \
`static int`	`CV_SEQ_POINT_SET`
`static int`	`CV_SEQ_POINT3D_SET`
`static int`	`CV_SEQ_POLYGON`
`static int`	`CV_SEQ_POLYGON_TREE`
`static int`	`CV_SEQ_POLYLINE`
`static int`	`CV_SEQ_SIMPLE_POLYGON`
`static int`	`CV_SET_ELEM_FREE_FLAG`
`static int`	`CV_SET_ELEM_IDX_MASK`
`static int`	`CV_SET_MAGIC_VAL`
`static int`	`CV_SORT_ASCENDING`
`static int`	`CV_SORT_DESCENDING`
`static int`	`CV_SORT_EVERY_COLUMN`
`static int`	`CV_SORT_EVERY_ROW`
`static int`	`CV_SPARSE_MAT_MAGIC_VAL` \ Multi-dimensional sparse array (CvSparseMat) * \
`static int`	`CV_STORAGE_APPEND`
`static int`	`CV_STORAGE_FORMAT_AUTO`
`static int`	`CV_STORAGE_FORMAT_MASK`
`static int`	`CV_STORAGE_FORMAT_XML`
`static int`	`CV_STORAGE_FORMAT_YAML`
`static int`	`CV_STORAGE_MAGIC_VAL`
`static int`	`CV_STORAGE_MEMORY`
`static int`	`CV_STORAGE_READ`
`static int`	`CV_STORAGE_WRITE`
`static int`	`CV_STORAGE_WRITE_BINARY`
`static int`	`CV_STORAGE_WRITE_TEXT`
`static int`	`CV_StsAssert` enum
`static int`	`CV_StsAutoTrace` enum
`static int`	`CV_StsBackTrace` enum
`static int`	`CV_StsBadArg` enum
`static int`	`CV_StsBadFlag` enum
`static int`	`CV_StsBadFunc` enum
`static int`	`CV_StsBadMask` enum
`static int`	`CV_StsBadMemBlock` enum
`static int`	`CV_StsBadPoint` enum
`static int`	`CV_StsBadSize` enum
`static int`	`CV_StsDivByZero` enum
`static int`	`CV_StsError` enum
`static int`	`CV_StsFilterOffsetErr` enum
`static int`	`CV_StsFilterStructContentErr` enum
`static int`	`CV_StsInplaceNotSupported` enum
`static int`	`CV_StsInternal` enum
`static int`	`CV_StsKernelStructContentErr` enum
`static int`	`CV_StsNoConv` enum
`static int`	`CV_StsNoMem` enum
`static int`	`CV_StsNotImplemented` enum
`static int`	`CV_StsNullPtr` enum
`static int`	`CV_StsObjectNotFound` enum
`static int`	`CV_StsOk` enum
`static int`	`CV_StsOutOfRange` enum
`static int`	`CV_StsParseError` enum
`static int`	`CV_StsUnmatchedFormats` enum
`static int`	`CV_StsUnmatchedSizes` enum
`static int`	`CV_StsUnsupportedFormat` enum
`static int`	`CV_StsVecLengthErr` enum
`static int`	`CV_SUBMAT_FLAG`
`static int`	`CV_SUBMAT_FLAG_SHIFT`
`static int`	`CV_SVD`
`static int`	`CV_SVD_MODIFY_A`
`static int`	`CV_SVD_SYM`
`static int`	`CV_SVD_U_T`
`static int`	`CV_SVD_V_T`
`static int`	`CV_TERMCRIT_EPS`
`static int`	`CV_TERMCRIT_ITER` CvTermCriteria
`static int`	`CV_TERMCRIT_NUMBER`
`static String`	`CV_TYPE_NAME_GRAPH`
`static String`	`CV_TYPE_NAME_IMAGE`
`static String`	`CV_TYPE_NAME_MAT`
`static String`	`CV_TYPE_NAME_MATND`
`static String`	`CV_TYPE_NAME_SEQ`
`static String`	`CV_TYPE_NAME_SEQ_TREE`
`static String`	`CV_TYPE_NAME_SPARSE_MAT`
`static int`	`CV_USRTYPE1`
`static opencv_core.CvSlice`	`CV_WHOLE_ARR`
`static opencv_core.CvSlice`	`CV_WHOLE_SEQ`
`static int`	`CV_WHOLE_SEQ_END_INDEX`
`static String`	`cvFuncName`
`static int`	`DCT_INVERSE` enum cv::
`static int`	`DCT_ROWS` enum cv::
`static int`	`DECOMP_CHOLESKY` enum cv::
`static int`	`DECOMP_EIG` enum cv::
`static int`	`DECOMP_LU` enum cv::
`static int`	`DECOMP_NORMAL` enum cv::
`static int`	`DECOMP_QR` enum cv::
`static int`	`DECOMP_SVD` enum cv::
`static int`	`DEPTH_MASK` enum cv::
`static int`	`DEPTH_MASK_16S` enum cv::
`static int`	`DEPTH_MASK_16U` enum cv::
`static int`	`DEPTH_MASK_32F` enum cv::
`static int`	`DEPTH_MASK_32S` enum cv::
`static int`	`DEPTH_MASK_64F` enum cv::
`static int`	`DEPTH_MASK_8S` enum cv::
`static int`	`DEPTH_MASK_8U` enum cv::
`static int`	`DEPTH_MASK_ALL` enum cv::
`static int`	`DEPTH_MASK_ALL_BUT_8S` enum cv::
`static int`	`DEPTH_MASK_FLT` enum cv::
`static int`	`DFT_COMPLEX_OUTPUT` enum cv::
`static int`	`DFT_INVERSE` enum cv::
`static int`	`DFT_REAL_OUTPUT` enum cv::
`static int`	`DFT_ROWS` enum cv::
`static int`	`DFT_SCALE` enum cv::
`static int`	`FONT_HERSHEY_COMPLEX` enum cv::
`static int`	`FONT_HERSHEY_COMPLEX_SMALL` enum cv::
`static int`	`FONT_HERSHEY_DUPLEX` enum cv::
`static int`	`FONT_HERSHEY_PLAIN` enum cv::
`static int`	`FONT_HERSHEY_SCRIPT_COMPLEX` enum cv::
`static int`	`FONT_HERSHEY_SCRIPT_SIMPLEX` enum cv::
`static int`	`FONT_HERSHEY_SIMPLEX` enum cv::
`static int`	`FONT_HERSHEY_TRIPLEX` enum cv::
`static int`	`FONT_ITALIC` enum cv::
`static int`	`GEMM_1_T` enum cv::
`static int`	`GEMM_2_T` enum cv::
`static int`	`GEMM_3_T` enum cv::
`static int`	`IPL_ALIGN_16BYTES`
`static int`	`IPL_ALIGN_32BYTES`
`static int`	`IPL_ALIGN_4BYTES`
`static int`	`IPL_ALIGN_8BYTES`
`static int`	`IPL_ALIGN_DWORD`
`static int`	`IPL_ALIGN_QWORD`
`static int`	`IPL_BORDER_CONSTANT`
`static int`	`IPL_BORDER_REFLECT`
`static int`	`IPL_BORDER_REFLECT_101`
`static int`	`IPL_BORDER_REPLICATE`
`static int`	`IPL_BORDER_TRANSPARENT`
`static int`	`IPL_BORDER_WRAP`
`static int`	`IPL_DATA_ORDER_PIXEL`
`static int`	`IPL_DATA_ORDER_PLANE`
`static int`	`IPL_DEPTH_16S`
`static int`	`IPL_DEPTH_16U`
`static int`	`IPL_DEPTH_1U`
`static int`	`IPL_DEPTH_32F`
`static int`	`IPL_DEPTH_32S`
`static int`	`IPL_DEPTH_64F`
`static int`	`IPL_DEPTH_8S`
`static int`	`IPL_DEPTH_8U`
`static int`	`IPL_DEPTH_SIGN` \ Image type (IplImage) * \
`static int`	`IPL_IMAGE_DATA`
`static int`	`IPL_IMAGE_HEADER`
`static int`	`IPL_IMAGE_MAGIC_VAL`
`static int`	`IPL_IMAGE_ROI`
`static int`	`IPL_ORIGIN_BL`
`static int`	`IPL_ORIGIN_TL`
`static int`	`KMEANS_PP_CENTERS` enum cv::
`static int`	`KMEANS_RANDOM_CENTERS` enum cv::
`static int`	`KMEANS_USE_INITIAL_LABELS` enum cv::
`static int`	`MAGIC_MASK` enum cv::
`static int`	`NORM_HAMMING` enum cv::
`static int`	`NORM_HAMMING2` enum cv::
`static int`	`NORM_INF` enum cv::
`static int`	`NORM_L1` enum cv::
`static int`	`NORM_L2` enum cv::
`static int`	`NORM_L2SQR` enum cv::
`static int`	`NORM_MINMAX` enum cv::
`static int`	`NORM_RELATIVE` enum cv::
`static int`	`NORM_TYPE_MASK` enum cv::
`static int`	`SORT_ASCENDING` enum cv::
`static int`	`SORT_DESCENDING` enum cv::
`static int`	`SORT_EVERY_COLUMN` enum cv::
`static int`	`SORT_EVERY_ROW` enum cv::
`static int`	`TYPE_MASK` enum cv::

Constructor Summary

Constructors
Constructor and Description

opencv_core()

Constructors
Constructor and Description
`opencv_core()`

Method Summary

All Methods Static Methods Concrete Methods
Modifier and Type	Method and Description
`static opencv_core.MatExpr`	`abs(opencv_core.Mat m)`
`static opencv_core.MatExpr`	`abs(opencv_core.MatExpr e)`
`static void`	`absdiff(opencv_core.Mat src1, opencv_core.Mat src2, opencv_core.Mat dst)` computes element-wise absolute difference of two arrays (dst = abs(src1 - src2))
`static opencv_core.Range`	`add(int delta, opencv_core.Range r1)`
`static opencv_core.MatConstIterator`	`add(long ofs, opencv_core.MatConstIterator a)`
`static opencv_core.MatConstIterator`	`add(opencv_core.MatConstIterator a, long ofs)`
`static opencv_core.MatExpr`	`add(opencv_core.MatExpr e, opencv_core.Mat m)`
`static opencv_core.MatExpr`	`add(opencv_core.MatExpr e1, opencv_core.MatExpr e2)`
`static opencv_core.MatExpr`	`add(opencv_core.MatExpr e, opencv_core.Scalar s)`
`static opencv_core.MatExpr`	`add(opencv_core.Mat a, opencv_core.Mat b)`
`static opencv_core.MatExpr`	`add(opencv_core.Mat m, opencv_core.MatExpr e)`
`static void`	`add(opencv_core.Mat src1, opencv_core.Mat src2, opencv_core.Mat dst)`
`static void`	`add(opencv_core.Mat src1, opencv_core.Mat src2, opencv_core.Mat dst, opencv_core.Mat mask, int dtype)` adds one matrix to another (dst = src1 + src2)
`static opencv_core.MatExpr`	`add(opencv_core.Mat a, opencv_core.Scalar s)`
`static opencv_core.Range`	`add(opencv_core.Range r1, int delta)`
`static opencv_core.MatExpr`	`add(opencv_core.Scalar s, opencv_core.Mat a)`
`static opencv_core.MatExpr`	`add(opencv_core.Scalar s, opencv_core.MatExpr e)`
`static opencv_core.Mat`	`addPut(opencv_core.Mat a, opencv_core.Mat b)`
`static opencv_core.Mat`	`addPut(opencv_core.Mat a, opencv_core.MatExpr b)`
`static opencv_core.Mat`	`addPut(opencv_core.Mat a, opencv_core.Scalar s)`
`static void`	`addWeighted(opencv_core.Mat src1, double alpha, opencv_core.Mat src2, double beta, double gamma, opencv_core.Mat dst)`
`static void`	`addWeighted(opencv_core.Mat src1, double alpha, opencv_core.Mat src2, double beta, double gamma, opencv_core.Mat dst, int dtype)` computes weighted sum of two arrays (dst = alphasrc1 + betasrc2 + gamma)
`static long`	`alignSize(long sz, int n)` Aligns buffer size by the certain number of bytes This small inline function aligns a buffer size by the certian number of bytes by enlarging it.
`static opencv_core.MatExpr`	`and(opencv_core.Mat a, opencv_core.Mat b)`
`static opencv_core.MatExpr`	`and(opencv_core.Mat a, opencv_core.Scalar s)`
`static opencv_core.Range`	`and(opencv_core.Range r1, opencv_core.Range r2)`
`static opencv_core.MatExpr`	`and(opencv_core.Scalar s, opencv_core.Mat a)`
`static opencv_core.Mat`	`andPut(opencv_core.Mat a, opencv_core.Mat b)`
`static opencv_core.Mat`	`andPut(opencv_core.Mat a, opencv_core.Scalar s)`
`static opencv_core.Range`	`andPut(opencv_core.Range r1, opencv_core.Range r2)`
`static void`	`arrowedLine(opencv_core.Mat img, opencv_core.Point pt1, opencv_core.Point pt2, opencv_core.Scalar color)`
`static void`	`arrowedLine(opencv_core.Mat img, opencv_core.Point pt1, opencv_core.Point pt2, opencv_core.Scalar color, int thickness, int line_type, int shift, double tipLength)` draws an arrow from pt1 to pt2 in the image
`static void`	`batchDistance(opencv_core.Mat src1, opencv_core.Mat src2, opencv_core.Mat dist, int dtype, opencv_core.Mat nidx)`
`static void`	`batchDistance(opencv_core.Mat src1, opencv_core.Mat src2, opencv_core.Mat dist, int dtype, opencv_core.Mat nidx, int normType, int K, opencv_core.Mat mask, int update, boolean crosscheck)` naive nearest neighbor finder
`static void`	`bitwise_and(opencv_core.Mat src1, opencv_core.Mat src2, opencv_core.Mat dst)`
`static void`	`bitwise_and(opencv_core.Mat src1, opencv_core.Mat src2, opencv_core.Mat dst, opencv_core.Mat mask)` computes bitwise conjunction of the two arrays (dst = src1 & src2)
`static void`	`bitwise_not(opencv_core.Mat src, opencv_core.Mat dst)`
`static void`	`bitwise_not(opencv_core.Mat src, opencv_core.Mat dst, opencv_core.Mat mask)` inverts each bit of array (dst = ~src)
`static void`	`bitwise_or(opencv_core.Mat src1, opencv_core.Mat src2, opencv_core.Mat dst)`
`static void`	`bitwise_or(opencv_core.Mat src1, opencv_core.Mat src2, opencv_core.Mat dst, opencv_core.Mat mask)` computes bitwise disjunction of the two arrays (dst = src1 \| src2)
`static void`	`bitwise_xor(opencv_core.Mat src1, opencv_core.Mat src2, opencv_core.Mat dst)`
`static void`	`bitwise_xor(opencv_core.Mat src1, opencv_core.Mat src2, opencv_core.Mat dst, opencv_core.Mat mask)` computes bitwise exclusive-or of the two arrays (dst = src1 ^ src2)
`static void`	`calcCovarMatrix(opencv_core.Mat samples, int nsamples, opencv_core.Mat covar, opencv_core.Mat mean, int flags)`
`static void`	`calcCovarMatrix(opencv_core.Mat samples, int nsamples, opencv_core.Mat covar, opencv_core.Mat mean, int flags, int ctype)` computes covariation matrix of a set of samples
`static void`	`calcCovarMatrix(opencv_core.Mat samples, opencv_core.Mat covar, opencv_core.Mat mean, int flags)`
`static void`	`calcCovarMatrix(opencv_core.Mat samples, opencv_core.Mat covar, opencv_core.Mat mean, int flags, int ctype)` computes covariation matrix of a set of samples
`static void`	`cartToPolar(opencv_core.Mat x, opencv_core.Mat y, opencv_core.Mat magnitude, opencv_core.Mat angle)`
`static void`	`cartToPolar(opencv_core.Mat x, opencv_core.Mat y, opencv_core.Mat magnitude, opencv_core.Mat angle, boolean angleInDegrees)` converts Cartesian coordinates to polar
`static boolean`	`checkHardwareSupport(int feature)` Returns SSE etc.
`static boolean`	`checkRange(opencv_core.Mat a)`
`static boolean`	`checkRange(opencv_core.Mat a, boolean quiet, opencv_core.Point pos, double minVal, double maxVal)` checks that each matrix element is within the specified range.
`static boolean`	`Cholesky(double[] A, long astep, int m, double[] b, long bstep, int n)`
`static boolean`	`Cholesky(DoubleBuffer A, long astep, int m, DoubleBuffer b, long bstep, int n)`
`static boolean`	`Cholesky(DoublePointer A, long astep, int m, DoublePointer b, long bstep, int n)`
`static boolean`	`Cholesky(float[] A, long astep, int m, float[] b, long bstep, int n)`
`static boolean`	`Cholesky(FloatBuffer A, long astep, int m, FloatBuffer b, long bstep, int n)`
`static boolean`	`Cholesky(FloatPointer A, long astep, int m, FloatPointer b, long bstep, int n)`
`static void`	`circle(opencv_core.Mat img, opencv_core.Point center, int radius, opencv_core.Scalar color)`
`static void`	`circle(opencv_core.Mat img, opencv_core.Point center, int radius, opencv_core.Scalar color, int thickness, int lineType, int shift)` draws the circle outline or a solid circle in the image
`static void`	`clearSeq(opencv_core.CvSeq seq)`
`static boolean`	`clipLine(opencv_core.Rect imgRect, opencv_core.Point pt1, opencv_core.Point pt2)` clips the line segment by the rectangle imgRect
`static boolean`	`clipLine(opencv_core.Size imgSize, opencv_core.Point pt1, opencv_core.Point pt2)` clips the line segment by the rectangle Rect(0, 0, imgSize.width, imgSize.height)
`static void`	`compare(opencv_core.Mat src1, opencv_core.Mat src2, opencv_core.Mat dst, int cmpop)` compares elements of two arrays (dst = src1 src2)
`static void`	`completeSymm(opencv_core.Mat mtx)`
`static void`	`completeSymm(opencv_core.Mat mtx, boolean lowerToUpper)` extends the symmetrical matrix from the lower half or from the upper half
`static void`	`convertScaleAbs(opencv_core.Mat src, opencv_core.Mat dst)`
`static void`	`convertScaleAbs(opencv_core.Mat src, opencv_core.Mat dst, double alpha, double beta)` scales array elements, computes absolute values and converts the results to 8-bit unsigned integers: dst(i)=saturate_castabs(src(i)*alpha+beta)
`static int`	`countNonZero(opencv_core.Mat src)` computes the number of nonzero array elements
`static float`	`cubeRoot(float val)` computes cube root of the argument
`static int`	`CV_16SC(int n)`
`static int`	`CV_16UC(int n)`
`static int`	`CV_32FC(int n)`
`static int`	`CV_32SC(int n)`
`static int`	`CV_64FC(int n)`
`static int`	`CV_8SC(int n)`
`static int`	`CV_8UC(int n)`
`static int`	`CV_IS_CONT_MAT(int arg1)`
`static int`	`CV_IS_MAT_CONT(int flags)`
`static int`	`CV_MAKE_TYPE(int arg1, int arg2)`
`static int`	`CV_MAKETYPE(int depth, int cn)`
`static int`	`CV_MAT_CN(int flags)`
`static int`	`CV_MAT_DEPTH(int flags)`
`static int`	`CV_MAT_TYPE(int flags)`
`static int`	`CV_SET_ELEM_FREE_FLAG()`
`static int`	`CV_XADD(int[] addr, int delta)`
`static int`	`CV_XADD(IntBuffer addr, int delta)`
`static int`	`CV_XADD(IntPointer addr, int delta)`
`static void`	`cvAbsDiff(opencv_core.CvArr src1, opencv_core.CvArr src2, opencv_core.CvArr dst)`
`static void`	`cvAbsDiffS(opencv_core.CvArr src, opencv_core.CvArr dst, opencv_core.CvScalar value)`
`static void`	`cvAdd(opencv_core.CvArr src1, opencv_core.CvArr src2, opencv_core.CvArr dst)`
`static void`	`cvAdd(opencv_core.CvArr src1, opencv_core.CvArr src2, opencv_core.CvArr dst, opencv_core.CvArr mask)` \ Arithmetic, logic and comparison operations * \
`static void`	`cvAddS(opencv_core.CvArr src, opencv_core.CvScalar value, opencv_core.CvArr dst)`
`static void`	`cvAddS(opencv_core.CvArr src, opencv_core.CvScalar value, opencv_core.CvArr dst, opencv_core.CvArr mask)`
`static void`	`cvAddWeighted(opencv_core.CvArr src1, double alpha, opencv_core.CvArr src2, double beta, double gamma, opencv_core.CvArr dst)`
`static Pointer`	`cvAlloc(long size)` \ Array allocation, deallocation, initialization and access to elements * \
`static void`	`cvAnd(opencv_core.CvArr src1, opencv_core.CvArr src2, opencv_core.CvArr dst)`
`static void`	`cvAnd(opencv_core.CvArr src1, opencv_core.CvArr src2, opencv_core.CvArr dst, opencv_core.CvArr mask)`
`static void`	`cvAndS(opencv_core.CvArr src, opencv_core.CvScalar value, opencv_core.CvArr dst)`
`static void`	`cvAndS(opencv_core.CvArr src, opencv_core.CvScalar value, opencv_core.CvArr dst, opencv_core.CvArr mask)`
`static opencv_core.Mat`	`cvarrToMat(opencv_core.CvArr arr)`
`static opencv_core.Mat`	`cvarrToMat(opencv_core.CvArr arr, boolean copyData, boolean allowND, int coiMode)` converts array (CvMat or IplImage) to cv::Mat
`static opencv_core.Mat`	`cvarrToMatND(opencv_core.CvArr arr)`
`static opencv_core.Mat`	`cvarrToMatND(opencv_core.CvArr arr, boolean copyData, int coiMode)` Writes a Rect_ to an output stream.
`static opencv_core.CvAttrList`	`cvAttrList()`
`static opencv_core.CvAttrList`	`cvAttrList(byte[] attr, opencv_core.CvAttrList next)`
`static opencv_core.CvAttrList`	`cvAttrList(ByteBuffer attr, opencv_core.CvAttrList next)`
`static opencv_core.CvAttrList`	`cvAttrList(BytePointer attr, opencv_core.CvAttrList next)`
`static opencv_core.CvAttrList`	`cvAttrList(PointerPointer attr, opencv_core.CvAttrList next)`
`static BytePointer`	`cvAttrValue(opencv_core.CvAttrList attr, BytePointer attr_name)`
`static String`	`cvAttrValue(opencv_core.CvAttrList attr, String attr_name)`
`static opencv_core.CvScalar`	`cvAvg(opencv_core.CvArr arr)`
`static opencv_core.CvScalar`	`cvAvg(opencv_core.CvArr arr, opencv_core.CvArr mask)`
`static void`	`cvAvgSdv(opencv_core.CvArr arr, opencv_core.CvScalar mean, opencv_core.CvScalar std_dev)`
`static void`	`cvAvgSdv(opencv_core.CvArr arr, opencv_core.CvScalar mean, opencv_core.CvScalar std_dev, opencv_core.CvArr mask)`
`static void`	`cvBackProjectPCA(opencv_core.CvArr proj, opencv_core.CvArr mean, opencv_core.CvArr eigenvects, opencv_core.CvArr result)`
`static void`	`cvCalcCovarMatrix(opencv_core.CvArr vects, int count, opencv_core.CvArr cov_mat, opencv_core.CvArr avg, int flags)`
`static void`	`cvCalcCovarMatrix(PointerPointer vects, int count, opencv_core.CvArr cov_mat, opencv_core.CvArr avg, int flags)`
`static void`	`cvCalcPCA(opencv_core.CvArr data, opencv_core.CvArr mean, opencv_core.CvArr eigenvals, opencv_core.CvArr eigenvects, int flags)`
`static void`	`cvCartToPolar(opencv_core.CvArr x, opencv_core.CvArr y, opencv_core.CvArr magnitude)`
`static void`	`cvCartToPolar(opencv_core.CvArr x, opencv_core.CvArr y, opencv_core.CvArr magnitude, opencv_core.CvArr angle, int angle_in_degrees)` \ Math operations * \
`static float`	`cvCbrt(float value)`
`static int`	`cvCeil(double value)`
`static void`	`cvChangeSeqBlock(Pointer reader, int direction)` Internal sequence functions
`static int`	`cvCheckArr(opencv_core.CvArr arr)`
`static int`	`cvCheckArr(opencv_core.CvArr arr, int flags, double min_val, double max_val)`
`static int`	`cvCheckArray(opencv_core.CvArr arg1, int arg2, double arg3, double arg4)`
`static int`	`cvCheckHardwareSupport(int feature)`
`static opencv_core.CvTermCriteria`	`cvCheckTermCriteria(opencv_core.CvTermCriteria criteria, double default_eps, int default_max_iters)`
`static void`	`cvCircle(opencv_core.CvArr img, int[] center, int radius, opencv_core.CvScalar color)`
`static void`	`cvCircle(opencv_core.CvArr img, int[] center, int radius, opencv_core.CvScalar color, int thickness, int line_type, int shift)`
`static void`	`cvCircle(opencv_core.CvArr img, IntBuffer center, int radius, opencv_core.CvScalar color)`
`static void`	`cvCircle(opencv_core.CvArr img, IntBuffer center, int radius, opencv_core.CvScalar color, int thickness, int line_type, int shift)`
`static void`	`cvCircle(opencv_core.CvArr img, opencv_core.CvPoint center, int radius, opencv_core.CvScalar color)`
`static void`	`cvCircle(opencv_core.CvArr img, opencv_core.CvPoint center, int radius, opencv_core.CvScalar color, int thickness, int line_type, int shift)`
`static void`	`cvClearGraph(opencv_core.CvGraph graph)`
`static void`	`cvClearMemStorage(opencv_core.CvMemStorage storage)`
`static void`	`cvClearND(opencv_core.CvArr arr, int[] idx)`
`static void`	`cvClearND(opencv_core.CvArr arr, IntBuffer idx)`
`static void`	`cvClearND(opencv_core.CvArr arr, IntPointer idx)`
`static void`	`cvClearSeq(opencv_core.CvSeq seq)`
`static void`	`cvClearSet(opencv_core.CvSet set_header)`
`static int`	`cvClipLine(opencv_core.CvSize img_size, int[] pt1, int[] pt2)`
`static int`	`cvClipLine(opencv_core.CvSize img_size, IntBuffer pt1, IntBuffer pt2)`
`static int`	`cvClipLine(opencv_core.CvSize img_size, opencv_core.CvPoint pt1, opencv_core.CvPoint pt2)`
`static Pointer`	`cvClone(Pointer struct_ptr)`
`static opencv_core.CvGraph`	`cvCloneGraph(opencv_core.CvGraph graph, opencv_core.CvMemStorage storage)`
`static opencv_core.IplImage`	`cvCloneImage(opencv_core.IplImage image)`
`static opencv_core.CvMat`	`cvCloneMat(opencv_core.CvMat mat)`
`static opencv_core.CvMatND`	`cvCloneMatND(opencv_core.CvMatND mat)`
`static opencv_core.CvSeq`	`cvCloneSeq(opencv_core.CvSeq seq)`
`static opencv_core.CvSeq`	`cvCloneSeq(opencv_core.CvSeq seq, opencv_core.CvMemStorage storage)`
`static opencv_core.CvSparseMat`	`cvCloneSparseMat(opencv_core.CvSparseMat mat)`
`static void`	`cvCmp(opencv_core.CvArr src1, opencv_core.CvArr src2, opencv_core.CvArr dst, int cmp_op)`
`static void`	`cvCmpS(opencv_core.CvArr src, double value, opencv_core.CvArr dst, int cmp_op)`
`static opencv_core.CvScalar`	`cvColorToScalar(double packed_color, int arrtype)`
`static void`	`cvCompleteSymm(opencv_core.CvMat matrix)`
`static void`	`cvCompleteSymm(opencv_core.CvMat matrix, int LtoR)`
`static void`	`cvConvert(opencv_core.CvArr src, opencv_core.CvArr dst)`
`static void`	`cvConvertScale(opencv_core.CvArr src, opencv_core.CvArr dst)`
`static void`	`cvConvertScale(opencv_core.CvArr src, opencv_core.CvArr dst, double scale, double shift)`
`static void`	`cvConvertScaleAbs(opencv_core.CvArr src, opencv_core.CvArr dst)`
`static void`	`cvConvertScaleAbs(opencv_core.CvArr src, opencv_core.CvArr dst, double scale, double shift)`
`static void`	`cvCopy(opencv_core.CvArr src, opencv_core.CvArr dst)`
`static void`	`cvCopy(opencv_core.CvArr src, opencv_core.CvArr dst, opencv_core.CvArr mask)`
`static int`	`cvCountNonZero(opencv_core.CvArr arr)`
`static opencv_core.CvMemStorage`	`cvCreateChildMemStorage(opencv_core.CvMemStorage parent)`
`static void`	`cvCreateData(opencv_core.CvArr arr)`
`static opencv_core.CvGraph`	`cvCreateGraph(int graph_flags, int header_size, int vtx_size, int edge_size, opencv_core.CvMemStorage storage)`
`static opencv_core.CvGraphScanner`	`cvCreateGraphScanner(opencv_core.CvGraph graph)`
`static opencv_core.CvGraphScanner`	`cvCreateGraphScanner(opencv_core.CvGraph graph, opencv_core.CvGraphVtx vtx, int mask)`
`static opencv_core.IplImage`	`cvCreateImage(opencv_core.CvSize size, int depth, int channels)`
`static opencv_core.IplImage`	`cvCreateImageHeader(opencv_core.CvSize size, int depth, int channels)`
`static opencv_core.CvMat`	`cvCreateMat(int rows, int cols, int type)`
`static opencv_core.CvMat`	`cvCreateMatHeader(int rows, int cols, int type)`
`static opencv_core.CvMatND`	`cvCreateMatND(int dims, int[] sizes, int type)`
`static opencv_core.CvMatND`	`cvCreateMatND(int dims, IntBuffer sizes, int type)`
`static opencv_core.CvMatND`	`cvCreateMatND(int dims, IntPointer sizes, int type)`
`static opencv_core.CvMatND`	`cvCreateMatNDHeader(int dims, int[] sizes, int type)`
`static opencv_core.CvMatND`	`cvCreateMatNDHeader(int dims, IntBuffer sizes, int type)`
`static opencv_core.CvMatND`	`cvCreateMatNDHeader(int dims, IntPointer sizes, int type)`
`static opencv_core.CvMemStorage`	`cvCreateMemStorage()`
`static opencv_core.CvMemStorage`	`cvCreateMemStorage(int block_size)`
`static opencv_core.CvSeq`	`cvCreateSeq(int seq_flags, long header_size, long elem_size, opencv_core.CvMemStorage storage)`
`static void`	`cvCreateSeqBlock(opencv_core.CvSeqWriter writer)`
`static opencv_core.CvSet`	`cvCreateSet(int set_flags, int header_size, int elem_size, opencv_core.CvMemStorage storage)`
`static opencv_core.CvSparseMat`	`cvCreateSparseMat(int dims, int[] sizes, int type)`
`static opencv_core.CvSparseMat`	`cvCreateSparseMat(int dims, IntBuffer sizes, int type)`
`static opencv_core.CvSparseMat`	`cvCreateSparseMat(int dims, IntPointer sizes, int type)`
`static void`	`cvCrossProduct(opencv_core.CvArr src1, opencv_core.CvArr src2, opencv_core.CvArr dst)` \ Matrix operations * \
`static void`	`cvCvtScale(opencv_core.CvArr arg1, opencv_core.CvArr arg2, double arg3, double arg4)`
`static void`	`cvCvtScaleAbs(opencv_core.CvArr arg1, opencv_core.CvArr arg2, double arg3, double arg4)`
`static Pointer`	`cvCvtSeqToArray(opencv_core.CvSeq seq, Pointer elements)`
`static Pointer`	`cvCvtSeqToArray(opencv_core.CvSeq seq, Pointer elements, opencv_core.CvSlice slice)`
`static void`	`cvDCT(opencv_core.CvArr src, opencv_core.CvArr dst, int flags)`
`static void`	`cvDecRefData(opencv_core.CvArr arr)`
`static double`	`cvDet(opencv_core.CvArr mat)`
`static void`	`cvDFT(opencv_core.CvArr src, opencv_core.CvArr dst, int flags)`
`static void`	`cvDFT(opencv_core.CvArr src, opencv_core.CvArr dst, int flags, int nonzero_rows)`
`static void`	`cvDiv(opencv_core.CvArr src1, opencv_core.CvArr src2, opencv_core.CvArr dst)`
`static void`	`cvDiv(opencv_core.CvArr src1, opencv_core.CvArr src2, opencv_core.CvArr dst, double scale)`
`static double`	`cvDotProduct(opencv_core.CvArr src1, opencv_core.CvArr src2)`
`static void`	`cvDrawCircle(opencv_core.CvArr arg1, int[] arg2, int arg3, opencv_core.CvScalar arg4, int arg5, int arg6, int arg7)`
`static void`	`cvDrawCircle(opencv_core.CvArr arg1, IntBuffer arg2, int arg3, opencv_core.CvScalar arg4, int arg5, int arg6, int arg7)`
`static void`	`cvDrawCircle(opencv_core.CvArr arg1, opencv_core.CvPoint arg2, int arg3, opencv_core.CvScalar arg4, int arg5, int arg6, int arg7)`
`static void`	`cvDrawContours(opencv_core.CvArr img, opencv_core.CvSeq contour, opencv_core.CvScalar external_color, opencv_core.CvScalar hole_color, int max_level)`
`static void`	`cvDrawContours(opencv_core.CvArr img, opencv_core.CvSeq contour, opencv_core.CvScalar external_color, opencv_core.CvScalar hole_color, int max_level, int thickness, int line_type, int[] offset)`
`static void`	`cvDrawContours(opencv_core.CvArr img, opencv_core.CvSeq contour, opencv_core.CvScalar external_color, opencv_core.CvScalar hole_color, int max_level, int thickness, int line_type, IntBuffer offset)`
`static void`	`cvDrawContours(opencv_core.CvArr img, opencv_core.CvSeq contour, opencv_core.CvScalar external_color, opencv_core.CvScalar hole_color, int max_level, int thickness, int line_type, opencv_core.CvPoint offset)`
`static void`	`cvDrawEllipse(opencv_core.CvArr arg1, int[] arg2, opencv_core.CvSize arg3, double arg4, double arg5, double arg6, opencv_core.CvScalar arg7, int arg8, int arg9, int arg10)`
`static void`	`cvDrawEllipse(opencv_core.CvArr arg1, IntBuffer arg2, opencv_core.CvSize arg3, double arg4, double arg5, double arg6, opencv_core.CvScalar arg7, int arg8, int arg9, int arg10)`
`static void`	`cvDrawEllipse(opencv_core.CvArr arg1, opencv_core.CvPoint arg2, opencv_core.CvSize arg3, double arg4, double arg5, double arg6, opencv_core.CvScalar arg7, int arg8, int arg9, int arg10)`
`static void`	`cvDrawLine(opencv_core.CvArr arg1, int[] arg2, int[] arg3, opencv_core.CvScalar arg4, int arg5, int arg6, int arg7)`
`static void`	`cvDrawLine(opencv_core.CvArr arg1, IntBuffer arg2, IntBuffer arg3, opencv_core.CvScalar arg4, int arg5, int arg6, int arg7)`
`static void`	`cvDrawLine(opencv_core.CvArr arg1, opencv_core.CvPoint arg2, opencv_core.CvPoint arg3, opencv_core.CvScalar arg4, int arg5, int arg6, int arg7)`
`static void`	`cvDrawPolyLine(opencv_core.CvArr arg1, int[] arg2, int[] arg3, int arg4, int arg5, opencv_core.CvScalar arg6, int arg7, int arg8, int arg9)`
`static void`	`cvDrawPolyLine(opencv_core.CvArr arg1, IntBuffer arg2, IntBuffer arg3, int arg4, int arg5, opencv_core.CvScalar arg6, int arg7, int arg8, int arg9)`
`static void`	`cvDrawPolyLine(opencv_core.CvArr arg1, opencv_core.CvPoint arg2, IntPointer arg3, int arg4, int arg5, opencv_core.CvScalar arg6, int arg7, int arg8, int arg9)`
`static void`	`cvDrawPolyLine(opencv_core.CvArr arg1, PointerPointer arg2, IntPointer arg3, int arg4, int arg5, opencv_core.CvScalar arg6, int arg7, int arg8, int arg9)`
`static void`	`cvDrawRect(opencv_core.CvArr arg1, int[] arg2, int[] arg3, opencv_core.CvScalar arg4, int arg5, int arg6, int arg7)`
`static void`	`cvDrawRect(opencv_core.CvArr arg1, IntBuffer arg2, IntBuffer arg3, opencv_core.CvScalar arg4, int arg5, int arg6, int arg7)`
`static void`	`cvDrawRect(opencv_core.CvArr arg1, opencv_core.CvPoint arg2, opencv_core.CvPoint arg3, opencv_core.CvScalar arg4, int arg5, int arg6, int arg7)`
`static void`	`cvEigenVV(opencv_core.CvArr mat, opencv_core.CvArr evects, opencv_core.CvArr evals)`
`static void`	`cvEigenVV(opencv_core.CvArr mat, opencv_core.CvArr evects, opencv_core.CvArr evals, double eps, int lowindex, int highindex)`
`static void`	`cvEllipse(opencv_core.CvArr img, int[] center, opencv_core.CvSize axes, double angle, double start_angle, double end_angle, opencv_core.CvScalar color)`
`static void`	`cvEllipse(opencv_core.CvArr img, int[] center, opencv_core.CvSize axes, double angle, double start_angle, double end_angle, opencv_core.CvScalar color, int thickness, int line_type, int shift)`
`static void`	`cvEllipse(opencv_core.CvArr img, IntBuffer center, opencv_core.CvSize axes, double angle, double start_angle, double end_angle, opencv_core.CvScalar color)`
`static void`	`cvEllipse(opencv_core.CvArr img, IntBuffer center, opencv_core.CvSize axes, double angle, double start_angle, double end_angle, opencv_core.CvScalar color, int thickness, int line_type, int shift)`
`static void`	`cvEllipse(opencv_core.CvArr img, opencv_core.CvPoint center, opencv_core.CvSize axes, double angle, double start_angle, double end_angle, opencv_core.CvScalar color)`
`static void`	`cvEllipse(opencv_core.CvArr img, opencv_core.CvPoint center, opencv_core.CvSize axes, double angle, double start_angle, double end_angle, opencv_core.CvScalar color, int thickness, int line_type, int shift)`
`static int`	`cvEllipse2Poly(int[] center, opencv_core.CvSize axes, int angle, int arc_start, int arc_end, int[] pts, int delta)`
`static int`	`cvEllipse2Poly(IntBuffer center, opencv_core.CvSize axes, int angle, int arc_start, int arc_end, IntBuffer pts, int delta)`
`static int`	`cvEllipse2Poly(opencv_core.CvPoint center, opencv_core.CvSize axes, int angle, int arc_start, int arc_end, opencv_core.CvPoint pts, int delta)`
`static void`	`cvEllipseBox(opencv_core.CvArr img, opencv_core.CvBox2D box, opencv_core.CvScalar color)`
`static void`	`cvEllipseBox(opencv_core.CvArr img, opencv_core.CvBox2D box, opencv_core.CvScalar color, int thickness, int line_type, int shift)`
`static opencv_core.CvSeq`	`cvEndWriteSeq(opencv_core.CvSeqWriter writer)`
`static void`	`cvEndWriteStruct(opencv_core.CvFileStorage fs)`
`static void`	`cvError(int status, BytePointer func_name, BytePointer err_msg, BytePointer file_name, int line)`
`static void`	`cvError(int status, String func_name, String err_msg, String file_name, int line)`
`static int`	`cvErrorFromIppStatus(int ipp_status)`
`static BytePointer`	`cvErrorStr(int status)`
`static void`	`cvExp(opencv_core.CvArr src, opencv_core.CvArr dst)`
`static float`	`cvFastArctan(float y, float x)`
`static void`	`cvFFT(opencv_core.CvArr arg1, opencv_core.CvArr arg2, int arg3, int arg4)`
`static void`	`cvFillConvexPoly(opencv_core.CvArr img, int[] pts, int npts, opencv_core.CvScalar color)`
`static void`	`cvFillConvexPoly(opencv_core.CvArr img, int[] pts, int npts, opencv_core.CvScalar color, int line_type, int shift)`
`static void`	`cvFillConvexPoly(opencv_core.CvArr img, IntBuffer pts, int npts, opencv_core.CvScalar color)`
`static void`	`cvFillConvexPoly(opencv_core.CvArr img, IntBuffer pts, int npts, opencv_core.CvScalar color, int line_type, int shift)`
`static void`	`cvFillConvexPoly(opencv_core.CvArr img, opencv_core.CvPoint pts, int npts, opencv_core.CvScalar color)`
`static void`	`cvFillConvexPoly(opencv_core.CvArr img, opencv_core.CvPoint pts, int npts, opencv_core.CvScalar color, int line_type, int shift)`
`static void`	`cvFillPoly(opencv_core.CvArr img, int[] pts, int[] npts, int contours, opencv_core.CvScalar color)`
`static void`	`cvFillPoly(opencv_core.CvArr img, int[] pts, int[] npts, int contours, opencv_core.CvScalar color, int line_type, int shift)`
`static void`	`cvFillPoly(opencv_core.CvArr img, IntBuffer pts, IntBuffer npts, int contours, opencv_core.CvScalar color)`
`static void`	`cvFillPoly(opencv_core.CvArr img, IntBuffer pts, IntBuffer npts, int contours, opencv_core.CvScalar color, int line_type, int shift)`
`static void`	`cvFillPoly(opencv_core.CvArr img, opencv_core.CvPoint pts, IntPointer npts, int contours, opencv_core.CvScalar color)`
`static void`	`cvFillPoly(opencv_core.CvArr img, opencv_core.CvPoint pts, IntPointer npts, int contours, opencv_core.CvScalar color, int line_type, int shift)`
`static void`	`cvFillPoly(opencv_core.CvArr img, PointerPointer pts, IntPointer npts, int contours, opencv_core.CvScalar color, int line_type, int shift)`
`static opencv_core.CvGraphEdge`	`cvFindGraphEdge(opencv_core.CvGraph graph, int start_idx, int end_idx)`
`static opencv_core.CvGraphEdge`	`cvFindGraphEdgeByPtr(opencv_core.CvGraph graph, opencv_core.CvGraphVtx start_vtx, opencv_core.CvGraphVtx end_vtx)`
`static opencv_core.CvTypeInfo`	`cvFindType(BytePointer type_name)`
`static opencv_core.CvTypeInfo`	`cvFindType(String type_name)`
`static opencv_core.CvTypeInfo`	`cvFirstType()`
`static void`	`cvFlip(opencv_core.CvArr src)`
`static void`	`cvFlip(opencv_core.CvArr src, opencv_core.CvArr dst, int flip_mode)`
`static int`	`cvFloor(double value)`
`static void`	`cvFlushSeqWriter(opencv_core.CvSeqWriter writer)`
`static opencv_core.CvFont`	`cvFont(double scale)`
`static opencv_core.CvFont`	`cvFont(double scale, int thickness)`
`static void`	`cvFree_(Pointer ptr)`
`static void`	`cvGEMM(opencv_core.CvArr src1, opencv_core.CvArr src2, double alpha, opencv_core.CvArr src3, double beta, opencv_core.CvArr dst)`
`static void`	`cvGEMM(opencv_core.CvArr src1, opencv_core.CvArr src2, double alpha, opencv_core.CvArr src3, double beta, opencv_core.CvArr dst, int tABC)`
`static opencv_core.CvScalar`	`cvGet1D(opencv_core.CvArr arr, int idx0)`
`static opencv_core.CvScalar`	`cvGet2D(opencv_core.CvArr arr, int idx0, int idx1)`
`static opencv_core.CvScalar`	`cvGet3D(opencv_core.CvArr arr, int idx0, int idx1, int idx2)`
`static opencv_core.CvMat`	`cvGetCol(opencv_core.CvArr arr, opencv_core.CvMat submat, int col)`
`static opencv_core.CvMat`	`cvGetCols(opencv_core.CvArr arr, opencv_core.CvMat submat, int start_col, int end_col)`
`static opencv_core.CvMat`	`cvGetDiag(opencv_core.CvArr arr, opencv_core.CvMat submat)`
`static opencv_core.CvMat`	`cvGetDiag(opencv_core.CvArr arr, opencv_core.CvMat submat, int diag)`
`static int`	`cvGetDims(opencv_core.CvArr arr)`
`static int`	`cvGetDims(opencv_core.CvArr arr, int[] sizes)`
`static int`	`cvGetDims(opencv_core.CvArr arr, IntBuffer sizes)`
`static int`	`cvGetDims(opencv_core.CvArr arr, IntPointer sizes)`
`static int`	`cvGetDimSize(opencv_core.CvArr arr, int index)`
`static int`	`cvGetElemType(opencv_core.CvArr arr)`
`static int`	`cvGetErrInfo(byte[] errcode_desc, byte[] description, byte[] filename, int[] line)`
`static int`	`cvGetErrInfo(ByteBuffer errcode_desc, ByteBuffer description, ByteBuffer filename, IntBuffer line)`
`static int`	`cvGetErrInfo(BytePointer errcode_desc, BytePointer description, BytePointer filename, IntPointer line)`
`static int`	`cvGetErrInfo(PointerPointer errcode_desc, PointerPointer description, PointerPointer filename, IntPointer line)`
`static int`	`cvGetErrMode()`
`static int`	`cvGetErrStatus()` Error Handling
`static opencv_core.CvFileNode`	`cvGetFileNode(opencv_core.CvFileStorage fs, opencv_core.CvFileNode map, opencv_core.CvStringHashNode key)`
`static opencv_core.CvFileNode`	`cvGetFileNode(opencv_core.CvFileStorage fs, opencv_core.CvFileNode map, opencv_core.CvStringHashNode key, int create_missing)`
`static opencv_core.CvFileNode`	`cvGetFileNodeByName(opencv_core.CvFileStorage fs, opencv_core.CvFileNode map, BytePointer name)`
`static opencv_core.CvFileNode`	`cvGetFileNodeByName(opencv_core.CvFileStorage fs, opencv_core.CvFileNode map, String name)`
`static BytePointer`	`cvGetFileNodeName(opencv_core.CvFileNode node)`
`static opencv_core.CvStringHashNode`	`cvGetHashedKey(opencv_core.CvFileStorage fs, BytePointer name)`
`static opencv_core.CvStringHashNode`	`cvGetHashedKey(opencv_core.CvFileStorage fs, BytePointer name, int len, int create_missing)`
`static opencv_core.CvStringHashNode`	`cvGetHashedKey(opencv_core.CvFileStorage fs, String name)`
`static opencv_core.CvStringHashNode`	`cvGetHashedKey(opencv_core.CvFileStorage fs, String name, int len, int create_missing)`
`static opencv_core.IplImage`	`cvGetImage(opencv_core.CvArr arr, opencv_core.IplImage image_header)`
`static int`	`cvGetImageCOI(opencv_core.IplImage image)`
`static opencv_core.CvRect`	`cvGetImageROI(opencv_core.IplImage image)`
`static opencv_core.CvMat`	`cvGetMat(opencv_core.CvArr arr, opencv_core.CvMat header)`
`static opencv_core.CvMat`	`cvGetMat(opencv_core.CvArr arr, opencv_core.CvMat header, int[] coi, int allowND)`
`static opencv_core.CvMat`	`cvGetMat(opencv_core.CvArr arr, opencv_core.CvMat header, IntBuffer coi, int allowND)`
`static opencv_core.CvMat`	`cvGetMat(opencv_core.CvArr arr, opencv_core.CvMat header, IntPointer coi, int allowND)`
`static void`	`cvGetModuleInfo(BytePointer module_name, byte[] version, byte[] loaded_addon_plugins)`
`static void`	`cvGetModuleInfo(BytePointer module_name, ByteBuffer version, ByteBuffer loaded_addon_plugins)`
`static void`	`cvGetModuleInfo(BytePointer module_name, BytePointer version, BytePointer loaded_addon_plugins)`
`static void`	`cvGetModuleInfo(BytePointer module_name, PointerPointer version, PointerPointer loaded_addon_plugins)`
`static void`	`cvGetModuleInfo(String module_name, byte[] version, byte[] loaded_addon_plugins)`
`static void`	`cvGetModuleInfo(String module_name, ByteBuffer version, ByteBuffer loaded_addon_plugins)`
`static void`	`cvGetModuleInfo(String module_name, BytePointer version, BytePointer loaded_addon_plugins)`
`static opencv_core.CvScalar`	`cvGetND(opencv_core.CvArr arr, int[] idx)`
`static opencv_core.CvScalar`	`cvGetND(opencv_core.CvArr arr, IntBuffer idx)`
`static opencv_core.CvScalar`	`cvGetND(opencv_core.CvArr arr, IntPointer idx)`
`static opencv_core.CvSparseNode`	`cvGetNextSparseNode(opencv_core.CvSparseMatIterator mat_iterator)`
`static int`	`cvGetNumThreads()` Multi-Threading
`static int`	`cvGetOptimalDFTSize(int size0)`
`static void`	`cvGetRawData(opencv_core.CvArr arr, byte[] data)`
`static void`	`cvGetRawData(opencv_core.CvArr arr, byte[] data, int[] step, opencv_core.CvSize roi_size)`
`static void`	`cvGetRawData(opencv_core.CvArr arr, ByteBuffer data)`
`static void`	`cvGetRawData(opencv_core.CvArr arr, ByteBuffer data, IntBuffer step, opencv_core.CvSize roi_size)`
`static void`	`cvGetRawData(opencv_core.CvArr arr, BytePointer data)`
`static void`	`cvGetRawData(opencv_core.CvArr arr, BytePointer data, IntPointer step, opencv_core.CvSize roi_size)`
`static void`	`cvGetRawData(opencv_core.CvArr arr, PointerPointer data, IntPointer step, opencv_core.CvSize roi_size)`
`static double`	`cvGetReal1D(opencv_core.CvArr arr, int idx0)`
`static double`	`cvGetReal2D(opencv_core.CvArr arr, int idx0, int idx1)`
`static double`	`cvGetReal3D(opencv_core.CvArr arr, int idx0, int idx1, int idx2)`
`static double`	`cvGetRealND(opencv_core.CvArr arr, int[] idx)`
`static double`	`cvGetRealND(opencv_core.CvArr arr, IntBuffer idx)`
`static double`	`cvGetRealND(opencv_core.CvArr arr, IntPointer idx)`
`static opencv_core.CvFileNode`	`cvGetRootFileNode(opencv_core.CvFileStorage fs)`
`static opencv_core.CvFileNode`	`cvGetRootFileNode(opencv_core.CvFileStorage fs, int stream_index)`
`static opencv_core.CvMat`	`cvGetRow(opencv_core.CvArr arr, opencv_core.CvMat submat, int row)`
`static opencv_core.CvMat`	`cvGetRows(opencv_core.CvArr arr, opencv_core.CvMat submat, int start_row, int end_row)`
`static opencv_core.CvMat`	`cvGetRows(opencv_core.CvArr arr, opencv_core.CvMat submat, int start_row, int end_row, int delta_row)`
`static BytePointer`	`cvGetSeqElem(opencv_core.CvSeq seq, int index)`
`static int`	`cvGetSeqReaderPos(opencv_core.CvSeqReader reader)`
`static opencv_core.CvSetElem`	`cvGetSetElem(opencv_core.CvSet set_header, int idx)`
`static opencv_core.CvSize`	`cvGetSize(opencv_core.CvArr arr)`
`static opencv_core.CvMat`	`cvGetSubArr(opencv_core.CvArr arg1, opencv_core.CvMat arg2, opencv_core.CvRect arg3)`
`static opencv_core.CvMat`	`cvGetSubRect(opencv_core.CvArr arr, opencv_core.CvMat submat, opencv_core.CvRect rect)`
`static void`	`cvGetTextSize(BytePointer text_string, opencv_core.CvFont font, opencv_core.CvSize text_size, int[] baseline)`
`static void`	`cvGetTextSize(BytePointer text_string, opencv_core.CvFont font, opencv_core.CvSize text_size, IntBuffer baseline)`
`static void`	`cvGetTextSize(BytePointer text_string, opencv_core.CvFont font, opencv_core.CvSize text_size, IntPointer baseline)`
`static void`	`cvGetTextSize(String text_string, opencv_core.CvFont font, opencv_core.CvSize text_size, int[] baseline)`
`static void`	`cvGetTextSize(String text_string, opencv_core.CvFont font, opencv_core.CvSize text_size, IntBuffer baseline)`
`static void`	`cvGetTextSize(String text_string, opencv_core.CvFont font, opencv_core.CvSize text_size, IntPointer baseline)`
`static int`	`cvGetThreadNum()`
`static long`	`cvGetTickCount()` Measuring Execution Time
`static double`	`cvGetTickFrequency()`
`static int`	`cvGraphAddEdge(opencv_core.CvGraph graph, int start_idx, int end_idx)`
`static int`	`cvGraphAddEdge(opencv_core.CvGraph graph, int start_idx, int end_idx, opencv_core.CvGraphEdge edge, opencv_core.CvGraphEdge inserted_edge)`
`static int`	`cvGraphAddEdge(opencv_core.CvGraph graph, int start_idx, int end_idx, opencv_core.CvGraphEdge edge, PointerPointer inserted_edge)`
`static int`	`cvGraphAddEdgeByPtr(opencv_core.CvGraph graph, opencv_core.CvGraphVtx start_vtx, opencv_core.CvGraphVtx end_vtx)`
`static int`	`cvGraphAddEdgeByPtr(opencv_core.CvGraph graph, opencv_core.CvGraphVtx start_vtx, opencv_core.CvGraphVtx end_vtx, opencv_core.CvGraphEdge edge, opencv_core.CvGraphEdge inserted_edge)`
`static int`	`cvGraphAddEdgeByPtr(opencv_core.CvGraph graph, opencv_core.CvGraphVtx start_vtx, opencv_core.CvGraphVtx end_vtx, opencv_core.CvGraphEdge edge, PointerPointer inserted_edge)`
`static int`	`cvGraphAddVtx(opencv_core.CvGraph graph)`
`static int`	`cvGraphAddVtx(opencv_core.CvGraph graph, opencv_core.CvGraphVtx vtx, opencv_core.CvGraphVtx inserted_vtx)`
`static int`	`cvGraphAddVtx(opencv_core.CvGraph graph, opencv_core.CvGraphVtx vtx, PointerPointer inserted_vtx)`
`static opencv_core.CvGraphEdge`	`cvGraphFindEdge(opencv_core.CvGraph arg1, int arg2, int arg3)`
`static opencv_core.CvGraphEdge`	`cvGraphFindEdgeByPtr(opencv_core.CvGraph arg1, opencv_core.CvGraphVtx arg2, opencv_core.CvGraphVtx arg3)`
`static void`	`cvGraphRemoveEdge(opencv_core.CvGraph graph, int start_idx, int end_idx)`
`static void`	`cvGraphRemoveEdgeByPtr(opencv_core.CvGraph graph, opencv_core.CvGraphVtx start_vtx, opencv_core.CvGraphVtx end_vtx)`
`static int`	`cvGraphRemoveVtx(opencv_core.CvGraph graph, int index)`
`static int`	`cvGraphRemoveVtxByPtr(opencv_core.CvGraph graph, opencv_core.CvGraphVtx vtx)`
`static int`	`cvGraphVtxDegree(opencv_core.CvGraph graph, int vtx_idx)`
`static int`	`cvGraphVtxDegreeByPtr(opencv_core.CvGraph graph, opencv_core.CvGraphVtx vtx)`
`static int`	`cvGuiBoxReport(int status, BytePointer func_name, BytePointer err_msg, BytePointer file_name, int line, Pointer userdata)`
`static int`	`cvGuiBoxReport(int status, String func_name, String err_msg, String file_name, int line, Pointer userdata)`
`static int`	`cvIncRefData(opencv_core.CvArr arr)`
`static void`	`cvInitFont(opencv_core.CvFont font, int font_face, double hscale, double vscale)`
`static void`	`cvInitFont(opencv_core.CvFont font, int font_face, double hscale, double vscale, double shear, int thickness, int line_type)`
`static opencv_core.IplImage`	`cvInitImageHeader(opencv_core.IplImage image, opencv_core.CvSize size, int depth, int channels)`
`static opencv_core.IplImage`	`cvInitImageHeader(opencv_core.IplImage image, opencv_core.CvSize size, int depth, int channels, int origin, int align)`
`static int`	`cvInitLineIterator(opencv_core.CvArr image, int[] pt1, int[] pt2, opencv_core.CvLineIterator line_iterator)`
`static int`	`cvInitLineIterator(opencv_core.CvArr image, int[] pt1, int[] pt2, opencv_core.CvLineIterator line_iterator, int connectivity, int left_to_right)`
`static int`	`cvInitLineIterator(opencv_core.CvArr image, IntBuffer pt1, IntBuffer pt2, opencv_core.CvLineIterator line_iterator)`
`static int`	`cvInitLineIterator(opencv_core.CvArr image, IntBuffer pt1, IntBuffer pt2, opencv_core.CvLineIterator line_iterator, int connectivity, int left_to_right)`
`static int`	`cvInitLineIterator(opencv_core.CvArr image, opencv_core.CvPoint pt1, opencv_core.CvPoint pt2, opencv_core.CvLineIterator line_iterator)`
`static int`	`cvInitLineIterator(opencv_core.CvArr image, opencv_core.CvPoint pt1, opencv_core.CvPoint pt2, opencv_core.CvLineIterator line_iterator, int connectivity, int left_to_right)`
`static opencv_core.CvMat`	`cvInitMatHeader(opencv_core.CvMat mat, int rows, int cols, int type)`
`static opencv_core.CvMat`	`cvInitMatHeader(opencv_core.CvMat mat, int rows, int cols, int type, Pointer data, int step)`
`static opencv_core.CvMatND`	`cvInitMatNDHeader(opencv_core.CvMatND mat, int dims, int[] sizes, int type)`
`static opencv_core.CvMatND`	`cvInitMatNDHeader(opencv_core.CvMatND mat, int dims, int[] sizes, int type, Pointer data)`
`static opencv_core.CvMatND`	`cvInitMatNDHeader(opencv_core.CvMatND mat, int dims, IntBuffer sizes, int type)`
`static opencv_core.CvMatND`	`cvInitMatNDHeader(opencv_core.CvMatND mat, int dims, IntBuffer sizes, int type, Pointer data)`
`static opencv_core.CvMatND`	`cvInitMatNDHeader(opencv_core.CvMatND mat, int dims, IntPointer sizes, int type)`
`static opencv_core.CvMatND`	`cvInitMatNDHeader(opencv_core.CvMatND mat, int dims, IntPointer sizes, int type, Pointer data)`
`static int`	`cvInitNArrayIterator(int count, opencv_core.CvArr arrs, opencv_core.CvArr mask, opencv_core.CvMatND stubs, opencv_core.CvNArrayIterator array_iterator)`
`static int`	`cvInitNArrayIterator(int count, opencv_core.CvArr arrs, opencv_core.CvArr mask, opencv_core.CvMatND stubs, opencv_core.CvNArrayIterator array_iterator, int flags)`
`static int`	`cvInitNArrayIterator(int count, PointerPointer arrs, opencv_core.CvArr mask, opencv_core.CvMatND stubs, opencv_core.CvNArrayIterator array_iterator, int flags)`
`static opencv_core.CvSparseNode`	`cvInitSparseMatIterator(opencv_core.CvSparseMat mat, opencv_core.CvSparseMatIterator mat_iterator)`
`static void`	`cvInitTreeNodeIterator(opencv_core.CvTreeNodeIterator tree_iterator, Pointer first, int max_level)`
`static void`	`cvInRange(opencv_core.CvArr src, opencv_core.CvArr lower, opencv_core.CvArr upper, opencv_core.CvArr dst)`
`static void`	`cvInRangeS(opencv_core.CvArr src, opencv_core.CvScalar lower, opencv_core.CvScalar upper, opencv_core.CvArr dst)`
`static void`	`cvInsertNodeIntoTree(Pointer node, Pointer parent, Pointer frame)`
`static void`	`cvInv(opencv_core.CvArr arg1, opencv_core.CvArr arg2, int arg3)`
`static double`	`cvInvert(opencv_core.CvArr src, opencv_core.CvArr dst)`
`static double`	`cvInvert(opencv_core.CvArr src, opencv_core.CvArr dst, int method)`
`static int`	`cvIplDepth(int type)`
`static int`	`cvIsInf(double value)`
`static int`	`cvIsNaN(double value)`
`static int`	`cvKMeans2(opencv_core.CvArr samples, int cluster_count, opencv_core.CvArr labels, opencv_core.CvTermCriteria termcrit)`
`static int`	`cvKMeans2(opencv_core.CvArr samples, int cluster_count, opencv_core.CvArr labels, opencv_core.CvTermCriteria termcrit, int attempts, long[] rng, int flags, opencv_core.CvArr _centers, double[] compactness)`
`static int`	`cvKMeans2(opencv_core.CvArr samples, int cluster_count, opencv_core.CvArr labels, opencv_core.CvTermCriteria termcrit, int attempts, LongBuffer rng, int flags, opencv_core.CvArr _centers, DoubleBuffer compactness)`
`static int`	`cvKMeans2(opencv_core.CvArr samples, int cluster_count, opencv_core.CvArr labels, opencv_core.CvTermCriteria termcrit, int attempts, LongPointer rng, int flags, opencv_core.CvArr _centers, DoublePointer compactness)`
`static void`	`cvLine(opencv_core.CvArr img, int[] pt1, int[] pt2, opencv_core.CvScalar color)`
`static void`	`cvLine(opencv_core.CvArr img, int[] pt1, int[] pt2, opencv_core.CvScalar color, int thickness, int line_type, int shift)`
`static void`	`cvLine(opencv_core.CvArr img, IntBuffer pt1, IntBuffer pt2, opencv_core.CvScalar color)`
`static void`	`cvLine(opencv_core.CvArr img, IntBuffer pt1, IntBuffer pt2, opencv_core.CvScalar color, int thickness, int line_type, int shift)`
`static void`	`cvLine(opencv_core.CvArr img, opencv_core.CvPoint pt1, opencv_core.CvPoint pt2, opencv_core.CvScalar color)`
`static void`	`cvLine(opencv_core.CvArr img, opencv_core.CvPoint pt1, opencv_core.CvPoint pt2, opencv_core.CvScalar color, int thickness, int line_type, int shift)`
`static Pointer`	`cvLoad(BytePointer filename)`
`static Pointer`	`cvLoad(BytePointer filename, opencv_core.CvMemStorage memstorage, BytePointer name, byte[] real_name)`
`static Pointer`	`cvLoad(BytePointer filename, opencv_core.CvMemStorage memstorage, BytePointer name, ByteBuffer real_name)`
`static Pointer`	`cvLoad(BytePointer filename, opencv_core.CvMemStorage memstorage, BytePointer name, BytePointer real_name)`
`static Pointer`	`cvLoad(BytePointer filename, opencv_core.CvMemStorage memstorage, BytePointer name, PointerPointer real_name)`
`static Pointer`	`cvLoad(String filename)`
`static Pointer`	`cvLoad(String filename, opencv_core.CvMemStorage memstorage, String name, byte[] real_name)`
`static Pointer`	`cvLoad(String filename, opencv_core.CvMemStorage memstorage, String name, ByteBuffer real_name)`
`static Pointer`	`cvLoad(String filename, opencv_core.CvMemStorage memstorage, String name, BytePointer real_name)`
`static void`	`cvLog(opencv_core.CvArr src, opencv_core.CvArr dst)`
`static void`	`cvLUT(opencv_core.CvArr src, opencv_core.CvArr dst, opencv_core.CvArr lut)`
`static double`	`cvMahalanobis(opencv_core.CvArr vec1, opencv_core.CvArr vec2, opencv_core.CvArr mat)`
`static double`	`cvMahalonobis(opencv_core.CvArr arg1, opencv_core.CvArr arg2, opencv_core.CvArr arg3)`
`static opencv_core.CvSeq`	`cvMakeSeqHeaderForArray(int seq_type, int header_size, int elem_size, Pointer elements, int total, opencv_core.CvSeq seq, opencv_core.CvSeqBlock block)`
`static opencv_core.CvMat`	`cvMat(int rows, int cols, int type)`
`static opencv_core.CvMat`	`cvMat(int rows, int cols, int type, Pointer data)`
`static void`	`cvMatMul(opencv_core.CvArr src1, opencv_core.CvArr src2, opencv_core.CvArr dst)`
`static void`	`cvMatMulAdd(opencv_core.CvArr src1, opencv_core.CvArr src2, opencv_core.CvArr src3, opencv_core.CvArr dst)`
`static void`	`cvMatMulAddEx(opencv_core.CvArr arg1, opencv_core.CvArr arg2, double arg3, opencv_core.CvArr arg4, double arg5, opencv_core.CvArr arg6, int arg7)`
`static void`	`cvMatMulAddS(opencv_core.CvArr arg1, opencv_core.CvArr arg2, opencv_core.CvMat arg3, opencv_core.CvMat arg4)`
`static void`	`cvMax(opencv_core.CvArr src1, opencv_core.CvArr src2, opencv_core.CvArr dst)`
`static void`	`cvMaxS(opencv_core.CvArr src, double value, opencv_core.CvArr dst)`
`static Pointer`	`cvMemStorageAlloc(opencv_core.CvMemStorage storage, long size)`
`static opencv_core.CvString`	`cvMemStorageAllocString(opencv_core.CvMemStorage storage, BytePointer ptr)`
`static opencv_core.CvString`	`cvMemStorageAllocString(opencv_core.CvMemStorage storage, BytePointer ptr, int len)`
`static opencv_core.CvString`	`cvMemStorageAllocString(opencv_core.CvMemStorage storage, String ptr)`
`static opencv_core.CvString`	`cvMemStorageAllocString(opencv_core.CvMemStorage storage, String ptr, int len)`
`static void`	`cvMerge(opencv_core.CvArr src0, opencv_core.CvArr src1, opencv_core.CvArr src2, opencv_core.CvArr src3, opencv_core.CvArr dst)`
`static double`	`cvmGet(opencv_core.CvMat mat, int row, int col)`
`static void`	`cvMin(opencv_core.CvArr src1, opencv_core.CvArr src2, opencv_core.CvArr dst)`
`static void`	`cvMinMaxLoc(opencv_core.CvArr arr, double[] min_val, double[] max_val)`
`static void`	`cvMinMaxLoc(opencv_core.CvArr arr, double[] min_val, double[] max_val, int[] min_loc, int[] max_loc, opencv_core.CvArr mask)`
`static void`	`cvMinMaxLoc(opencv_core.CvArr arr, DoubleBuffer min_val, DoubleBuffer max_val)`
`static void`	`cvMinMaxLoc(opencv_core.CvArr arr, DoubleBuffer min_val, DoubleBuffer max_val, IntBuffer min_loc, IntBuffer max_loc, opencv_core.CvArr mask)`
`static void`	`cvMinMaxLoc(opencv_core.CvArr arr, DoublePointer min_val, DoublePointer max_val)`
`static void`	`cvMinMaxLoc(opencv_core.CvArr arr, DoublePointer min_val, DoublePointer max_val, opencv_core.CvPoint min_loc, opencv_core.CvPoint max_loc, opencv_core.CvArr mask)`
`static void`	`cvMinS(opencv_core.CvArr src, double value, opencv_core.CvArr dst)`
`static void`	`cvMirror(opencv_core.CvArr arg1, opencv_core.CvArr arg2, int arg3)`
`static void`	`cvMixChannels(opencv_core.CvArr src, int src_count, opencv_core.CvArr dst, int dst_count, int[] from_to, int pair_count)`
`static void`	`cvMixChannels(opencv_core.CvArr src, int src_count, opencv_core.CvArr dst, int dst_count, IntBuffer from_to, int pair_count)`
`static void`	`cvMixChannels(opencv_core.CvArr src, int src_count, opencv_core.CvArr dst, int dst_count, IntPointer from_to, int pair_count)`
`static void`	`cvMixChannels(PointerPointer src, int src_count, PointerPointer dst, int dst_count, IntPointer from_to, int pair_count)`
`static void`	`cvmSet(opencv_core.CvMat mat, int row, int col, double value)`
`static void`	`cvMul(opencv_core.CvArr src1, opencv_core.CvArr src2, opencv_core.CvArr dst)`
`static void`	`cvMul(opencv_core.CvArr src1, opencv_core.CvArr src2, opencv_core.CvArr dst, double scale)`
`static void`	`cvMulSpectrums(opencv_core.CvArr src1, opencv_core.CvArr src2, opencv_core.CvArr dst, int flags)`
`static void`	`cvMulTransposed(opencv_core.CvArr src, opencv_core.CvArr dst, int order)`
`static void`	`cvMulTransposed(opencv_core.CvArr src, opencv_core.CvArr dst, int order, opencv_core.CvArr delta, double scale)`
`static int`	`cvNextGraphItem(opencv_core.CvGraphScanner scanner)`
`static int`	`cvNextNArraySlice(opencv_core.CvNArrayIterator array_iterator)`
`static Pointer`	`cvNextTreeNode(opencv_core.CvTreeNodeIterator tree_iterator)`
`static double`	`cvNorm(opencv_core.CvArr arr1)`
`static double`	`cvNorm(opencv_core.CvArr arr1, opencv_core.CvArr arr2, int norm_type, opencv_core.CvArr mask)`
`static void`	`cvNormalize(opencv_core.CvArr src, opencv_core.CvArr dst)`
`static void`	`cvNormalize(opencv_core.CvArr src, opencv_core.CvArr dst, double a, double b, int norm_type, opencv_core.CvArr mask)`
`static void`	`cvNot(opencv_core.CvArr src, opencv_core.CvArr dst)`
`static int`	`cvNulDevReport(int status, BytePointer func_name, BytePointer err_msg, BytePointer file_name, int line, Pointer userdata)`
`static int`	`cvNulDevReport(int status, String func_name, String err_msg, String file_name, int line, Pointer userdata)`
`static opencv_core.CvFileStorage`	`cvOpenFileStorage(BytePointer filename, opencv_core.CvMemStorage memstorage, int flags)`
`static opencv_core.CvFileStorage`	`cvOpenFileStorage(BytePointer filename, opencv_core.CvMemStorage memstorage, int flags, BytePointer encoding)` High-level functions
`static opencv_core.CvFileStorage`	`cvOpenFileStorage(String filename, opencv_core.CvMemStorage memstorage, int flags)`
`static opencv_core.CvFileStorage`	`cvOpenFileStorage(String filename, opencv_core.CvMemStorage memstorage, int flags, String encoding)`
`static void`	`cvOr(opencv_core.CvArr src1, opencv_core.CvArr src2, opencv_core.CvArr dst)`
`static void`	`cvOr(opencv_core.CvArr src1, opencv_core.CvArr src2, opencv_core.CvArr dst, opencv_core.CvArr mask)`
`static void`	`cvOrS(opencv_core.CvArr src, opencv_core.CvScalar value, opencv_core.CvArr dst)`
`static void`	`cvOrS(opencv_core.CvArr src, opencv_core.CvScalar value, opencv_core.CvArr dst, opencv_core.CvArr mask)`
`static void`	`cvPerspectiveTransform(opencv_core.CvArr src, opencv_core.CvArr dst, opencv_core.CvMat mat)`
`static opencv_core.CvPoint`	`cvPoint(int x, int y)`
`static opencv_core.CvPoint2D32f`	`cvPoint2D32f(double x, double y)`
`static opencv_core.CvPoint2D64f`	`cvPoint2D64f(double x, double y)`
`static opencv_core.CvPoint3D32f`	`cvPoint3D32f(double x, double y, double z)`
`static opencv_core.CvPoint3D64f`	`cvPoint3D64f(double x, double y, double z)`
`static int[]`	`cvPointFrom32f(float[] point)`
`static IntBuffer`	`cvPointFrom32f(FloatBuffer point)`
`static opencv_core.CvPoint`	`cvPointFrom32f(opencv_core.CvPoint2D32f point)`
`static float[]`	`cvPointTo32f(int[] point)`
`static FloatBuffer`	`cvPointTo32f(IntBuffer point)`
`static opencv_core.CvPoint2D32f`	`cvPointTo32f(opencv_core.CvPoint point)`
`static void`	`cvPolarToCart(opencv_core.CvArr magnitude, opencv_core.CvArr angle, opencv_core.CvArr x, opencv_core.CvArr y)`
`static void`	`cvPolarToCart(opencv_core.CvArr magnitude, opencv_core.CvArr angle, opencv_core.CvArr x, opencv_core.CvArr y, int angle_in_degrees)`
`static void`	`cvPolyLine(opencv_core.CvArr img, int[] pts, int[] npts, int contours, int is_closed, opencv_core.CvScalar color)`
`static void`	`cvPolyLine(opencv_core.CvArr img, int[] pts, int[] npts, int contours, int is_closed, opencv_core.CvScalar color, int thickness, int line_type, int shift)`
`static void`	`cvPolyLine(opencv_core.CvArr img, IntBuffer pts, IntBuffer npts, int contours, int is_closed, opencv_core.CvScalar color)`
`static void`	`cvPolyLine(opencv_core.CvArr img, IntBuffer pts, IntBuffer npts, int contours, int is_closed, opencv_core.CvScalar color, int thickness, int line_type, int shift)`
`static void`	`cvPolyLine(opencv_core.CvArr img, opencv_core.CvPoint pts, IntPointer npts, int contours, int is_closed, opencv_core.CvScalar color)`
`static void`	`cvPolyLine(opencv_core.CvArr img, opencv_core.CvPoint pts, IntPointer npts, int contours, int is_closed, opencv_core.CvScalar color, int thickness, int line_type, int shift)`
`static void`	`cvPolyLine(opencv_core.CvArr img, PointerPointer pts, IntPointer npts, int contours, int is_closed, opencv_core.CvScalar color, int thickness, int line_type, int shift)`
`static void`	`cvPow(opencv_core.CvArr src, opencv_core.CvArr dst, double power)`
`static Pointer`	`cvPrevTreeNode(opencv_core.CvTreeNodeIterator tree_iterator)`
`static void`	`cvProjectPCA(opencv_core.CvArr data, opencv_core.CvArr mean, opencv_core.CvArr eigenvects, opencv_core.CvArr result)`
`static BytePointer`	`cvPtr1D(opencv_core.CvArr arr, int idx0)`
`static byte[]`	`cvPtr1D(opencv_core.CvArr arr, int idx0, int[] type)`
`static ByteBuffer`	`cvPtr1D(opencv_core.CvArr arr, int idx0, IntBuffer type)`
`static BytePointer`	`cvPtr1D(opencv_core.CvArr arr, int idx0, IntPointer type)`
`static BytePointer`	`cvPtr2D(opencv_core.CvArr arr, int idx0, int idx1)`
`static byte[]`	`cvPtr2D(opencv_core.CvArr arr, int idx0, int idx1, int[] type)`
`static ByteBuffer`	`cvPtr2D(opencv_core.CvArr arr, int idx0, int idx1, IntBuffer type)`
`static BytePointer`	`cvPtr2D(opencv_core.CvArr arr, int idx0, int idx1, IntPointer type)`
`static BytePointer`	`cvPtr3D(opencv_core.CvArr arr, int idx0, int idx1, int idx2)`
`static byte[]`	`cvPtr3D(opencv_core.CvArr arr, int idx0, int idx1, int idx2, int[] type)`
`static ByteBuffer`	`cvPtr3D(opencv_core.CvArr arr, int idx0, int idx1, int idx2, IntBuffer type)`
`static BytePointer`	`cvPtr3D(opencv_core.CvArr arr, int idx0, int idx1, int idx2, IntPointer type)`
`static byte[]`	`cvPtrND(opencv_core.CvArr arr, int[] idx)`
`static byte[]`	`cvPtrND(opencv_core.CvArr arr, int[] idx, int[] type, int create_node, int[] precalc_hashval)`
`static ByteBuffer`	`cvPtrND(opencv_core.CvArr arr, IntBuffer idx)`
`static ByteBuffer`	`cvPtrND(opencv_core.CvArr arr, IntBuffer idx, IntBuffer type, int create_node, IntBuffer precalc_hashval)`
`static BytePointer`	`cvPtrND(opencv_core.CvArr arr, IntPointer idx)`
`static BytePointer`	`cvPtrND(opencv_core.CvArr arr, IntPointer idx, IntPointer type, int create_node, IntPointer precalc_hashval)`
`static void`	`cvPutText(opencv_core.CvArr img, BytePointer text, int[] org, opencv_core.CvFont font, opencv_core.CvScalar color)`
`static void`	`cvPutText(opencv_core.CvArr img, BytePointer text, IntBuffer org, opencv_core.CvFont font, opencv_core.CvScalar color)`
`static void`	`cvPutText(opencv_core.CvArr img, BytePointer text, opencv_core.CvPoint org, opencv_core.CvFont font, opencv_core.CvScalar color)`
`static void`	`cvPutText(opencv_core.CvArr img, String text, int[] org, opencv_core.CvFont font, opencv_core.CvScalar color)`
`static void`	`cvPutText(opencv_core.CvArr img, String text, IntBuffer org, opencv_core.CvFont font, opencv_core.CvScalar color)`
`static void`	`cvPutText(opencv_core.CvArr img, String text, opencv_core.CvPoint org, opencv_core.CvFont font, opencv_core.CvScalar color)`
`static void`	`cvRandArr(long[] rng, opencv_core.CvArr arr, int dist_type, opencv_core.CvScalar param1, opencv_core.CvScalar param2)`
`static void`	`cvRandArr(LongBuffer rng, opencv_core.CvArr arr, int dist_type, opencv_core.CvScalar param1, opencv_core.CvScalar param2)`
`static void`	`cvRandArr(LongPointer rng, opencv_core.CvArr arr, int dist_type, opencv_core.CvScalar param1, opencv_core.CvScalar param2)`
`static int`	`cvRandInt(long[] rng)`
`static int`	`cvRandInt(LongBuffer rng)`
`static int`	`cvRandInt(LongPointer rng)`
`static double`	`cvRandReal(long[] rng)`
`static double`	`cvRandReal(LongBuffer rng)`
`static double`	`cvRandReal(LongPointer rng)`
`static void`	`cvRandShuffle(opencv_core.CvArr mat, long[] rng)`
`static void`	`cvRandShuffle(opencv_core.CvArr mat, long[] rng, double iter_factor)`
`static void`	`cvRandShuffle(opencv_core.CvArr mat, LongBuffer rng)`
`static void`	`cvRandShuffle(opencv_core.CvArr mat, LongBuffer rng, double iter_factor)`
`static void`	`cvRandShuffle(opencv_core.CvArr mat, LongPointer rng)`
`static void`	`cvRandShuffle(opencv_core.CvArr mat, LongPointer rng, double iter_factor)`
`static opencv_core.CvArr`	`cvRange(opencv_core.CvArr mat, double start, double end)`
`static void`	`cvRawDataToScalar(Pointer data, int type, opencv_core.CvScalar scalar)`
`static Pointer`	`cvRead(opencv_core.CvFileStorage fs, opencv_core.CvFileNode node)`
`static Pointer`	`cvRead(opencv_core.CvFileStorage fs, opencv_core.CvFileNode node, opencv_core.CvAttrList attributes)`
`static Pointer`	`cvReadByName(opencv_core.CvFileStorage fs, opencv_core.CvFileNode map, BytePointer name)`
`static Pointer`	`cvReadByName(opencv_core.CvFileStorage fs, opencv_core.CvFileNode map, BytePointer name, opencv_core.CvAttrList attributes)`
`static Pointer`	`cvReadByName(opencv_core.CvFileStorage fs, opencv_core.CvFileNode map, String name)`
`static Pointer`	`cvReadByName(opencv_core.CvFileStorage fs, opencv_core.CvFileNode map, String name, opencv_core.CvAttrList attributes)`
`static int`	`cvReadInt(opencv_core.CvFileNode node)`
`static int`	`cvReadInt(opencv_core.CvFileNode node, int default_value)`
`static int`	`cvReadIntByName(opencv_core.CvFileStorage fs, opencv_core.CvFileNode map, BytePointer name)`
`static int`	`cvReadIntByName(opencv_core.CvFileStorage fs, opencv_core.CvFileNode map, BytePointer name, int default_value)`
`static int`	`cvReadIntByName(opencv_core.CvFileStorage fs, opencv_core.CvFileNode map, String name)`
`static int`	`cvReadIntByName(opencv_core.CvFileStorage fs, opencv_core.CvFileNode map, String name, int default_value)`
`static void`	`cvReadRawData(opencv_core.CvFileStorage fs, opencv_core.CvFileNode src, Pointer dst, BytePointer dt)`
`static void`	`cvReadRawData(opencv_core.CvFileStorage fs, opencv_core.CvFileNode src, Pointer dst, String dt)`
`static void`	`cvReadRawDataSlice(opencv_core.CvFileStorage fs, opencv_core.CvSeqReader reader, int count, Pointer dst, BytePointer dt)`
`static void`	`cvReadRawDataSlice(opencv_core.CvFileStorage fs, opencv_core.CvSeqReader reader, int count, Pointer dst, String dt)`
`static double`	`cvReadReal(opencv_core.CvFileNode node)`
`static double`	`cvReadReal(opencv_core.CvFileNode node, double default_value)`
`static double`	`cvReadRealByName(opencv_core.CvFileStorage fs, opencv_core.CvFileNode map, BytePointer name)`
`static double`	`cvReadRealByName(opencv_core.CvFileStorage fs, opencv_core.CvFileNode map, BytePointer name, double default_value)`
`static double`	`cvReadRealByName(opencv_core.CvFileStorage fs, opencv_core.CvFileNode map, String name)`
`static double`	`cvReadRealByName(opencv_core.CvFileStorage fs, opencv_core.CvFileNode map, String name, double default_value)`
`static BytePointer`	`cvReadString(opencv_core.CvFileNode node)`
`static BytePointer`	`cvReadString(opencv_core.CvFileNode node, BytePointer default_value)`
`static String`	`cvReadString(opencv_core.CvFileNode node, String default_value)`
`static BytePointer`	`cvReadStringByName(opencv_core.CvFileStorage fs, opencv_core.CvFileNode map, BytePointer name)`
`static BytePointer`	`cvReadStringByName(opencv_core.CvFileStorage fs, opencv_core.CvFileNode map, BytePointer name, BytePointer default_value)`
`static String`	`cvReadStringByName(opencv_core.CvFileStorage fs, opencv_core.CvFileNode map, String name)`
`static String`	`cvReadStringByName(opencv_core.CvFileStorage fs, opencv_core.CvFileNode map, String name, String default_value)`
`static opencv_core.CvScalar`	`cvRealScalar(double val0)`
`static opencv_core.CvRect`	`cvRect(int x, int y, int width, int height)`
`static void`	`cvRectangle(opencv_core.CvArr img, int[] pt1, int[] pt2, opencv_core.CvScalar color)`
`static void`	`cvRectangle(opencv_core.CvArr img, int[] pt1, int[] pt2, opencv_core.CvScalar color, int thickness, int line_type, int shift)`
`static void`	`cvRectangle(opencv_core.CvArr img, IntBuffer pt1, IntBuffer pt2, opencv_core.CvScalar color)`
`static void`	`cvRectangle(opencv_core.CvArr img, IntBuffer pt1, IntBuffer pt2, opencv_core.CvScalar color, int thickness, int line_type, int shift)`
`static void`	`cvRectangle(opencv_core.CvArr img, opencv_core.CvPoint pt1, opencv_core.CvPoint pt2, opencv_core.CvScalar color)`
`static void`	`cvRectangle(opencv_core.CvArr img, opencv_core.CvPoint pt1, opencv_core.CvPoint pt2, opencv_core.CvScalar color, int thickness, int line_type, int shift)`
`static void`	`cvRectangleR(opencv_core.CvArr img, opencv_core.CvRect r, opencv_core.CvScalar color)`
`static void`	`cvRectangleR(opencv_core.CvArr img, opencv_core.CvRect r, opencv_core.CvScalar color, int thickness, int line_type, int shift)`
`static opencv_core.IplROI`	`cvRectToROI(opencv_core.CvRect rect, int coi)`
`static opencv_core.CvErrorCallback`	`cvRedirectError(opencv_core.CvErrorCallback error_handler)`
`static opencv_core.CvErrorCallback`	`cvRedirectError(opencv_core.CvErrorCallback error_handler, Pointer userdata, Pointer prev_userdata)`
`static opencv_core.CvErrorCallback`	`cvRedirectError(opencv_core.CvErrorCallback error_handler, Pointer userdata, PointerPointer prev_userdata)`
`static void`	`cvReduce(opencv_core.CvArr src, opencv_core.CvArr dst)`
`static void`	`cvReduce(opencv_core.CvArr src, opencv_core.CvArr dst, int dim, int op)`
`static int`	`cvRegisterModule(opencv_core.CvModuleInfo module_info)` \ System functions * \
`static void`	`cvRegisterType(opencv_core.CvTypeInfo info)` Adding own types
`static void`	`cvRelease(Pointer struct_ptr)`
`static void`	`cvRelease(PointerPointer struct_ptr)`
`static void`	`cvReleaseData(opencv_core.CvArr arr)`
`static void`	`cvReleaseFileStorage(opencv_core.CvFileStorage fs)`
`static void`	`cvReleaseFileStorage(PointerPointer fs)`
`static void`	`cvReleaseGraphScanner(opencv_core.CvGraphScanner scanner)`
`static void`	`cvReleaseGraphScanner(PointerPointer scanner)`
`static void`	`cvReleaseImage(opencv_core.IplImage image)`
`static void`	`cvReleaseImage(PointerPointer image)`
`static void`	`cvReleaseImageHeader(opencv_core.IplImage image)`
`static void`	`cvReleaseImageHeader(PointerPointer image)`
`static void`	`cvReleaseMat(opencv_core.CvMat mat)`
`static void`	`cvReleaseMat(PointerPointer mat)`
`static void`	`cvReleaseMatND(opencv_core.CvMatND mat)`
`static void`	`cvReleaseMatND(PointerPointer mat)`
`static void`	`cvReleaseMemStorage(opencv_core.CvMemStorage storage)`
`static void`	`cvReleaseMemStorage(PointerPointer storage)`
`static void`	`cvReleaseSparseMat(opencv_core.CvSparseMat mat)`
`static void`	`cvReleaseSparseMat(PointerPointer mat)`
`static void`	`cvRemoveNodeFromTree(Pointer node, Pointer frame)`
`static void`	`cvRepeat(opencv_core.CvArr src, opencv_core.CvArr dst)`
`static void`	`cvResetImageROI(opencv_core.IplImage image)`
`static opencv_core.CvMat`	`cvReshape(opencv_core.CvArr arr, opencv_core.CvMat header, int new_cn)`
`static opencv_core.CvMat`	`cvReshape(opencv_core.CvArr arr, opencv_core.CvMat header, int new_cn, int new_rows)`
`static opencv_core.CvArr`	`cvReshapeMatND(opencv_core.CvArr arr, int sizeof_header, opencv_core.CvArr header, int new_cn, int new_dims, int[] new_sizes)`
`static opencv_core.CvArr`	`cvReshapeMatND(opencv_core.CvArr arr, int sizeof_header, opencv_core.CvArr header, int new_cn, int new_dims, IntBuffer new_sizes)`
`static opencv_core.CvArr`	`cvReshapeMatND(opencv_core.CvArr arr, int sizeof_header, opencv_core.CvArr header, int new_cn, int new_dims, IntPointer new_sizes)`
`static void`	`cvRestoreMemStoragePos(opencv_core.CvMemStorage storage, opencv_core.CvMemStoragePos pos)`
`static long`	`cvRNG()`
`static long`	`cvRNG(long seed)`
`static opencv_core.CvRect`	`cvROIToRect(opencv_core.IplROI roi)`
`static int`	`cvRound(double value)`
`static void`	`cvSave(BytePointer filename, Pointer struct_ptr)`
`static void`	`cvSave(BytePointer filename, Pointer struct_ptr, BytePointer name, BytePointer comment, opencv_core.CvAttrList attributes)`
`static void`	`cvSave(String filename, Pointer struct_ptr)`
`static void`	`cvSave(String filename, Pointer struct_ptr, String name, String comment, opencv_core.CvAttrList attributes)`
`static void`	`cvSaveMemStoragePos(opencv_core.CvMemStorage storage, opencv_core.CvMemStoragePos pos)`
`static opencv_core.CvScalar`	`cvScalar(double val0)`
`static opencv_core.CvScalar`	`cvScalar(double val0, double val1, double val2, double val3)`
`static opencv_core.CvScalar`	`cvScalarAll(double val0123)`
`static void`	`cvScalarToRawData(opencv_core.CvScalar scalar, Pointer data, int type)`
`static void`	`cvScalarToRawData(opencv_core.CvScalar scalar, Pointer data, int type, int extend_to_12)`
`static void`	`cvScale(opencv_core.CvArr arg1, opencv_core.CvArr arg2, double arg3, double arg4)`
`static void`	`cvScaleAdd(opencv_core.CvArr src1, opencv_core.CvScalar scale, opencv_core.CvArr src2, opencv_core.CvArr dst)`
`static int`	`cvSeqElemIdx(opencv_core.CvSeq seq, Pointer element)`
`static int`	`cvSeqElemIdx(opencv_core.CvSeq seq, Pointer element, opencv_core.CvSeqBlock block)`
`static int`	`cvSeqElemIdx(opencv_core.CvSeq seq, Pointer element, PointerPointer block)`
`static BytePointer`	`cvSeqInsert(opencv_core.CvSeq seq, int before_index)`
`static BytePointer`	`cvSeqInsert(opencv_core.CvSeq seq, int before_index, Pointer element)`
`static void`	`cvSeqInsertSlice(opencv_core.CvSeq seq, int before_index, opencv_core.CvArr from_arr)`
`static void`	`cvSeqInvert(opencv_core.CvSeq seq)`
`static int`	`cvSeqPartition(opencv_core.CvSeq seq, opencv_core.CvMemStorage storage, opencv_core.CvSeq labels, opencv_core.CvCmpFunc is_equal, Pointer userdata)`
`static int`	`cvSeqPartition(opencv_core.CvSeq seq, opencv_core.CvMemStorage storage, PointerPointer labels, opencv_core.CvCmpFunc is_equal, Pointer userdata)`
`static void`	`cvSeqPop(opencv_core.CvSeq seq)`
`static void`	`cvSeqPop(opencv_core.CvSeq seq, Pointer element)`
`static void`	`cvSeqPopFront(opencv_core.CvSeq seq)`
`static void`	`cvSeqPopFront(opencv_core.CvSeq seq, Pointer element)`
`static void`	`cvSeqPopMulti(opencv_core.CvSeq seq, Pointer elements, int count)`
`static void`	`cvSeqPopMulti(opencv_core.CvSeq seq, Pointer elements, int count, int in_front)`
`static BytePointer`	`cvSeqPush(opencv_core.CvSeq seq)`
`static BytePointer`	`cvSeqPush(opencv_core.CvSeq seq, Pointer element)`
`static BytePointer`	`cvSeqPushFront(opencv_core.CvSeq seq)`
`static BytePointer`	`cvSeqPushFront(opencv_core.CvSeq seq, Pointer element)`
`static void`	`cvSeqPushMulti(opencv_core.CvSeq seq, Pointer elements, int count)`
`static void`	`cvSeqPushMulti(opencv_core.CvSeq seq, Pointer elements, int count, int in_front)`
`static void`	`cvSeqRemove(opencv_core.CvSeq seq, int index)`
`static void`	`cvSeqRemoveSlice(opencv_core.CvSeq seq, opencv_core.CvSlice slice)`
`static byte[]`	`cvSeqSearch(opencv_core.CvSeq seq, Pointer elem, opencv_core.CvCmpFunc func, int is_sorted, int[] elem_idx)`
`static byte[]`	`cvSeqSearch(opencv_core.CvSeq seq, Pointer elem, opencv_core.CvCmpFunc func, int is_sorted, int[] elem_idx, Pointer userdata)`
`static ByteBuffer`	`cvSeqSearch(opencv_core.CvSeq seq, Pointer elem, opencv_core.CvCmpFunc func, int is_sorted, IntBuffer elem_idx)`
`static ByteBuffer`	`cvSeqSearch(opencv_core.CvSeq seq, Pointer elem, opencv_core.CvCmpFunc func, int is_sorted, IntBuffer elem_idx, Pointer userdata)`
`static BytePointer`	`cvSeqSearch(opencv_core.CvSeq seq, Pointer elem, opencv_core.CvCmpFunc func, int is_sorted, IntPointer elem_idx)`
`static BytePointer`	`cvSeqSearch(opencv_core.CvSeq seq, Pointer elem, opencv_core.CvCmpFunc func, int is_sorted, IntPointer elem_idx, Pointer userdata)`
`static opencv_core.CvSeq`	`cvSeqSlice(opencv_core.CvSeq seq, opencv_core.CvSlice slice)`
`static opencv_core.CvSeq`	`cvSeqSlice(opencv_core.CvSeq seq, opencv_core.CvSlice slice, opencv_core.CvMemStorage storage, int copy_data)`
`static void`	`cvSeqSort(opencv_core.CvSeq seq, opencv_core.CvCmpFunc func)`
`static void`	`cvSeqSort(opencv_core.CvSeq seq, opencv_core.CvCmpFunc func, Pointer userdata)`
`static void`	`cvSet(opencv_core.CvArr arr, opencv_core.CvScalar value)`
`static void`	`cvSet(opencv_core.CvArr arr, opencv_core.CvScalar value, opencv_core.CvArr mask)`
`static void`	`cvSet1D(opencv_core.CvArr arr, int idx0, opencv_core.CvScalar value)`
`static void`	`cvSet2D(opencv_core.CvArr arr, int idx0, int idx1, opencv_core.CvScalar value)`
`static void`	`cvSet3D(opencv_core.CvArr arr, int idx0, int idx1, int idx2, opencv_core.CvScalar value)`
`static int`	`cvSetAdd(opencv_core.CvSet set_header)`
`static int`	`cvSetAdd(opencv_core.CvSet set_header, opencv_core.CvSetElem elem, opencv_core.CvSetElem inserted_elem)`
`static int`	`cvSetAdd(opencv_core.CvSet set_header, opencv_core.CvSetElem elem, PointerPointer inserted_elem)`
`static void`	`cvSetData(opencv_core.CvArr arr, Pointer data, int step)`
`static int`	`cvSetErrMode(int mode)`
`static void`	`cvSetErrStatus(int status)`
`static void`	`cvSetIdentity(opencv_core.CvArr mat)`
`static void`	`cvSetIdentity(opencv_core.CvArr mat, opencv_core.CvScalar value)`
`static void`	`cvSetImageCOI(opencv_core.IplImage image, int coi)`
`static void`	`cvSetImageROI(opencv_core.IplImage image, opencv_core.CvRect rect)`
`static void`	`cvSetIPLAllocators(opencv_core.Cv_iplCreateImageHeader create_header, opencv_core.Cv_iplAllocateImageData allocate_data, opencv_core.Cv_iplDeallocate deallocate, opencv_core.Cv_iplCreateROI create_roi, opencv_core.Cv_iplCloneImage clone_image)`
`static void`	`cvSetMemoryManager()`
`static void`	`cvSetMemoryManager(opencv_core.CvAllocFunc alloc_func, opencv_core.CvFreeFunc free_func, Pointer userdata)`
`static void`	`cvSetND(opencv_core.CvArr arr, int[] idx, opencv_core.CvScalar value)`
`static void`	`cvSetND(opencv_core.CvArr arr, IntBuffer idx, opencv_core.CvScalar value)`
`static void`	`cvSetND(opencv_core.CvArr arr, IntPointer idx, opencv_core.CvScalar value)`
`static opencv_core.CvSetElem`	`cvSetNew(opencv_core.CvSet set_header)`
`static void`	`cvSetNumThreads()`
`static void`	`cvSetNumThreads(int threads)`
`static void`	`cvSetReal1D(opencv_core.CvArr arr, int idx0, double value)`
`static void`	`cvSetReal2D(opencv_core.CvArr arr, int idx0, int idx1, double value)`
`static void`	`cvSetReal3D(opencv_core.CvArr arr, int idx0, int idx1, int idx2, double value)`
`static void`	`cvSetRealND(opencv_core.CvArr arr, int[] idx, double value)`
`static void`	`cvSetRealND(opencv_core.CvArr arr, IntBuffer idx, double value)`
`static void`	`cvSetRealND(opencv_core.CvArr arr, IntPointer idx, double value)`
`static void`	`cvSetRemove(opencv_core.CvSet set_header, int index)`
`static void`	`cvSetRemoveByPtr(opencv_core.CvSet set_header, Pointer elem)`
`static void`	`cvSetSeqBlockSize(opencv_core.CvSeq seq, int delta_elems)`
`static void`	`cvSetSeqReaderPos(opencv_core.CvSeqReader reader, int index)`
`static void`	`cvSetSeqReaderPos(opencv_core.CvSeqReader reader, int index, int is_relative)`
`static void`	`cvSetZero(opencv_core.CvArr arr)`
`static opencv_core.CvSize`	`cvSize(int width, int height)`
`static opencv_core.CvSize2D32f`	`cvSize2D32f(double width, double height)`
`static opencv_core.CvSlice`	`cvSlice(int start, int end)`
`static int`	`cvSliceLength(opencv_core.CvSlice slice, opencv_core.CvSeq seq)` \ Dynamic data structures * \
`static int`	`cvSolve(opencv_core.CvArr src1, opencv_core.CvArr src2, opencv_core.CvArr dst)`
`static int`	`cvSolve(opencv_core.CvArr src1, opencv_core.CvArr src2, opencv_core.CvArr dst, int method)`
`static int`	`cvSolveCubic(opencv_core.CvMat coeffs, opencv_core.CvMat roots)`
`static void`	`cvSolvePoly(opencv_core.CvMat coeffs, opencv_core.CvMat roots2)`
`static void`	`cvSolvePoly(opencv_core.CvMat coeffs, opencv_core.CvMat roots2, int maxiter, int fig)`
`static void`	`cvSort(opencv_core.CvArr src)`
`static void`	`cvSort(opencv_core.CvArr src, opencv_core.CvArr dst, opencv_core.CvArr idxmat, int flags)`
`static void`	`cvSplit(opencv_core.CvArr src, opencv_core.CvArr dst0, opencv_core.CvArr dst1, opencv_core.CvArr dst2, opencv_core.CvArr dst3)`
`static void`	`cvStartAppendToSeq(opencv_core.CvSeq seq, opencv_core.CvSeqWriter writer)`
`static void`	`cvStartNextStream(opencv_core.CvFileStorage fs)`
`static void`	`cvStartReadRawData(opencv_core.CvFileStorage fs, opencv_core.CvFileNode src, opencv_core.CvSeqReader reader)`
`static void`	`cvStartReadSeq(opencv_core.CvSeq seq, opencv_core.CvSeqReader reader)`
`static void`	`cvStartReadSeq(opencv_core.CvSeq seq, opencv_core.CvSeqReader reader, int reverse)`
`static void`	`cvStartWriteSeq(int seq_flags, int header_size, int elem_size, opencv_core.CvMemStorage storage, opencv_core.CvSeqWriter writer)`
`static void`	`cvStartWriteStruct(opencv_core.CvFileStorage fs, BytePointer name, int struct_flags)`
`static void`	`cvStartWriteStruct(opencv_core.CvFileStorage fs, BytePointer name, int struct_flags, BytePointer type_name, opencv_core.CvAttrList attributes)`
`static void`	`cvStartWriteStruct(opencv_core.CvFileStorage fs, String name, int struct_flags)`
`static void`	`cvStartWriteStruct(opencv_core.CvFileStorage fs, String name, int struct_flags, String type_name, opencv_core.CvAttrList attributes)`
`static int`	`cvStdErrReport(int status, BytePointer func_name, BytePointer err_msg, BytePointer file_name, int line, Pointer userdata)`
`static int`	`cvStdErrReport(int status, String func_name, String err_msg, String file_name, int line, Pointer userdata)`
`static void`	`cvSub(opencv_core.CvArr src1, opencv_core.CvArr src2, opencv_core.CvArr dst)`
`static void`	`cvSub(opencv_core.CvArr src1, opencv_core.CvArr src2, opencv_core.CvArr dst, opencv_core.CvArr mask)`
`static void`	`cvSubRS(opencv_core.CvArr src, opencv_core.CvScalar value, opencv_core.CvArr dst)`
`static void`	`cvSubRS(opencv_core.CvArr src, opencv_core.CvScalar value, opencv_core.CvArr dst, opencv_core.CvArr mask)`
`static void`	`cvSubS(opencv_core.CvArr src, opencv_core.CvScalar value, opencv_core.CvArr dst)`
`static void`	`cvSubS(opencv_core.CvArr src, opencv_core.CvScalar value, opencv_core.CvArr dst, opencv_core.CvArr mask)`
`static opencv_core.CvScalar`	`cvSum(opencv_core.CvArr arr)` \ Array Statistics * \
`static void`	`cvSVBkSb(opencv_core.CvArr W, opencv_core.CvArr U, opencv_core.CvArr V, opencv_core.CvArr B, opencv_core.CvArr X, int flags)`
`static void`	`cvSVD(opencv_core.CvArr A, opencv_core.CvArr W)`
`static void`	`cvSVD(opencv_core.CvArr A, opencv_core.CvArr W, opencv_core.CvArr U, opencv_core.CvArr V, int flags)`
`static void`	`cvT(opencv_core.CvArr arg1, opencv_core.CvArr arg2)`
`static opencv_core.CvTermCriteria`	`cvTermCriteria(int type, int max_iter, double epsilon)`
`static opencv_core.CvScalar`	`cvTrace(opencv_core.CvArr mat)`
`static void`	`cvTransform(opencv_core.CvArr src, opencv_core.CvArr dst, opencv_core.CvMat transmat)`
`static void`	`cvTransform(opencv_core.CvArr src, opencv_core.CvArr dst, opencv_core.CvMat transmat, opencv_core.CvMat shiftvec)`
`static void`	`cvTranspose(opencv_core.CvArr src, opencv_core.CvArr dst)`
`static opencv_core.CvSeq`	`cvTreeToNodeSeq(Pointer first, int header_size, opencv_core.CvMemStorage storage)`
`static opencv_core.CvTypeInfo`	`cvTypeOf(Pointer struct_ptr)`
`static void`	`cvUnregisterType(BytePointer type_name)`
`static void`	`cvUnregisterType(String type_name)`
`static int`	`cvUseOptimized(int on_off)`
`static void`	`cvWrite(opencv_core.CvFileStorage fs, BytePointer name, Pointer ptr)`
`static void`	`cvWrite(opencv_core.CvFileStorage fs, BytePointer name, Pointer ptr, opencv_core.CvAttrList attributes)`
`static void`	`cvWrite(opencv_core.CvFileStorage fs, String name, Pointer ptr)`
`static void`	`cvWrite(opencv_core.CvFileStorage fs, String name, Pointer ptr, opencv_core.CvAttrList attributes)`
`static void`	`cvWriteComment(opencv_core.CvFileStorage fs, BytePointer comment, int eol_comment)`
`static void`	`cvWriteComment(opencv_core.CvFileStorage fs, String comment, int eol_comment)`
`static void`	`cvWriteFileNode(opencv_core.CvFileStorage fs, BytePointer new_node_name, opencv_core.CvFileNode node, int embed)`
`static void`	`cvWriteFileNode(opencv_core.CvFileStorage fs, String new_node_name, opencv_core.CvFileNode node, int embed)`
`static void`	`cvWriteInt(opencv_core.CvFileStorage fs, BytePointer name, int value)`
`static void`	`cvWriteInt(opencv_core.CvFileStorage fs, String name, int value)`
`static void`	`cvWriteRawData(opencv_core.CvFileStorage fs, Pointer src, int len, BytePointer dt)`
`static void`	`cvWriteRawData(opencv_core.CvFileStorage fs, Pointer src, int len, String dt)`
`static void`	`cvWriteReal(opencv_core.CvFileStorage fs, BytePointer name, double value)`
`static void`	`cvWriteReal(opencv_core.CvFileStorage fs, String name, double value)`
`static void`	`cvWriteString(opencv_core.CvFileStorage fs, BytePointer name, BytePointer str)`
`static void`	`cvWriteString(opencv_core.CvFileStorage fs, BytePointer name, BytePointer str, int quote)`
`static void`	`cvWriteString(opencv_core.CvFileStorage fs, String name, String str)`
`static void`	`cvWriteString(opencv_core.CvFileStorage fs, String name, String str, int quote)`
`static void`	`cvXor(opencv_core.CvArr src1, opencv_core.CvArr src2, opencv_core.CvArr dst)`
`static void`	`cvXor(opencv_core.CvArr src1, opencv_core.CvArr src2, opencv_core.CvArr dst, opencv_core.CvArr mask)`
`static void`	`cvXorS(opencv_core.CvArr src, opencv_core.CvScalar value, opencv_core.CvArr dst)`
`static void`	`cvXorS(opencv_core.CvArr src, opencv_core.CvScalar value, opencv_core.CvArr dst, opencv_core.CvArr mask)`
`static void`	`cvZero(opencv_core.CvArr arg1)`
`static void`	`dct(opencv_core.Mat src, opencv_core.Mat dst)`
`static void`	`dct(opencv_core.Mat src, opencv_core.Mat dst, int flags)` performs forward or inverse 1D or 2D Discrete Cosine Transformation
`static double`	`determinant(opencv_core.Mat mtx)` computes determinant of a square matrix
`static void`	`dft(opencv_core.Mat src, opencv_core.Mat dst)`
`static void`	`dft(opencv_core.Mat src, opencv_core.Mat dst, int flags, int nonzeroRows)` performs forward or inverse 1D or 2D Discrete Fourier Transformation
`static opencv_core.MatExpr`	`divide(double s, opencv_core.Mat a)`
`static opencv_core.MatExpr`	`divide(double s, opencv_core.MatExpr e)`
`static void`	`divide(double scale, opencv_core.Mat src2, opencv_core.Mat dst)`
`static void`	`divide(double scale, opencv_core.Mat src2, opencv_core.Mat dst, int dtype)` computes element-wise weighted reciprocal of an array (dst = scale/src2)
`static opencv_core.MatExpr`	`divide(opencv_core.Mat a, double s)`
`static opencv_core.MatExpr`	`divide(opencv_core.MatExpr e, double s)`
`static opencv_core.MatExpr`	`divide(opencv_core.MatExpr e, opencv_core.Mat m)`
`static opencv_core.MatExpr`	`divide(opencv_core.MatExpr e1, opencv_core.MatExpr e2)`
`static opencv_core.MatExpr`	`divide(opencv_core.Mat a, opencv_core.Mat b)`
`static opencv_core.MatExpr`	`divide(opencv_core.Mat m, opencv_core.MatExpr e)`
`static void`	`divide(opencv_core.Mat src1, opencv_core.Mat src2, opencv_core.Mat dst)`
`static void`	`divide(opencv_core.Mat src1, opencv_core.Mat src2, opencv_core.Mat dst, double scale, int dtype)` computes element-wise weighted quotient of the two arrays (dst = scale*src1/src2)
`static opencv_core.Mat`	`dividePut(opencv_core.Mat a, double s)`
`static opencv_core.Mat`	`dividePut(opencv_core.Mat a, opencv_core.Mat b)`
`static opencv_core.Mat`	`dividePut(opencv_core.Mat a, opencv_core.MatExpr b)`
`static boolean`	`eigen(opencv_core.Mat src, boolean computeEigenvectors, opencv_core.Mat eigenvalues, opencv_core.Mat eigenvectors)`
`static boolean`	`eigen(opencv_core.Mat src, opencv_core.Mat eigenvalues)`
`static boolean`	`eigen(opencv_core.Mat src, opencv_core.Mat eigenvalues, int lowindex, int highindex)` finds eigenvalues of a symmetric matrix
`static boolean`	`eigen(opencv_core.Mat src, opencv_core.Mat eigenvalues, opencv_core.Mat eigenvectors)`
`static boolean`	`eigen(opencv_core.Mat src, opencv_core.Mat eigenvalues, opencv_core.Mat eigenvectors, int lowindex, int highindex)` finds eigenvalues and eigenvectors of a symmetric matrix
`static void`	`ellipse(opencv_core.Mat img, opencv_core.Point center, opencv_core.Size axes, double angle, double startAngle, double endAngle, opencv_core.Scalar color)`
`static void`	`ellipse(opencv_core.Mat img, opencv_core.Point center, opencv_core.Size axes, double angle, double startAngle, double endAngle, opencv_core.Scalar color, int thickness, int lineType, int shift)` draws an elliptic arc, ellipse sector or a rotated ellipse in the image
`static void`	`ellipse(opencv_core.Mat img, opencv_core.RotatedRect box, opencv_core.Scalar color)`
`static void`	`ellipse(opencv_core.Mat img, opencv_core.RotatedRect box, opencv_core.Scalar color, int thickness, int lineType)` draws a rotated ellipse in the image
`static void`	`ellipse2Poly(opencv_core.Point center, opencv_core.Size axes, int angle, int arcStart, int arcEnd, int delta, opencv_core.Point pts)` converts elliptic arc to a polygonal curve
`static opencv_core.MatExpr`	`equals(double s, opencv_core.Mat a)`
`static boolean`	`equals(opencv_core.FileNodeIterator it1, opencv_core.FileNodeIterator it2)`
`static boolean`	`equals(opencv_core.MatConstIterator a, opencv_core.MatConstIterator b)`
`static opencv_core.MatExpr`	`equals(opencv_core.Mat a, double s)`
`static opencv_core.MatExpr`	`equals(opencv_core.Mat a, opencv_core.Mat b)`
`static boolean`	`equals(opencv_core.Range r1, opencv_core.Range r2)`
`static boolean`	`equals(opencv_core.SparseMatConstIterator it1, opencv_core.SparseMatConstIterator it2)`
`static void`	`exp(float[] src, float[] dst, int n)`
`static void`	`exp(FloatBuffer src, FloatBuffer dst, int n)`
`static void`	`exp(FloatPointer src, FloatPointer dst, int n)`
`static void`	`exp(opencv_core.Mat src, opencv_core.Mat dst)` computes exponent of each matrix element (dst = e**src)
`static void`	`extractChannel(opencv_core.Mat src, opencv_core.Mat dst, int coi)` extracts a single channel from src (coi is 0-based index)
`static void`	`extractImageCOI(opencv_core.CvArr arr, opencv_core.Mat coiimg)`
`static void`	`extractImageCOI(opencv_core.CvArr arr, opencv_core.Mat coiimg, int coi)` extracts Channel of Interest from CvMat or IplImage and makes cv::Mat out of it.
`static int`	`fast_abs(byte v)`
`static double`	`fast_abs(double v)`
`static float`	`fast_abs(float v)`
`static int`	`fast_abs(int v)`
`static int`	`fast_abs(short v)`
`static void`	`fastAtan2(float[] y, float[] x, float[] dst, int n, boolean angleInDegrees)`
`static void`	`fastAtan2(FloatBuffer y, FloatBuffer x, FloatBuffer dst, int n, boolean angleInDegrees)`
`static float`	`fastAtan2(float y, float x)` computes the angle in degrees (0..360) of the vector (x,y)
`static void`	`fastAtan2(FloatPointer y, FloatPointer x, FloatPointer dst, int n, boolean angleInDegrees)`
`static void`	`fastFree(Pointer ptr)` Frees the memory allocated with cv::fastMalloc This is the corresponding deallocation function for cv::fastMalloc().
`static Pointer`	`fastMalloc(long bufSize)` Allocates memory buffer This is specialized OpenCV memory allocation function that returns properly aligned memory buffers.
`static void`	`fillConvexPoly(opencv_core.Mat img, opencv_core.Mat points, opencv_core.Scalar color)`
`static void`	`fillConvexPoly(opencv_core.Mat img, opencv_core.Mat points, opencv_core.Scalar color, int lineType, int shift)`
`static void`	`fillConvexPoly(opencv_core.Mat img, opencv_core.Point pts, int npts, opencv_core.Scalar color)`
`static void`	`fillConvexPoly(opencv_core.Mat img, opencv_core.Point pts, int npts, opencv_core.Scalar color, int lineType, int shift)` draws a filled convex polygon in the image
`static void`	`fillPoly(opencv_core.Mat img, opencv_core.MatVector pts, opencv_core.Scalar color)`
`static void`	`fillPoly(opencv_core.Mat img, opencv_core.MatVector pts, opencv_core.Scalar color, int lineType, int shift, opencv_core.Point offset)`
`static void`	`fillPoly(opencv_core.Mat img, opencv_core.Point pts, int[] npts, int ncontours, opencv_core.Scalar color)`
`static void`	`fillPoly(opencv_core.Mat img, opencv_core.Point pts, int[] npts, int ncontours, opencv_core.Scalar color, int lineType, int shift, opencv_core.Point offset)`
`static void`	`fillPoly(opencv_core.Mat img, opencv_core.Point pts, IntBuffer npts, int ncontours, opencv_core.Scalar color)`
`static void`	`fillPoly(opencv_core.Mat img, opencv_core.Point pts, IntBuffer npts, int ncontours, opencv_core.Scalar color, int lineType, int shift, opencv_core.Point offset)`
`static void`	`fillPoly(opencv_core.Mat img, opencv_core.Point pts, IntPointer npts, int ncontours, opencv_core.Scalar color)`
`static void`	`fillPoly(opencv_core.Mat img, opencv_core.Point pts, IntPointer npts, int ncontours, opencv_core.Scalar color, int lineType, int shift, opencv_core.Point offset)`
`static void`	`fillPoly(opencv_core.Mat img, PointerPointer pts, IntPointer npts, int ncontours, opencv_core.Scalar color, int lineType, int shift, opencv_core.Point offset)` fills an area bounded by one or more polygons
`static void`	`findNonZero(opencv_core.Mat src, opencv_core.Mat idx)` returns the list of locations of non-zero pixels
`static void`	`flip(opencv_core.Mat src, opencv_core.Mat dst, int flipCode)` reverses the order of the rows, columns or both in a matrix
`static BytePointer`	`format(BytePointer fmt)`
`static opencv_core.Formatted`	`format(opencv_core.Mat mtx, BytePointer fmt)`
`static opencv_core.Formatted`	`format(opencv_core.Mat mtx, BytePointer fmt, int[] params)`
`static opencv_core.Formatted`	`format(opencv_core.Mat mtx, BytePointer fmt, IntBuffer params)`
`static opencv_core.Formatted`	`format(opencv_core.Mat mtx, BytePointer fmt, IntPointer params)`
`static opencv_core.Formatted`	`format(opencv_core.Mat mtx, String fmt)`
`static opencv_core.Formatted`	`format(opencv_core.Mat mtx, String fmt, int[] params)`
`static opencv_core.Formatted`	`format(opencv_core.Mat mtx, String fmt, IntBuffer params)`
`static opencv_core.Formatted`	`format(opencv_core.Mat mtx, String fmt, IntPointer params)`
`static String`	`format(String fmt)`
`static void`	`gemm(opencv_core.Mat src1, opencv_core.Mat src2, double alpha, opencv_core.Mat src3, double beta, opencv_core.Mat dst)`
`static void`	`gemm(opencv_core.Mat src1, opencv_core.Mat src2, double alpha, opencv_core.Mat src3, double beta, opencv_core.Mat dst, int flags)` implements generalized matrix product algorithm GEMM from BLAS
`static BytePointer`	`getBuildInformation()`
`static opencv_core.ConvertData`	`getConvertElem(int fromType, int toType)` returns the function for converting pixels from one data type to another
`static opencv_core.BinaryFunc`	`getConvertFunc(int sdepth, int ddepth)`
`static opencv_core.ConvertScaleData`	`getConvertScaleElem(int fromType, int toType)` returns the function for converting pixels from one data type to another with the optional scaling
`static opencv_core.BinaryFunc`	`getConvertScaleFunc(int sdepth, int ddepth)`
`static opencv_core.BinaryFunc`	`getCopyMaskFunc(long esz)`
`static long`	`getCPUTickCount()` Returns the number of CPU ticks.
`static long`	`getElemSize(int type)`
`static int`	`getNumberOfCPUs()` returns the number of CPUs (including hyper-threading)
`static int`	`getNumThreads()`
`static int`	`getOptimalDFTSize(int vecsize)` computes the minimal vector size vecsize1 >= vecsize so that the dft() of the vector of length vecsize1 can be computed efficiently
`static BytePointer`	`getSeqElem(opencv_core.CvSeq seq, int index)`
`static opencv_core.Size`	`getTextSize(BytePointer text, int fontFace, double fontScale, int thickness, int[] baseLine)`
`static opencv_core.Size`	`getTextSize(BytePointer text, int fontFace, double fontScale, int thickness, IntBuffer baseLine)`
`static opencv_core.Size`	`getTextSize(BytePointer text, int fontFace, double fontScale, int thickness, IntPointer baseLine)` returns bounding box of the text string
`static opencv_core.Size`	`getTextSize(String text, int fontFace, double fontScale, int thickness, int[] baseLine)`
`static opencv_core.Size`	`getTextSize(String text, int fontFace, double fontScale, int thickness, IntBuffer baseLine)`
`static opencv_core.Size`	`getTextSize(String text, int fontFace, double fontScale, int thickness, IntPointer baseLine)`
`static int`	`getThreadNum()`
`static long`	`getTickCount()` Returns the number of ticks.
`static double`	`getTickFrequency()` Returns the number of ticks per seconds.
`static void`	`glob(BytePointer pattern, opencv_core.StringVector result)`
`static void`	`glob(BytePointer pattern, opencv_core.StringVector result, boolean recursive)`
`static void`	`glob(String pattern, opencv_core.StringVector result)`
`static void`	`glob(String pattern, opencv_core.StringVector result, boolean recursive)`
`static opencv_core.MatExpr`	`greaterThan(double s, opencv_core.Mat a)`
`static boolean`	`greaterThan(opencv_core.MatConstIterator a, opencv_core.MatConstIterator b)`
`static opencv_core.MatExpr`	`greaterThan(opencv_core.Mat a, double s)`
`static opencv_core.MatExpr`	`greaterThan(opencv_core.Mat a, opencv_core.Mat b)`
`static opencv_core.MatExpr`	`greaterThanEquals(double s, opencv_core.Mat a)`
`static boolean`	`greaterThanEquals(opencv_core.MatConstIterator a, opencv_core.MatConstIterator b)`
`static opencv_core.MatExpr`	`greaterThanEquals(opencv_core.Mat a, double s)`
`static opencv_core.MatExpr`	`greaterThanEquals(opencv_core.Mat a, opencv_core.Mat b)`
`static void`	`hconcat(opencv_core.Mat src, long nsrc, opencv_core.Mat dst)`
`static void`	`hconcat(opencv_core.Mat src1, opencv_core.Mat src2, opencv_core.Mat dst)`
`static void`	`hconcat(opencv_core.MatVector src, opencv_core.Mat dst)`
`static void`	`idct(opencv_core.Mat src, opencv_core.Mat dst)`
`static void`	`idct(opencv_core.Mat src, opencv_core.Mat dst, int flags)` performs inverse 1D or 2D Discrete Cosine Transformation
`static void`	`idft(opencv_core.Mat src, opencv_core.Mat dst)`
`static void`	`idft(opencv_core.Mat src, opencv_core.Mat dst, int flags, int nonzeroRows)` performs inverse 1D or 2D Discrete Fourier Transformation
`static void`	`inRange(opencv_core.Mat src, opencv_core.Mat lowerb, opencv_core.Mat upperb, opencv_core.Mat dst)` set mask elements for those array elements which are within the element-specific bounding box (dst = lowerb <= src && src < upperb)
`static void`	`insertChannel(opencv_core.Mat src, opencv_core.Mat dst, int coi)` inserts a single channel to dst (coi is 0-based index)
`static void`	`insertImageCOI(opencv_core.Mat coiimg, opencv_core.CvArr arr)`
`static void`	`insertImageCOI(opencv_core.Mat coiimg, opencv_core.CvArr arr, int coi)` inserts single-channel cv::Mat into a multi-channel CvMat or IplImage
`static double`	`invert(opencv_core.Mat src, opencv_core.Mat dst)`
`static double`	`invert(opencv_core.Mat src, opencv_core.Mat dst, int flags)` computes inverse or pseudo-inverse matrix
`static int`	`IPL_IMAGE_MAGIC_VAL()`
`static double`	`kmeans(opencv_core.Mat data, int K, opencv_core.Mat bestLabels, opencv_core.TermCriteria criteria, int attempts, int flags)`
`static double`	`kmeans(opencv_core.Mat data, int K, opencv_core.Mat bestLabels, opencv_core.TermCriteria criteria, int attempts, int flags, opencv_core.Mat centers)` clusters the input data using k-Means algorithm
`static opencv_core.MatExpr`	`lessThan(double s, opencv_core.Mat a)`
`static boolean`	`lessThan(opencv_core.FileNodeIterator it1, opencv_core.FileNodeIterator it2)`
`static boolean`	`lessThan(opencv_core.MatConstIterator a, opencv_core.MatConstIterator b)`
`static opencv_core.MatExpr`	`lessThan(opencv_core.Mat a, double s)`
`static opencv_core.MatExpr`	`lessThan(opencv_core.Mat a, opencv_core.Mat b)`
`static opencv_core.MatExpr`	`lessThanEquals(double s, opencv_core.Mat a)`
`static boolean`	`lessThanEquals(opencv_core.MatConstIterator a, opencv_core.MatConstIterator b)`
`static opencv_core.MatExpr`	`lessThanEquals(opencv_core.Mat a, double s)`
`static opencv_core.MatExpr`	`lessThanEquals(opencv_core.Mat a, opencv_core.Mat b)`
`static void`	`line(opencv_core.Mat img, opencv_core.Point pt1, opencv_core.Point pt2, opencv_core.Scalar color)`
`static void`	`line(opencv_core.Mat img, opencv_core.Point pt1, opencv_core.Point pt2, opencv_core.Scalar color, int thickness, int lineType, int shift)` draws the line segment (pt1, pt2) in the image
`static void`	`log(float[] src, float[] dst, int n)`
`static void`	`log(FloatBuffer src, FloatBuffer dst, int n)`
`static void`	`log(FloatPointer src, FloatPointer dst, int n)`
`static void`	`log(opencv_core.Mat src, opencv_core.Mat dst)` computes natural logarithm of absolute value of each matrix element: dst = log(abs(src))
`static int`	`LU(double[] A, long astep, int m, double[] b, long bstep, int n)`
`static int`	`LU(DoubleBuffer A, long astep, int m, DoubleBuffer b, long bstep, int n)`
`static int`	`LU(DoublePointer A, long astep, int m, DoublePointer b, long bstep, int n)`
`static int`	`LU(float[] A, long astep, int m, float[] b, long bstep, int n)`
`static int`	`LU(FloatBuffer A, long astep, int m, FloatBuffer b, long bstep, int n)`
`static int`	`LU(FloatPointer A, long astep, int m, FloatPointer b, long bstep, int n)`
`static void`	`LUT(opencv_core.Mat src, opencv_core.Mat lut, opencv_core.Mat dst)`
`static void`	`LUT(opencv_core.Mat src, opencv_core.Mat lut, opencv_core.Mat dst, int interpolation)` transforms array of numbers using a lookup table: dst(i)=lut(src(i))
`static void`	`magnitude(float[] x, float[] y, float[] dst, int n)`
`static void`	`magnitude(FloatBuffer x, FloatBuffer y, FloatBuffer dst, int n)`
`static void`	`magnitude(FloatPointer x, FloatPointer y, FloatPointer dst, int n)`
`static void`	`magnitude(opencv_core.Mat x, opencv_core.Mat y, opencv_core.Mat magnitude)` computes magnitude (magnitude(i)) of each (x(i), y(i)) vector
`static double`	`Mahalanobis(opencv_core.Mat v1, opencv_core.Mat v2, opencv_core.Mat icovar)` computes Mahalanobis distance between two vectors: sqrt((v1-v2)'icovar(v1-v2)), where icovar is the inverse covariation matrix
`static double`	`Mahalonobis(opencv_core.Mat v1, opencv_core.Mat v2, opencv_core.Mat icovar)` a synonym for Mahalanobis
`static opencv_core.MatExpr`	`max(double s, opencv_core.Mat a)`
`static opencv_core.MatExpr`	`max(opencv_core.Mat a, double s)`
`static void`	`max(opencv_core.Mat src1, double src2, opencv_core.Mat dst)` computes per-element maximum of array and scalar (dst = max(src1, src2))
`static opencv_core.MatExpr`	`max(opencv_core.Mat a, opencv_core.Mat b)`
`static void`	`max(opencv_core.Mat src1, opencv_core.Mat src2, opencv_core.Mat dst)` computes per-element maximum of two arrays (dst = max(src1, src2))
`static opencv_core.Scalar`	`mean(opencv_core.Mat src)`
`static opencv_core.Scalar`	`mean(opencv_core.Mat src, opencv_core.Mat mask)` computes mean value of selected array elements
`static void`	`meanStdDev(opencv_core.Mat src, opencv_core.Mat mean, opencv_core.Mat stddev)`
`static void`	`meanStdDev(opencv_core.Mat src, opencv_core.Mat mean, opencv_core.Mat stddev, opencv_core.Mat mask)` computes mean value and standard deviation of all or selected array elements
`static void`	`merge(opencv_core.Mat mv, long count, opencv_core.Mat dst)` makes multi-channel array out of several single-channel arrays
`static void`	`merge(opencv_core.MatVector mv, opencv_core.Mat dst)`
`static opencv_core.MatExpr`	`min(double s, opencv_core.Mat a)`
`static opencv_core.MatExpr`	`min(opencv_core.Mat a, double s)`
`static void`	`min(opencv_core.Mat src1, double src2, opencv_core.Mat dst)` computes per-element minimum of array and scalar (dst = min(src1, src2))
`static opencv_core.MatExpr`	`min(opencv_core.Mat a, opencv_core.Mat b)`
`static void`	`min(opencv_core.Mat src1, opencv_core.Mat src2, opencv_core.Mat dst)` computes per-element minimum of two arrays (dst = min(src1, src2))
`static void`	`minMaxIdx(opencv_core.Mat src, double[] minVal, double[] maxVal)`
`static void`	`minMaxIdx(opencv_core.Mat src, double[] minVal, double[] maxVal, int[] minIdx, int[] maxIdx, opencv_core.Mat mask)`
`static void`	`minMaxIdx(opencv_core.Mat src, DoubleBuffer minVal, DoubleBuffer maxVal)`
`static void`	`minMaxIdx(opencv_core.Mat src, DoubleBuffer minVal, DoubleBuffer maxVal, IntBuffer minIdx, IntBuffer maxIdx, opencv_core.Mat mask)`
`static void`	`minMaxIdx(opencv_core.Mat src, DoublePointer minVal, DoublePointer maxVal)`
`static void`	`minMaxIdx(opencv_core.Mat src, DoublePointer minVal, DoublePointer maxVal, IntPointer minIdx, IntPointer maxIdx, opencv_core.Mat mask)`
`static void`	`minMaxLoc(opencv_core.Mat src, double[] minVal)`
`static void`	`minMaxLoc(opencv_core.Mat src, double[] minVal, double[] maxVal, opencv_core.Point minLoc, opencv_core.Point maxLoc, opencv_core.Mat mask)`
`static void`	`minMaxLoc(opencv_core.Mat src, DoubleBuffer minVal)`
`static void`	`minMaxLoc(opencv_core.Mat src, DoubleBuffer minVal, DoubleBuffer maxVal, opencv_core.Point minLoc, opencv_core.Point maxLoc, opencv_core.Mat mask)`
`static void`	`minMaxLoc(opencv_core.Mat src, DoublePointer minVal)`
`static void`	`minMaxLoc(opencv_core.Mat src, DoublePointer minVal, DoublePointer maxVal, opencv_core.Point minLoc, opencv_core.Point maxLoc, opencv_core.Mat mask)` finds global minimum and maximum array elements and returns their values and their locations
`static void`	`minMaxLoc(opencv_core.SparseMat a, double[] minVal, double[] maxVal)`
`static void`	`minMaxLoc(opencv_core.SparseMat a, double[] minVal, double[] maxVal, int[] minIdx, int[] maxIdx)`
`static void`	`minMaxLoc(opencv_core.SparseMat a, DoubleBuffer minVal, DoubleBuffer maxVal)`
`static void`	`minMaxLoc(opencv_core.SparseMat a, DoubleBuffer minVal, DoubleBuffer maxVal, IntBuffer minIdx, IntBuffer maxIdx)`
`static void`	`minMaxLoc(opencv_core.SparseMat a, DoublePointer minVal, DoublePointer maxVal)`
`static void`	`minMaxLoc(opencv_core.SparseMat a, DoublePointer minVal, DoublePointer maxVal, IntPointer minIdx, IntPointer maxIdx)` finds global minimum and maximum sparse array elements and returns their values and their locations
`static void`	`mixChannels(opencv_core.Mat src, long nsrcs, opencv_core.Mat dst, long ndsts, int[] fromTo, long npairs)`
`static void`	`mixChannels(opencv_core.Mat src, long nsrcs, opencv_core.Mat dst, long ndsts, IntBuffer fromTo, long npairs)`
`static void`	`mixChannels(opencv_core.Mat src, long nsrcs, opencv_core.Mat dst, long ndsts, IntPointer fromTo, long npairs)` copies selected channels from the input arrays to the selected channels of the output arrays
`static void`	`mixChannels(opencv_core.MatVector src, opencv_core.MatVector dst, int[] fromTo)`
`static void`	`mixChannels(opencv_core.MatVector src, opencv_core.MatVector dst, int[] fromTo, long npairs)`
`static void`	`mixChannels(opencv_core.MatVector src, opencv_core.MatVector dst, IntBuffer fromTo)`
`static void`	`mixChannels(opencv_core.MatVector src, opencv_core.MatVector dst, IntBuffer fromTo, long npairs)`
`static void`	`mixChannels(opencv_core.MatVector src, opencv_core.MatVector dst, IntPointer fromTo)`
`static void`	`mixChannels(opencv_core.MatVector src, opencv_core.MatVector dst, IntPointer fromTo, long npairs)`
`static void`	`mulSpectrums(opencv_core.Mat a, opencv_core.Mat b, opencv_core.Mat c, int flags)`
`static void`	`mulSpectrums(opencv_core.Mat a, opencv_core.Mat b, opencv_core.Mat c, int flags, boolean conjB)` computes element-wise product of the two Fourier spectrums.
`static opencv_core.MatExpr`	`multiply(double s, opencv_core.Mat a)`
`static opencv_core.MatExpr`	`multiply(double s, opencv_core.MatExpr e)`
`static opencv_core.MatExpr`	`multiply(opencv_core.Mat a, double s)`
`static opencv_core.MatExpr`	`multiply(opencv_core.MatExpr e, double s)`
`static opencv_core.MatExpr`	`multiply(opencv_core.MatExpr e, opencv_core.Mat m)`
`static opencv_core.MatExpr`	`multiply(opencv_core.MatExpr e1, opencv_core.MatExpr e2)`
`static opencv_core.MatExpr`	`multiply(opencv_core.Mat a, opencv_core.Mat b)`
`static opencv_core.MatExpr`	`multiply(opencv_core.Mat m, opencv_core.MatExpr e)`
`static void`	`multiply(opencv_core.Mat src1, opencv_core.Mat src2, opencv_core.Mat dst)`
`static void`	`multiply(opencv_core.Mat src1, opencv_core.Mat src2, opencv_core.Mat dst, double scale, int dtype)` computes element-wise weighted product of the two arrays (dst = scalesrc1src2)
`static opencv_core.Mat`	`multiplyPut(opencv_core.Mat a, double s)`
`static opencv_core.Mat`	`multiplyPut(opencv_core.Mat a, opencv_core.Mat b)`
`static opencv_core.Mat`	`multiplyPut(opencv_core.Mat a, opencv_core.MatExpr b)`
`static void`	`mulTransposed(opencv_core.Mat src, opencv_core.Mat dst, boolean aTa)`
`static void`	`mulTransposed(opencv_core.Mat src, opencv_core.Mat dst, boolean aTa, opencv_core.Mat delta, double scale, int dtype)` multiplies matrix by its transposition from the left or from the right
`static double`	`norm(opencv_core.Mat src1)`
`static double`	`norm(opencv_core.Mat src1, int normType, opencv_core.Mat mask)` computes norm of the selected array part
`static double`	`norm(opencv_core.Mat src1, opencv_core.Mat src2)`
`static double`	`norm(opencv_core.Mat src1, opencv_core.Mat src2, int normType, opencv_core.Mat mask)` computes norm of selected part of the difference between two arrays
`static double`	`norm(opencv_core.SparseMat src, int normType)` computes norm of a sparse matrix
`static void`	`normalize(opencv_core.Mat src, opencv_core.Mat dst)`
`static void`	`normalize(opencv_core.Mat src, opencv_core.Mat dst, double alpha, double beta, int norm_type, int dtype, opencv_core.Mat mask)` scales and shifts array elements so that either the specified norm (alpha) or the minimum (alpha) and maximum (beta) array values get the specified values
`static void`	`normalize(opencv_core.SparseMat src, opencv_core.SparseMat dst, double alpha, int normType)` scales and shifts array elements so that either the specified norm (alpha) or the minimum (alpha) and maximum (beta) array values get the specified values
`static int`	`normHamming(byte[] a, byte[] b, int n)`
`static int`	`normHamming(byte[] a, byte[] b, int n, int cellSize)`
`static int`	`normHamming(ByteBuffer a, ByteBuffer b, int n)`
`static int`	`normHamming(ByteBuffer a, ByteBuffer b, int n, int cellSize)`
`static int`	`normHamming(BytePointer a, BytePointer b, int n)`
`static int`	`normHamming(BytePointer a, BytePointer b, int n, int cellSize)`
`static int`	`normL1_(byte[] a, byte[] b, int n)`
`static int`	`normL1_(ByteBuffer a, ByteBuffer b, int n)`
`static int`	`normL1_(BytePointer a, BytePointer b, int n)`
`static float`	`normL1_(float[] a, float[] b, int n)`
`static float`	`normL1_(FloatBuffer a, FloatBuffer b, int n)`
`static float`	`normL1_(FloatPointer a, FloatPointer b, int n)`
`static float`	`normL2Sqr_(float[] a, float[] b, int n)`
`static float`	`normL2Sqr_(FloatBuffer a, FloatBuffer b, int n)`
`static float`	`normL2Sqr_(FloatPointer a, FloatPointer b, int n)`
`static opencv_core.MatExpr`	`not(opencv_core.Mat m)`
`static boolean`	`not(opencv_core.Range r)`
`static opencv_core.MatExpr`	`notEquals(double s, opencv_core.Mat a)`
`static boolean`	`notEquals(opencv_core.FileNodeIterator it1, opencv_core.FileNodeIterator it2)`
`static opencv_core.MatExpr`	`notEquals(opencv_core.Mat a, double s)`
`static opencv_core.MatExpr`	`notEquals(opencv_core.Mat a, opencv_core.Mat b)`
`static boolean`	`notEquals(opencv_core.Range r1, opencv_core.Range r2)`
`static boolean`	`notEquals(opencv_core.SparseMatConstIterator it1, opencv_core.SparseMatConstIterator it2)`
`static opencv_core.MatExpr`	`or(opencv_core.Mat a, opencv_core.Mat b)`
`static opencv_core.MatExpr`	`or(opencv_core.Mat a, opencv_core.Scalar s)`
`static opencv_core.MatExpr`	`or(opencv_core.Scalar s, opencv_core.Mat a)`
`static opencv_core.Mat`	`orPut(opencv_core.Mat a, opencv_core.Mat b)`
`static opencv_core.Mat`	`orPut(opencv_core.Mat a, opencv_core.Scalar s)`
`static void`	`parallel_for_(opencv_core.Range range, opencv_core.ParallelLoopBody body)`
`static void`	`parallel_for_(opencv_core.Range range, opencv_core.ParallelLoopBody body, double nstripes)`
`static void`	`patchNaNs(opencv_core.Mat a)`
`static void`	`patchNaNs(opencv_core.Mat a, double val)` converts NaN's to the given number
`static void`	`PCABackProject(opencv_core.Mat data, opencv_core.Mat mean, opencv_core.Mat eigenvectors, opencv_core.Mat result)`
`static void`	`PCACompute(opencv_core.Mat data, opencv_core.Mat mean, opencv_core.Mat eigenvectors)`
`static void`	`PCACompute(opencv_core.Mat data, opencv_core.Mat mean, opencv_core.Mat eigenvectors, int maxComponents)`
`static void`	`PCAComputeVar(opencv_core.Mat data, opencv_core.Mat mean, opencv_core.Mat eigenvectors, double retainedVariance)`
`static void`	`PCAProject(opencv_core.Mat data, opencv_core.Mat mean, opencv_core.Mat eigenvectors, opencv_core.Mat result)`
`static void`	`perspectiveTransform(opencv_core.Mat src, opencv_core.Mat dst, opencv_core.Mat m)` performs perspective transformation of each element of multi-channel input matrix
`static void`	`phase(opencv_core.Mat x, opencv_core.Mat y, opencv_core.Mat angle)`
`static void`	`phase(opencv_core.Mat x, opencv_core.Mat y, opencv_core.Mat angle, boolean angleInDegrees)` computes angle (angle(i)) of each (x(i), y(i)) vector
`static void`	`polarToCart(opencv_core.Mat magnitude, opencv_core.Mat angle, opencv_core.Mat x, opencv_core.Mat y)`
`static void`	`polarToCart(opencv_core.Mat magnitude, opencv_core.Mat angle, opencv_core.Mat x, opencv_core.Mat y, boolean angleInDegrees)` converts polar coordinates to Cartesian
`static void`	`polylines(opencv_core.Mat img, opencv_core.MatVector pts, boolean isClosed, opencv_core.Scalar color)`
`static void`	`polylines(opencv_core.Mat img, opencv_core.MatVector pts, boolean isClosed, opencv_core.Scalar color, int thickness, int lineType, int shift)`
`static void`	`polylines(opencv_core.Mat img, opencv_core.Point pts, int[] npts, int ncontours, boolean isClosed, opencv_core.Scalar color)`
`static void`	`polylines(opencv_core.Mat img, opencv_core.Point pts, int[] npts, int ncontours, boolean isClosed, opencv_core.Scalar color, int thickness, int lineType, int shift)`
`static void`	`polylines(opencv_core.Mat img, opencv_core.Point pts, IntBuffer npts, int ncontours, boolean isClosed, opencv_core.Scalar color)`
`static void`	`polylines(opencv_core.Mat img, opencv_core.Point pts, IntBuffer npts, int ncontours, boolean isClosed, opencv_core.Scalar color, int thickness, int lineType, int shift)`
`static void`	`polylines(opencv_core.Mat img, opencv_core.Point pts, IntPointer npts, int ncontours, boolean isClosed, opencv_core.Scalar color)`
`static void`	`polylines(opencv_core.Mat img, opencv_core.Point pts, IntPointer npts, int ncontours, boolean isClosed, opencv_core.Scalar color, int thickness, int lineType, int shift)`
`static void`	`polylines(opencv_core.Mat img, PointerPointer pts, IntPointer npts, int ncontours, boolean isClosed, opencv_core.Scalar color, int thickness, int lineType, int shift)` draws one or more polygonal curves
`static void`	`pow(opencv_core.Mat src, double power, opencv_core.Mat dst)` raises the input matrix elements to the specified power (b = a**power)
`static void`	`putText(opencv_core.Mat img, BytePointer text, opencv_core.Point org, int fontFace, double fontScale, opencv_core.Scalar color)`
`static void`	`putText(opencv_core.Mat img, BytePointer text, opencv_core.Point org, int fontFace, double fontScale, opencv_core.Scalar color, int thickness, int lineType, boolean bottomLeftOrigin)` renders text string in the image
`static void`	`putText(opencv_core.Mat img, String text, opencv_core.Point org, int fontFace, double fontScale, opencv_core.Scalar color)`
`static void`	`putText(opencv_core.Mat img, String text, opencv_core.Point org, int fontFace, double fontScale, opencv_core.Scalar color, int thickness, int lineType, boolean bottomLeftOrigin)`
`static double`	`randDouble()`
`static float`	`randFloat()`
`static int`	`randInt()` returns the next unifomly-distributed random number of the specified type
`static void`	`randn(opencv_core.Mat dst, opencv_core.Mat mean, opencv_core.Mat stddev)` fills array with normally-distributed random numbers with the specified mean and the standard deviation
`static void`	`randShuffle(opencv_core.Mat dst)`
`static void`	`randShuffle(opencv_core.Mat dst, double iterFactor)`
`static void`	`randShuffle(opencv_core.Mat dst, double iterFactor, opencv_core.RNG rng)` shuffles the input array elements
`static void`	`randu(opencv_core.Mat dst, opencv_core.Mat low, opencv_core.Mat high)` fills array with uniformly-distributed random numbers from the range [low, high)
`static void`	`read(opencv_core.FileNode node, BoolPointer value, boolean default_value)`
`static void`	`read(opencv_core.FileNode node, byte[] value, byte default_value)`
`static void`	`read(opencv_core.FileNode node, ByteBuffer value, byte default_value)`
`static void`	`read(opencv_core.FileNode node, BytePointer value, byte default_value)`
`static void`	`read(opencv_core.FileNode node, BytePointer value, BytePointer default_value)`
`static void`	`read(opencv_core.FileNode node, double[] value, double default_value)`
`static void`	`read(opencv_core.FileNode node, DoubleBuffer value, double default_value)`
`static void`	`read(opencv_core.FileNode node, DoublePointer value, double default_value)`
`static void`	`read(opencv_core.FileNode node, float[] value, float default_value)`
`static void`	`read(opencv_core.FileNode node, FloatBuffer value, float default_value)`
`static void`	`read(opencv_core.FileNode node, FloatPointer value, float default_value)`
`static void`	`read(opencv_core.FileNode node, int[] value, int default_value)`
`static void`	`read(opencv_core.FileNode node, IntBuffer value, int default_value)`
`static void`	`read(opencv_core.FileNode node, IntPointer value, int default_value)`
`static void`	`read(opencv_core.FileNode node, opencv_core.Mat mat)`
`static void`	`read(opencv_core.FileNode node, opencv_core.Mat mat, opencv_core.Mat default_mat)`
`static void`	`read(opencv_core.FileNode node, opencv_core.Range value, opencv_core.Range default_value)`
`static void`	`read(opencv_core.FileNode node, opencv_core.SparseMat mat)`
`static void`	`read(opencv_core.FileNode node, opencv_core.SparseMat mat, opencv_core.SparseMat default_mat)`
`static void`	`read(opencv_core.FileNode node, short[] value, short default_value)`
`static void`	`read(opencv_core.FileNode node, ShortBuffer value, short default_value)`
`static void`	`read(opencv_core.FileNode node, ShortPointer value, short default_value)`
`static void`	`read(opencv_core.FileNode node, String value, String default_value)`
`static void`	`rectangle(opencv_core.Mat img, opencv_core.Point pt1, opencv_core.Point pt2, opencv_core.Scalar color)`
`static void`	`rectangle(opencv_core.Mat img, opencv_core.Point pt1, opencv_core.Point pt2, opencv_core.Scalar color, int thickness, int lineType, int shift)` draws the rectangle outline or a solid rectangle with the opposite corners pt1 and pt2 in the image
`static void`	`rectangle(opencv_core.Mat img, opencv_core.Rect rec, opencv_core.Scalar color)`
`static void`	`rectangle(opencv_core.Mat img, opencv_core.Rect rec, opencv_core.Scalar color, int thickness, int lineType, int shift)` draws the rectangle outline or a solid rectangle covering rec in the image
`static opencv_core.ErrorCallback`	`redirectError(opencv_core.ErrorCallback errCallback)`
`static opencv_core.ErrorCallback`	`redirectError(opencv_core.ErrorCallback errCallback, Pointer userdata, Pointer prevUserdata)`
`static opencv_core.ErrorCallback`	`redirectError(opencv_core.ErrorCallback errCallback, Pointer userdata, PointerPointer prevUserdata)` Sets the new error handler and the optional user data.
`static void`	`reduce(opencv_core.Mat src, opencv_core.Mat dst, int dim, int rtype)`
`static void`	`reduce(opencv_core.Mat src, opencv_core.Mat dst, int dim, int rtype, int dtype)` transforms 2D matrix to 1D row or column vector by taking sum, minimum, maximum or mean value over all the rows
`static opencv_core.Mat`	`repeat(opencv_core.Mat src, int ny, int nx)`
`static void`	`repeat(opencv_core.Mat src, int ny, int nx, opencv_core.Mat dst)` replicates the input matrix the specified number of times in the horizontal and/or vertical direction
`static int`	`saturateCastInt(byte v)`
`static int`	`saturateCastInt(double v)`
`static int`	`saturateCastInt(float v)`
`static int`	`saturateCastInt(int v)`
`static int`	`saturateCastInt(short v)`
`static byte`	`saturateCastSchar(byte v)`
`static byte`	`saturateCastSchar(double v)`
`static byte`	`saturateCastSchar(float v)`
`static byte`	`saturateCastSchar(int v)`
`static byte`	`saturateCastSchar(short v)`
`static short`	`saturateCastShort(byte v)`
`static short`	`saturateCastShort(double v)`
`static short`	`saturateCastShort(float v)`
`static short`	`saturateCastShort(int v)`
`static short`	`saturateCastShort(short v)`
`static byte`	`saturateCastUchar(byte v)`
`static byte`	`saturateCastUchar(double v)`
`static byte`	`saturateCastUchar(float v)`
`static byte`	`saturateCastUchar(int v)`
`static byte`	`saturateCastUchar(short v)`
`static int`	`saturateCastUnsigned(byte v)`
`static int`	`saturateCastUnsigned(double v)`
`static int`	`saturateCastUnsigned(float v)`
`static int`	`saturateCastUnsigned(int v)`
`static int`	`saturateCastUnsigned(short v)`
`static short`	`saturateCastUshort(byte v)`
`static short`	`saturateCastUshort(double v)`
`static short`	`saturateCastUshort(float v)`
`static short`	`saturateCastUshort(int v)`
`static short`	`saturateCastUshort(short v)`
`static void`	`scalarToRawData(opencv_core.Scalar s, Pointer buf, int type)`
`static void`	`scalarToRawData(opencv_core.Scalar s, Pointer buf, int type, int unroll_to)`
`static void`	`scaleAdd(opencv_core.Mat src1, double alpha, opencv_core.Mat src2, opencv_core.Mat dst)` adds scaled array to another one (dst = alpha*src1 + src2)
`static void`	`seqInsertSlice(opencv_core.CvSeq seq, int before_index, opencv_core.CvArr from_arr)`
`static void`	`seqPop(opencv_core.CvSeq seq)`
`static void`	`seqPop(opencv_core.CvSeq seq, Pointer element)`
`static void`	`seqPopFront(opencv_core.CvSeq seq)`
`static void`	`seqPopFront(opencv_core.CvSeq seq, Pointer element)`
`static BytePointer`	`seqPush(opencv_core.CvSeq seq)`
`static BytePointer`	`seqPush(opencv_core.CvSeq seq, Pointer element)` \ Generic implementation of QuickSort algorithm Use it as: vector<_Tp> a; ...
`static BytePointer`	`seqPushFront(opencv_core.CvSeq seq)`
`static BytePointer`	`seqPushFront(opencv_core.CvSeq seq, Pointer element)`
`static void`	`seqRemove(opencv_core.CvSeq seq, int index)`
`static void`	`seqRemoveSlice(opencv_core.CvSeq seq, opencv_core.CvSlice slice)`
`static boolean`	`setBreakOnError(boolean flag)` Sets/resets the break-on-error mode.
`static void`	`setIdentity(opencv_core.Mat mtx)`
`static void`	`setIdentity(opencv_core.Mat mtx, opencv_core.Scalar s)` initializes scaled identity matrix
`static void`	`setNumThreads(int nthreads)`
`static void`	`setUseOptimized(boolean onoff)` Turns on/off available optimization The function turns on or off the optimized code in OpenCV.
`static opencv_core.FileStorage`	`shiftLeft(opencv_core.FileStorage fs, byte[] value)`
`static opencv_core.FileStorage`	`shiftLeft(opencv_core.FileStorage fs, ByteBuffer value)`
`static opencv_core.FileStorage`	`shiftLeft(opencv_core.FileStorage fs, BytePointer str)`
`static opencv_core.FileStorage`	`shiftLeft(opencv_core.FileStorage fs, String str)`
`static Pointer`	`shiftLeft(Pointer out, opencv_core.Formatted fmtd)` \brief prints Mat to the output stream allows in the specified notation (see format) use like
`static Pointer`	`shiftLeft(Pointer out, opencv_core.Mat mtx)` \brief prints Mat to the output stream in Matlab notation use like
`static boolean`	`solve(opencv_core.Mat src1, opencv_core.Mat src2, opencv_core.Mat dst)`
`static boolean`	`solve(opencv_core.Mat src1, opencv_core.Mat src2, opencv_core.Mat dst, int flags)` solves linear system or a least-square problem
`static int`	`solveCubic(opencv_core.Mat coeffs, opencv_core.Mat roots)` finds real roots of a cubic polynomial
`static double`	`solvePoly(opencv_core.Mat coeffs, opencv_core.Mat roots)`
`static double`	`solvePoly(opencv_core.Mat coeffs, opencv_core.Mat roots, int maxIters)` finds real and complex roots of a polynomial
`static void`	`sort(opencv_core.Mat src, opencv_core.Mat dst, int flags)` sorts independently each matrix row or each matrix column
`static void`	`sortIdx(opencv_core.Mat src, opencv_core.Mat dst, int flags)` sorts independently each matrix row or each matrix column
`static void`	`split(opencv_core.Mat src, opencv_core.Mat mvbegin)` copies each plane of a multi-channel array to a dedicated array
`static void`	`split(opencv_core.Mat m, opencv_core.MatVector mv)`
`static void`	`sqrt(opencv_core.Mat src, opencv_core.Mat dst)` computes square root of each matrix element (dst = src**0.5)
`static long`	`subtract(opencv_core.FileNodeIterator it1, opencv_core.FileNodeIterator it2)`
`static opencv_core.MatExpr`	`subtract(opencv_core.Mat m)`
`static opencv_core.MatConstIterator`	`subtract(opencv_core.MatConstIterator a, long ofs)`
`static long`	`subtract(opencv_core.MatConstIterator b, opencv_core.MatConstIterator a)`
`static opencv_core.MatExpr`	`subtract(opencv_core.MatExpr e)`
`static opencv_core.MatExpr`	`subtract(opencv_core.MatExpr e, opencv_core.Mat m)`
`static opencv_core.MatExpr`	`subtract(opencv_core.MatExpr e1, opencv_core.MatExpr e2)`
`static opencv_core.MatExpr`	`subtract(opencv_core.MatExpr e, opencv_core.Scalar s)`
`static opencv_core.MatExpr`	`subtract(opencv_core.Mat a, opencv_core.Mat b)`
`static opencv_core.MatExpr`	`subtract(opencv_core.Mat m, opencv_core.MatExpr e)`
`static void`	`subtract(opencv_core.Mat src1, opencv_core.Mat src2, opencv_core.Mat dst)`
`static void`	`subtract(opencv_core.Mat src1, opencv_core.Mat src2, opencv_core.Mat dst, opencv_core.Mat mask, int dtype)` subtracts one matrix from another (dst = src1 - src2)
`static opencv_core.MatExpr`	`subtract(opencv_core.Mat a, opencv_core.Scalar s)`
`static opencv_core.Range`	`subtract(opencv_core.Range r1, int delta)`
`static opencv_core.MatExpr`	`subtract(opencv_core.Scalar s, opencv_core.Mat a)`
`static opencv_core.MatExpr`	`subtract(opencv_core.Scalar s, opencv_core.MatExpr e)`
`static opencv_core.Mat`	`subtractPut(opencv_core.Mat a, opencv_core.Mat b)`
`static opencv_core.Mat`	`subtractPut(opencv_core.Mat a, opencv_core.MatExpr b)`
`static opencv_core.Mat`	`subtractPut(opencv_core.Mat a, opencv_core.Scalar s)`
`static opencv_core.Scalar`	`sumElems(opencv_core.Mat src)` computes sum of array elements
`static void`	`SVBackSubst(opencv_core.Mat w, opencv_core.Mat u, opencv_core.Mat vt, opencv_core.Mat rhs, opencv_core.Mat dst)` performs back substitution for the previously computed SVD
`static void`	`SVDecomp(opencv_core.Mat src, opencv_core.Mat w, opencv_core.Mat u, opencv_core.Mat vt)`
`static void`	`SVDecomp(opencv_core.Mat src, opencv_core.Mat w, opencv_core.Mat u, opencv_core.Mat vt, int flags)` computes SVD of src
`static void`	`swap(opencv_core.Mat a, opencv_core.Mat b)` swaps two matrices
`static BytePointer`	`tempfile()`
`static BytePointer`	`tempfile(BytePointer suffix)`
`static String`	`tempfile(String suffix)`
`static opencv_core.RNG`	`theRNG()` returns the thread-local Random number generator
`static opencv_core.Scalar`	`trace(opencv_core.Mat mtx)` computes trace of a matrix
`static void`	`transform(opencv_core.Mat src, opencv_core.Mat dst, opencv_core.Mat m)` performs affine transformation of each element of multi-channel input matrix
`static void`	`transpose(opencv_core.Mat src, opencv_core.Mat dst)` transposes the matrix
`static boolean`	`useOptimized()` Returns the current optimization status The function returns the current optimization status, which is controlled by cv::setUseOptimized().
`static void`	`vconcat(opencv_core.Mat src, long nsrc, opencv_core.Mat dst)`
`static void`	`vconcat(opencv_core.Mat src1, opencv_core.Mat src2, opencv_core.Mat dst)`
`static void`	`vconcat(opencv_core.MatVector src, opencv_core.Mat dst)`
`static void`	`write(opencv_core.FileStorage fs, BytePointer value)`
`static void`	`write(opencv_core.FileStorage fs, BytePointer name, BytePointer value)`
`static void`	`write(opencv_core.FileStorage fs, BytePointer name, double value)`
`static void`	`write(opencv_core.FileStorage fs, BytePointer name, float value)`
`static void`	`write(opencv_core.FileStorage fs, BytePointer name, int value)`
`static void`	`write(opencv_core.FileStorage fs, BytePointer name, opencv_core.Mat value)`
`static void`	`write(opencv_core.FileStorage fs, BytePointer name, opencv_core.Range r)`
`static void`	`write(opencv_core.FileStorage fs, BytePointer name, opencv_core.SparseMat value)`
`static void`	`write(opencv_core.FileStorage fs, double value)`
`static void`	`write(opencv_core.FileStorage fs, float value)`
`static void`	`write(opencv_core.FileStorage fs, int value)`
`static void`	`write(opencv_core.FileStorage fs, opencv_core.Range r)`
`static void`	`write(opencv_core.FileStorage fs, String value)`
`static void`	`write(opencv_core.FileStorage fs, String name, double value)`
`static void`	`write(opencv_core.FileStorage fs, String name, float value)`
`static void`	`write(opencv_core.FileStorage fs, String name, int value)`
`static void`	`write(opencv_core.FileStorage fs, String name, opencv_core.Mat value)`
`static void`	`write(opencv_core.FileStorage fs, String name, opencv_core.Range r)`
`static void`	`write(opencv_core.FileStorage fs, String name, opencv_core.SparseMat value)`
`static void`	`write(opencv_core.FileStorage fs, String name, String value)`
`static void`	`writeScalar(opencv_core.FileStorage fs, BytePointer value)`
`static void`	`writeScalar(opencv_core.FileStorage fs, double value)`
`static void`	`writeScalar(opencv_core.FileStorage fs, float value)`
`static void`	`writeScalar(opencv_core.FileStorage fs, int value)`
`static void`	`writeScalar(opencv_core.FileStorage fs, String value)`
`static opencv_core.MatExpr`	`xor(opencv_core.Mat a, opencv_core.Mat b)`
`static opencv_core.MatExpr`	`xor(opencv_core.Mat a, opencv_core.Scalar s)`
`static opencv_core.MatExpr`	`xor(opencv_core.Scalar s, opencv_core.Mat a)`
`static opencv_core.Mat`	`xorPut(opencv_core.Mat a, opencv_core.Mat b)`
`static opencv_core.Mat`	`xorPut(opencv_core.Mat a, opencv_core.Scalar s)`

Methods inherited from class org.bytedeco.javacpp.helper.opencv_core
CV_RGB, cvCalcCovarMatrix, cvDrawContours, cvDrawPolyLine, cvFillPoly, cvInitNArrayIterator, cvMixChannels, cvNorm, cvPolyLine

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

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

Field Detail
- CV_StsOk
```
public static final int CV_StsOk
```
  enum
  
  See Also:
  
  Constant Field Values
- CV_StsBackTrace
```
public static final int CV_StsBackTrace
```
  enum
  
  See Also:
  
  Constant Field Values
- CV_StsError
```
public static final int CV_StsError
```
  enum
  
  See Also:
  
  Constant Field Values
- CV_StsInternal
```
public static final int CV_StsInternal
```
  enum
  
  See Also:
  
  Constant Field Values
- CV_StsNoMem
```
public static final int CV_StsNoMem
```
  enum
  
  See Also:
  
  Constant Field Values
- CV_StsBadArg
```
public static final int CV_StsBadArg
```
  enum
  
  See Also:
  
  Constant Field Values
- CV_StsBadFunc
```
public static final int CV_StsBadFunc
```
  enum
  
  See Also:
  
  Constant Field Values
- CV_StsNoConv
```
public static final int CV_StsNoConv
```
  enum
  
  See Also:
  
  Constant Field Values
- CV_StsAutoTrace
```
public static final int CV_StsAutoTrace
```
  enum
  
  See Also:
  
  Constant Field Values
- CV_HeaderIsNull
```
public static final int CV_HeaderIsNull
```
  enum
  
  See Also:
  
  Constant Field Values
- CV_BadImageSize
```
public static final int CV_BadImageSize
```
  enum
  
  See Also:
  
  Constant Field Values
- CV_BadOffset
```
public static final int CV_BadOffset
```
  enum
  
  See Also:
  
  Constant Field Values
- CV_BadDataPtr
```
public static final int CV_BadDataPtr
```
  enum
  
  See Also:
  
  Constant Field Values
- CV_BadStep
```
public static final int CV_BadStep
```
  enum
  
  See Also:
  
  Constant Field Values
- CV_BadModelOrChSeq
```
public static final int CV_BadModelOrChSeq
```
  enum
  
  See Also:
  
  Constant Field Values
- CV_BadNumChannels
```
public static final int CV_BadNumChannels
```
  enum
  
  See Also:
  
  Constant Field Values
- CV_BadNumChannel1U
```
public static final int CV_BadNumChannel1U
```
  enum
  
  See Also:
  
  Constant Field Values
- CV_BadDepth
```
public static final int CV_BadDepth
```
  enum
  
  See Also:
  
  Constant Field Values
- CV_BadAlphaChannel
```
public static final int CV_BadAlphaChannel
```
  enum
  
  See Also:
  
  Constant Field Values
- CV_BadOrder
```
public static final int CV_BadOrder
```
  enum
  
  See Also:
  
  Constant Field Values
- CV_BadOrigin
```
public static final int CV_BadOrigin
```
  enum
  
  See Also:
  
  Constant Field Values
- CV_BadAlign
```
public static final int CV_BadAlign
```
  enum
  
  See Also:
  
  Constant Field Values
- CV_BadCallBack
```
public static final int CV_BadCallBack
```
  enum
  
  See Also:
  
  Constant Field Values
- CV_BadTileSize
```
public static final int CV_BadTileSize
```
  enum
  
  See Also:
  
  Constant Field Values
- CV_BadCOI
```
public static final int CV_BadCOI
```
  enum
  
  See Also:
  
  Constant Field Values
- CV_BadROISize
```
public static final int CV_BadROISize
```
  enum
  
  See Also:
  
  Constant Field Values
- CV_MaskIsTiled
```
public static final int CV_MaskIsTiled
```
  enum
  
  See Also:
  
  Constant Field Values
- CV_StsNullPtr
```
public static final int CV_StsNullPtr
```
  enum
  
  See Also:
  
  Constant Field Values
- CV_StsVecLengthErr
```
public static final int CV_StsVecLengthErr
```
  enum
  
  See Also:
  
  Constant Field Values
- CV_StsFilterStructContentErr
```
public static final int CV_StsFilterStructContentErr
```
  enum
  
  See Also:
  
  Constant Field Values
- CV_StsKernelStructContentErr
```
public static final int CV_StsKernelStructContentErr
```
  enum
  
  See Also:
  
  Constant Field Values
- CV_StsFilterOffsetErr
```
public static final int CV_StsFilterOffsetErr
```
  enum
  
  See Also:
  
  Constant Field Values
- CV_StsBadSize
```
public static final int CV_StsBadSize
```
  enum
  
  See Also:
  
  Constant Field Values
- CV_StsDivByZero
```
public static final int CV_StsDivByZero
```
  enum
  
  See Also:
  
  Constant Field Values
- CV_StsInplaceNotSupported
```
public static final int CV_StsInplaceNotSupported
```
  enum
  
  See Also:
  
  Constant Field Values
- CV_StsObjectNotFound
```
public static final int CV_StsObjectNotFound
```
  enum
  
  See Also:
  
  Constant Field Values
- CV_StsUnmatchedFormats
```
public static final int CV_StsUnmatchedFormats
```
  enum
  
  See Also:
  
  Constant Field Values
- CV_StsBadFlag
```
public static final int CV_StsBadFlag
```
  enum
  
  See Also:
  
  Constant Field Values
- CV_StsBadPoint
```
public static final int CV_StsBadPoint
```
  enum
  
  See Also:
  
  Constant Field Values
- CV_StsBadMask
```
public static final int CV_StsBadMask
```
  enum
  
  See Also:
  
  Constant Field Values
- CV_StsUnmatchedSizes
```
public static final int CV_StsUnmatchedSizes
```
  enum
  
  See Also:
  
  Constant Field Values
- CV_StsUnsupportedFormat
```
public static final int CV_StsUnsupportedFormat
```
  enum
  
  See Also:
  
  Constant Field Values
- CV_StsOutOfRange
```
public static final int CV_StsOutOfRange
```
  enum
  
  See Also:
  
  Constant Field Values
- CV_StsParseError
```
public static final int CV_StsParseError
```
  enum
  
  See Also:
  
  Constant Field Values
- CV_StsNotImplemented
```
public static final int CV_StsNotImplemented
```
  enum
  
  See Also:
  
  Constant Field Values
- CV_StsBadMemBlock
```
public static final int CV_StsBadMemBlock
```
  enum
  
  See Also:
  
  Constant Field Values
- CV_StsAssert
```
public static final int CV_StsAssert
```
  enum
  
  See Also:
  
  Constant Field Values
- CV_GpuNotSupported
```
public static final int CV_GpuNotSupported
```
  enum
  
  See Also:
  
  Constant Field Values
- CV_GpuApiCallError
```
public static final int CV_GpuApiCallError
```
  enum
  
  See Also:
  
  Constant Field Values
- CV_OpenGlNotSupported
```
public static final int CV_OpenGlNotSupported
```
  enum
  
  See Also:
  
  Constant Field Values
- CV_OpenGlApiCallError
```
public static final int CV_OpenGlApiCallError
```
  enum
  
  See Also:
  
  Constant Field Values
- CV_OpenCLDoubleNotSupported
```
public static final int CV_OpenCLDoubleNotSupported
```
  enum
  
  See Also:
  
  Constant Field Values
- CV_OpenCLInitError
```
public static final int CV_OpenCLInitError
```
  enum
  
  See Also:
  
  Constant Field Values
- CV_OpenCLNoAMDBlasFft
```
public static final int CV_OpenCLNoAMDBlasFft
```
  enum
  
  See Also:
  
  Constant Field Values
- CV_PI
```
public static final double CV_PI
```
  \ Common macros and inline functions * \
  
  See Also:
  
  Constant Field Values
- CV_LOG2
```
public static final double CV_LOG2
```
  See Also:
  
  Constant Field Values
- CV_RNG_COEFF
```
public static final long CV_RNG_COEFF
```
  Random number generation
  
  See Also:
  
  Constant Field Values
- IPL_DEPTH_SIGN
```
public static final int IPL_DEPTH_SIGN
```
  \ Image type (IplImage) * \
  
  See Also:
  
  Constant Field Values
- IPL_DEPTH_1U
```
public static final int IPL_DEPTH_1U
```
  See Also:
  
  Constant Field Values
- IPL_DEPTH_8U
```
public static final int IPL_DEPTH_8U
```
  See Also:
  
  Constant Field Values
- IPL_DEPTH_16U
```
public static final int IPL_DEPTH_16U
```
  See Also:
  
  Constant Field Values
- IPL_DEPTH_32F
```
public static final int IPL_DEPTH_32F
```
  See Also:
  
  Constant Field Values
- IPL_DEPTH_8S
```
public static final int IPL_DEPTH_8S
```
  See Also:
  
  Constant Field Values
- IPL_DEPTH_16S
```
public static final int IPL_DEPTH_16S
```
  See Also:
  
  Constant Field Values
- IPL_DEPTH_32S
```
public static final int IPL_DEPTH_32S
```
  See Also:
  
  Constant Field Values
- IPL_DATA_ORDER_PIXEL
```
public static final int IPL_DATA_ORDER_PIXEL
```
  See Also:
  
  Constant Field Values
- IPL_DATA_ORDER_PLANE
```
public static final int IPL_DATA_ORDER_PLANE
```
  See Also:
  
  Constant Field Values
- IPL_ORIGIN_TL
```
public static final int IPL_ORIGIN_TL
```
  See Also:
  
  Constant Field Values
- IPL_ORIGIN_BL
```
public static final int IPL_ORIGIN_BL
```
  See Also:
  
  Constant Field Values
- IPL_ALIGN_4BYTES
```
public static final int IPL_ALIGN_4BYTES
```
  See Also:
  
  Constant Field Values
- IPL_ALIGN_8BYTES
```
public static final int IPL_ALIGN_8BYTES
```
  See Also:
  
  Constant Field Values
- IPL_ALIGN_16BYTES
```
public static final int IPL_ALIGN_16BYTES
```
  See Also:
  
  Constant Field Values
- IPL_ALIGN_32BYTES
```
public static final int IPL_ALIGN_32BYTES
```
  See Also:
  
  Constant Field Values
- IPL_ALIGN_DWORD
```
public static final int IPL_ALIGN_DWORD
```
  See Also:
  
  Constant Field Values
- IPL_ALIGN_QWORD
```
public static final int IPL_ALIGN_QWORD
```
  See Also:
  
  Constant Field Values
- IPL_BORDER_CONSTANT
```
public static final int IPL_BORDER_CONSTANT
```
  See Also:
  
  Constant Field Values
- IPL_BORDER_REPLICATE
```
public static final int IPL_BORDER_REPLICATE
```
  See Also:
  
  Constant Field Values
- IPL_BORDER_REFLECT
```
public static final int IPL_BORDER_REFLECT
```
  See Also:
  
  Constant Field Values
- IPL_BORDER_WRAP
```
public static final int IPL_BORDER_WRAP
```
  See Also:
  
  Constant Field Values
- IPL_IMAGE_HEADER
```
public static final int IPL_IMAGE_HEADER
```
  See Also:
  
  Constant Field Values
- IPL_IMAGE_DATA
```
public static final int IPL_IMAGE_DATA
```
  See Also:
  
  Constant Field Values
- IPL_IMAGE_ROI
```
public static final int IPL_IMAGE_ROI
```
  See Also:
  
  Constant Field Values
- IPL_BORDER_REFLECT_101
```
public static final int IPL_BORDER_REFLECT_101
```
  See Also:
  
  Constant Field Values
- IPL_BORDER_TRANSPARENT
```
public static final int IPL_BORDER_TRANSPARENT
```
  See Also:
  
  Constant Field Values
- IPL_IMAGE_MAGIC_VAL
```
public static final int IPL_IMAGE_MAGIC_VAL
```
- CV_TYPE_NAME_IMAGE
```
public static final String CV_TYPE_NAME_IMAGE
```
  See Also:
  
  Constant Field Values
- IPL_DEPTH_64F
```
public static final int IPL_DEPTH_64F
```
  See Also:
  
  Constant Field Values
- CV_CN_MAX
```
public static final int CV_CN_MAX
```
  \ Matrix type (CvMat) * \
  
  See Also:
  
  Constant Field Values
- CV_CN_SHIFT
```
public static final int CV_CN_SHIFT
```
  See Also:
  
  Constant Field Values
- CV_DEPTH_MAX
```
public static final int CV_DEPTH_MAX
```
  See Also:
  
  Constant Field Values
- CV_8U
```
public static final int CV_8U
```
  See Also:
  
  Constant Field Values
- CV_8S
```
public static final int CV_8S
```
  See Also:
  
  Constant Field Values
- CV_16U
```
public static final int CV_16U
```
  See Also:
  
  Constant Field Values
- CV_16S
```
public static final int CV_16S
```
  See Also:
  
  Constant Field Values
- CV_32S
```
public static final int CV_32S
```
  See Also:
  
  Constant Field Values
- CV_32F
```
public static final int CV_32F
```
  See Also:
  
  Constant Field Values
- CV_64F
```
public static final int CV_64F
```
  See Also:
  
  Constant Field Values
- CV_USRTYPE1
```
public static final int CV_USRTYPE1
```
  See Also:
  
  Constant Field Values
- CV_MAT_DEPTH_MASK
```
public static final int CV_MAT_DEPTH_MASK
```
  See Also:
  
  Constant Field Values
- CV_8UC1
```
public static final int CV_8UC1
```
- CV_8UC2
```
public static final int CV_8UC2
```
- CV_8UC3
```
public static final int CV_8UC3
```
- CV_8UC4
```
public static final int CV_8UC4
```
- CV_8SC1
```
public static final int CV_8SC1
```
- CV_8SC2
```
public static final int CV_8SC2
```
- CV_8SC3
```
public static final int CV_8SC3
```
- CV_8SC4
```
public static final int CV_8SC4
```
- CV_16UC1
```
public static final int CV_16UC1
```
- CV_16UC2
```
public static final int CV_16UC2
```
- CV_16UC3
```
public static final int CV_16UC3
```
- CV_16UC4
```
public static final int CV_16UC4
```
- CV_16SC1
```
public static final int CV_16SC1
```
- CV_16SC2
```
public static final int CV_16SC2
```
- CV_16SC3
```
public static final int CV_16SC3
```
- CV_16SC4
```
public static final int CV_16SC4
```
- CV_32SC1
```
public static final int CV_32SC1
```
- CV_32SC2
```
public static final int CV_32SC2
```
- CV_32SC3
```
public static final int CV_32SC3
```
- CV_32SC4
```
public static final int CV_32SC4
```
- CV_32FC1
```
public static final int CV_32FC1
```
- CV_32FC2
```
public static final int CV_32FC2
```
- CV_32FC3
```
public static final int CV_32FC3
```
- CV_32FC4
```
public static final int CV_32FC4
```
- CV_64FC1
```
public static final int CV_64FC1
```
- CV_64FC2
```
public static final int CV_64FC2
```
- CV_64FC3
```
public static final int CV_64FC3
```
- CV_64FC4
```
public static final int CV_64FC4
```
- CV_AUTO_STEP
```
public static final int CV_AUTO_STEP
```
  See Also:
  
  Constant Field Values
- CV_WHOLE_ARR
```
public static final opencv_core.CvSlice CV_WHOLE_ARR
```
- CV_MAT_CN_MASK
```
public static final int CV_MAT_CN_MASK
```
  See Also:
  
  Constant Field Values
- CV_MAT_TYPE_MASK
```
public static final int CV_MAT_TYPE_MASK
```
  See Also:
  
  Constant Field Values
- CV_MAT_CONT_FLAG_SHIFT
```
public static final int CV_MAT_CONT_FLAG_SHIFT
```
  See Also:
  
  Constant Field Values
- CV_MAT_CONT_FLAG
```
public static final int CV_MAT_CONT_FLAG
```
  See Also:
  
  Constant Field Values
- CV_SUBMAT_FLAG_SHIFT
```
public static final int CV_SUBMAT_FLAG_SHIFT
```
  See Also:
  
  Constant Field Values
- CV_SUBMAT_FLAG
```
public static final int CV_SUBMAT_FLAG
```
  See Also:
  
  Constant Field Values
- CV_MAGIC_MASK
```
public static final int CV_MAGIC_MASK
```
  See Also:
  
  Constant Field Values
- CV_MAT_MAGIC_VAL
```
public static final int CV_MAT_MAGIC_VAL
```
  See Also:
  
  Constant Field Values
- CV_TYPE_NAME_MAT
```
public static final String CV_TYPE_NAME_MAT
```
  See Also:
  
  Constant Field Values
- CV_MATND_MAGIC_VAL
```
public static final int CV_MATND_MAGIC_VAL
```
  \ Multi-dimensional dense array (CvMatND) * \
  
  See Also:
  
  Constant Field Values
- CV_TYPE_NAME_MATND
```
public static final String CV_TYPE_NAME_MATND
```
  See Also:
  
  Constant Field Values
- CV_MAX_DIM
```
public static final int CV_MAX_DIM
```
  See Also:
  
  Constant Field Values
- CV_MAX_DIM_HEAP
```
public static final int CV_MAX_DIM_HEAP
```
  See Also:
  
  Constant Field Values
- CV_SPARSE_MAT_MAGIC_VAL
```
public static final int CV_SPARSE_MAT_MAGIC_VAL
```
  \ Multi-dimensional sparse array (CvSparseMat) * \
  
  See Also:
  
  Constant Field Values
- CV_TYPE_NAME_SPARSE_MAT
```
public static final String CV_TYPE_NAME_SPARSE_MAT
```
  See Also:
  
  Constant Field Values
- CV_HIST_MAGIC_VAL
```
public static final int CV_HIST_MAGIC_VAL
```
  \ Histogram * \
  
  See Also:
  
  Constant Field Values
- CV_HIST_UNIFORM_FLAG
```
public static final int CV_HIST_UNIFORM_FLAG
```
  See Also:
  
  Constant Field Values
- CV_HIST_RANGES_FLAG
```
public static final int CV_HIST_RANGES_FLAG
```
  See Also:
  
  Constant Field Values
- CV_HIST_ARRAY
```
public static final int CV_HIST_ARRAY
```
  See Also:
  
  Constant Field Values
- CV_HIST_SPARSE
```
public static final int CV_HIST_SPARSE
```
  See Also:
  
  Constant Field Values
- CV_HIST_TREE
```
public static final int CV_HIST_TREE
```
  See Also:
  
  Constant Field Values
- CV_HIST_UNIFORM
```
public static final int CV_HIST_UNIFORM
```
  See Also:
  
  Constant Field Values
- CV_TERMCRIT_ITER
```
public static final int CV_TERMCRIT_ITER
```
  CvTermCriteria
  
  See Also:
  
  Constant Field Values
- CV_TERMCRIT_NUMBER
```
public static final int CV_TERMCRIT_NUMBER
```
  See Also:
  
  Constant Field Values
- CV_TERMCRIT_EPS
```
public static final int CV_TERMCRIT_EPS
```
  See Also:
  
  Constant Field Values
- CV_WHOLE_SEQ_END_INDEX
```
public static final int CV_WHOLE_SEQ_END_INDEX
```
  See Also:
  
  Constant Field Values
- CV_WHOLE_SEQ
```
public static final opencv_core.CvSlice CV_WHOLE_SEQ
```
- CV_STORAGE_MAGIC_VAL
```
public static final int CV_STORAGE_MAGIC_VAL
```
  See Also:
  
  Constant Field Values
- CV_TYPE_NAME_SEQ
```
public static final String CV_TYPE_NAME_SEQ
```
  See Also:
  
  Constant Field Values
- CV_TYPE_NAME_SEQ_TREE
```
public static final String CV_TYPE_NAME_SEQ_TREE
```
  See Also:
  
  Constant Field Values
- CV_SET_ELEM_IDX_MASK
```
public static final int CV_SET_ELEM_IDX_MASK
```
  See Also:
  
  Constant Field Values
- CV_SET_ELEM_FREE_FLAG
```
public static final int CV_SET_ELEM_FREE_FLAG
```
- CV_TYPE_NAME_GRAPH
```
public static final String CV_TYPE_NAME_GRAPH
```
  See Also:
  
  Constant Field Values
- CV_SEQ_MAGIC_VAL
```
public static final int CV_SEQ_MAGIC_VAL
```
  \ Sequence types * \
  
  See Also:
  
  Constant Field Values
- CV_SET_MAGIC_VAL
```
public static final int CV_SET_MAGIC_VAL
```
  See Also:
  
  Constant Field Values
- CV_SEQ_ELTYPE_BITS
```
public static final int CV_SEQ_ELTYPE_BITS
```
  See Also:
  
  Constant Field Values
- CV_SEQ_ELTYPE_MASK
```
public static final int CV_SEQ_ELTYPE_MASK
```
  See Also:
  
  Constant Field Values
- CV_SEQ_ELTYPE_POINT
```
public static final int CV_SEQ_ELTYPE_POINT
```
- CV_SEQ_ELTYPE_CODE
```
public static final int CV_SEQ_ELTYPE_CODE
```
- CV_SEQ_ELTYPE_GENERIC
```
public static final int CV_SEQ_ELTYPE_GENERIC
```
  See Also:
  
  Constant Field Values
- CV_SEQ_ELTYPE_PTR
```
public static final int CV_SEQ_ELTYPE_PTR
```
  See Also:
  
  Constant Field Values
- CV_SEQ_ELTYPE_PPOINT
```
public static final int CV_SEQ_ELTYPE_PPOINT
```
  See Also:
  
  Constant Field Values
- CV_SEQ_ELTYPE_INDEX
```
public static final int CV_SEQ_ELTYPE_INDEX
```
- CV_SEQ_ELTYPE_GRAPH_EDGE
```
public static final int CV_SEQ_ELTYPE_GRAPH_EDGE
```
  See Also:
  
  Constant Field Values
- CV_SEQ_ELTYPE_GRAPH_VERTEX
```
public static final int CV_SEQ_ELTYPE_GRAPH_VERTEX
```
  See Also:
  
  Constant Field Values
- CV_SEQ_ELTYPE_TRIAN_ATR
```
public static final int CV_SEQ_ELTYPE_TRIAN_ATR
```
  See Also:
  
  Constant Field Values
- CV_SEQ_ELTYPE_CONNECTED_COMP
```
public static final int CV_SEQ_ELTYPE_CONNECTED_COMP
```
  See Also:
  
  Constant Field Values
- CV_SEQ_ELTYPE_POINT3D
```
public static final int CV_SEQ_ELTYPE_POINT3D
```
- CV_SEQ_KIND_BITS
```
public static final int CV_SEQ_KIND_BITS
```
  See Also:
  
  Constant Field Values
- CV_SEQ_KIND_MASK
```
public static final int CV_SEQ_KIND_MASK
```
  See Also:
  
  Constant Field Values
- CV_SEQ_KIND_GENERIC
```
public static final int CV_SEQ_KIND_GENERIC
```
  See Also:
  
  Constant Field Values
- CV_SEQ_KIND_CURVE
```
public static final int CV_SEQ_KIND_CURVE
```
  See Also:
  
  Constant Field Values
- CV_SEQ_KIND_BIN_TREE
```
public static final int CV_SEQ_KIND_BIN_TREE
```
  See Also:
  
  Constant Field Values
- CV_SEQ_KIND_GRAPH
```
public static final int CV_SEQ_KIND_GRAPH
```
  See Also:
  
  Constant Field Values
- CV_SEQ_KIND_SUBDIV2D
```
public static final int CV_SEQ_KIND_SUBDIV2D
```
  See Also:
  
  Constant Field Values
- CV_SEQ_FLAG_SHIFT
```
public static final int CV_SEQ_FLAG_SHIFT
```
  See Also:
  
  Constant Field Values
- CV_SEQ_FLAG_CLOSED
```
public static final int CV_SEQ_FLAG_CLOSED
```
  See Also:
  
  Constant Field Values
- CV_SEQ_FLAG_SIMPLE
```
public static final int CV_SEQ_FLAG_SIMPLE
```
  See Also:
  
  Constant Field Values
- CV_SEQ_FLAG_CONVEX
```
public static final int CV_SEQ_FLAG_CONVEX
```
  See Also:
  
  Constant Field Values
- CV_SEQ_FLAG_HOLE
```
public static final int CV_SEQ_FLAG_HOLE
```
  See Also:
  
  Constant Field Values
- CV_GRAPH_FLAG_ORIENTED
```
public static final int CV_GRAPH_FLAG_ORIENTED
```
  See Also:
  
  Constant Field Values
- CV_GRAPH
```
public static final int CV_GRAPH
```
  See Also:
  
  Constant Field Values
- CV_ORIENTED_GRAPH
```
public static final int CV_ORIENTED_GRAPH
```
  See Also:
  
  Constant Field Values
- CV_SEQ_POINT_SET
```
public static final int CV_SEQ_POINT_SET
```
- CV_SEQ_POINT3D_SET
```
public static final int CV_SEQ_POINT3D_SET
```
- CV_SEQ_POLYLINE
```
public static final int CV_SEQ_POLYLINE
```
- CV_SEQ_POLYGON
```
public static final int CV_SEQ_POLYGON
```
- CV_SEQ_CONTOUR
```
public static final int CV_SEQ_CONTOUR
```
- CV_SEQ_SIMPLE_POLYGON
```
public static final int CV_SEQ_SIMPLE_POLYGON
```
- CV_SEQ_CHAIN
```
public static final int CV_SEQ_CHAIN
```
- CV_SEQ_CHAIN_CONTOUR
```
public static final int CV_SEQ_CHAIN_CONTOUR
```
- CV_SEQ_POLYGON_TREE
```
public static final int CV_SEQ_POLYGON_TREE
```
  See Also:
  
  Constant Field Values
- CV_SEQ_CONNECTED_COMP
```
public static final int CV_SEQ_CONNECTED_COMP
```
  See Also:
  
  Constant Field Values
- CV_SEQ_INDEX
```
public static final int CV_SEQ_INDEX
```
- CV_STORAGE_READ
```
public static final int CV_STORAGE_READ
```
  See Also:
  
  Constant Field Values
- CV_STORAGE_WRITE
```
public static final int CV_STORAGE_WRITE
```
  See Also:
  
  Constant Field Values
- CV_STORAGE_WRITE_TEXT
```
public static final int CV_STORAGE_WRITE_TEXT
```
  See Also:
  
  Constant Field Values
- CV_STORAGE_WRITE_BINARY
```
public static final int CV_STORAGE_WRITE_BINARY
```
  See Also:
  
  Constant Field Values
- CV_STORAGE_APPEND
```
public static final int CV_STORAGE_APPEND
```
  See Also:
  
  Constant Field Values
- CV_STORAGE_MEMORY
```
public static final int CV_STORAGE_MEMORY
```
  See Also:
  
  Constant Field Values
- CV_STORAGE_FORMAT_MASK
```
public static final int CV_STORAGE_FORMAT_MASK
```
  See Also:
  
  Constant Field Values
- CV_STORAGE_FORMAT_AUTO
```
public static final int CV_STORAGE_FORMAT_AUTO
```
  See Also:
  
  Constant Field Values
- CV_STORAGE_FORMAT_XML
```
public static final int CV_STORAGE_FORMAT_XML
```
  See Also:
  
  Constant Field Values
- CV_STORAGE_FORMAT_YAML
```
public static final int CV_STORAGE_FORMAT_YAML
```
  See Also:
  
  Constant Field Values
- CV_NODE_NONE
```
public static final int CV_NODE_NONE
```
  See Also:
  
  Constant Field Values
- CV_NODE_INT
```
public static final int CV_NODE_INT
```
  See Also:
  
  Constant Field Values
- CV_NODE_INTEGER
```
public static final int CV_NODE_INTEGER
```
  See Also:
  
  Constant Field Values
- CV_NODE_REAL
```
public static final int CV_NODE_REAL
```
  See Also:
  
  Constant Field Values
- CV_NODE_FLOAT
```
public static final int CV_NODE_FLOAT
```
  See Also:
  
  Constant Field Values
- CV_NODE_STR
```
public static final int CV_NODE_STR
```
  See Also:
  
  Constant Field Values
- CV_NODE_STRING
```
public static final int CV_NODE_STRING
```
  See Also:
  
  Constant Field Values
- CV_NODE_REF
```
public static final int CV_NODE_REF
```
  See Also:
  
  Constant Field Values
- CV_NODE_SEQ
```
public static final int CV_NODE_SEQ
```
  See Also:
  
  Constant Field Values
- CV_NODE_MAP
```
public static final int CV_NODE_MAP
```
  See Also:
  
  Constant Field Values
- CV_NODE_TYPE_MASK
```
public static final int CV_NODE_TYPE_MASK
```
  See Also:
  
  Constant Field Values
- CV_NODE_FLOW
```
public static final int CV_NODE_FLOW
```
  See Also:
  
  Constant Field Values
- CV_NODE_USER
```
public static final int CV_NODE_USER
```
  See Also:
  
  Constant Field Values
- CV_NODE_EMPTY
```
public static final int CV_NODE_EMPTY
```
  See Also:
  
  Constant Field Values
- CV_NODE_NAMED
```
public static final int CV_NODE_NAMED
```
  See Also:
  
  Constant Field Values
- CV_NODE_SEQ_SIMPLE
```
public static final int CV_NODE_SEQ_SIMPLE
```
  See Also:
  
  Constant Field Values
- CV_AUTOSTEP
```
public static final int CV_AUTOSTEP
```
  See Also:
  
  Constant Field Values
- CV_MAX_ARR
```
public static final int CV_MAX_ARR
```
  matrix iterator: used for n-ary operations on dense arrays
  
  See Also:
  
  Constant Field Values
- CV_NO_DEPTH_CHECK
```
public static final int CV_NO_DEPTH_CHECK
```
  See Also:
  
  Constant Field Values
- CV_NO_CN_CHECK
```
public static final int CV_NO_CN_CHECK
```
  See Also:
  
  Constant Field Values
- CV_NO_SIZE_CHECK
```
public static final int CV_NO_SIZE_CHECK
```
  See Also:
  
  Constant Field Values
- CV_CMP_EQ
```
public static final int CV_CMP_EQ
```
  See Also:
  
  Constant Field Values
- CV_CMP_GT
```
public static final int CV_CMP_GT
```
  See Also:
  
  Constant Field Values
- CV_CMP_GE
```
public static final int CV_CMP_GE
```
  See Also:
  
  Constant Field Values
- CV_CMP_LT
```
public static final int CV_CMP_LT
```
  See Also:
  
  Constant Field Values
- CV_CMP_LE
```
public static final int CV_CMP_LE
```
  See Also:
  
  Constant Field Values
- CV_CMP_NE
```
public static final int CV_CMP_NE
```
  See Also:
  
  Constant Field Values
- CV_CHECK_RANGE
```
public static final int CV_CHECK_RANGE
```
  See Also:
  
  Constant Field Values
- CV_CHECK_QUIET
```
public static final int CV_CHECK_QUIET
```
  See Also:
  
  Constant Field Values
- CV_RAND_UNI
```
public static final int CV_RAND_UNI
```
  See Also:
  
  Constant Field Values
- CV_RAND_NORMAL
```
public static final int CV_RAND_NORMAL
```
  See Also:
  
  Constant Field Values
- CV_SORT_EVERY_ROW
```
public static final int CV_SORT_EVERY_ROW
```
  See Also:
  
  Constant Field Values
- CV_SORT_EVERY_COLUMN
```
public static final int CV_SORT_EVERY_COLUMN
```
  See Also:
  
  Constant Field Values
- CV_SORT_ASCENDING
```
public static final int CV_SORT_ASCENDING
```
  See Also:
  
  Constant Field Values
- CV_SORT_DESCENDING
```
public static final int CV_SORT_DESCENDING
```
  See Also:
  
  Constant Field Values
- CV_GEMM_A_T
```
public static final int CV_GEMM_A_T
```
  See Also:
  
  Constant Field Values
- CV_GEMM_B_T
```
public static final int CV_GEMM_B_T
```
  See Also:
  
  Constant Field Values
- CV_GEMM_C_T
```
public static final int CV_GEMM_C_T
```
  See Also:
  
  Constant Field Values
- CV_SVD_MODIFY_A
```
public static final int CV_SVD_MODIFY_A
```
  See Also:
  
  Constant Field Values
- CV_SVD_U_T
```
public static final int CV_SVD_U_T
```
  See Also:
  
  Constant Field Values
- CV_SVD_V_T
```
public static final int CV_SVD_V_T
```
  See Also:
  
  Constant Field Values
- CV_LU
```
public static final int CV_LU
```
  See Also:
  
  Constant Field Values
- CV_SVD
```
public static final int CV_SVD
```
  See Also:
  
  Constant Field Values
- CV_SVD_SYM
```
public static final int CV_SVD_SYM
```
  See Also:
  
  Constant Field Values
- CV_CHOLESKY
```
public static final int CV_CHOLESKY
```
  See Also:
  
  Constant Field Values
- CV_QR
```
public static final int CV_QR
```
  See Also:
  
  Constant Field Values
- CV_NORMAL
```
public static final int CV_NORMAL
```
  See Also:
  
  Constant Field Values
- CV_COVAR_SCRAMBLED
```
public static final int CV_COVAR_SCRAMBLED
```
  See Also:
  
  Constant Field Values
- CV_COVAR_NORMAL
```
public static final int CV_COVAR_NORMAL
```
  See Also:
  
  Constant Field Values
- CV_COVAR_USE_AVG
```
public static final int CV_COVAR_USE_AVG
```
  See Also:
  
  Constant Field Values
- CV_COVAR_SCALE
```
public static final int CV_COVAR_SCALE
```
  See Also:
  
  Constant Field Values
- CV_COVAR_ROWS
```
public static final int CV_COVAR_ROWS
```
  See Also:
  
  Constant Field Values
- CV_COVAR_COLS
```
public static final int CV_COVAR_COLS
```
  See Also:
  
  Constant Field Values
- CV_PCA_DATA_AS_ROW
```
public static final int CV_PCA_DATA_AS_ROW
```
  See Also:
  
  Constant Field Values
- CV_PCA_DATA_AS_COL
```
public static final int CV_PCA_DATA_AS_COL
```
  See Also:
  
  Constant Field Values
- CV_PCA_USE_AVG
```
public static final int CV_PCA_USE_AVG
```
  See Also:
  
  Constant Field Values
- CV_C
```
public static final int CV_C
```
  See Also:
  
  Constant Field Values
- CV_L1
```
public static final int CV_L1
```
  See Also:
  
  Constant Field Values
- CV_L2
```
public static final int CV_L2
```
  See Also:
  
  Constant Field Values
- CV_NORM_MASK
```
public static final int CV_NORM_MASK
```
  See Also:
  
  Constant Field Values
- CV_RELATIVE
```
public static final int CV_RELATIVE
```
  See Also:
  
  Constant Field Values
- CV_DIFF
```
public static final int CV_DIFF
```
  See Also:
  
  Constant Field Values
- CV_MINMAX
```
public static final int CV_MINMAX
```
  See Also:
  
  Constant Field Values
- CV_DIFF_C
```
public static final int CV_DIFF_C
```
  See Also:
  
  Constant Field Values
- CV_DIFF_L1
```
public static final int CV_DIFF_L1
```
  See Also:
  
  Constant Field Values
- CV_DIFF_L2
```
public static final int CV_DIFF_L2
```
  See Also:
  
  Constant Field Values
- CV_RELATIVE_C
```
public static final int CV_RELATIVE_C
```
  See Also:
  
  Constant Field Values
- CV_RELATIVE_L1
```
public static final int CV_RELATIVE_L1
```
  See Also:
  
  Constant Field Values
- CV_RELATIVE_L2
```
public static final int CV_RELATIVE_L2
```
  See Also:
  
  Constant Field Values
- CV_REDUCE_SUM
```
public static final int CV_REDUCE_SUM
```
  See Also:
  
  Constant Field Values
- CV_REDUCE_AVG
```
public static final int CV_REDUCE_AVG
```
  See Also:
  
  Constant Field Values
- CV_REDUCE_MAX
```
public static final int CV_REDUCE_MAX
```
  See Also:
  
  Constant Field Values
- CV_REDUCE_MIN
```
public static final int CV_REDUCE_MIN
```
  See Also:
  
  Constant Field Values
- CV_DXT_FORWARD
```
public static final int CV_DXT_FORWARD
```
  \ Discrete Linear Transforms and Related Functions * \
  
  See Also:
  
  Constant Field Values
- CV_DXT_INVERSE
```
public static final int CV_DXT_INVERSE
```
  See Also:
  
  Constant Field Values
- CV_DXT_SCALE
```
public static final int CV_DXT_SCALE
```
  See Also:
  
  Constant Field Values
- CV_DXT_INV_SCALE
```
public static final int CV_DXT_INV_SCALE
```
  See Also:
  
  Constant Field Values
- CV_DXT_INVERSE_SCALE
```
public static final int CV_DXT_INVERSE_SCALE
```
  See Also:
  
  Constant Field Values
- CV_DXT_ROWS
```
public static final int CV_DXT_ROWS
```
  See Also:
  
  Constant Field Values
- CV_DXT_MUL_CONJ
```
public static final int CV_DXT_MUL_CONJ
```
  See Also:
  
  Constant Field Values
- CV_FRONT
```
public static final int CV_FRONT
```
  See Also:
  
  Constant Field Values
- CV_BACK
```
public static final int CV_BACK
```
  See Also:
  
  Constant Field Values
- CV_GRAPH_VERTEX
```
public static final int CV_GRAPH_VERTEX
```
  See Also:
  
  Constant Field Values
- CV_GRAPH_TREE_EDGE
```
public static final int CV_GRAPH_TREE_EDGE
```
  See Also:
  
  Constant Field Values
- CV_GRAPH_BACK_EDGE
```
public static final int CV_GRAPH_BACK_EDGE
```
  See Also:
  
  Constant Field Values
- CV_GRAPH_FORWARD_EDGE
```
public static final int CV_GRAPH_FORWARD_EDGE
```
  See Also:
  
  Constant Field Values
- CV_GRAPH_CROSS_EDGE
```
public static final int CV_GRAPH_CROSS_EDGE
```
  See Also:
  
  Constant Field Values
- CV_GRAPH_ANY_EDGE
```
public static final int CV_GRAPH_ANY_EDGE
```
  See Also:
  
  Constant Field Values
- CV_GRAPH_NEW_TREE
```
public static final int CV_GRAPH_NEW_TREE
```
  See Also:
  
  Constant Field Values
- CV_GRAPH_BACKTRACKING
```
public static final int CV_GRAPH_BACKTRACKING
```
  See Also:
  
  Constant Field Values
- CV_GRAPH_OVER
```
public static final int CV_GRAPH_OVER
```
  See Also:
  
  Constant Field Values
- CV_GRAPH_ALL_ITEMS
```
public static final int CV_GRAPH_ALL_ITEMS
```
  See Also:
  
  Constant Field Values
- CV_GRAPH_ITEM_VISITED_FLAG
```
public static final int CV_GRAPH_ITEM_VISITED_FLAG
```
  See Also:
  
  Constant Field Values
- CV_GRAPH_SEARCH_TREE_NODE_FLAG
```
public static final int CV_GRAPH_SEARCH_TREE_NODE_FLAG
```
  See Also:
  
  Constant Field Values
- CV_GRAPH_FORWARD_EDGE_FLAG
```
public static final int CV_GRAPH_FORWARD_EDGE_FLAG
```
  See Also:
  
  Constant Field Values
- CV_FILLED
```
public static final int CV_FILLED
```
  \ Drawing functions work with images/matrices of arbitrary type. * For color images the channel order is BGR[A] * Antialiasing is supported only for 8-bit image now. * All the functions include parameter color that means rgb value (that may be * constructed with CV_RGB macro) for color images and brightness * for grayscale images. * If a drawn figure is partially or completely outside of the image, it is clipped.* \
  
  See Also:
  
  Constant Field Values
- CV_AA
```
public static final int CV_AA
```
  See Also:
  
  Constant Field Values
- CV_FONT_HERSHEY_SIMPLEX
```
public static final int CV_FONT_HERSHEY_SIMPLEX
```
  See Also:
  
  Constant Field Values
- CV_FONT_HERSHEY_PLAIN
```
public static final int CV_FONT_HERSHEY_PLAIN
```
  See Also:
  
  Constant Field Values
- CV_FONT_HERSHEY_DUPLEX
```
public static final int CV_FONT_HERSHEY_DUPLEX
```
  See Also:
  
  Constant Field Values
- CV_FONT_HERSHEY_COMPLEX
```
public static final int CV_FONT_HERSHEY_COMPLEX
```
  See Also:
  
  Constant Field Values
- CV_FONT_HERSHEY_TRIPLEX
```
public static final int CV_FONT_HERSHEY_TRIPLEX
```
  See Also:
  
  Constant Field Values
- CV_FONT_HERSHEY_COMPLEX_SMALL
```
public static final int CV_FONT_HERSHEY_COMPLEX_SMALL
```
  See Also:
  
  Constant Field Values
- CV_FONT_HERSHEY_SCRIPT_SIMPLEX
```
public static final int CV_FONT_HERSHEY_SCRIPT_SIMPLEX
```
  See Also:
  
  Constant Field Values
- CV_FONT_HERSHEY_SCRIPT_COMPLEX
```
public static final int CV_FONT_HERSHEY_SCRIPT_COMPLEX
```
  See Also:
  
  Constant Field Values
- CV_FONT_ITALIC
```
public static final int CV_FONT_ITALIC
```
  See Also:
  
  Constant Field Values
- CV_FONT_VECTOR0
```
public static final int CV_FONT_VECTOR0
```
  See Also:
  
  Constant Field Values
- CV_KMEANS_USE_INITIAL_LABELS
```
public static final int CV_KMEANS_USE_INITIAL_LABELS
```
  See Also:
  
  Constant Field Values
- CV_CPU_NONE
```
public static final int CV_CPU_NONE
```
  CPU capabilities
  
  See Also:
  
  Constant Field Values
- CV_CPU_MMX
```
public static final int CV_CPU_MMX
```
  See Also:
  
  Constant Field Values
- CV_CPU_SSE
```
public static final int CV_CPU_SSE
```
  See Also:
  
  Constant Field Values
- CV_CPU_SSE2
```
public static final int CV_CPU_SSE2
```
  See Also:
  
  Constant Field Values
- CV_CPU_SSE3
```
public static final int CV_CPU_SSE3
```
  See Also:
  
  Constant Field Values
- CV_CPU_SSSE3
```
public static final int CV_CPU_SSSE3
```
  See Also:
  
  Constant Field Values
- CV_CPU_SSE4_1
```
public static final int CV_CPU_SSE4_1
```
  See Also:
  
  Constant Field Values
- CV_CPU_SSE4_2
```
public static final int CV_CPU_SSE4_2
```
  See Also:
  
  Constant Field Values
- CV_CPU_POPCNT
```
public static final int CV_CPU_POPCNT
```
  See Also:
  
  Constant Field Values
- CV_CPU_AVX
```
public static final int CV_CPU_AVX
```
  See Also:
  
  Constant Field Values
- CV_CPU_AVX2
```
public static final int CV_CPU_AVX2
```
  See Also:
  
  Constant Field Values
- CV_HARDWARE_MAX_FEATURE
```
public static final int CV_HARDWARE_MAX_FEATURE
```
  See Also:
  
  Constant Field Values
- CV_ErrModeLeaf
```
public static final int CV_ErrModeLeaf
```
  See Also:
  
  Constant Field Values
- CV_ErrModeParent
```
public static final int CV_ErrModeParent
```
  See Also:
  
  Constant Field Values
- CV_ErrModeSilent
```
public static final int CV_ErrModeSilent
```
  See Also:
  
  Constant Field Values
- cvFuncName
```
public static final String cvFuncName
```
  See Also:
  
  Constant Field Values
- DECOMP_LU
```
public static final int DECOMP_LU
```
  enum cv::
  
  See Also:
  
  Constant Field Values
- DECOMP_SVD
```
public static final int DECOMP_SVD
```
  enum cv::
  
  See Also:
  
  Constant Field Values
- DECOMP_EIG
```
public static final int DECOMP_EIG
```
  enum cv::
  
  See Also:
  
  Constant Field Values
- DECOMP_CHOLESKY
```
public static final int DECOMP_CHOLESKY
```
  enum cv::
  
  See Also:
  
  Constant Field Values
- DECOMP_QR
```
public static final int DECOMP_QR
```
  enum cv::
  
  See Also:
  
  Constant Field Values
- DECOMP_NORMAL
```
public static final int DECOMP_NORMAL
```
  enum cv::
  
  See Also:
  
  Constant Field Values
- NORM_INF
```
public static final int NORM_INF
```
  enum cv::
  
  See Also:
  
  Constant Field Values
- NORM_L1
```
public static final int NORM_L1
```
  enum cv::
  
  See Also:
  
  Constant Field Values
- NORM_L2
```
public static final int NORM_L2
```
  enum cv::
  
  See Also:
  
  Constant Field Values
- NORM_L2SQR
```
public static final int NORM_L2SQR
```
  enum cv::
  
  See Also:
  
  Constant Field Values
- NORM_HAMMING
```
public static final int NORM_HAMMING
```
  enum cv::
  
  See Also:
  
  Constant Field Values
- NORM_HAMMING2
```
public static final int NORM_HAMMING2
```
  enum cv::
  
  See Also:
  
  Constant Field Values
- NORM_TYPE_MASK
```
public static final int NORM_TYPE_MASK
```
  enum cv::
  
  See Also:
  
  Constant Field Values
- NORM_RELATIVE
```
public static final int NORM_RELATIVE
```
  enum cv::
  
  See Also:
  
  Constant Field Values
- NORM_MINMAX
```
public static final int NORM_MINMAX
```
  enum cv::
  
  See Also:
  
  Constant Field Values
- CMP_EQ
```
public static final int CMP_EQ
```
  enum cv::
  
  See Also:
  
  Constant Field Values
- CMP_GT
```
public static final int CMP_GT
```
  enum cv::
  
  See Also:
  
  Constant Field Values
- CMP_GE
```
public static final int CMP_GE
```
  enum cv::
  
  See Also:
  
  Constant Field Values
- CMP_LT
```
public static final int CMP_LT
```
  enum cv::
  
  See Also:
  
  Constant Field Values
- CMP_LE
```
public static final int CMP_LE
```
  enum cv::
  
  See Also:
  
  Constant Field Values
- CMP_NE
```
public static final int CMP_NE
```
  enum cv::
  
  See Also:
  
  Constant Field Values
- GEMM_1_T
```
public static final int GEMM_1_T
```
  enum cv::
  
  See Also:
  
  Constant Field Values
- GEMM_2_T
```
public static final int GEMM_2_T
```
  enum cv::
  
  See Also:
  
  Constant Field Values
- GEMM_3_T
```
public static final int GEMM_3_T
```
  enum cv::
  
  See Also:
  
  Constant Field Values
- DFT_INVERSE
```
public static final int DFT_INVERSE
```
  enum cv::
  
  See Also:
  
  Constant Field Values
- DFT_SCALE
```
public static final int DFT_SCALE
```
  enum cv::
  
  See Also:
  
  Constant Field Values
- DFT_ROWS
```
public static final int DFT_ROWS
```
  enum cv::
  
  See Also:
  
  Constant Field Values
- DFT_COMPLEX_OUTPUT
```
public static final int DFT_COMPLEX_OUTPUT
```
  enum cv::
  
  See Also:
  
  Constant Field Values
- DFT_REAL_OUTPUT
```
public static final int DFT_REAL_OUTPUT
```
  enum cv::
  
  See Also:
  
  Constant Field Values
- DCT_INVERSE
```
public static final int DCT_INVERSE
```
  enum cv::
  
  See Also:
  
  Constant Field Values
- DCT_ROWS
```
public static final int DCT_ROWS
```
  enum cv::
  
  See Also:
  
  Constant Field Values
- DEPTH_MASK_8U
```
public static final int DEPTH_MASK_8U
```
  enum cv::
  
  See Also:
  
  Constant Field Values
- DEPTH_MASK_8S
```
public static final int DEPTH_MASK_8S
```
  enum cv::
  
  See Also:
  
  Constant Field Values
- DEPTH_MASK_16U
```
public static final int DEPTH_MASK_16U
```
  enum cv::
  
  See Also:
  
  Constant Field Values
- DEPTH_MASK_16S
```
public static final int DEPTH_MASK_16S
```
  enum cv::
  
  See Also:
  
  Constant Field Values
- DEPTH_MASK_32S
```
public static final int DEPTH_MASK_32S
```
  enum cv::
  
  See Also:
  
  Constant Field Values
- DEPTH_MASK_32F
```
public static final int DEPTH_MASK_32F
```
  enum cv::
  
  See Also:
  
  Constant Field Values
- DEPTH_MASK_64F
```
public static final int DEPTH_MASK_64F
```
  enum cv::
  
  See Also:
  
  Constant Field Values
- DEPTH_MASK_ALL
```
public static final int DEPTH_MASK_ALL
```
  enum cv::
  
  See Also:
  
  Constant Field Values
- DEPTH_MASK_ALL_BUT_8S
```
public static final int DEPTH_MASK_ALL_BUT_8S
```
  enum cv::
  
  See Also:
  
  Constant Field Values
- DEPTH_MASK_FLT
```
public static final int DEPTH_MASK_FLT
```
  enum cv::
  
  See Also:
  
  Constant Field Values
- MAGIC_MASK
```
public static final int MAGIC_MASK
```
  enum cv::
  
  See Also:
  
  Constant Field Values
- TYPE_MASK
```
public static final int TYPE_MASK
```
  enum cv::
  
  See Also:
  
  Constant Field Values
- DEPTH_MASK
```
public static final int DEPTH_MASK
```
  enum cv::
  
  See Also:
  
  Constant Field Values
- SORT_EVERY_ROW
```
public static final int SORT_EVERY_ROW
```
  enum cv::
  
  See Also:
  
  Constant Field Values
- SORT_EVERY_COLUMN
```
public static final int SORT_EVERY_COLUMN
```
  enum cv::
  
  See Also:
  
  Constant Field Values
- SORT_ASCENDING
```
public static final int SORT_ASCENDING
```
  enum cv::
  
  See Also:
  
  Constant Field Values
- SORT_DESCENDING
```
public static final int SORT_DESCENDING
```
  enum cv::
  
  See Also:
  
  Constant Field Values
- COVAR_SCRAMBLED
```
public static final int COVAR_SCRAMBLED
```
  enum cv::
  
  See Also:
  
  Constant Field Values
- COVAR_NORMAL
```
public static final int COVAR_NORMAL
```
  enum cv::
  
  See Also:
  
  Constant Field Values
- COVAR_USE_AVG
```
public static final int COVAR_USE_AVG
```
  enum cv::
  
  See Also:
  
  Constant Field Values
- COVAR_SCALE
```
public static final int COVAR_SCALE
```
  enum cv::
  
  See Also:
  
  Constant Field Values
- COVAR_ROWS
```
public static final int COVAR_ROWS
```
  enum cv::
  
  See Also:
  
  Constant Field Values
- COVAR_COLS
```
public static final int COVAR_COLS
```
  enum cv::
  
  See Also:
  
  Constant Field Values
- KMEANS_RANDOM_CENTERS
```
public static final int KMEANS_RANDOM_CENTERS
```
  enum cv::
  
  See Also:
  
  Constant Field Values
- KMEANS_PP_CENTERS
```
public static final int KMEANS_PP_CENTERS
```
  enum cv::
  
  See Also:
  
  Constant Field Values
- KMEANS_USE_INITIAL_LABELS
```
public static final int KMEANS_USE_INITIAL_LABELS
```
  enum cv::
  
  See Also:
  
  Constant Field Values
- FONT_HERSHEY_SIMPLEX
```
public static final int FONT_HERSHEY_SIMPLEX
```
  enum cv::
  
  See Also:
  
  Constant Field Values
- FONT_HERSHEY_PLAIN
```
public static final int FONT_HERSHEY_PLAIN
```
  enum cv::
  
  See Also:
  
  Constant Field Values
- FONT_HERSHEY_DUPLEX
```
public static final int FONT_HERSHEY_DUPLEX
```
  enum cv::
  
  See Also:
  
  Constant Field Values
- FONT_HERSHEY_COMPLEX
```
public static final int FONT_HERSHEY_COMPLEX
```
  enum cv::
  
  See Also:
  
  Constant Field Values
- FONT_HERSHEY_TRIPLEX
```
public static final int FONT_HERSHEY_TRIPLEX
```
  enum cv::
  
  See Also:
  
  Constant Field Values
- FONT_HERSHEY_COMPLEX_SMALL
```
public static final int FONT_HERSHEY_COMPLEX_SMALL
```
  enum cv::
  
  See Also:
  
  Constant Field Values
- FONT_HERSHEY_SCRIPT_SIMPLEX
```
public static final int FONT_HERSHEY_SCRIPT_SIMPLEX
```
  enum cv::
  
  See Also:
  
  Constant Field Values
- FONT_HERSHEY_SCRIPT_COMPLEX
```
public static final int FONT_HERSHEY_SCRIPT_COMPLEX
```
  enum cv::
  
  See Also:
  
  Constant Field Values
- FONT_ITALIC
```
public static final int FONT_ITALIC
```
  enum cv::
  
  See Also:
  
  Constant Field Values

Constructor Detail
- opencv_core
```
public opencv_core()
```

Method Detail

cvRound

public static int cvRound(double value)

cvFloor

public static int cvFloor(double value)

cvCeil

public static int cvCeil(double value)

cvIsNaN

public static int cvIsNaN(double value)

cvIsInf

public static int cvIsInf(double value)

cvRNG
```
public static long cvRNG(long seed)
```

cvRNG
```
public static long cvRNG()
```

cvRandInt

public static int cvRandInt(LongPointer rng)

cvRandInt

public static int cvRandInt(LongBuffer rng)

cvRandInt

public static int cvRandInt(long[] rng)

cvRandReal

public static double cvRandReal(LongPointer rng)

cvRandReal

public static double cvRandReal(LongBuffer rng)

cvRandReal

public static double cvRandReal(long[] rng)

IPL_IMAGE_MAGIC_VAL

public static int IPL_IMAGE_MAGIC_VAL()

CV_MAT_DEPTH

public static int CV_MAT_DEPTH(int flags)

CV_MAKETYPE

public static int CV_MAKETYPE(int depth,
                              int cn)

CV_MAKE_TYPE

public static int CV_MAKE_TYPE(int arg1,
                               int arg2)

CV_8UC
```
public static int CV_8UC(int n)
```

CV_8SC
```
public static int CV_8SC(int n)
```

CV_16UC
```
public static int CV_16UC(int n)
```

CV_16SC
```
public static int CV_16SC(int n)
```

CV_32SC
```
public static int CV_32SC(int n)
```

CV_32FC
```
public static int CV_32FC(int n)
```

CV_64FC
```
public static int CV_64FC(int n)
```

CV_MAT_CN

public static int CV_MAT_CN(int flags)

CV_MAT_TYPE

public static int CV_MAT_TYPE(int flags)

CV_IS_MAT_CONT

public static int CV_IS_MAT_CONT(int flags)

CV_IS_CONT_MAT

public static int CV_IS_CONT_MAT(int arg1)

cvMat

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

cvMat

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

cvmGet

public static double cvmGet(opencv_core.CvMat mat,
                            int row,
                            int col)

cvmSet

public static void cvmSet(opencv_core.CvMat mat,
                          int row,
                          int col,
                          double value)

cvIplDepth

public static int cvIplDepth(int type)

cvRect

public static opencv_core.CvRect cvRect(int x,
                                        int y,
                                        int width,
                                        int height)

cvRectToROI

public static opencv_core.IplROI cvRectToROI(opencv_core.CvRect rect,
                                             int coi)

cvROIToRect

public static opencv_core.CvRect cvROIToRect(opencv_core.IplROI roi)

cvTermCriteria

public static opencv_core.CvTermCriteria cvTermCriteria(int type,
                                                        int max_iter,
                                                        double epsilon)

cvPoint

public static opencv_core.CvPoint cvPoint(int x,
                                          int y)

cvPoint2D32f

public static opencv_core.CvPoint2D32f cvPoint2D32f(double x,
                                                    double y)

cvPointTo32f

public static opencv_core.CvPoint2D32f cvPointTo32f(opencv_core.CvPoint point)

cvPointTo32f

public static FloatBuffer cvPointTo32f(IntBuffer point)

cvPointTo32f

public static float[] cvPointTo32f(int[] point)

cvPointFrom32f

public static opencv_core.CvPoint cvPointFrom32f(opencv_core.CvPoint2D32f point)

cvPointFrom32f

public static IntBuffer cvPointFrom32f(FloatBuffer point)

cvPointFrom32f

public static int[] cvPointFrom32f(float[] point)

cvPoint3D32f

public static opencv_core.CvPoint3D32f cvPoint3D32f(double x,
                                                    double y,
                                                    double z)

cvPoint2D64f

public static opencv_core.CvPoint2D64f cvPoint2D64f(double x,
                                                    double y)

cvPoint3D64f

public static opencv_core.CvPoint3D64f cvPoint3D64f(double x,
                                                    double y,
                                                    double z)

cvSize

public static opencv_core.CvSize cvSize(int width,
                                        int height)

cvSize2D32f

public static opencv_core.CvSize2D32f cvSize2D32f(double width,
                                                  double height)

cvSlice

public static opencv_core.CvSlice cvSlice(int start,
                                          int end)

cvScalar

public static opencv_core.CvScalar cvScalar(double val0,
                                            double val1,
                                            double val2,
                                            double val3)

cvScalar

public static opencv_core.CvScalar cvScalar(double val0)

cvRealScalar

public static opencv_core.CvScalar cvRealScalar(double val0)

cvScalarAll

public static opencv_core.CvScalar cvScalarAll(double val0123)

CV_SET_ELEM_FREE_FLAG

public static int CV_SET_ELEM_FREE_FLAG()

cvAttrList

public static opencv_core.CvAttrList cvAttrList(PointerPointer attr,
                                                opencv_core.CvAttrList next)

cvAttrList

public static opencv_core.CvAttrList cvAttrList()

cvAttrList

public static opencv_core.CvAttrList cvAttrList(BytePointer attr,
                                                opencv_core.CvAttrList next)

cvAttrList

public static opencv_core.CvAttrList cvAttrList(ByteBuffer attr,
                                                opencv_core.CvAttrList next)

cvAttrList

public static opencv_core.CvAttrList cvAttrList(byte[] attr,
                                                opencv_core.CvAttrList next)

cvAlloc
```
public static Pointer cvAlloc(long size)
```
\ Array allocation, deallocation, initialization and access to elements * \

cvFree_

public static void cvFree_(Pointer ptr)

cvCreateImageHeader

public static opencv_core.IplImage cvCreateImageHeader(opencv_core.CvSize size,
                                                       int depth,
                                                       int channels)

cvInitImageHeader

public static opencv_core.IplImage cvInitImageHeader(opencv_core.IplImage image,
                                                     opencv_core.CvSize size,
                                                     int depth,
                                                     int channels,
                                                     int origin,
                                                     int align)

cvInitImageHeader

public static opencv_core.IplImage cvInitImageHeader(opencv_core.IplImage image,
                                                     opencv_core.CvSize size,
                                                     int depth,
                                                     int channels)

cvCreateImage

public static opencv_core.IplImage cvCreateImage(opencv_core.CvSize size,
                                                 int depth,
                                                 int channels)

cvReleaseImageHeader

public static void cvReleaseImageHeader(PointerPointer image)

cvReleaseImageHeader

public static void cvReleaseImageHeader(opencv_core.IplImage image)

cvReleaseImage

public static void cvReleaseImage(PointerPointer image)

cvReleaseImage

public static void cvReleaseImage(opencv_core.IplImage image)

cvCloneImage

public static opencv_core.IplImage cvCloneImage(opencv_core.IplImage image)

cvSetImageCOI

public static void cvSetImageCOI(opencv_core.IplImage image,
                                 int coi)

cvGetImageCOI

public static int cvGetImageCOI(opencv_core.IplImage image)

cvSetImageROI

public static void cvSetImageROI(opencv_core.IplImage image,
                                 opencv_core.CvRect rect)

cvResetImageROI

public static void cvResetImageROI(opencv_core.IplImage image)

cvGetImageROI

public static opencv_core.CvRect cvGetImageROI(opencv_core.IplImage image)

cvCreateMatHeader

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

cvInitMatHeader

public static opencv_core.CvMat cvInitMatHeader(opencv_core.CvMat mat,
                                                int rows,
                                                int cols,
                                                int type,
                                                Pointer data,
                                                int step)

cvInitMatHeader

public static opencv_core.CvMat cvInitMatHeader(opencv_core.CvMat mat,
                                                int rows,
                                                int cols,
                                                int type)

cvCreateMat

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

cvReleaseMat

public static void cvReleaseMat(PointerPointer mat)

cvReleaseMat

public static void cvReleaseMat(opencv_core.CvMat mat)

cvDecRefData

public static void cvDecRefData(opencv_core.CvArr arr)

cvIncRefData

public static int cvIncRefData(opencv_core.CvArr arr)

cvCloneMat

public static opencv_core.CvMat cvCloneMat(opencv_core.CvMat mat)

cvGetSubRect

public static opencv_core.CvMat cvGetSubRect(opencv_core.CvArr arr,
                                             opencv_core.CvMat submat,
                                             opencv_core.CvRect rect)

cvGetSubArr

public static opencv_core.CvMat cvGetSubArr(opencv_core.CvArr arg1,
                                            opencv_core.CvMat arg2,
                                            opencv_core.CvRect arg3)

cvGetRows

public static opencv_core.CvMat cvGetRows(opencv_core.CvArr arr,
                                          opencv_core.CvMat submat,
                                          int start_row,
                                          int end_row,
                                          int delta_row)

cvGetRows

public static opencv_core.CvMat cvGetRows(opencv_core.CvArr arr,
                                          opencv_core.CvMat submat,
                                          int start_row,
                                          int end_row)

cvGetRow

public static opencv_core.CvMat cvGetRow(opencv_core.CvArr arr,
                                         opencv_core.CvMat submat,
                                         int row)

cvGetCols

public static opencv_core.CvMat cvGetCols(opencv_core.CvArr arr,
                                          opencv_core.CvMat submat,
                                          int start_col,
                                          int end_col)

cvGetCol

public static opencv_core.CvMat cvGetCol(opencv_core.CvArr arr,
                                         opencv_core.CvMat submat,
                                         int col)

cvGetDiag

public static opencv_core.CvMat cvGetDiag(opencv_core.CvArr arr,
                                          opencv_core.CvMat submat,
                                          int diag)

cvGetDiag

public static opencv_core.CvMat cvGetDiag(opencv_core.CvArr arr,
                                          opencv_core.CvMat submat)

cvScalarToRawData

public static void cvScalarToRawData(opencv_core.CvScalar scalar,
                                     Pointer data,
                                     int type,
                                     int extend_to_12)

cvScalarToRawData

public static void cvScalarToRawData(opencv_core.CvScalar scalar,
                                     Pointer data,
                                     int type)

cvRawDataToScalar

public static void cvRawDataToScalar(Pointer data,
                                     int type,
                                     opencv_core.CvScalar scalar)

cvCreateMatNDHeader

public static opencv_core.CvMatND cvCreateMatNDHeader(int dims,
                                                      IntPointer sizes,
                                                      int type)

cvCreateMatNDHeader

public static opencv_core.CvMatND cvCreateMatNDHeader(int dims,
                                                      IntBuffer sizes,
                                                      int type)

cvCreateMatNDHeader

public static opencv_core.CvMatND cvCreateMatNDHeader(int dims,
                                                      int[] sizes,
                                                      int type)

cvCreateMatND

public static opencv_core.CvMatND cvCreateMatND(int dims,
                                                IntPointer sizes,
                                                int type)

cvCreateMatND

public static opencv_core.CvMatND cvCreateMatND(int dims,
                                                IntBuffer sizes,
                                                int type)

cvCreateMatND

public static opencv_core.CvMatND cvCreateMatND(int dims,
                                                int[] sizes,
                                                int type)

cvInitMatNDHeader

public static opencv_core.CvMatND cvInitMatNDHeader(opencv_core.CvMatND mat,
                                                    int dims,
                                                    IntPointer sizes,
                                                    int type,
                                                    Pointer data)

cvInitMatNDHeader

public static opencv_core.CvMatND cvInitMatNDHeader(opencv_core.CvMatND mat,
                                                    int dims,
                                                    IntPointer sizes,
                                                    int type)

cvInitMatNDHeader

public static opencv_core.CvMatND cvInitMatNDHeader(opencv_core.CvMatND mat,
                                                    int dims,
                                                    IntBuffer sizes,
                                                    int type,
                                                    Pointer data)

cvInitMatNDHeader

public static opencv_core.CvMatND cvInitMatNDHeader(opencv_core.CvMatND mat,
                                                    int dims,
                                                    IntBuffer sizes,
                                                    int type)

cvInitMatNDHeader

public static opencv_core.CvMatND cvInitMatNDHeader(opencv_core.CvMatND mat,
                                                    int dims,
                                                    int[] sizes,
                                                    int type,
                                                    Pointer data)

cvInitMatNDHeader

public static opencv_core.CvMatND cvInitMatNDHeader(opencv_core.CvMatND mat,
                                                    int dims,
                                                    int[] sizes,
                                                    int type)

cvReleaseMatND

public static void cvReleaseMatND(PointerPointer mat)

cvReleaseMatND

public static void cvReleaseMatND(opencv_core.CvMatND mat)

cvCloneMatND

public static opencv_core.CvMatND cvCloneMatND(opencv_core.CvMatND mat)

cvCreateSparseMat

public static opencv_core.CvSparseMat cvCreateSparseMat(int dims,
                                                        IntPointer sizes,
                                                        int type)

cvCreateSparseMat

public static opencv_core.CvSparseMat cvCreateSparseMat(int dims,
                                                        IntBuffer sizes,
                                                        int type)

cvCreateSparseMat

public static opencv_core.CvSparseMat cvCreateSparseMat(int dims,
                                                        int[] sizes,
                                                        int type)

cvReleaseSparseMat

public static void cvReleaseSparseMat(PointerPointer mat)

cvReleaseSparseMat

public static void cvReleaseSparseMat(opencv_core.CvSparseMat mat)

cvCloneSparseMat

public static opencv_core.CvSparseMat cvCloneSparseMat(opencv_core.CvSparseMat mat)

cvInitSparseMatIterator

public static opencv_core.CvSparseNode cvInitSparseMatIterator(opencv_core.CvSparseMat mat,
                                                               opencv_core.CvSparseMatIterator mat_iterator)

cvGetNextSparseNode

public static opencv_core.CvSparseNode cvGetNextSparseNode(opencv_core.CvSparseMatIterator mat_iterator)

cvInitNArrayIterator

public static int cvInitNArrayIterator(int count,
                                       PointerPointer arrs,
                                       opencv_core.CvArr mask,
                                       opencv_core.CvMatND stubs,
                                       opencv_core.CvNArrayIterator array_iterator,
                                       int flags)

cvInitNArrayIterator

public static int cvInitNArrayIterator(int count,
                                       opencv_core.CvArr arrs,
                                       opencv_core.CvArr mask,
                                       opencv_core.CvMatND stubs,
                                       opencv_core.CvNArrayIterator array_iterator)

cvInitNArrayIterator

public static int cvInitNArrayIterator(int count,
                                       opencv_core.CvArr arrs,
                                       opencv_core.CvArr mask,
                                       opencv_core.CvMatND stubs,
                                       opencv_core.CvNArrayIterator array_iterator,
                                       int flags)

cvNextNArraySlice

public static int cvNextNArraySlice(opencv_core.CvNArrayIterator array_iterator)

cvGetElemType

public static int cvGetElemType(opencv_core.CvArr arr)

cvGetDims

public static int cvGetDims(opencv_core.CvArr arr,
                            IntPointer sizes)

cvGetDims

public static int cvGetDims(opencv_core.CvArr arr)

cvGetDims

public static int cvGetDims(opencv_core.CvArr arr,
                            IntBuffer sizes)

cvGetDims

public static int cvGetDims(opencv_core.CvArr arr,
                            int[] sizes)

cvGetDimSize

public static int cvGetDimSize(opencv_core.CvArr arr,
                               int index)

cvPtr1D

public static BytePointer cvPtr1D(opencv_core.CvArr arr,
                                  int idx0,
                                  IntPointer type)

cvPtr1D

public static BytePointer cvPtr1D(opencv_core.CvArr arr,
                                  int idx0)

cvPtr1D

public static ByteBuffer cvPtr1D(opencv_core.CvArr arr,
                                 int idx0,
                                 IntBuffer type)

cvPtr1D

public static byte[] cvPtr1D(opencv_core.CvArr arr,
                             int idx0,
                             int[] type)

cvPtr2D

public static BytePointer cvPtr2D(opencv_core.CvArr arr,
                                  int idx0,
                                  int idx1,
                                  IntPointer type)

cvPtr2D

public static BytePointer cvPtr2D(opencv_core.CvArr arr,
                                  int idx0,
                                  int idx1)

cvPtr2D

public static ByteBuffer cvPtr2D(opencv_core.CvArr arr,
                                 int idx0,
                                 int idx1,
                                 IntBuffer type)

cvPtr2D

public static byte[] cvPtr2D(opencv_core.CvArr arr,
                             int idx0,
                             int idx1,
                             int[] type)

cvPtr3D

public static BytePointer cvPtr3D(opencv_core.CvArr arr,
                                  int idx0,
                                  int idx1,
                                  int idx2,
                                  IntPointer type)

cvPtr3D

public static BytePointer cvPtr3D(opencv_core.CvArr arr,
                                  int idx0,
                                  int idx1,
                                  int idx2)

cvPtr3D

public static ByteBuffer cvPtr3D(opencv_core.CvArr arr,
                                 int idx0,
                                 int idx1,
                                 int idx2,
                                 IntBuffer type)

cvPtr3D

public static byte[] cvPtr3D(opencv_core.CvArr arr,
                             int idx0,
                             int idx1,
                             int idx2,
                             int[] type)

cvPtrND

public static BytePointer cvPtrND(opencv_core.CvArr arr,
                                  IntPointer idx,
                                  IntPointer type,
                                  int create_node,
                                  IntPointer precalc_hashval)

cvPtrND

public static BytePointer cvPtrND(opencv_core.CvArr arr,
                                  IntPointer idx)

cvPtrND

public static ByteBuffer cvPtrND(opencv_core.CvArr arr,
                                 IntBuffer idx,
                                 IntBuffer type,
                                 int create_node,
                                 IntBuffer precalc_hashval)

cvPtrND

public static ByteBuffer cvPtrND(opencv_core.CvArr arr,
                                 IntBuffer idx)

cvPtrND

public static byte[] cvPtrND(opencv_core.CvArr arr,
                             int[] idx,
                             int[] type,
                             int create_node,
                             int[] precalc_hashval)

cvPtrND

public static byte[] cvPtrND(opencv_core.CvArr arr,
                             int[] idx)

cvGet1D

public static opencv_core.CvScalar cvGet1D(opencv_core.CvArr arr,
                                           int idx0)

cvGet2D

public static opencv_core.CvScalar cvGet2D(opencv_core.CvArr arr,
                                           int idx0,
                                           int idx1)

cvGet3D

public static opencv_core.CvScalar cvGet3D(opencv_core.CvArr arr,
                                           int idx0,
                                           int idx1,
                                           int idx2)

cvGetND

public static opencv_core.CvScalar cvGetND(opencv_core.CvArr arr,
                                           IntPointer idx)

cvGetND

public static opencv_core.CvScalar cvGetND(opencv_core.CvArr arr,
                                           IntBuffer idx)

cvGetND

public static opencv_core.CvScalar cvGetND(opencv_core.CvArr arr,
                                           int[] idx)

cvGetReal1D

public static double cvGetReal1D(opencv_core.CvArr arr,
                                 int idx0)

cvGetReal2D

public static double cvGetReal2D(opencv_core.CvArr arr,
                                 int idx0,
                                 int idx1)

cvGetReal3D

public static double cvGetReal3D(opencv_core.CvArr arr,
                                 int idx0,
                                 int idx1,
                                 int idx2)

cvGetRealND

public static double cvGetRealND(opencv_core.CvArr arr,
                                 IntPointer idx)

cvGetRealND

public static double cvGetRealND(opencv_core.CvArr arr,
                                 IntBuffer idx)

cvGetRealND

public static double cvGetRealND(opencv_core.CvArr arr,
                                 int[] idx)

cvSet1D

public static void cvSet1D(opencv_core.CvArr arr,
                           int idx0,
                           opencv_core.CvScalar value)

cvSet2D

public static void cvSet2D(opencv_core.CvArr arr,
                           int idx0,
                           int idx1,
                           opencv_core.CvScalar value)

cvSet3D

public static void cvSet3D(opencv_core.CvArr arr,
                           int idx0,
                           int idx1,
                           int idx2,
                           opencv_core.CvScalar value)

cvSetND

public static void cvSetND(opencv_core.CvArr arr,
                           IntPointer idx,
                           opencv_core.CvScalar value)

cvSetND

public static void cvSetND(opencv_core.CvArr arr,
                           IntBuffer idx,
                           opencv_core.CvScalar value)

cvSetND

public static void cvSetND(opencv_core.CvArr arr,
                           int[] idx,
                           opencv_core.CvScalar value)

cvSetReal1D

public static void cvSetReal1D(opencv_core.CvArr arr,
                               int idx0,
                               double value)

cvSetReal2D

public static void cvSetReal2D(opencv_core.CvArr arr,
                               int idx0,
                               int idx1,
                               double value)

cvSetReal3D

public static void cvSetReal3D(opencv_core.CvArr arr,
                               int idx0,
                               int idx1,
                               int idx2,
                               double value)

cvSetRealND

public static void cvSetRealND(opencv_core.CvArr arr,
                               IntPointer idx,
                               double value)

cvSetRealND

public static void cvSetRealND(opencv_core.CvArr arr,
                               IntBuffer idx,
                               double value)

cvSetRealND

public static void cvSetRealND(opencv_core.CvArr arr,
                               int[] idx,
                               double value)

cvClearND

public static void cvClearND(opencv_core.CvArr arr,
                             IntPointer idx)

cvClearND

public static void cvClearND(opencv_core.CvArr arr,
                             IntBuffer idx)

cvClearND

public static void cvClearND(opencv_core.CvArr arr,
                             int[] idx)

cvGetMat

public static opencv_core.CvMat cvGetMat(opencv_core.CvArr arr,
                                         opencv_core.CvMat header,
                                         IntPointer coi,
                                         int allowND)

cvGetMat

public static opencv_core.CvMat cvGetMat(opencv_core.CvArr arr,
                                         opencv_core.CvMat header)

cvGetMat

public static opencv_core.CvMat cvGetMat(opencv_core.CvArr arr,
                                         opencv_core.CvMat header,
                                         IntBuffer coi,
                                         int allowND)

cvGetMat

public static opencv_core.CvMat cvGetMat(opencv_core.CvArr arr,
                                         opencv_core.CvMat header,
                                         int[] coi,
                                         int allowND)

cvGetImage

public static opencv_core.IplImage cvGetImage(opencv_core.CvArr arr,
                                              opencv_core.IplImage image_header)

cvReshapeMatND

public static opencv_core.CvArr cvReshapeMatND(opencv_core.CvArr arr,
                                               int sizeof_header,
                                               opencv_core.CvArr header,
                                               int new_cn,
                                               int new_dims,
                                               IntPointer new_sizes)

cvReshapeMatND

public static opencv_core.CvArr cvReshapeMatND(opencv_core.CvArr arr,
                                               int sizeof_header,
                                               opencv_core.CvArr header,
                                               int new_cn,
                                               int new_dims,
                                               IntBuffer new_sizes)

cvReshapeMatND

public static opencv_core.CvArr cvReshapeMatND(opencv_core.CvArr arr,
                                               int sizeof_header,
                                               opencv_core.CvArr header,
                                               int new_cn,
                                               int new_dims,
                                               int[] new_sizes)

cvReshape

public static opencv_core.CvMat cvReshape(opencv_core.CvArr arr,
                                          opencv_core.CvMat header,
                                          int new_cn,
                                          int new_rows)

cvReshape

public static opencv_core.CvMat cvReshape(opencv_core.CvArr arr,
                                          opencv_core.CvMat header,
                                          int new_cn)

cvRepeat

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

cvCreateData

public static void cvCreateData(opencv_core.CvArr arr)

cvReleaseData

public static void cvReleaseData(opencv_core.CvArr arr)

cvSetData

public static void cvSetData(opencv_core.CvArr arr,
                             Pointer data,
                             int step)

cvGetRawData

public static void cvGetRawData(opencv_core.CvArr arr,
                                PointerPointer data,
                                IntPointer step,
                                opencv_core.CvSize roi_size)

cvGetRawData

public static void cvGetRawData(opencv_core.CvArr arr,
                                BytePointer data)

cvGetRawData

public static void cvGetRawData(opencv_core.CvArr arr,
                                BytePointer data,
                                IntPointer step,
                                opencv_core.CvSize roi_size)

cvGetRawData

public static void cvGetRawData(opencv_core.CvArr arr,
                                ByteBuffer data,
                                IntBuffer step,
                                opencv_core.CvSize roi_size)

cvGetRawData

public static void cvGetRawData(opencv_core.CvArr arr,
                                ByteBuffer data)

cvGetRawData

public static void cvGetRawData(opencv_core.CvArr arr,
                                byte[] data,
                                int[] step,
                                opencv_core.CvSize roi_size)

cvGetRawData

public static void cvGetRawData(opencv_core.CvArr arr,
                                byte[] data)

cvGetSize

public static opencv_core.CvSize cvGetSize(opencv_core.CvArr arr)

cvCopy

public static void cvCopy(opencv_core.CvArr src,
                          opencv_core.CvArr dst,
                          opencv_core.CvArr mask)

cvCopy

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

cvSet

public static void cvSet(opencv_core.CvArr arr,
                         opencv_core.CvScalar value,
                         opencv_core.CvArr mask)

cvSet

public static void cvSet(opencv_core.CvArr arr,
                         opencv_core.CvScalar value)

cvSetZero

public static void cvSetZero(opencv_core.CvArr arr)

cvZero

public static void cvZero(opencv_core.CvArr arg1)

cvSplit

public static void cvSplit(opencv_core.CvArr src,
                           opencv_core.CvArr dst0,
                           opencv_core.CvArr dst1,
                           opencv_core.CvArr dst2,
                           opencv_core.CvArr dst3)

cvMerge

public static void cvMerge(opencv_core.CvArr src0,
                           opencv_core.CvArr src1,
                           opencv_core.CvArr src2,
                           opencv_core.CvArr src3,
                           opencv_core.CvArr dst)

cvMixChannels

public static void cvMixChannels(PointerPointer src,
                                 int src_count,
                                 PointerPointer dst,
                                 int dst_count,
                                 IntPointer from_to,
                                 int pair_count)

cvMixChannels

public static void cvMixChannels(opencv_core.CvArr src,
                                 int src_count,
                                 opencv_core.CvArr dst,
                                 int dst_count,
                                 IntPointer from_to,
                                 int pair_count)

cvMixChannels

public static void cvMixChannels(opencv_core.CvArr src,
                                 int src_count,
                                 opencv_core.CvArr dst,
                                 int dst_count,
                                 IntBuffer from_to,
                                 int pair_count)

cvMixChannels

public static void cvMixChannels(opencv_core.CvArr src,
                                 int src_count,
                                 opencv_core.CvArr dst,
                                 int dst_count,
                                 int[] from_to,
                                 int pair_count)

cvConvertScale

public static void cvConvertScale(opencv_core.CvArr src,
                                  opencv_core.CvArr dst,
                                  double scale,
                                  double shift)

cvConvertScale

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

cvCvtScale

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

cvScale

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

cvConvert

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

cvConvertScaleAbs

public static void cvConvertScaleAbs(opencv_core.CvArr src,
                                     opencv_core.CvArr dst,
                                     double scale,
                                     double shift)

cvConvertScaleAbs

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

cvCvtScaleAbs

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

cvCheckTermCriteria

public static opencv_core.CvTermCriteria cvCheckTermCriteria(opencv_core.CvTermCriteria criteria,
                                                             double default_eps,
                                                             int default_max_iters)

cvAdd

public static void cvAdd(opencv_core.CvArr src1,
                         opencv_core.CvArr src2,
                         opencv_core.CvArr dst,
                         opencv_core.CvArr mask)

\ Arithmetic, logic and comparison operations * \

cvAdd

public static void cvAdd(opencv_core.CvArr src1,
                         opencv_core.CvArr src2,
                         opencv_core.CvArr dst)

cvAddS

public static void cvAddS(opencv_core.CvArr src,
                          opencv_core.CvScalar value,
                          opencv_core.CvArr dst,
                          opencv_core.CvArr mask)

cvAddS

public static void cvAddS(opencv_core.CvArr src,
                          opencv_core.CvScalar value,
                          opencv_core.CvArr dst)

cvSub

public static void cvSub(opencv_core.CvArr src1,
                         opencv_core.CvArr src2,
                         opencv_core.CvArr dst,
                         opencv_core.CvArr mask)

cvSub

public static void cvSub(opencv_core.CvArr src1,
                         opencv_core.CvArr src2,
                         opencv_core.CvArr dst)

cvSubS

public static void cvSubS(opencv_core.CvArr src,
                          opencv_core.CvScalar value,
                          opencv_core.CvArr dst,
                          opencv_core.CvArr mask)

cvSubS

public static void cvSubS(opencv_core.CvArr src,
                          opencv_core.CvScalar value,
                          opencv_core.CvArr dst)

cvSubRS

public static void cvSubRS(opencv_core.CvArr src,
                           opencv_core.CvScalar value,
                           opencv_core.CvArr dst,
                           opencv_core.CvArr mask)

cvSubRS

public static void cvSubRS(opencv_core.CvArr src,
                           opencv_core.CvScalar value,
                           opencv_core.CvArr dst)

cvMul

public static void cvMul(opencv_core.CvArr src1,
                         opencv_core.CvArr src2,
                         opencv_core.CvArr dst,
                         double scale)

cvMul

public static void cvMul(opencv_core.CvArr src1,
                         opencv_core.CvArr src2,
                         opencv_core.CvArr dst)

cvDiv

public static void cvDiv(opencv_core.CvArr src1,
                         opencv_core.CvArr src2,
                         opencv_core.CvArr dst,
                         double scale)

cvDiv

public static void cvDiv(opencv_core.CvArr src1,
                         opencv_core.CvArr src2,
                         opencv_core.CvArr dst)

cvScaleAdd

public static void cvScaleAdd(opencv_core.CvArr src1,
                              opencv_core.CvScalar scale,
                              opencv_core.CvArr src2,
                              opencv_core.CvArr dst)

cvAddWeighted

public static void cvAddWeighted(opencv_core.CvArr src1,
                                 double alpha,
                                 opencv_core.CvArr src2,
                                 double beta,
                                 double gamma,
                                 opencv_core.CvArr dst)

cvDotProduct

public static double cvDotProduct(opencv_core.CvArr src1,
                                  opencv_core.CvArr src2)

cvAnd

public static void cvAnd(opencv_core.CvArr src1,
                         opencv_core.CvArr src2,
                         opencv_core.CvArr dst,
                         opencv_core.CvArr mask)

cvAnd

public static void cvAnd(opencv_core.CvArr src1,
                         opencv_core.CvArr src2,
                         opencv_core.CvArr dst)

cvAndS

public static void cvAndS(opencv_core.CvArr src,
                          opencv_core.CvScalar value,
                          opencv_core.CvArr dst,
                          opencv_core.CvArr mask)

cvAndS

public static void cvAndS(opencv_core.CvArr src,
                          opencv_core.CvScalar value,
                          opencv_core.CvArr dst)

cvOr

public static void cvOr(opencv_core.CvArr src1,
                        opencv_core.CvArr src2,
                        opencv_core.CvArr dst,
                        opencv_core.CvArr mask)

cvOr

public static void cvOr(opencv_core.CvArr src1,
                        opencv_core.CvArr src2,
                        opencv_core.CvArr dst)

cvOrS

public static void cvOrS(opencv_core.CvArr src,
                         opencv_core.CvScalar value,
                         opencv_core.CvArr dst,
                         opencv_core.CvArr mask)

cvOrS

public static void cvOrS(opencv_core.CvArr src,
                         opencv_core.CvScalar value,
                         opencv_core.CvArr dst)

cvXor

public static void cvXor(opencv_core.CvArr src1,
                         opencv_core.CvArr src2,
                         opencv_core.CvArr dst,
                         opencv_core.CvArr mask)

cvXor

public static void cvXor(opencv_core.CvArr src1,
                         opencv_core.CvArr src2,
                         opencv_core.CvArr dst)

cvXorS

public static void cvXorS(opencv_core.CvArr src,
                          opencv_core.CvScalar value,
                          opencv_core.CvArr dst,
                          opencv_core.CvArr mask)

cvXorS

public static void cvXorS(opencv_core.CvArr src,
                          opencv_core.CvScalar value,
                          opencv_core.CvArr dst)

cvNot

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

cvInRange

public static void cvInRange(opencv_core.CvArr src,
                             opencv_core.CvArr lower,
                             opencv_core.CvArr upper,
                             opencv_core.CvArr dst)

cvInRangeS

public static void cvInRangeS(opencv_core.CvArr src,
                              opencv_core.CvScalar lower,
                              opencv_core.CvScalar upper,
                              opencv_core.CvArr dst)

cvCmp

public static void cvCmp(opencv_core.CvArr src1,
                         opencv_core.CvArr src2,
                         opencv_core.CvArr dst,
                         int cmp_op)

cvCmpS

public static void cvCmpS(opencv_core.CvArr src,
                          double value,
                          opencv_core.CvArr dst,
                          int cmp_op)

cvMin

public static void cvMin(opencv_core.CvArr src1,
                         opencv_core.CvArr src2,
                         opencv_core.CvArr dst)

cvMax

public static void cvMax(opencv_core.CvArr src1,
                         opencv_core.CvArr src2,
                         opencv_core.CvArr dst)

cvMinS

public static void cvMinS(opencv_core.CvArr src,
                          double value,
                          opencv_core.CvArr dst)

cvMaxS

public static void cvMaxS(opencv_core.CvArr src,
                          double value,
                          opencv_core.CvArr dst)

cvAbsDiff

public static void cvAbsDiff(opencv_core.CvArr src1,
                             opencv_core.CvArr src2,
                             opencv_core.CvArr dst)

cvAbsDiffS

public static void cvAbsDiffS(opencv_core.CvArr src,
                              opencv_core.CvArr dst,
                              opencv_core.CvScalar value)

cvCartToPolar

public static void cvCartToPolar(opencv_core.CvArr x,
                                 opencv_core.CvArr y,
                                 opencv_core.CvArr magnitude,
                                 opencv_core.CvArr angle,
                                 int angle_in_degrees)

\ Math operations * \

cvCartToPolar

public static void cvCartToPolar(opencv_core.CvArr x,
                                 opencv_core.CvArr y,
                                 opencv_core.CvArr magnitude)

cvPolarToCart

public static void cvPolarToCart(opencv_core.CvArr magnitude,
                                 opencv_core.CvArr angle,
                                 opencv_core.CvArr x,
                                 opencv_core.CvArr y,
                                 int angle_in_degrees)

cvPolarToCart

public static void cvPolarToCart(opencv_core.CvArr magnitude,
                                 opencv_core.CvArr angle,
                                 opencv_core.CvArr x,
                                 opencv_core.CvArr y)

cvPow

public static void cvPow(opencv_core.CvArr src,
                         opencv_core.CvArr dst,
                         double power)

cvExp

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

cvLog

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

cvFastArctan

public static float cvFastArctan(float y,
                                 float x)

cvCbrt

public static float cvCbrt(float value)

cvCheckArr

public static int cvCheckArr(opencv_core.CvArr arr,
                             int flags,
                             double min_val,
                             double max_val)

cvCheckArr

public static int cvCheckArr(opencv_core.CvArr arr)

cvCheckArray

public static int cvCheckArray(opencv_core.CvArr arg1,
                               int arg2,
                               double arg3,
                               double arg4)

cvRandArr

public static void cvRandArr(LongPointer rng,
                             opencv_core.CvArr arr,
                             int dist_type,
                             opencv_core.CvScalar param1,
                             opencv_core.CvScalar param2)

cvRandArr

public static void cvRandArr(LongBuffer rng,
                             opencv_core.CvArr arr,
                             int dist_type,
                             opencv_core.CvScalar param1,
                             opencv_core.CvScalar param2)

cvRandArr

public static void cvRandArr(long[] rng,
                             opencv_core.CvArr arr,
                             int dist_type,
                             opencv_core.CvScalar param1,
                             opencv_core.CvScalar param2)

cvRandShuffle

public static void cvRandShuffle(opencv_core.CvArr mat,
                                 LongPointer rng,
                                 double iter_factor)

cvRandShuffle

public static void cvRandShuffle(opencv_core.CvArr mat,
                                 LongPointer rng)

cvRandShuffle

public static void cvRandShuffle(opencv_core.CvArr mat,
                                 LongBuffer rng,
                                 double iter_factor)

cvRandShuffle

public static void cvRandShuffle(opencv_core.CvArr mat,
                                 LongBuffer rng)

cvRandShuffle

public static void cvRandShuffle(opencv_core.CvArr mat,
                                 long[] rng,
                                 double iter_factor)

cvRandShuffle

public static void cvRandShuffle(opencv_core.CvArr mat,
                                 long[] rng)

cvSort

public static void cvSort(opencv_core.CvArr src,
                          opencv_core.CvArr dst,
                          opencv_core.CvArr idxmat,
                          int flags)

cvSort

public static void cvSort(opencv_core.CvArr src)

cvSolveCubic

public static int cvSolveCubic(opencv_core.CvMat coeffs,
                               opencv_core.CvMat roots)

cvSolvePoly

public static void cvSolvePoly(opencv_core.CvMat coeffs,
                               opencv_core.CvMat roots2,
                               int maxiter,
                               int fig)

cvSolvePoly

public static void cvSolvePoly(opencv_core.CvMat coeffs,
                               opencv_core.CvMat roots2)

cvCrossProduct

public static void cvCrossProduct(opencv_core.CvArr src1,
                                  opencv_core.CvArr src2,
                                  opencv_core.CvArr dst)

\ Matrix operations * \

cvMatMulAdd

public static void cvMatMulAdd(opencv_core.CvArr src1,
                               opencv_core.CvArr src2,
                               opencv_core.CvArr src3,
                               opencv_core.CvArr dst)

cvMatMul

public static void cvMatMul(opencv_core.CvArr src1,
                            opencv_core.CvArr src2,
                            opencv_core.CvArr dst)

cvGEMM

public static void cvGEMM(opencv_core.CvArr src1,
                          opencv_core.CvArr src2,
                          double alpha,
                          opencv_core.CvArr src3,
                          double beta,
                          opencv_core.CvArr dst,
                          int tABC)

cvGEMM

public static void cvGEMM(opencv_core.CvArr src1,
                          opencv_core.CvArr src2,
                          double alpha,
                          opencv_core.CvArr src3,
                          double beta,
                          opencv_core.CvArr dst)

cvMatMulAddEx

public static void cvMatMulAddEx(opencv_core.CvArr arg1,
                                 opencv_core.CvArr arg2,
                                 double arg3,
                                 opencv_core.CvArr arg4,
                                 double arg5,
                                 opencv_core.CvArr arg6,
                                 int arg7)

cvTransform

public static void cvTransform(opencv_core.CvArr src,
                               opencv_core.CvArr dst,
                               opencv_core.CvMat transmat,
                               opencv_core.CvMat shiftvec)

cvTransform

public static void cvTransform(opencv_core.CvArr src,
                               opencv_core.CvArr dst,
                               opencv_core.CvMat transmat)

cvMatMulAddS

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

cvPerspectiveTransform

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

cvMulTransposed

public static void cvMulTransposed(opencv_core.CvArr src,
                                   opencv_core.CvArr dst,
                                   int order,
                                   opencv_core.CvArr delta,
                                   double scale)

cvMulTransposed

public static void cvMulTransposed(opencv_core.CvArr src,
                                   opencv_core.CvArr dst,
                                   int order)

cvTranspose

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

cvT

public static void cvT(opencv_core.CvArr arg1,
                       opencv_core.CvArr arg2)

cvCompleteSymm

public static void cvCompleteSymm(opencv_core.CvMat matrix,
                                  int LtoR)

cvCompleteSymm

public static void cvCompleteSymm(opencv_core.CvMat matrix)

cvFlip

public static void cvFlip(opencv_core.CvArr src,
                          opencv_core.CvArr dst,
                          int flip_mode)

cvFlip

public static void cvFlip(opencv_core.CvArr src)

cvMirror

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

cvSVD

public static void cvSVD(opencv_core.CvArr A,
                         opencv_core.CvArr W,
                         opencv_core.CvArr U,
                         opencv_core.CvArr V,
                         int flags)

cvSVD

public static void cvSVD(opencv_core.CvArr A,
                         opencv_core.CvArr W)

cvSVBkSb

public static void cvSVBkSb(opencv_core.CvArr W,
                            opencv_core.CvArr U,
                            opencv_core.CvArr V,
                            opencv_core.CvArr B,
                            opencv_core.CvArr X,
                            int flags)

cvInvert

public static double cvInvert(opencv_core.CvArr src,
                              opencv_core.CvArr dst,
                              int method)

cvInvert

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

cvInv

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

cvSolve

public static int cvSolve(opencv_core.CvArr src1,
                          opencv_core.CvArr src2,
                          opencv_core.CvArr dst,
                          int method)

cvSolve

public static int cvSolve(opencv_core.CvArr src1,
                          opencv_core.CvArr src2,
                          opencv_core.CvArr dst)

cvDet

public static double cvDet(opencv_core.CvArr mat)

cvTrace

public static opencv_core.CvScalar cvTrace(opencv_core.CvArr mat)

cvEigenVV

public static void cvEigenVV(opencv_core.CvArr mat,
                             opencv_core.CvArr evects,
                             opencv_core.CvArr evals,
                             double eps,
                             int lowindex,
                             int highindex)

cvEigenVV

public static void cvEigenVV(opencv_core.CvArr mat,
                             opencv_core.CvArr evects,
                             opencv_core.CvArr evals)

cvSetIdentity

public static void cvSetIdentity(opencv_core.CvArr mat,
                                 opencv_core.CvScalar value)

cvSetIdentity

public static void cvSetIdentity(opencv_core.CvArr mat)

cvRange

public static opencv_core.CvArr cvRange(opencv_core.CvArr mat,
                                        double start,
                                        double end)

cvCalcCovarMatrix

public static void cvCalcCovarMatrix(PointerPointer vects,
                                     int count,
                                     opencv_core.CvArr cov_mat,
                                     opencv_core.CvArr avg,
                                     int flags)

cvCalcCovarMatrix

public static void cvCalcCovarMatrix(opencv_core.CvArr vects,
                                     int count,
                                     opencv_core.CvArr cov_mat,
                                     opencv_core.CvArr avg,
                                     int flags)

cvCalcPCA

public static void cvCalcPCA(opencv_core.CvArr data,
                             opencv_core.CvArr mean,
                             opencv_core.CvArr eigenvals,
                             opencv_core.CvArr eigenvects,
                             int flags)

cvProjectPCA

public static void cvProjectPCA(opencv_core.CvArr data,
                                opencv_core.CvArr mean,
                                opencv_core.CvArr eigenvects,
                                opencv_core.CvArr result)

cvBackProjectPCA

public static void cvBackProjectPCA(opencv_core.CvArr proj,
                                    opencv_core.CvArr mean,
                                    opencv_core.CvArr eigenvects,
                                    opencv_core.CvArr result)

cvMahalanobis

public static double cvMahalanobis(opencv_core.CvArr vec1,
                                   opencv_core.CvArr vec2,
                                   opencv_core.CvArr mat)

cvMahalonobis

public static double cvMahalonobis(opencv_core.CvArr arg1,
                                   opencv_core.CvArr arg2,
                                   opencv_core.CvArr arg3)

cvSum
```
public static opencv_core.CvScalar cvSum(opencv_core.CvArr arr)
```
\ Array Statistics * \

cvCountNonZero

public static int cvCountNonZero(opencv_core.CvArr arr)

cvAvg

public static opencv_core.CvScalar cvAvg(opencv_core.CvArr arr,
                                         opencv_core.CvArr mask)

cvAvg

public static opencv_core.CvScalar cvAvg(opencv_core.CvArr arr)

cvAvgSdv

public static void cvAvgSdv(opencv_core.CvArr arr,
                            opencv_core.CvScalar mean,
                            opencv_core.CvScalar std_dev,
                            opencv_core.CvArr mask)

cvAvgSdv

public static void cvAvgSdv(opencv_core.CvArr arr,
                            opencv_core.CvScalar mean,
                            opencv_core.CvScalar std_dev)

cvMinMaxLoc

public static void cvMinMaxLoc(opencv_core.CvArr arr,
                               DoublePointer min_val,
                               DoublePointer max_val,
                               opencv_core.CvPoint min_loc,
                               opencv_core.CvPoint max_loc,
                               opencv_core.CvArr mask)

cvMinMaxLoc

public static void cvMinMaxLoc(opencv_core.CvArr arr,
                               DoublePointer min_val,
                               DoublePointer max_val)

cvMinMaxLoc

public static void cvMinMaxLoc(opencv_core.CvArr arr,
                               DoubleBuffer min_val,
                               DoubleBuffer max_val,
                               IntBuffer min_loc,
                               IntBuffer max_loc,
                               opencv_core.CvArr mask)

cvMinMaxLoc

public static void cvMinMaxLoc(opencv_core.CvArr arr,
                               DoubleBuffer min_val,
                               DoubleBuffer max_val)

cvMinMaxLoc

public static void cvMinMaxLoc(opencv_core.CvArr arr,
                               double[] min_val,
                               double[] max_val,
                               int[] min_loc,
                               int[] max_loc,
                               opencv_core.CvArr mask)

cvMinMaxLoc

public static void cvMinMaxLoc(opencv_core.CvArr arr,
                               double[] min_val,
                               double[] max_val)

cvNorm

public static double cvNorm(opencv_core.CvArr arr1,
                            opencv_core.CvArr arr2,
                            int norm_type,
                            opencv_core.CvArr mask)

cvNorm

public static double cvNorm(opencv_core.CvArr arr1)

cvNormalize

public static void cvNormalize(opencv_core.CvArr src,
                               opencv_core.CvArr dst,
                               double a,
                               double b,
                               int norm_type,
                               opencv_core.CvArr mask)

cvNormalize

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

cvReduce

public static void cvReduce(opencv_core.CvArr src,
                            opencv_core.CvArr dst,
                            int dim,
                            int op)

cvReduce

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

cvDFT

public static void cvDFT(opencv_core.CvArr src,
                         opencv_core.CvArr dst,
                         int flags,
                         int nonzero_rows)

cvDFT

public static void cvDFT(opencv_core.CvArr src,
                         opencv_core.CvArr dst,
                         int flags)

cvFFT

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

cvMulSpectrums

public static void cvMulSpectrums(opencv_core.CvArr src1,
                                  opencv_core.CvArr src2,
                                  opencv_core.CvArr dst,
                                  int flags)

cvGetOptimalDFTSize

public static int cvGetOptimalDFTSize(int size0)

cvDCT

public static void cvDCT(opencv_core.CvArr src,
                         opencv_core.CvArr dst,
                         int flags)

cvSliceLength

public static int cvSliceLength(opencv_core.CvSlice slice,
                                opencv_core.CvSeq seq)

\ Dynamic data structures * \

cvCreateMemStorage

public static opencv_core.CvMemStorage cvCreateMemStorage(int block_size)

cvCreateMemStorage

public static opencv_core.CvMemStorage cvCreateMemStorage()

cvCreateChildMemStorage

public static opencv_core.CvMemStorage cvCreateChildMemStorage(opencv_core.CvMemStorage parent)

cvReleaseMemStorage

public static void cvReleaseMemStorage(PointerPointer storage)

cvReleaseMemStorage

public static void cvReleaseMemStorage(opencv_core.CvMemStorage storage)

cvClearMemStorage

public static void cvClearMemStorage(opencv_core.CvMemStorage storage)

cvSaveMemStoragePos

public static void cvSaveMemStoragePos(opencv_core.CvMemStorage storage,
                                       opencv_core.CvMemStoragePos pos)

cvRestoreMemStoragePos

public static void cvRestoreMemStoragePos(opencv_core.CvMemStorage storage,
                                          opencv_core.CvMemStoragePos pos)

cvMemStorageAlloc

public static Pointer cvMemStorageAlloc(opencv_core.CvMemStorage storage,
                                        long size)

cvMemStorageAllocString

public static opencv_core.CvString cvMemStorageAllocString(opencv_core.CvMemStorage storage,
                                                           BytePointer ptr,
                                                           int len)

cvMemStorageAllocString

public static opencv_core.CvString cvMemStorageAllocString(opencv_core.CvMemStorage storage,
                                                           BytePointer ptr)

cvMemStorageAllocString

public static opencv_core.CvString cvMemStorageAllocString(opencv_core.CvMemStorage storage,
                                                           String ptr,
                                                           int len)

cvMemStorageAllocString

public static opencv_core.CvString cvMemStorageAllocString(opencv_core.CvMemStorage storage,
                                                           String ptr)

cvCreateSeq

public static opencv_core.CvSeq cvCreateSeq(int seq_flags,
                                            long header_size,
                                            long elem_size,
                                            opencv_core.CvMemStorage storage)

cvSetSeqBlockSize

public static void cvSetSeqBlockSize(opencv_core.CvSeq seq,
                                     int delta_elems)

cvSeqPush

public static BytePointer cvSeqPush(opencv_core.CvSeq seq,
                                    Pointer element)

cvSeqPush

public static BytePointer cvSeqPush(opencv_core.CvSeq seq)

cvSeqPushFront

public static BytePointer cvSeqPushFront(opencv_core.CvSeq seq,
                                         Pointer element)

cvSeqPushFront

public static BytePointer cvSeqPushFront(opencv_core.CvSeq seq)

cvSeqPop

public static void cvSeqPop(opencv_core.CvSeq seq,
                            Pointer element)

cvSeqPop

public static void cvSeqPop(opencv_core.CvSeq seq)

cvSeqPopFront

public static void cvSeqPopFront(opencv_core.CvSeq seq,
                                 Pointer element)

cvSeqPopFront

public static void cvSeqPopFront(opencv_core.CvSeq seq)

cvSeqPushMulti

public static void cvSeqPushMulti(opencv_core.CvSeq seq,
                                  Pointer elements,
                                  int count,
                                  int in_front)

cvSeqPushMulti

public static void cvSeqPushMulti(opencv_core.CvSeq seq,
                                  Pointer elements,
                                  int count)

cvSeqPopMulti

public static void cvSeqPopMulti(opencv_core.CvSeq seq,
                                 Pointer elements,
                                 int count,
                                 int in_front)

cvSeqPopMulti

public static void cvSeqPopMulti(opencv_core.CvSeq seq,
                                 Pointer elements,
                                 int count)

cvSeqInsert

public static BytePointer cvSeqInsert(opencv_core.CvSeq seq,
                                      int before_index,
                                      Pointer element)

cvSeqInsert

public static BytePointer cvSeqInsert(opencv_core.CvSeq seq,
                                      int before_index)

cvSeqRemove

public static void cvSeqRemove(opencv_core.CvSeq seq,
                               int index)

cvClearSeq

public static void cvClearSeq(opencv_core.CvSeq seq)

cvGetSeqElem

public static BytePointer cvGetSeqElem(opencv_core.CvSeq seq,
                                       int index)

cvSeqElemIdx

public static int cvSeqElemIdx(opencv_core.CvSeq seq,
                               Pointer element,
                               PointerPointer block)

cvSeqElemIdx

public static int cvSeqElemIdx(opencv_core.CvSeq seq,
                               Pointer element)

cvSeqElemIdx

public static int cvSeqElemIdx(opencv_core.CvSeq seq,
                               Pointer element,
                               opencv_core.CvSeqBlock block)

cvStartAppendToSeq

public static void cvStartAppendToSeq(opencv_core.CvSeq seq,
                                      opencv_core.CvSeqWriter writer)

cvStartWriteSeq

public static void cvStartWriteSeq(int seq_flags,
                                   int header_size,
                                   int elem_size,
                                   opencv_core.CvMemStorage storage,
                                   opencv_core.CvSeqWriter writer)

cvEndWriteSeq

public static opencv_core.CvSeq cvEndWriteSeq(opencv_core.CvSeqWriter writer)

cvFlushSeqWriter

public static void cvFlushSeqWriter(opencv_core.CvSeqWriter writer)

cvStartReadSeq

public static void cvStartReadSeq(opencv_core.CvSeq seq,
                                  opencv_core.CvSeqReader reader,
                                  int reverse)

cvStartReadSeq

public static void cvStartReadSeq(opencv_core.CvSeq seq,
                                  opencv_core.CvSeqReader reader)

cvGetSeqReaderPos

public static int cvGetSeqReaderPos(opencv_core.CvSeqReader reader)

cvSetSeqReaderPos

public static void cvSetSeqReaderPos(opencv_core.CvSeqReader reader,
                                     int index,
                                     int is_relative)

cvSetSeqReaderPos

public static void cvSetSeqReaderPos(opencv_core.CvSeqReader reader,
                                     int index)

cvCvtSeqToArray

public static Pointer cvCvtSeqToArray(opencv_core.CvSeq seq,
                                      Pointer elements,
                                      opencv_core.CvSlice slice)

cvCvtSeqToArray

public static Pointer cvCvtSeqToArray(opencv_core.CvSeq seq,
                                      Pointer elements)

cvMakeSeqHeaderForArray

public static opencv_core.CvSeq cvMakeSeqHeaderForArray(int seq_type,
                                                        int header_size,
                                                        int elem_size,
                                                        Pointer elements,
                                                        int total,
                                                        opencv_core.CvSeq seq,
                                                        opencv_core.CvSeqBlock block)

cvSeqSlice

public static opencv_core.CvSeq cvSeqSlice(opencv_core.CvSeq seq,
                                           opencv_core.CvSlice slice,
                                           opencv_core.CvMemStorage storage,
                                           int copy_data)

cvSeqSlice

public static opencv_core.CvSeq cvSeqSlice(opencv_core.CvSeq seq,
                                           opencv_core.CvSlice slice)

cvCloneSeq

public static opencv_core.CvSeq cvCloneSeq(opencv_core.CvSeq seq,
                                           opencv_core.CvMemStorage storage)

cvCloneSeq

public static opencv_core.CvSeq cvCloneSeq(opencv_core.CvSeq seq)

cvSeqRemoveSlice

public static void cvSeqRemoveSlice(opencv_core.CvSeq seq,
                                    opencv_core.CvSlice slice)

cvSeqInsertSlice

public static void cvSeqInsertSlice(opencv_core.CvSeq seq,
                                    int before_index,
                                    opencv_core.CvArr from_arr)

cvSeqSort

public static void cvSeqSort(opencv_core.CvSeq seq,
                             opencv_core.CvCmpFunc func,
                             Pointer userdata)

cvSeqSort

public static void cvSeqSort(opencv_core.CvSeq seq,
                             opencv_core.CvCmpFunc func)

cvSeqSearch

public static BytePointer cvSeqSearch(opencv_core.CvSeq seq,
                                      Pointer elem,
                                      opencv_core.CvCmpFunc func,
                                      int is_sorted,
                                      IntPointer elem_idx,
                                      Pointer userdata)

cvSeqSearch

public static BytePointer cvSeqSearch(opencv_core.CvSeq seq,
                                      Pointer elem,
                                      opencv_core.CvCmpFunc func,
                                      int is_sorted,
                                      IntPointer elem_idx)

cvSeqSearch

public static ByteBuffer cvSeqSearch(opencv_core.CvSeq seq,
                                     Pointer elem,
                                     opencv_core.CvCmpFunc func,
                                     int is_sorted,
                                     IntBuffer elem_idx,
                                     Pointer userdata)

cvSeqSearch

public static ByteBuffer cvSeqSearch(opencv_core.CvSeq seq,
                                     Pointer elem,
                                     opencv_core.CvCmpFunc func,
                                     int is_sorted,
                                     IntBuffer elem_idx)

cvSeqSearch

public static byte[] cvSeqSearch(opencv_core.CvSeq seq,
                                 Pointer elem,
                                 opencv_core.CvCmpFunc func,
                                 int is_sorted,
                                 int[] elem_idx,
                                 Pointer userdata)

cvSeqSearch

public static byte[] cvSeqSearch(opencv_core.CvSeq seq,
                                 Pointer elem,
                                 opencv_core.CvCmpFunc func,
                                 int is_sorted,
                                 int[] elem_idx)

cvSeqInvert

public static void cvSeqInvert(opencv_core.CvSeq seq)

cvSeqPartition

public static int cvSeqPartition(opencv_core.CvSeq seq,
                                 opencv_core.CvMemStorage storage,
                                 PointerPointer labels,
                                 opencv_core.CvCmpFunc is_equal,
                                 Pointer userdata)

cvSeqPartition

public static int cvSeqPartition(opencv_core.CvSeq seq,
                                 opencv_core.CvMemStorage storage,
                                 opencv_core.CvSeq labels,
                                 opencv_core.CvCmpFunc is_equal,
                                 Pointer userdata)

cvChangeSeqBlock

public static void cvChangeSeqBlock(Pointer reader,
                                    int direction)

Internal sequence functions

cvCreateSeqBlock

public static void cvCreateSeqBlock(opencv_core.CvSeqWriter writer)

cvCreateSet

public static opencv_core.CvSet cvCreateSet(int set_flags,
                                            int header_size,
                                            int elem_size,
                                            opencv_core.CvMemStorage storage)

cvSetAdd

public static int cvSetAdd(opencv_core.CvSet set_header,
                           opencv_core.CvSetElem elem,
                           PointerPointer inserted_elem)

cvSetAdd

public static int cvSetAdd(opencv_core.CvSet set_header)

cvSetAdd

public static int cvSetAdd(opencv_core.CvSet set_header,
                           opencv_core.CvSetElem elem,
                           opencv_core.CvSetElem inserted_elem)

cvSetNew

public static opencv_core.CvSetElem cvSetNew(opencv_core.CvSet set_header)

cvSetRemoveByPtr

public static void cvSetRemoveByPtr(opencv_core.CvSet set_header,
                                    Pointer elem)

cvSetRemove

public static void cvSetRemove(opencv_core.CvSet set_header,
                               int index)

cvGetSetElem

public static opencv_core.CvSetElem cvGetSetElem(opencv_core.CvSet set_header,
                                                 int idx)

cvClearSet

public static void cvClearSet(opencv_core.CvSet set_header)

cvCreateGraph

public static opencv_core.CvGraph cvCreateGraph(int graph_flags,
                                                int header_size,
                                                int vtx_size,
                                                int edge_size,
                                                opencv_core.CvMemStorage storage)

cvGraphAddVtx

public static int cvGraphAddVtx(opencv_core.CvGraph graph,
                                opencv_core.CvGraphVtx vtx,
                                PointerPointer inserted_vtx)

cvGraphAddVtx

public static int cvGraphAddVtx(opencv_core.CvGraph graph)

cvGraphAddVtx

public static int cvGraphAddVtx(opencv_core.CvGraph graph,
                                opencv_core.CvGraphVtx vtx,
                                opencv_core.CvGraphVtx inserted_vtx)

cvGraphRemoveVtx

public static int cvGraphRemoveVtx(opencv_core.CvGraph graph,
                                   int index)

cvGraphRemoveVtxByPtr

public static int cvGraphRemoveVtxByPtr(opencv_core.CvGraph graph,
                                        opencv_core.CvGraphVtx vtx)

cvGraphAddEdge

public static int cvGraphAddEdge(opencv_core.CvGraph graph,
                                 int start_idx,
                                 int end_idx,
                                 opencv_core.CvGraphEdge edge,
                                 PointerPointer inserted_edge)

cvGraphAddEdge

public static int cvGraphAddEdge(opencv_core.CvGraph graph,
                                 int start_idx,
                                 int end_idx)

cvGraphAddEdge

public static int cvGraphAddEdge(opencv_core.CvGraph graph,
                                 int start_idx,
                                 int end_idx,
                                 opencv_core.CvGraphEdge edge,
                                 opencv_core.CvGraphEdge inserted_edge)

cvGraphAddEdgeByPtr

public static int cvGraphAddEdgeByPtr(opencv_core.CvGraph graph,
                                      opencv_core.CvGraphVtx start_vtx,
                                      opencv_core.CvGraphVtx end_vtx,
                                      opencv_core.CvGraphEdge edge,
                                      PointerPointer inserted_edge)

cvGraphAddEdgeByPtr

public static int cvGraphAddEdgeByPtr(opencv_core.CvGraph graph,
                                      opencv_core.CvGraphVtx start_vtx,
                                      opencv_core.CvGraphVtx end_vtx)

cvGraphAddEdgeByPtr

public static int cvGraphAddEdgeByPtr(opencv_core.CvGraph graph,
                                      opencv_core.CvGraphVtx start_vtx,
                                      opencv_core.CvGraphVtx end_vtx,
                                      opencv_core.CvGraphEdge edge,
                                      opencv_core.CvGraphEdge inserted_edge)

cvGraphRemoveEdge

public static void cvGraphRemoveEdge(opencv_core.CvGraph graph,
                                     int start_idx,
                                     int end_idx)

cvGraphRemoveEdgeByPtr

public static void cvGraphRemoveEdgeByPtr(opencv_core.CvGraph graph,
                                          opencv_core.CvGraphVtx start_vtx,
                                          opencv_core.CvGraphVtx end_vtx)

cvFindGraphEdge

public static opencv_core.CvGraphEdge cvFindGraphEdge(opencv_core.CvGraph graph,
                                                      int start_idx,
                                                      int end_idx)

cvFindGraphEdgeByPtr

public static opencv_core.CvGraphEdge cvFindGraphEdgeByPtr(opencv_core.CvGraph graph,
                                                           opencv_core.CvGraphVtx start_vtx,
                                                           opencv_core.CvGraphVtx end_vtx)

cvGraphFindEdge

public static opencv_core.CvGraphEdge cvGraphFindEdge(opencv_core.CvGraph arg1,
                                                      int arg2,
                                                      int arg3)

cvGraphFindEdgeByPtr

public static opencv_core.CvGraphEdge cvGraphFindEdgeByPtr(opencv_core.CvGraph arg1,
                                                           opencv_core.CvGraphVtx arg2,
                                                           opencv_core.CvGraphVtx arg3)

cvClearGraph

public static void cvClearGraph(opencv_core.CvGraph graph)

cvGraphVtxDegree

public static int cvGraphVtxDegree(opencv_core.CvGraph graph,
                                   int vtx_idx)

cvGraphVtxDegreeByPtr

public static int cvGraphVtxDegreeByPtr(opencv_core.CvGraph graph,
                                        opencv_core.CvGraphVtx vtx)

cvCreateGraphScanner

public static opencv_core.CvGraphScanner cvCreateGraphScanner(opencv_core.CvGraph graph,
                                                              opencv_core.CvGraphVtx vtx,
                                                              int mask)

cvCreateGraphScanner

public static opencv_core.CvGraphScanner cvCreateGraphScanner(opencv_core.CvGraph graph)

cvReleaseGraphScanner

public static void cvReleaseGraphScanner(PointerPointer scanner)

cvReleaseGraphScanner

public static void cvReleaseGraphScanner(opencv_core.CvGraphScanner scanner)

cvNextGraphItem

public static int cvNextGraphItem(opencv_core.CvGraphScanner scanner)

cvCloneGraph

public static opencv_core.CvGraph cvCloneGraph(opencv_core.CvGraph graph,
                                               opencv_core.CvMemStorage storage)

cvLine

public static void cvLine(opencv_core.CvArr img,
                          opencv_core.CvPoint pt1,
                          opencv_core.CvPoint pt2,
                          opencv_core.CvScalar color,
                          int thickness,
                          int line_type,
                          int shift)

cvLine

public static void cvLine(opencv_core.CvArr img,
                          opencv_core.CvPoint pt1,
                          opencv_core.CvPoint pt2,
                          opencv_core.CvScalar color)

cvLine

public static void cvLine(opencv_core.CvArr img,
                          IntBuffer pt1,
                          IntBuffer pt2,
                          opencv_core.CvScalar color,
                          int thickness,
                          int line_type,
                          int shift)

cvLine

public static void cvLine(opencv_core.CvArr img,
                          IntBuffer pt1,
                          IntBuffer pt2,
                          opencv_core.CvScalar color)

cvLine

public static void cvLine(opencv_core.CvArr img,
                          int[] pt1,
                          int[] pt2,
                          opencv_core.CvScalar color,
                          int thickness,
                          int line_type,
                          int shift)

cvLine

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

cvRectangle

public static void cvRectangle(opencv_core.CvArr img,
                               opencv_core.CvPoint pt1,
                               opencv_core.CvPoint pt2,
                               opencv_core.CvScalar color,
                               int thickness,
                               int line_type,
                               int shift)

cvRectangle

public static void cvRectangle(opencv_core.CvArr img,
                               opencv_core.CvPoint pt1,
                               opencv_core.CvPoint pt2,
                               opencv_core.CvScalar color)

cvRectangle

public static void cvRectangle(opencv_core.CvArr img,
                               IntBuffer pt1,
                               IntBuffer pt2,
                               opencv_core.CvScalar color,
                               int thickness,
                               int line_type,
                               int shift)

cvRectangle

public static void cvRectangle(opencv_core.CvArr img,
                               IntBuffer pt1,
                               IntBuffer pt2,
                               opencv_core.CvScalar color)

cvRectangle

public static void cvRectangle(opencv_core.CvArr img,
                               int[] pt1,
                               int[] pt2,
                               opencv_core.CvScalar color,
                               int thickness,
                               int line_type,
                               int shift)

cvRectangle

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

cvRectangleR

public static void cvRectangleR(opencv_core.CvArr img,
                                opencv_core.CvRect r,
                                opencv_core.CvScalar color,
                                int thickness,
                                int line_type,
                                int shift)

cvRectangleR

public static void cvRectangleR(opencv_core.CvArr img,
                                opencv_core.CvRect r,
                                opencv_core.CvScalar color)

cvCircle

public static void cvCircle(opencv_core.CvArr img,
                            opencv_core.CvPoint center,
                            int radius,
                            opencv_core.CvScalar color,
                            int thickness,
                            int line_type,
                            int shift)

cvCircle

public static void cvCircle(opencv_core.CvArr img,
                            opencv_core.CvPoint center,
                            int radius,
                            opencv_core.CvScalar color)

cvCircle

public static void cvCircle(opencv_core.CvArr img,
                            IntBuffer center,
                            int radius,
                            opencv_core.CvScalar color,
                            int thickness,
                            int line_type,
                            int shift)

cvCircle

public static void cvCircle(opencv_core.CvArr img,
                            IntBuffer center,
                            int radius,
                            opencv_core.CvScalar color)

cvCircle

public static void cvCircle(opencv_core.CvArr img,
                            int[] center,
                            int radius,
                            opencv_core.CvScalar color,
                            int thickness,
                            int line_type,
                            int shift)

cvCircle

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

cvEllipse

public static void cvEllipse(opencv_core.CvArr img,
                             opencv_core.CvPoint center,
                             opencv_core.CvSize axes,
                             double angle,
                             double start_angle,
                             double end_angle,
                             opencv_core.CvScalar color,
                             int thickness,
                             int line_type,
                             int shift)

cvEllipse

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

cvEllipse

public static void cvEllipse(opencv_core.CvArr img,
                             IntBuffer center,
                             opencv_core.CvSize axes,
                             double angle,
                             double start_angle,
                             double end_angle,
                             opencv_core.CvScalar color,
                             int thickness,
                             int line_type,
                             int shift)

cvEllipse

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

cvEllipse

public static void cvEllipse(opencv_core.CvArr img,
                             int[] center,
                             opencv_core.CvSize axes,
                             double angle,
                             double start_angle,
                             double end_angle,
                             opencv_core.CvScalar color,
                             int thickness,
                             int line_type,
                             int shift)

cvEllipse

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

cvEllipseBox

public static void cvEllipseBox(opencv_core.CvArr img,
                                opencv_core.CvBox2D box,
                                opencv_core.CvScalar color,
                                int thickness,
                                int line_type,
                                int shift)

cvEllipseBox

public static void cvEllipseBox(opencv_core.CvArr img,
                                opencv_core.CvBox2D box,
                                opencv_core.CvScalar color)

cvFillConvexPoly

public static void cvFillConvexPoly(opencv_core.CvArr img,
                                    opencv_core.CvPoint pts,
                                    int npts,
                                    opencv_core.CvScalar color,
                                    int line_type,
                                    int shift)

cvFillConvexPoly

public static void cvFillConvexPoly(opencv_core.CvArr img,
                                    opencv_core.CvPoint pts,
                                    int npts,
                                    opencv_core.CvScalar color)

cvFillConvexPoly

public static void cvFillConvexPoly(opencv_core.CvArr img,
                                    IntBuffer pts,
                                    int npts,
                                    opencv_core.CvScalar color,
                                    int line_type,
                                    int shift)

cvFillConvexPoly

public static void cvFillConvexPoly(opencv_core.CvArr img,
                                    IntBuffer pts,
                                    int npts,
                                    opencv_core.CvScalar color)

cvFillConvexPoly

public static void cvFillConvexPoly(opencv_core.CvArr img,
                                    int[] pts,
                                    int npts,
                                    opencv_core.CvScalar color,
                                    int line_type,
                                    int shift)

cvFillConvexPoly

public static void cvFillConvexPoly(opencv_core.CvArr img,
                                    int[] pts,
                                    int npts,
                                    opencv_core.CvScalar color)

cvFillPoly

public static void cvFillPoly(opencv_core.CvArr img,
                              PointerPointer pts,
                              IntPointer npts,
                              int contours,
                              opencv_core.CvScalar color,
                              int line_type,
                              int shift)

cvFillPoly

public static void cvFillPoly(opencv_core.CvArr img,
                              opencv_core.CvPoint pts,
                              IntPointer npts,
                              int contours,
                              opencv_core.CvScalar color)

cvFillPoly

public static void cvFillPoly(opencv_core.CvArr img,
                              opencv_core.CvPoint pts,
                              IntPointer npts,
                              int contours,
                              opencv_core.CvScalar color,
                              int line_type,
                              int shift)

cvFillPoly

public static void cvFillPoly(opencv_core.CvArr img,
                              IntBuffer pts,
                              IntBuffer npts,
                              int contours,
                              opencv_core.CvScalar color,
                              int line_type,
                              int shift)

cvFillPoly

public static void cvFillPoly(opencv_core.CvArr img,
                              IntBuffer pts,
                              IntBuffer npts,
                              int contours,
                              opencv_core.CvScalar color)

cvFillPoly

public static void cvFillPoly(opencv_core.CvArr img,
                              int[] pts,
                              int[] npts,
                              int contours,
                              opencv_core.CvScalar color,
                              int line_type,
                              int shift)

cvFillPoly

public static void cvFillPoly(opencv_core.CvArr img,
                              int[] pts,
                              int[] npts,
                              int contours,
                              opencv_core.CvScalar color)

cvPolyLine

public static void cvPolyLine(opencv_core.CvArr img,
                              PointerPointer pts,
                              IntPointer npts,
                              int contours,
                              int is_closed,
                              opencv_core.CvScalar color,
                              int thickness,
                              int line_type,
                              int shift)

cvPolyLine

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

cvPolyLine

public static void cvPolyLine(opencv_core.CvArr img,
                              opencv_core.CvPoint pts,
                              IntPointer npts,
                              int contours,
                              int is_closed,
                              opencv_core.CvScalar color,
                              int thickness,
                              int line_type,
                              int shift)

cvPolyLine

public static void cvPolyLine(opencv_core.CvArr img,
                              IntBuffer pts,
                              IntBuffer npts,
                              int contours,
                              int is_closed,
                              opencv_core.CvScalar color,
                              int thickness,
                              int line_type,
                              int shift)

cvPolyLine

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

cvPolyLine

public static void cvPolyLine(opencv_core.CvArr img,
                              int[] pts,
                              int[] npts,
                              int contours,
                              int is_closed,
                              opencv_core.CvScalar color,
                              int thickness,
                              int line_type,
                              int shift)

cvPolyLine

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

cvDrawRect

public static void cvDrawRect(opencv_core.CvArr arg1,
                              opencv_core.CvPoint arg2,
                              opencv_core.CvPoint arg3,
                              opencv_core.CvScalar arg4,
                              int arg5,
                              int arg6,
                              int arg7)

cvDrawRect

public static void cvDrawRect(opencv_core.CvArr arg1,
                              IntBuffer arg2,
                              IntBuffer arg3,
                              opencv_core.CvScalar arg4,
                              int arg5,
                              int arg6,
                              int arg7)

cvDrawRect

public static void cvDrawRect(opencv_core.CvArr arg1,
                              int[] arg2,
                              int[] arg3,
                              opencv_core.CvScalar arg4,
                              int arg5,
                              int arg6,
                              int arg7)

cvDrawLine

public static void cvDrawLine(opencv_core.CvArr arg1,
                              opencv_core.CvPoint arg2,
                              opencv_core.CvPoint arg3,
                              opencv_core.CvScalar arg4,
                              int arg5,
                              int arg6,
                              int arg7)

cvDrawLine

public static void cvDrawLine(opencv_core.CvArr arg1,
                              IntBuffer arg2,
                              IntBuffer arg3,
                              opencv_core.CvScalar arg4,
                              int arg5,
                              int arg6,
                              int arg7)

cvDrawLine

public static void cvDrawLine(opencv_core.CvArr arg1,
                              int[] arg2,
                              int[] arg3,
                              opencv_core.CvScalar arg4,
                              int arg5,
                              int arg6,
                              int arg7)

cvDrawCircle

public static void cvDrawCircle(opencv_core.CvArr arg1,
                                opencv_core.CvPoint arg2,
                                int arg3,
                                opencv_core.CvScalar arg4,
                                int arg5,
                                int arg6,
                                int arg7)

cvDrawCircle

public static void cvDrawCircle(opencv_core.CvArr arg1,
                                IntBuffer arg2,
                                int arg3,
                                opencv_core.CvScalar arg4,
                                int arg5,
                                int arg6,
                                int arg7)

cvDrawCircle

public static void cvDrawCircle(opencv_core.CvArr arg1,
                                int[] arg2,
                                int arg3,
                                opencv_core.CvScalar arg4,
                                int arg5,
                                int arg6,
                                int arg7)

cvDrawEllipse

public static void cvDrawEllipse(opencv_core.CvArr arg1,
                                 opencv_core.CvPoint arg2,
                                 opencv_core.CvSize arg3,
                                 double arg4,
                                 double arg5,
                                 double arg6,
                                 opencv_core.CvScalar arg7,
                                 int arg8,
                                 int arg9,
                                 int arg10)

cvDrawEllipse

public static void cvDrawEllipse(opencv_core.CvArr arg1,
                                 IntBuffer arg2,
                                 opencv_core.CvSize arg3,
                                 double arg4,
                                 double arg5,
                                 double arg6,
                                 opencv_core.CvScalar arg7,
                                 int arg8,
                                 int arg9,
                                 int arg10)

cvDrawEllipse

public static void cvDrawEllipse(opencv_core.CvArr arg1,
                                 int[] arg2,
                                 opencv_core.CvSize arg3,
                                 double arg4,
                                 double arg5,
                                 double arg6,
                                 opencv_core.CvScalar arg7,
                                 int arg8,
                                 int arg9,
                                 int arg10)

cvDrawPolyLine

public static void cvDrawPolyLine(opencv_core.CvArr arg1,
                                  PointerPointer arg2,
                                  IntPointer arg3,
                                  int arg4,
                                  int arg5,
                                  opencv_core.CvScalar arg6,
                                  int arg7,
                                  int arg8,
                                  int arg9)

cvDrawPolyLine

public static void cvDrawPolyLine(opencv_core.CvArr arg1,
                                  opencv_core.CvPoint arg2,
                                  IntPointer arg3,
                                  int arg4,
                                  int arg5,
                                  opencv_core.CvScalar arg6,
                                  int arg7,
                                  int arg8,
                                  int arg9)

cvDrawPolyLine

public static void cvDrawPolyLine(opencv_core.CvArr arg1,
                                  IntBuffer arg2,
                                  IntBuffer arg3,
                                  int arg4,
                                  int arg5,
                                  opencv_core.CvScalar arg6,
                                  int arg7,
                                  int arg8,
                                  int arg9)

cvDrawPolyLine

public static void cvDrawPolyLine(opencv_core.CvArr arg1,
                                  int[] arg2,
                                  int[] arg3,
                                  int arg4,
                                  int arg5,
                                  opencv_core.CvScalar arg6,
                                  int arg7,
                                  int arg8,
                                  int arg9)

cvClipLine

public static int cvClipLine(opencv_core.CvSize img_size,
                             opencv_core.CvPoint pt1,
                             opencv_core.CvPoint pt2)

cvClipLine

public static int cvClipLine(opencv_core.CvSize img_size,
                             IntBuffer pt1,
                             IntBuffer pt2)

cvClipLine

public static int cvClipLine(opencv_core.CvSize img_size,
                             int[] pt1,
                             int[] pt2)

cvInitLineIterator

public static int cvInitLineIterator(opencv_core.CvArr image,
                                     opencv_core.CvPoint pt1,
                                     opencv_core.CvPoint pt2,
                                     opencv_core.CvLineIterator line_iterator,
                                     int connectivity,
                                     int left_to_right)

cvInitLineIterator

public static int cvInitLineIterator(opencv_core.CvArr image,
                                     opencv_core.CvPoint pt1,
                                     opencv_core.CvPoint pt2,
                                     opencv_core.CvLineIterator line_iterator)

cvInitLineIterator

public static int cvInitLineIterator(opencv_core.CvArr image,
                                     IntBuffer pt1,
                                     IntBuffer pt2,
                                     opencv_core.CvLineIterator line_iterator,
                                     int connectivity,
                                     int left_to_right)

cvInitLineIterator

public static int cvInitLineIterator(opencv_core.CvArr image,
                                     IntBuffer pt1,
                                     IntBuffer pt2,
                                     opencv_core.CvLineIterator line_iterator)

cvInitLineIterator

public static int cvInitLineIterator(opencv_core.CvArr image,
                                     int[] pt1,
                                     int[] pt2,
                                     opencv_core.CvLineIterator line_iterator,
                                     int connectivity,
                                     int left_to_right)

cvInitLineIterator

public static int cvInitLineIterator(opencv_core.CvArr image,
                                     int[] pt1,
                                     int[] pt2,
                                     opencv_core.CvLineIterator line_iterator)

cvInitFont

public static void cvInitFont(opencv_core.CvFont font,
                              int font_face,
                              double hscale,
                              double vscale,
                              double shear,
                              int thickness,
                              int line_type)

cvInitFont

public static void cvInitFont(opencv_core.CvFont font,
                              int font_face,
                              double hscale,
                              double vscale)

cvFont

public static opencv_core.CvFont cvFont(double scale,
                                        int thickness)

cvFont

public static opencv_core.CvFont cvFont(double scale)

cvPutText

public static void cvPutText(opencv_core.CvArr img,
                             BytePointer text,
                             opencv_core.CvPoint org,
                             opencv_core.CvFont font,
                             opencv_core.CvScalar color)

cvPutText

public static void cvPutText(opencv_core.CvArr img,
                             String text,
                             IntBuffer org,
                             opencv_core.CvFont font,
                             opencv_core.CvScalar color)

cvPutText

public static void cvPutText(opencv_core.CvArr img,
                             BytePointer text,
                             int[] org,
                             opencv_core.CvFont font,
                             opencv_core.CvScalar color)

cvPutText

public static void cvPutText(opencv_core.CvArr img,
                             String text,
                             opencv_core.CvPoint org,
                             opencv_core.CvFont font,
                             opencv_core.CvScalar color)

cvPutText

public static void cvPutText(opencv_core.CvArr img,
                             BytePointer text,
                             IntBuffer org,
                             opencv_core.CvFont font,
                             opencv_core.CvScalar color)

cvPutText

public static void cvPutText(opencv_core.CvArr img,
                             String text,
                             int[] org,
                             opencv_core.CvFont font,
                             opencv_core.CvScalar color)

cvGetTextSize

public static void cvGetTextSize(BytePointer text_string,
                                 opencv_core.CvFont font,
                                 opencv_core.CvSize text_size,
                                 IntPointer baseline)

cvGetTextSize

public static void cvGetTextSize(String text_string,
                                 opencv_core.CvFont font,
                                 opencv_core.CvSize text_size,
                                 IntBuffer baseline)

cvGetTextSize

public static void cvGetTextSize(BytePointer text_string,
                                 opencv_core.CvFont font,
                                 opencv_core.CvSize text_size,
                                 int[] baseline)

cvGetTextSize

public static void cvGetTextSize(String text_string,
                                 opencv_core.CvFont font,
                                 opencv_core.CvSize text_size,
                                 IntPointer baseline)

cvGetTextSize

public static void cvGetTextSize(BytePointer text_string,
                                 opencv_core.CvFont font,
                                 opencv_core.CvSize text_size,
                                 IntBuffer baseline)

cvGetTextSize

public static void cvGetTextSize(String text_string,
                                 opencv_core.CvFont font,
                                 opencv_core.CvSize text_size,
                                 int[] baseline)

cvColorToScalar

public static opencv_core.CvScalar cvColorToScalar(double packed_color,
                                                   int arrtype)

cvEllipse2Poly

public static int cvEllipse2Poly(opencv_core.CvPoint center,
                                 opencv_core.CvSize axes,
                                 int angle,
                                 int arc_start,
                                 int arc_end,
                                 opencv_core.CvPoint pts,
                                 int delta)

cvEllipse2Poly

public static int cvEllipse2Poly(IntBuffer center,
                                 opencv_core.CvSize axes,
                                 int angle,
                                 int arc_start,
                                 int arc_end,
                                 IntBuffer pts,
                                 int delta)

cvEllipse2Poly

public static int cvEllipse2Poly(int[] center,
                                 opencv_core.CvSize axes,
                                 int angle,
                                 int arc_start,
                                 int arc_end,
                                 int[] pts,
                                 int delta)

cvDrawContours

public static void cvDrawContours(opencv_core.CvArr img,
                                  opencv_core.CvSeq contour,
                                  opencv_core.CvScalar external_color,
                                  opencv_core.CvScalar hole_color,
                                  int max_level,
                                  int thickness,
                                  int line_type,
                                  opencv_core.CvPoint offset)

cvDrawContours

public static void cvDrawContours(opencv_core.CvArr img,
                                  opencv_core.CvSeq contour,
                                  opencv_core.CvScalar external_color,
                                  opencv_core.CvScalar hole_color,
                                  int max_level)

cvDrawContours

public static void cvDrawContours(opencv_core.CvArr img,
                                  opencv_core.CvSeq contour,
                                  opencv_core.CvScalar external_color,
                                  opencv_core.CvScalar hole_color,
                                  int max_level,
                                  int thickness,
                                  int line_type,
                                  IntBuffer offset)

cvDrawContours

public static void cvDrawContours(opencv_core.CvArr img,
                                  opencv_core.CvSeq contour,
                                  opencv_core.CvScalar external_color,
                                  opencv_core.CvScalar hole_color,
                                  int max_level,
                                  int thickness,
                                  int line_type,
                                  int[] offset)

cvLUT

public static void cvLUT(opencv_core.CvArr src,
                         opencv_core.CvArr dst,
                         opencv_core.CvArr lut)

cvInitTreeNodeIterator

public static void cvInitTreeNodeIterator(opencv_core.CvTreeNodeIterator tree_iterator,
                                          Pointer first,
                                          int max_level)

cvNextTreeNode

public static Pointer cvNextTreeNode(opencv_core.CvTreeNodeIterator tree_iterator)

cvPrevTreeNode

public static Pointer cvPrevTreeNode(opencv_core.CvTreeNodeIterator tree_iterator)

cvInsertNodeIntoTree

public static void cvInsertNodeIntoTree(Pointer node,
                                        Pointer parent,
                                        Pointer frame)

cvRemoveNodeFromTree

public static void cvRemoveNodeFromTree(Pointer node,
                                        Pointer frame)

cvTreeToNodeSeq

public static opencv_core.CvSeq cvTreeToNodeSeq(Pointer first,
                                                int header_size,
                                                opencv_core.CvMemStorage storage)

cvKMeans2

public static int cvKMeans2(opencv_core.CvArr samples,
                            int cluster_count,
                            opencv_core.CvArr labels,
                            opencv_core.CvTermCriteria termcrit,
                            int attempts,
                            LongPointer rng,
                            int flags,
                            opencv_core.CvArr _centers,
                            DoublePointer compactness)

cvKMeans2

public static int cvKMeans2(opencv_core.CvArr samples,
                            int cluster_count,
                            opencv_core.CvArr labels,
                            opencv_core.CvTermCriteria termcrit)

cvKMeans2

public static int cvKMeans2(opencv_core.CvArr samples,
                            int cluster_count,
                            opencv_core.CvArr labels,
                            opencv_core.CvTermCriteria termcrit,
                            int attempts,
                            LongBuffer rng,
                            int flags,
                            opencv_core.CvArr _centers,
                            DoubleBuffer compactness)

cvKMeans2

public static int cvKMeans2(opencv_core.CvArr samples,
                            int cluster_count,
                            opencv_core.CvArr labels,
                            opencv_core.CvTermCriteria termcrit,
                            int attempts,
                            long[] rng,
                            int flags,
                            opencv_core.CvArr _centers,
                            double[] compactness)

cvRegisterModule
```
public static int cvRegisterModule(opencv_core.CvModuleInfo module_info)
```
\ System functions * \

cvUseOptimized

public static int cvUseOptimized(int on_off)

cvGetModuleInfo

public static void cvGetModuleInfo(BytePointer module_name,
                                   PointerPointer version,
                                   PointerPointer loaded_addon_plugins)

cvGetModuleInfo

public static void cvGetModuleInfo(BytePointer module_name,
                                   BytePointer version,
                                   BytePointer loaded_addon_plugins)

cvGetModuleInfo

public static void cvGetModuleInfo(String module_name,
                                   ByteBuffer version,
                                   ByteBuffer loaded_addon_plugins)

cvGetModuleInfo

public static void cvGetModuleInfo(BytePointer module_name,
                                   byte[] version,
                                   byte[] loaded_addon_plugins)

cvGetModuleInfo

public static void cvGetModuleInfo(String module_name,
                                   BytePointer version,
                                   BytePointer loaded_addon_plugins)

cvGetModuleInfo

public static void cvGetModuleInfo(BytePointer module_name,
                                   ByteBuffer version,
                                   ByteBuffer loaded_addon_plugins)

cvGetModuleInfo

public static void cvGetModuleInfo(String module_name,
                                   byte[] version,
                                   byte[] loaded_addon_plugins)

cvSetMemoryManager

public static void cvSetMemoryManager(opencv_core.CvAllocFunc alloc_func,
                                      opencv_core.CvFreeFunc free_func,
                                      Pointer userdata)

cvSetMemoryManager

public static void cvSetMemoryManager()

cvSetIPLAllocators

public static void cvSetIPLAllocators(opencv_core.Cv_iplCreateImageHeader create_header,
                                      opencv_core.Cv_iplAllocateImageData allocate_data,
                                      opencv_core.Cv_iplDeallocate deallocate,
                                      opencv_core.Cv_iplCreateROI create_roi,
                                      opencv_core.Cv_iplCloneImage clone_image)

cvOpenFileStorage

public static opencv_core.CvFileStorage cvOpenFileStorage(BytePointer filename,
                                                          opencv_core.CvMemStorage memstorage,
                                                          int flags,
                                                          BytePointer encoding)

High-level functions

cvOpenFileStorage

public static opencv_core.CvFileStorage cvOpenFileStorage(BytePointer filename,
                                                          opencv_core.CvMemStorage memstorage,
                                                          int flags)

cvOpenFileStorage

public static opencv_core.CvFileStorage cvOpenFileStorage(String filename,
                                                          opencv_core.CvMemStorage memstorage,
                                                          int flags,
                                                          String encoding)

cvOpenFileStorage

public static opencv_core.CvFileStorage cvOpenFileStorage(String filename,
                                                          opencv_core.CvMemStorage memstorage,
                                                          int flags)

cvReleaseFileStorage

public static void cvReleaseFileStorage(PointerPointer fs)

cvReleaseFileStorage

public static void cvReleaseFileStorage(opencv_core.CvFileStorage fs)

cvAttrValue

public static BytePointer cvAttrValue(opencv_core.CvAttrList attr,
                                      BytePointer attr_name)

cvAttrValue

public static String cvAttrValue(opencv_core.CvAttrList attr,
                                 String attr_name)

cvStartWriteStruct

public static void cvStartWriteStruct(opencv_core.CvFileStorage fs,
                                      BytePointer name,
                                      int struct_flags,
                                      BytePointer type_name,
                                      opencv_core.CvAttrList attributes)

cvStartWriteStruct

public static void cvStartWriteStruct(opencv_core.CvFileStorage fs,
                                      BytePointer name,
                                      int struct_flags)

cvStartWriteStruct

public static void cvStartWriteStruct(opencv_core.CvFileStorage fs,
                                      String name,
                                      int struct_flags,
                                      String type_name,
                                      opencv_core.CvAttrList attributes)

cvStartWriteStruct

public static void cvStartWriteStruct(opencv_core.CvFileStorage fs,
                                      String name,
                                      int struct_flags)

cvEndWriteStruct

public static void cvEndWriteStruct(opencv_core.CvFileStorage fs)

cvWriteInt

public static void cvWriteInt(opencv_core.CvFileStorage fs,
                              BytePointer name,
                              int value)

cvWriteInt

public static void cvWriteInt(opencv_core.CvFileStorage fs,
                              String name,
                              int value)

cvWriteReal

public static void cvWriteReal(opencv_core.CvFileStorage fs,
                               BytePointer name,
                               double value)

cvWriteReal

public static void cvWriteReal(opencv_core.CvFileStorage fs,
                               String name,
                               double value)

cvWriteString

public static void cvWriteString(opencv_core.CvFileStorage fs,
                                 BytePointer name,
                                 BytePointer str,
                                 int quote)

cvWriteString

public static void cvWriteString(opencv_core.CvFileStorage fs,
                                 BytePointer name,
                                 BytePointer str)

cvWriteString

public static void cvWriteString(opencv_core.CvFileStorage fs,
                                 String name,
                                 String str,
                                 int quote)

cvWriteString

public static void cvWriteString(opencv_core.CvFileStorage fs,
                                 String name,
                                 String str)

cvWriteComment

public static void cvWriteComment(opencv_core.CvFileStorage fs,
                                  BytePointer comment,
                                  int eol_comment)

cvWriteComment

public static void cvWriteComment(opencv_core.CvFileStorage fs,
                                  String comment,
                                  int eol_comment)

cvWrite

public static void cvWrite(opencv_core.CvFileStorage fs,
                           BytePointer name,
                           Pointer ptr,
                           opencv_core.CvAttrList attributes)

cvWrite

public static void cvWrite(opencv_core.CvFileStorage fs,
                           BytePointer name,
                           Pointer ptr)

cvWrite

public static void cvWrite(opencv_core.CvFileStorage fs,
                           String name,
                           Pointer ptr,
                           opencv_core.CvAttrList attributes)

cvWrite

public static void cvWrite(opencv_core.CvFileStorage fs,
                           String name,
                           Pointer ptr)

cvStartNextStream

public static void cvStartNextStream(opencv_core.CvFileStorage fs)

cvWriteRawData

public static void cvWriteRawData(opencv_core.CvFileStorage fs,
                                  Pointer src,
                                  int len,
                                  BytePointer dt)

cvWriteRawData

public static void cvWriteRawData(opencv_core.CvFileStorage fs,
                                  Pointer src,
                                  int len,
                                  String dt)

cvGetHashedKey

public static opencv_core.CvStringHashNode cvGetHashedKey(opencv_core.CvFileStorage fs,
                                                          BytePointer name,
                                                          int len,
                                                          int create_missing)

cvGetHashedKey

public static opencv_core.CvStringHashNode cvGetHashedKey(opencv_core.CvFileStorage fs,
                                                          BytePointer name)

cvGetHashedKey

public static opencv_core.CvStringHashNode cvGetHashedKey(opencv_core.CvFileStorage fs,
                                                          String name,
                                                          int len,
                                                          int create_missing)

cvGetHashedKey

public static opencv_core.CvStringHashNode cvGetHashedKey(opencv_core.CvFileStorage fs,
                                                          String name)

cvGetRootFileNode

public static opencv_core.CvFileNode cvGetRootFileNode(opencv_core.CvFileStorage fs,
                                                       int stream_index)

cvGetRootFileNode

public static opencv_core.CvFileNode cvGetRootFileNode(opencv_core.CvFileStorage fs)

cvGetFileNode

public static opencv_core.CvFileNode cvGetFileNode(opencv_core.CvFileStorage fs,
                                                   opencv_core.CvFileNode map,
                                                   opencv_core.CvStringHashNode key,
                                                   int create_missing)

cvGetFileNode

public static opencv_core.CvFileNode cvGetFileNode(opencv_core.CvFileStorage fs,
                                                   opencv_core.CvFileNode map,
                                                   opencv_core.CvStringHashNode key)

cvGetFileNodeByName

public static opencv_core.CvFileNode cvGetFileNodeByName(opencv_core.CvFileStorage fs,
                                                         opencv_core.CvFileNode map,
                                                         BytePointer name)

cvGetFileNodeByName

public static opencv_core.CvFileNode cvGetFileNodeByName(opencv_core.CvFileStorage fs,
                                                         opencv_core.CvFileNode map,
                                                         String name)

cvReadInt

public static int cvReadInt(opencv_core.CvFileNode node,
                            int default_value)

cvReadInt

public static int cvReadInt(opencv_core.CvFileNode node)

cvReadIntByName

public static int cvReadIntByName(opencv_core.CvFileStorage fs,
                                  opencv_core.CvFileNode map,
                                  BytePointer name,
                                  int default_value)

cvReadIntByName

public static int cvReadIntByName(opencv_core.CvFileStorage fs,
                                  opencv_core.CvFileNode map,
                                  BytePointer name)

cvReadIntByName

public static int cvReadIntByName(opencv_core.CvFileStorage fs,
                                  opencv_core.CvFileNode map,
                                  String name,
                                  int default_value)

cvReadIntByName

public static int cvReadIntByName(opencv_core.CvFileStorage fs,
                                  opencv_core.CvFileNode map,
                                  String name)

cvReadReal

public static double cvReadReal(opencv_core.CvFileNode node,
                                double default_value)

cvReadReal

public static double cvReadReal(opencv_core.CvFileNode node)

cvReadRealByName

public static double cvReadRealByName(opencv_core.CvFileStorage fs,
                                      opencv_core.CvFileNode map,
                                      BytePointer name,
                                      double default_value)

cvReadRealByName

public static double cvReadRealByName(opencv_core.CvFileStorage fs,
                                      opencv_core.CvFileNode map,
                                      BytePointer name)

cvReadRealByName

public static double cvReadRealByName(opencv_core.CvFileStorage fs,
                                      opencv_core.CvFileNode map,
                                      String name,
                                      double default_value)

cvReadRealByName

public static double cvReadRealByName(opencv_core.CvFileStorage fs,
                                      opencv_core.CvFileNode map,
                                      String name)

cvReadString

public static BytePointer cvReadString(opencv_core.CvFileNode node,
                                       BytePointer default_value)

cvReadString

public static BytePointer cvReadString(opencv_core.CvFileNode node)

cvReadString

public static String cvReadString(opencv_core.CvFileNode node,
                                  String default_value)

cvReadStringByName

public static BytePointer cvReadStringByName(opencv_core.CvFileStorage fs,
                                             opencv_core.CvFileNode map,
                                             BytePointer name,
                                             BytePointer default_value)

cvReadStringByName

public static BytePointer cvReadStringByName(opencv_core.CvFileStorage fs,
                                             opencv_core.CvFileNode map,
                                             BytePointer name)

cvReadStringByName

public static String cvReadStringByName(opencv_core.CvFileStorage fs,
                                        opencv_core.CvFileNode map,
                                        String name,
                                        String default_value)

cvReadStringByName

public static String cvReadStringByName(opencv_core.CvFileStorage fs,
                                        opencv_core.CvFileNode map,
                                        String name)

cvRead

public static Pointer cvRead(opencv_core.CvFileStorage fs,
                             opencv_core.CvFileNode node,
                             opencv_core.CvAttrList attributes)

cvRead

public static Pointer cvRead(opencv_core.CvFileStorage fs,
                             opencv_core.CvFileNode node)

cvReadByName

public static Pointer cvReadByName(opencv_core.CvFileStorage fs,
                                   opencv_core.CvFileNode map,
                                   BytePointer name,
                                   opencv_core.CvAttrList attributes)

cvReadByName

public static Pointer cvReadByName(opencv_core.CvFileStorage fs,
                                   opencv_core.CvFileNode map,
                                   BytePointer name)

cvReadByName

public static Pointer cvReadByName(opencv_core.CvFileStorage fs,
                                   opencv_core.CvFileNode map,
                                   String name,
                                   opencv_core.CvAttrList attributes)

cvReadByName

public static Pointer cvReadByName(opencv_core.CvFileStorage fs,
                                   opencv_core.CvFileNode map,
                                   String name)

cvStartReadRawData

public static void cvStartReadRawData(opencv_core.CvFileStorage fs,
                                      opencv_core.CvFileNode src,
                                      opencv_core.CvSeqReader reader)

cvReadRawDataSlice

public static void cvReadRawDataSlice(opencv_core.CvFileStorage fs,
                                      opencv_core.CvSeqReader reader,
                                      int count,
                                      Pointer dst,
                                      BytePointer dt)

cvReadRawDataSlice

public static void cvReadRawDataSlice(opencv_core.CvFileStorage fs,
                                      opencv_core.CvSeqReader reader,
                                      int count,
                                      Pointer dst,
                                      String dt)

cvReadRawData

public static void cvReadRawData(opencv_core.CvFileStorage fs,
                                 opencv_core.CvFileNode src,
                                 Pointer dst,
                                 BytePointer dt)

cvReadRawData

public static void cvReadRawData(opencv_core.CvFileStorage fs,
                                 opencv_core.CvFileNode src,
                                 Pointer dst,
                                 String dt)

cvWriteFileNode

public static void cvWriteFileNode(opencv_core.CvFileStorage fs,
                                   BytePointer new_node_name,
                                   opencv_core.CvFileNode node,
                                   int embed)

cvWriteFileNode

public static void cvWriteFileNode(opencv_core.CvFileStorage fs,
                                   String new_node_name,
                                   opencv_core.CvFileNode node,
                                   int embed)

cvGetFileNodeName

public static BytePointer cvGetFileNodeName(opencv_core.CvFileNode node)

cvRegisterType

public static void cvRegisterType(opencv_core.CvTypeInfo info)

Adding own types

cvUnregisterType

public static void cvUnregisterType(BytePointer type_name)

cvUnregisterType

public static void cvUnregisterType(String type_name)

cvFirstType

public static opencv_core.CvTypeInfo cvFirstType()

cvFindType

public static opencv_core.CvTypeInfo cvFindType(BytePointer type_name)

cvFindType

public static opencv_core.CvTypeInfo cvFindType(String type_name)

cvTypeOf

public static opencv_core.CvTypeInfo cvTypeOf(Pointer struct_ptr)

cvRelease

public static void cvRelease(PointerPointer struct_ptr)

cvRelease

public static void cvRelease(Pointer struct_ptr)

cvClone

public static Pointer cvClone(Pointer struct_ptr)

cvSave

public static void cvSave(BytePointer filename,
                          Pointer struct_ptr,
                          BytePointer name,
                          BytePointer comment,
                          opencv_core.CvAttrList attributes)

cvSave

public static void cvSave(BytePointer filename,
                          Pointer struct_ptr)

cvSave

public static void cvSave(String filename,
                          Pointer struct_ptr,
                          String name,
                          String comment,
                          opencv_core.CvAttrList attributes)

cvSave

public static void cvSave(String filename,
                          Pointer struct_ptr)

cvLoad

public static Pointer cvLoad(BytePointer filename,
                             opencv_core.CvMemStorage memstorage,
                             BytePointer name,
                             PointerPointer real_name)

cvLoad

public static Pointer cvLoad(BytePointer filename)

cvLoad

public static Pointer cvLoad(BytePointer filename,
                             opencv_core.CvMemStorage memstorage,
                             BytePointer name,
                             BytePointer real_name)

cvLoad

public static Pointer cvLoad(String filename,
                             opencv_core.CvMemStorage memstorage,
                             String name,
                             ByteBuffer real_name)

cvLoad

public static Pointer cvLoad(String filename)

cvLoad

public static Pointer cvLoad(BytePointer filename,
                             opencv_core.CvMemStorage memstorage,
                             BytePointer name,
                             byte[] real_name)

cvLoad

public static Pointer cvLoad(String filename,
                             opencv_core.CvMemStorage memstorage,
                             String name,
                             BytePointer real_name)

cvLoad

public static Pointer cvLoad(BytePointer filename,
                             opencv_core.CvMemStorage memstorage,
                             BytePointer name,
                             ByteBuffer real_name)

cvLoad

public static Pointer cvLoad(String filename,
                             opencv_core.CvMemStorage memstorage,
                             String name,
                             byte[] real_name)

cvGetTickCount
```
public static long cvGetTickCount()
```
Measuring Execution Time

cvGetTickFrequency

public static double cvGetTickFrequency()

cvCheckHardwareSupport

public static int cvCheckHardwareSupport(int feature)

cvGetNumThreads
```
public static int cvGetNumThreads()
```
Multi-Threading

cvSetNumThreads

public static void cvSetNumThreads(int threads)

cvSetNumThreads
```
public static void cvSetNumThreads()
```

cvGetThreadNum
```
public static int cvGetThreadNum()
```

cvGetErrStatus
```
public static int cvGetErrStatus()
```
Error Handling

cvSetErrStatus

public static void cvSetErrStatus(int status)

cvGetErrMode
```
public static int cvGetErrMode()
```

cvSetErrMode

public static int cvSetErrMode(int mode)

cvError

public static void cvError(int status,
                           BytePointer func_name,
                           BytePointer err_msg,
                           BytePointer file_name,
                           int line)

cvError

public static void cvError(int status,
                           String func_name,
                           String err_msg,
                           String file_name,
                           int line)

cvErrorStr

public static BytePointer cvErrorStr(int status)

cvGetErrInfo

public static int cvGetErrInfo(PointerPointer errcode_desc,
                               PointerPointer description,
                               PointerPointer filename,
                               IntPointer line)

cvGetErrInfo

public static int cvGetErrInfo(BytePointer errcode_desc,
                               BytePointer description,
                               BytePointer filename,
                               IntPointer line)

cvGetErrInfo

public static int cvGetErrInfo(ByteBuffer errcode_desc,
                               ByteBuffer description,
                               ByteBuffer filename,
                               IntBuffer line)

cvGetErrInfo

public static int cvGetErrInfo(byte[] errcode_desc,
                               byte[] description,
                               byte[] filename,
                               int[] line)

cvErrorFromIppStatus

public static int cvErrorFromIppStatus(int ipp_status)

cvRedirectError

public static opencv_core.CvErrorCallback cvRedirectError(opencv_core.CvErrorCallback error_handler,
                                                          Pointer userdata,
                                                          PointerPointer prev_userdata)

cvRedirectError

public static opencv_core.CvErrorCallback cvRedirectError(opencv_core.CvErrorCallback error_handler)

cvRedirectError

public static opencv_core.CvErrorCallback cvRedirectError(opencv_core.CvErrorCallback error_handler,
                                                          Pointer userdata,
                                                          Pointer prev_userdata)

cvNulDevReport

public static int cvNulDevReport(int status,
                                 BytePointer func_name,
                                 BytePointer err_msg,
                                 BytePointer file_name,
                                 int line,
                                 Pointer userdata)

cvNulDevReport

public static int cvNulDevReport(int status,
                                 String func_name,
                                 String err_msg,
                                 String file_name,
                                 int line,
                                 Pointer userdata)

cvStdErrReport

public static int cvStdErrReport(int status,
                                 BytePointer func_name,
                                 BytePointer err_msg,
                                 BytePointer file_name,
                                 int line,
                                 Pointer userdata)

cvStdErrReport

public static int cvStdErrReport(int status,
                                 String func_name,
                                 String err_msg,
                                 String file_name,
                                 int line,
                                 Pointer userdata)

cvGuiBoxReport

public static int cvGuiBoxReport(int status,
                                 BytePointer func_name,
                                 BytePointer err_msg,
                                 BytePointer file_name,
                                 int line,
                                 Pointer userdata)

cvGuiBoxReport

public static int cvGuiBoxReport(int status,
                                 String func_name,
                                 String err_msg,
                                 String file_name,
                                 int line,
                                 Pointer userdata)

format

public static BytePointer format(BytePointer fmt)

format

public static String format(String fmt)

tempfile

public static BytePointer tempfile(BytePointer suffix)

tempfile
```
public static BytePointer tempfile()
```

tempfile

public static String tempfile(String suffix)

setBreakOnError
```
public static boolean setBreakOnError(boolean flag)
```
Sets/resets the break-on-error mode. /** When the break-on-error mode is set, the default error handler issues a hardware exception, which can make debugging more convenient. \return the previous state

redirectError
```
public static opencv_core.ErrorCallback redirectError(opencv_core.ErrorCallback errCallback,
                                                      Pointer userdata,
                                                      PointerPointer prevUserdata)
```
Sets the new error handler and the optional user data. /** The function sets the new error handler, called from cv::error(). \param errCallback the new error handler. If NULL, the default error handler is used. \param userdata the optional user data pointer, passed to the callback. \param prevUserdata the optional output parameter where the previous user data pointer is stored \return the previous error handler

redirectError

public static opencv_core.ErrorCallback redirectError(opencv_core.ErrorCallback errCallback)

redirectError

public static opencv_core.ErrorCallback redirectError(opencv_core.ErrorCallback errCallback,
                                                      Pointer userdata,
                                                      Pointer prevUserdata)

glob

public static void glob(BytePointer pattern,
                        opencv_core.StringVector result,
                        boolean recursive)

glob

public static void glob(BytePointer pattern,
                        opencv_core.StringVector result)

glob

public static void glob(String pattern,
                        opencv_core.StringVector result,
                        boolean recursive)

glob

public static void glob(String pattern,
                        opencv_core.StringVector result)

setNumThreads

public static void setNumThreads(int nthreads)

getNumThreads
```
public static int getNumThreads()
```

getThreadNum
```
public static int getThreadNum()
```

getBuildInformation

public static BytePointer getBuildInformation()

getTickCount
```
public static long getTickCount()
```
Returns the number of ticks. /** The function returns the number of ticks since the certain event (e.g. when the machine was turned on). It can be used to initialize cv::RNG or to measure a function execution time by reading the tick count before and after the function call. The granularity of ticks depends on the hardware and OS used. Use cv::getTickFrequency() to convert ticks to seconds.

getTickFrequency
```
public static double getTickFrequency()
```
Returns the number of ticks per seconds. The function returns the number of ticks (as returned by cv::getTickCount()) per second. The following code computes the execution time in milliseconds: \code double exec_time = (double)getTickCount(); // do something ... exec_time = ((double)getTickCount() - exec_time)*1000./getTickFrequency(); \endcode

getCPUTickCount
```
public static long getCPUTickCount()
```
Returns the number of CPU ticks. On platforms where the feature is available, the function returns the number of CPU ticks since the certain event (normally, the system power-on moment). Using this function one can accurately measure the execution time of very small code fragments, for which cv::getTickCount() granularity is not enough.

checkHardwareSupport
```
public static boolean checkHardwareSupport(int feature)
```
Returns SSE etc. support status The function returns true if certain hardware features are available. Currently, the following features are recognized: - CV_CPU_MMX - MMX - CV_CPU_SSE - SSE - CV_CPU_SSE2 - SSE 2 - CV_CPU_SSE3 - SSE 3 - CV_CPU_SSSE3 - SSSE 3 - CV_CPU_SSE4_1 - SSE 4.1 - CV_CPU_SSE4_2 - SSE 4.2 - CV_CPU_POPCNT - POPCOUNT - CV_CPU_AVX - AVX - CV_CPU_AVX2 - AVX2 \note {Note that the function output is not static. Once you called cv::useOptimized(false), most of the hardware acceleration is disabled and thus the function will returns false, until you call cv::useOptimized(true)}

getNumberOfCPUs
```
public static int getNumberOfCPUs()
```
returns the number of CPUs (including hyper-threading)

fastMalloc
```
public static Pointer fastMalloc(long bufSize)
```
Allocates memory buffer This is specialized OpenCV memory allocation function that returns properly aligned memory buffers. The usage is identical to malloc(). The allocated buffers must be freed with cv::fastFree(). If there is not enough memory, the function calls cv::error(), which raises an exception. \param bufSize buffer size in bytes \return the allocated memory buffer.

fastFree
```
public static void fastFree(Pointer ptr)
```
Frees the memory allocated with cv::fastMalloc This is the corresponding deallocation function for cv::fastMalloc(). When ptr==NULL, the function has no effect.

alignSize
```
public static long alignSize(long sz,
                             int n)
```
Aligns buffer size by the certain number of bytes This small inline function aligns a buffer size by the certian number of bytes by enlarging it.

setUseOptimized
```
public static void setUseOptimized(boolean onoff)
```
Turns on/off available optimization The function turns on or off the optimized code in OpenCV. Some optimization can not be enabled or disabled, but, for example, most of SSE code in OpenCV can be temporarily turned on or off this way. \note{Since optimization may imply using special data structures, it may be unsafe to call this function anywhere in the code. Instead, call it somewhere at the top level.}

useOptimized
```
public static boolean useOptimized()
```
Returns the current optimization status The function returns the current optimization status, which is controlled by cv::setUseOptimized().

scalarToRawData

public static void scalarToRawData(opencv_core.Scalar s,
                                   Pointer buf,
                                   int type,
                                   int unroll_to)

scalarToRawData

public static void scalarToRawData(opencv_core.Scalar s,
                                   Pointer buf,
                                   int type)

getElemSize

public static long getElemSize(int type)

getConvertFunc

public static opencv_core.BinaryFunc getConvertFunc(int sdepth,
                                                    int ddepth)

getConvertScaleFunc

public static opencv_core.BinaryFunc getConvertScaleFunc(int sdepth,
                                                         int ddepth)

getCopyMaskFunc

public static opencv_core.BinaryFunc getCopyMaskFunc(long esz)

swap

public static void swap(opencv_core.Mat a,
                        opencv_core.Mat b)

swaps two matrices

cvarrToMat

public static opencv_core.Mat cvarrToMat(opencv_core.CvArr arr,
                                         boolean copyData,
                                         boolean allowND,
                                         int coiMode)

converts array (CvMat or IplImage) to cv::Mat

cvarrToMat

public static opencv_core.Mat cvarrToMat(opencv_core.CvArr arr)

extractImageCOI

public static void extractImageCOI(opencv_core.CvArr arr,
                                   opencv_core.Mat coiimg,
                                   int coi)

extracts Channel of Interest from CvMat or IplImage and makes cv::Mat out of it.

extractImageCOI

public static void extractImageCOI(opencv_core.CvArr arr,
                                   opencv_core.Mat coiimg)

insertImageCOI

public static void insertImageCOI(opencv_core.Mat coiimg,
                                  opencv_core.CvArr arr,
                                  int coi)

inserts single-channel cv::Mat into a multi-channel CvMat or IplImage

insertImageCOI

public static void insertImageCOI(opencv_core.Mat coiimg,
                                  opencv_core.CvArr arr)

add

public static void add(opencv_core.Mat src1,
                       opencv_core.Mat src2,
                       opencv_core.Mat dst,
                       opencv_core.Mat mask,
                       int dtype)

adds one matrix to another (dst = src1 + src2)

add

public static void add(opencv_core.Mat src1,
                       opencv_core.Mat src2,
                       opencv_core.Mat dst)

subtract

public static void subtract(opencv_core.Mat src1,
                            opencv_core.Mat src2,
                            opencv_core.Mat dst,
                            opencv_core.Mat mask,
                            int dtype)

subtracts one matrix from another (dst = src1 - src2)

subtract

public static void subtract(opencv_core.Mat src1,
                            opencv_core.Mat src2,
                            opencv_core.Mat dst)

multiply

public static void multiply(opencv_core.Mat src1,
                            opencv_core.Mat src2,
                            opencv_core.Mat dst,
                            double scale,
                            int dtype)

computes element-wise weighted product of the two arrays (dst = scale*src1*src2)

multiply

public static void multiply(opencv_core.Mat src1,
                            opencv_core.Mat src2,
                            opencv_core.Mat dst)

divide

public static void divide(opencv_core.Mat src1,
                          opencv_core.Mat src2,
                          opencv_core.Mat dst,
                          double scale,
                          int dtype)

computes element-wise weighted quotient of the two arrays (dst = scale*src1/src2)

divide

public static void divide(opencv_core.Mat src1,
                          opencv_core.Mat src2,
                          opencv_core.Mat dst)

divide

public static void divide(double scale,
                          opencv_core.Mat src2,
                          opencv_core.Mat dst,
                          int dtype)

computes element-wise weighted reciprocal of an array (dst = scale/src2)

divide

public static void divide(double scale,
                          opencv_core.Mat src2,
                          opencv_core.Mat dst)

scaleAdd

public static void scaleAdd(opencv_core.Mat src1,
                            double alpha,
                            opencv_core.Mat src2,
                            opencv_core.Mat dst)

adds scaled array to another one (dst = alpha*src1 + src2)

addWeighted

public static void addWeighted(opencv_core.Mat src1,
                               double alpha,
                               opencv_core.Mat src2,
                               double beta,
                               double gamma,
                               opencv_core.Mat dst,
                               int dtype)

computes weighted sum of two arrays (dst = alpha*src1 + beta*src2 + gamma)

addWeighted

public static void addWeighted(opencv_core.Mat src1,
                               double alpha,
                               opencv_core.Mat src2,
                               double beta,
                               double gamma,
                               opencv_core.Mat dst)

convertScaleAbs

public static void convertScaleAbs(opencv_core.Mat src,
                                   opencv_core.Mat dst,
                                   double alpha,
                                   double beta)

scales array elements, computes absolute values and converts the results to 8-bit unsigned integers: dst(i)=saturate_castabs(src(i)*alpha+beta)

convertScaleAbs

public static void convertScaleAbs(opencv_core.Mat src,
                                   opencv_core.Mat dst)

LUT

public static void LUT(opencv_core.Mat src,
                       opencv_core.Mat lut,
                       opencv_core.Mat dst,
                       int interpolation)

transforms array of numbers using a lookup table: dst(i)=lut(src(i))

LUT

public static void LUT(opencv_core.Mat src,
                       opencv_core.Mat lut,
                       opencv_core.Mat dst)

sumElems

public static opencv_core.Scalar sumElems(opencv_core.Mat src)

computes sum of array elements

countNonZero
```
public static int countNonZero(opencv_core.Mat src)
```
computes the number of nonzero array elements

findNonZero

public static void findNonZero(opencv_core.Mat src,
                               opencv_core.Mat idx)

returns the list of locations of non-zero pixels

mean

public static opencv_core.Scalar mean(opencv_core.Mat src,
                                      opencv_core.Mat mask)

computes mean value of selected array elements

mean

public static opencv_core.Scalar mean(opencv_core.Mat src)

meanStdDev

public static void meanStdDev(opencv_core.Mat src,
                              opencv_core.Mat mean,
                              opencv_core.Mat stddev,
                              opencv_core.Mat mask)

computes mean value and standard deviation of all or selected array elements

meanStdDev

public static void meanStdDev(opencv_core.Mat src,
                              opencv_core.Mat mean,
                              opencv_core.Mat stddev)

norm

public static double norm(opencv_core.Mat src1,
                          int normType,
                          opencv_core.Mat mask)

computes norm of the selected array part

norm

public static double norm(opencv_core.Mat src1)

norm

public static double norm(opencv_core.Mat src1,
                          opencv_core.Mat src2,
                          int normType,
                          opencv_core.Mat mask)

computes norm of selected part of the difference between two arrays

norm

public static double norm(opencv_core.Mat src1,
                          opencv_core.Mat src2)

batchDistance

public static void batchDistance(opencv_core.Mat src1,
                                 opencv_core.Mat src2,
                                 opencv_core.Mat dist,
                                 int dtype,
                                 opencv_core.Mat nidx,
                                 int normType,
                                 int K,
                                 opencv_core.Mat mask,
                                 int update,
                                 boolean crosscheck)

naive nearest neighbor finder

batchDistance

public static void batchDistance(opencv_core.Mat src1,
                                 opencv_core.Mat src2,
                                 opencv_core.Mat dist,
                                 int dtype,
                                 opencv_core.Mat nidx)

normalize

public static void normalize(opencv_core.Mat src,
                             opencv_core.Mat dst,
                             double alpha,
                             double beta,
                             int norm_type,
                             int dtype,
                             opencv_core.Mat mask)

scales and shifts array elements so that either the specified norm (alpha) or the minimum (alpha) and maximum (beta) array values get the specified values

normalize

public static void normalize(opencv_core.Mat src,
                             opencv_core.Mat dst)

minMaxLoc

public static void minMaxLoc(opencv_core.Mat src,
                             DoublePointer minVal,
                             DoublePointer maxVal,
                             opencv_core.Point minLoc,
                             opencv_core.Point maxLoc,
                             opencv_core.Mat mask)

finds global minimum and maximum array elements and returns their values and their locations

minMaxLoc

public static void minMaxLoc(opencv_core.Mat src,
                             DoublePointer minVal)

minMaxLoc

public static void minMaxLoc(opencv_core.Mat src,
                             DoubleBuffer minVal,
                             DoubleBuffer maxVal,
                             opencv_core.Point minLoc,
                             opencv_core.Point maxLoc,
                             opencv_core.Mat mask)

minMaxLoc

public static void minMaxLoc(opencv_core.Mat src,
                             DoubleBuffer minVal)

minMaxLoc

public static void minMaxLoc(opencv_core.Mat src,
                             double[] minVal,
                             double[] maxVal,
                             opencv_core.Point minLoc,
                             opencv_core.Point maxLoc,
                             opencv_core.Mat mask)

minMaxLoc

public static void minMaxLoc(opencv_core.Mat src,
                             double[] minVal)

minMaxIdx

public static void minMaxIdx(opencv_core.Mat src,
                             DoublePointer minVal,
                             DoublePointer maxVal,
                             IntPointer minIdx,
                             IntPointer maxIdx,
                             opencv_core.Mat mask)

minMaxIdx

public static void minMaxIdx(opencv_core.Mat src,
                             DoublePointer minVal,
                             DoublePointer maxVal)

minMaxIdx

public static void minMaxIdx(opencv_core.Mat src,
                             DoubleBuffer minVal,
                             DoubleBuffer maxVal,
                             IntBuffer minIdx,
                             IntBuffer maxIdx,
                             opencv_core.Mat mask)

minMaxIdx

public static void minMaxIdx(opencv_core.Mat src,
                             DoubleBuffer minVal,
                             DoubleBuffer maxVal)

minMaxIdx

public static void minMaxIdx(opencv_core.Mat src,
                             double[] minVal,
                             double[] maxVal,
                             int[] minIdx,
                             int[] maxIdx,
                             opencv_core.Mat mask)

minMaxIdx

public static void minMaxIdx(opencv_core.Mat src,
                             double[] minVal,
                             double[] maxVal)

reduce

public static void reduce(opencv_core.Mat src,
                          opencv_core.Mat dst,
                          int dim,
                          int rtype,
                          int dtype)

transforms 2D matrix to 1D row or column vector by taking sum, minimum, maximum or mean value over all the rows

reduce

public static void reduce(opencv_core.Mat src,
                          opencv_core.Mat dst,
                          int dim,
                          int rtype)

merge

public static void merge(opencv_core.Mat mv,
                         long count,
                         opencv_core.Mat dst)

makes multi-channel array out of several single-channel arrays

merge

public static void merge(opencv_core.MatVector mv,
                         opencv_core.Mat dst)

split

public static void split(opencv_core.Mat src,
                         opencv_core.Mat mvbegin)

copies each plane of a multi-channel array to a dedicated array

split

public static void split(opencv_core.Mat m,
                         opencv_core.MatVector mv)

mixChannels

public static void mixChannels(opencv_core.Mat src,
                               long nsrcs,
                               opencv_core.Mat dst,
                               long ndsts,
                               IntPointer fromTo,
                               long npairs)

copies selected channels from the input arrays to the selected channels of the output arrays

mixChannels

public static void mixChannels(opencv_core.Mat src,
                               long nsrcs,
                               opencv_core.Mat dst,
                               long ndsts,
                               IntBuffer fromTo,
                               long npairs)

mixChannels

public static void mixChannels(opencv_core.Mat src,
                               long nsrcs,
                               opencv_core.Mat dst,
                               long ndsts,
                               int[] fromTo,
                               long npairs)

mixChannels

public static void mixChannels(opencv_core.MatVector src,
                               opencv_core.MatVector dst,
                               IntPointer fromTo,
                               long npairs)

mixChannels

public static void mixChannels(opencv_core.MatVector src,
                               opencv_core.MatVector dst,
                               IntBuffer fromTo,
                               long npairs)

mixChannels

public static void mixChannels(opencv_core.MatVector src,
                               opencv_core.MatVector dst,
                               int[] fromTo,
                               long npairs)

mixChannels

public static void mixChannels(opencv_core.MatVector src,
                               opencv_core.MatVector dst,
                               IntPointer fromTo)

mixChannels

public static void mixChannels(opencv_core.MatVector src,
                               opencv_core.MatVector dst,
                               IntBuffer fromTo)

mixChannels

public static void mixChannels(opencv_core.MatVector src,
                               opencv_core.MatVector dst,
                               int[] fromTo)

extractChannel

public static void extractChannel(opencv_core.Mat src,
                                  opencv_core.Mat dst,
                                  int coi)

extracts a single channel from src (coi is 0-based index)

insertChannel

public static void insertChannel(opencv_core.Mat src,
                                 opencv_core.Mat dst,
                                 int coi)

inserts a single channel to dst (coi is 0-based index)

flip

public static void flip(opencv_core.Mat src,
                        opencv_core.Mat dst,
                        int flipCode)

reverses the order of the rows, columns or both in a matrix

repeat

public static void repeat(opencv_core.Mat src,
                          int ny,
                          int nx,
                          opencv_core.Mat dst)

replicates the input matrix the specified number of times in the horizontal and/or vertical direction

repeat

public static opencv_core.Mat repeat(opencv_core.Mat src,
                                     int ny,
                                     int nx)

hconcat

public static void hconcat(opencv_core.Mat src,
                           long nsrc,
                           opencv_core.Mat dst)

hconcat

public static void hconcat(opencv_core.Mat src1,
                           opencv_core.Mat src2,
                           opencv_core.Mat dst)

hconcat

public static void hconcat(opencv_core.MatVector src,
                           opencv_core.Mat dst)

vconcat

public static void vconcat(opencv_core.Mat src,
                           long nsrc,
                           opencv_core.Mat dst)

vconcat

public static void vconcat(opencv_core.Mat src1,
                           opencv_core.Mat src2,
                           opencv_core.Mat dst)

vconcat

public static void vconcat(opencv_core.MatVector src,
                           opencv_core.Mat dst)

bitwise_and

public static void bitwise_and(opencv_core.Mat src1,
                               opencv_core.Mat src2,
                               opencv_core.Mat dst,
                               opencv_core.Mat mask)

computes bitwise conjunction of the two arrays (dst = src1 & src2)

bitwise_and

public static void bitwise_and(opencv_core.Mat src1,
                               opencv_core.Mat src2,
                               opencv_core.Mat dst)

bitwise_or

public static void bitwise_or(opencv_core.Mat src1,
                              opencv_core.Mat src2,
                              opencv_core.Mat dst,
                              opencv_core.Mat mask)

computes bitwise disjunction of the two arrays (dst = src1 | src2)

bitwise_or

public static void bitwise_or(opencv_core.Mat src1,
                              opencv_core.Mat src2,
                              opencv_core.Mat dst)

bitwise_xor

public static void bitwise_xor(opencv_core.Mat src1,
                               opencv_core.Mat src2,
                               opencv_core.Mat dst,
                               opencv_core.Mat mask)

computes bitwise exclusive-or of the two arrays (dst = src1 ^ src2)

bitwise_xor

public static void bitwise_xor(opencv_core.Mat src1,
                               opencv_core.Mat src2,
                               opencv_core.Mat dst)

bitwise_not

public static void bitwise_not(opencv_core.Mat src,
                               opencv_core.Mat dst,
                               opencv_core.Mat mask)

inverts each bit of array (dst = ~src)

bitwise_not

public static void bitwise_not(opencv_core.Mat src,
                               opencv_core.Mat dst)

absdiff

public static void absdiff(opencv_core.Mat src1,
                           opencv_core.Mat src2,
                           opencv_core.Mat dst)

computes element-wise absolute difference of two arrays (dst = abs(src1 - src2))

inRange

public static void inRange(opencv_core.Mat src,
                           opencv_core.Mat lowerb,
                           opencv_core.Mat upperb,
                           opencv_core.Mat dst)

set mask elements for those array elements which are within the element-specific bounding box (dst = lowerb <= src && src < upperb)

compare

public static void compare(opencv_core.Mat src1,
                           opencv_core.Mat src2,
                           opencv_core.Mat dst,
                           int cmpop)

compares elements of two arrays (dst = src1 src2)

min

public static void min(opencv_core.Mat src1,
                       opencv_core.Mat src2,
                       opencv_core.Mat dst)

computes per-element minimum of two arrays (dst = min(src1, src2))

max

public static void max(opencv_core.Mat src1,
                       opencv_core.Mat src2,
                       opencv_core.Mat dst)

computes per-element maximum of two arrays (dst = max(src1, src2))

min

public static void min(opencv_core.Mat src1,
                       double src2,
                       opencv_core.Mat dst)

computes per-element minimum of array and scalar (dst = min(src1, src2))

max

public static void max(opencv_core.Mat src1,
                       double src2,
                       opencv_core.Mat dst)

computes per-element maximum of array and scalar (dst = max(src1, src2))

sqrt

public static void sqrt(opencv_core.Mat src,
                        opencv_core.Mat dst)

computes square root of each matrix element (dst = src**0.5)

pow

public static void pow(opencv_core.Mat src,
                       double power,
                       opencv_core.Mat dst)

raises the input matrix elements to the specified power (b = a**power)

exp

public static void exp(opencv_core.Mat src,
                       opencv_core.Mat dst)

computes exponent of each matrix element (dst = e**src)

log

public static void log(opencv_core.Mat src,
                       opencv_core.Mat dst)

computes natural logarithm of absolute value of each matrix element: dst = log(abs(src))

cubeRoot

public static float cubeRoot(float val)

computes cube root of the argument

fastAtan2

public static float fastAtan2(float y,
                              float x)

computes the angle in degrees (0..360) of the vector (x,y)

exp

public static void exp(FloatPointer src,
                       FloatPointer dst,
                       int n)

exp

public static void exp(FloatBuffer src,
                       FloatBuffer dst,
                       int n)

exp

public static void exp(float[] src,
                       float[] dst,
                       int n)

log

public static void log(FloatPointer src,
                       FloatPointer dst,
                       int n)

log

public static void log(FloatBuffer src,
                       FloatBuffer dst,
                       int n)

log

public static void log(float[] src,
                       float[] dst,
                       int n)

fastAtan2

public static void fastAtan2(FloatPointer y,
                             FloatPointer x,
                             FloatPointer dst,
                             int n,
                             boolean angleInDegrees)

fastAtan2

public static void fastAtan2(FloatBuffer y,
                             FloatBuffer x,
                             FloatBuffer dst,
                             int n,
                             boolean angleInDegrees)

fastAtan2

public static void fastAtan2(float[] y,
                             float[] x,
                             float[] dst,
                             int n,
                             boolean angleInDegrees)

magnitude

public static void magnitude(FloatPointer x,
                             FloatPointer y,
                             FloatPointer dst,
                             int n)

magnitude

public static void magnitude(FloatBuffer x,
                             FloatBuffer y,
                             FloatBuffer dst,
                             int n)

magnitude

public static void magnitude(float[] x,
                             float[] y,
                             float[] dst,
                             int n)

polarToCart

public static void polarToCart(opencv_core.Mat magnitude,
                               opencv_core.Mat angle,
                               opencv_core.Mat x,
                               opencv_core.Mat y,
                               boolean angleInDegrees)

converts polar coordinates to Cartesian

polarToCart

public static void polarToCart(opencv_core.Mat magnitude,
                               opencv_core.Mat angle,
                               opencv_core.Mat x,
                               opencv_core.Mat y)

cartToPolar

public static void cartToPolar(opencv_core.Mat x,
                               opencv_core.Mat y,
                               opencv_core.Mat magnitude,
                               opencv_core.Mat angle,
                               boolean angleInDegrees)

converts Cartesian coordinates to polar

cartToPolar

public static void cartToPolar(opencv_core.Mat x,
                               opencv_core.Mat y,
                               opencv_core.Mat magnitude,
                               opencv_core.Mat angle)

phase

public static void phase(opencv_core.Mat x,
                         opencv_core.Mat y,
                         opencv_core.Mat angle,
                         boolean angleInDegrees)

computes angle (angle(i)) of each (x(i), y(i)) vector

phase

public static void phase(opencv_core.Mat x,
                         opencv_core.Mat y,
                         opencv_core.Mat angle)

magnitude

public static void magnitude(opencv_core.Mat x,
                             opencv_core.Mat y,
                             opencv_core.Mat magnitude)

computes magnitude (magnitude(i)) of each (x(i), y(i)) vector

checkRange

public static boolean checkRange(opencv_core.Mat a,
                                 boolean quiet,
                                 opencv_core.Point pos,
                                 double minVal,
                                 double maxVal)

checks that each matrix element is within the specified range.

checkRange

public static boolean checkRange(opencv_core.Mat a)

patchNaNs

public static void patchNaNs(opencv_core.Mat a,
                             double val)

converts NaN's to the given number

patchNaNs

public static void patchNaNs(opencv_core.Mat a)

gemm

public static void gemm(opencv_core.Mat src1,
                        opencv_core.Mat src2,
                        double alpha,
                        opencv_core.Mat src3,
                        double beta,
                        opencv_core.Mat dst,
                        int flags)

implements generalized matrix product algorithm GEMM from BLAS

gemm

public static void gemm(opencv_core.Mat src1,
                        opencv_core.Mat src2,
                        double alpha,
                        opencv_core.Mat src3,
                        double beta,
                        opencv_core.Mat dst)

mulTransposed

public static void mulTransposed(opencv_core.Mat src,
                                 opencv_core.Mat dst,
                                 boolean aTa,
                                 opencv_core.Mat delta,
                                 double scale,
                                 int dtype)

multiplies matrix by its transposition from the left or from the right

mulTransposed

public static void mulTransposed(opencv_core.Mat src,
                                 opencv_core.Mat dst,
                                 boolean aTa)

transpose

public static void transpose(opencv_core.Mat src,
                             opencv_core.Mat dst)

transposes the matrix

transform

public static void transform(opencv_core.Mat src,
                             opencv_core.Mat dst,
                             opencv_core.Mat m)

performs affine transformation of each element of multi-channel input matrix

perspectiveTransform

public static void perspectiveTransform(opencv_core.Mat src,
                                        opencv_core.Mat dst,
                                        opencv_core.Mat m)

performs perspective transformation of each element of multi-channel input matrix

completeSymm

public static void completeSymm(opencv_core.Mat mtx,
                                boolean lowerToUpper)

extends the symmetrical matrix from the lower half or from the upper half

completeSymm

public static void completeSymm(opencv_core.Mat mtx)

setIdentity

public static void setIdentity(opencv_core.Mat mtx,
                               opencv_core.Scalar s)

initializes scaled identity matrix

setIdentity

public static void setIdentity(opencv_core.Mat mtx)

determinant

public static double determinant(opencv_core.Mat mtx)

computes determinant of a square matrix

trace

public static opencv_core.Scalar trace(opencv_core.Mat mtx)

computes trace of a matrix

invert

public static double invert(opencv_core.Mat src,
                            opencv_core.Mat dst,
                            int flags)

computes inverse or pseudo-inverse matrix

invert

public static double invert(opencv_core.Mat src,
                            opencv_core.Mat dst)

solve

public static boolean solve(opencv_core.Mat src1,
                            opencv_core.Mat src2,
                            opencv_core.Mat dst,
                            int flags)

solves linear system or a least-square problem

solve

public static boolean solve(opencv_core.Mat src1,
                            opencv_core.Mat src2,
                            opencv_core.Mat dst)

sort

public static void sort(opencv_core.Mat src,
                        opencv_core.Mat dst,
                        int flags)

sorts independently each matrix row or each matrix column

sortIdx

public static void sortIdx(opencv_core.Mat src,
                           opencv_core.Mat dst,
                           int flags)

sorts independently each matrix row or each matrix column

solveCubic

public static int solveCubic(opencv_core.Mat coeffs,
                             opencv_core.Mat roots)

finds real roots of a cubic polynomial

solvePoly

public static double solvePoly(opencv_core.Mat coeffs,
                               opencv_core.Mat roots,
                               int maxIters)

finds real and complex roots of a polynomial

solvePoly

public static double solvePoly(opencv_core.Mat coeffs,
                               opencv_core.Mat roots)

eigen

public static boolean eigen(opencv_core.Mat src,
                            opencv_core.Mat eigenvalues,
                            int lowindex,
                            int highindex)

finds eigenvalues of a symmetric matrix

eigen

public static boolean eigen(opencv_core.Mat src,
                            opencv_core.Mat eigenvalues)

eigen

public static boolean eigen(opencv_core.Mat src,
                            opencv_core.Mat eigenvalues,
                            opencv_core.Mat eigenvectors,
                            int lowindex,
                            int highindex)

finds eigenvalues and eigenvectors of a symmetric matrix

eigen

public static boolean eigen(opencv_core.Mat src,
                            opencv_core.Mat eigenvalues,
                            opencv_core.Mat eigenvectors)

eigen

public static boolean eigen(opencv_core.Mat src,
                            boolean computeEigenvectors,
                            opencv_core.Mat eigenvalues,
                            opencv_core.Mat eigenvectors)

calcCovarMatrix

public static void calcCovarMatrix(opencv_core.Mat samples,
                                   int nsamples,
                                   opencv_core.Mat covar,
                                   opencv_core.Mat mean,
                                   int flags,
                                   int ctype)

computes covariation matrix of a set of samples

calcCovarMatrix

public static void calcCovarMatrix(opencv_core.Mat samples,
                                   int nsamples,
                                   opencv_core.Mat covar,
                                   opencv_core.Mat mean,
                                   int flags)

calcCovarMatrix

public static void calcCovarMatrix(opencv_core.Mat samples,
                                   opencv_core.Mat covar,
                                   opencv_core.Mat mean,
                                   int flags,
                                   int ctype)

computes covariation matrix of a set of samples

calcCovarMatrix

public static void calcCovarMatrix(opencv_core.Mat samples,
                                   opencv_core.Mat covar,
                                   opencv_core.Mat mean,
                                   int flags)

PCACompute

public static void PCACompute(opencv_core.Mat data,
                              opencv_core.Mat mean,
                              opencv_core.Mat eigenvectors,
                              int maxComponents)

PCACompute

public static void PCACompute(opencv_core.Mat data,
                              opencv_core.Mat mean,
                              opencv_core.Mat eigenvectors)

PCAComputeVar

public static void PCAComputeVar(opencv_core.Mat data,
                                 opencv_core.Mat mean,
                                 opencv_core.Mat eigenvectors,
                                 double retainedVariance)

PCAProject

public static void PCAProject(opencv_core.Mat data,
                              opencv_core.Mat mean,
                              opencv_core.Mat eigenvectors,
                              opencv_core.Mat result)

PCABackProject

public static void PCABackProject(opencv_core.Mat data,
                                  opencv_core.Mat mean,
                                  opencv_core.Mat eigenvectors,
                                  opencv_core.Mat result)

SVDecomp

public static void SVDecomp(opencv_core.Mat src,
                            opencv_core.Mat w,
                            opencv_core.Mat u,
                            opencv_core.Mat vt,
                            int flags)

computes SVD of src

SVDecomp

public static void SVDecomp(opencv_core.Mat src,
                            opencv_core.Mat w,
                            opencv_core.Mat u,
                            opencv_core.Mat vt)

SVBackSubst

public static void SVBackSubst(opencv_core.Mat w,
                               opencv_core.Mat u,
                               opencv_core.Mat vt,
                               opencv_core.Mat rhs,
                               opencv_core.Mat dst)

performs back substitution for the previously computed SVD

Mahalanobis

public static double Mahalanobis(opencv_core.Mat v1,
                                 opencv_core.Mat v2,
                                 opencv_core.Mat icovar)

computes Mahalanobis distance between two vectors: sqrt((v1-v2)'*icovar*(v1-v2)), where icovar is the inverse covariation matrix

Mahalonobis

public static double Mahalonobis(opencv_core.Mat v1,
                                 opencv_core.Mat v2,
                                 opencv_core.Mat icovar)

a synonym for Mahalanobis

dft

public static void dft(opencv_core.Mat src,
                       opencv_core.Mat dst,
                       int flags,
                       int nonzeroRows)

performs forward or inverse 1D or 2D Discrete Fourier Transformation

dft

public static void dft(opencv_core.Mat src,
                       opencv_core.Mat dst)

idft

public static void idft(opencv_core.Mat src,
                        opencv_core.Mat dst,
                        int flags,
                        int nonzeroRows)

performs inverse 1D or 2D Discrete Fourier Transformation

idft

public static void idft(opencv_core.Mat src,
                        opencv_core.Mat dst)

dct

public static void dct(opencv_core.Mat src,
                       opencv_core.Mat dst,
                       int flags)

performs forward or inverse 1D or 2D Discrete Cosine Transformation

dct

public static void dct(opencv_core.Mat src,
                       opencv_core.Mat dst)

idct

public static void idct(opencv_core.Mat src,
                        opencv_core.Mat dst,
                        int flags)

performs inverse 1D or 2D Discrete Cosine Transformation

idct

public static void idct(opencv_core.Mat src,
                        opencv_core.Mat dst)

mulSpectrums

public static void mulSpectrums(opencv_core.Mat a,
                                opencv_core.Mat b,
                                opencv_core.Mat c,
                                int flags,
                                boolean conjB)

computes element-wise product of the two Fourier spectrums. The second spectrum can optionally be conjugated before the multiplication

mulSpectrums

public static void mulSpectrums(opencv_core.Mat a,
                                opencv_core.Mat b,
                                opencv_core.Mat c,
                                int flags)

getOptimalDFTSize
```
public static int getOptimalDFTSize(int vecsize)
```
computes the minimal vector size vecsize1 >= vecsize so that the dft() of the vector of length vecsize1 can be computed efficiently

kmeans

public static double kmeans(opencv_core.Mat data,
                            int K,
                            opencv_core.Mat bestLabels,
                            opencv_core.TermCriteria criteria,
                            int attempts,
                            int flags,
                            opencv_core.Mat centers)

clusters the input data using k-Means algorithm

kmeans

public static double kmeans(opencv_core.Mat data,
                            int K,
                            opencv_core.Mat bestLabels,
                            opencv_core.TermCriteria criteria,
                            int attempts,
                            int flags)

theRNG
```
public static opencv_core.RNG theRNG()
```
returns the thread-local Random number generator

randInt
```
public static int randInt()
```
returns the next unifomly-distributed random number of the specified type

randFloat
```
public static float randFloat()
```

randDouble
```
public static double randDouble()
```

randu

public static void randu(opencv_core.Mat dst,
                         opencv_core.Mat low,
                         opencv_core.Mat high)

fills array with uniformly-distributed random numbers from the range [low, high)

randn

public static void randn(opencv_core.Mat dst,
                         opencv_core.Mat mean,
                         opencv_core.Mat stddev)

fills array with normally-distributed random numbers with the specified mean and the standard deviation

randShuffle

public static void randShuffle(opencv_core.Mat dst,
                               double iterFactor,
                               opencv_core.RNG rng)

shuffles the input array elements

randShuffle

public static void randShuffle(opencv_core.Mat dst)

randShuffle

public static void randShuffle(opencv_core.Mat dst,
                               double iterFactor)

line

public static void line(opencv_core.Mat img,
                        opencv_core.Point pt1,
                        opencv_core.Point pt2,
                        opencv_core.Scalar color,
                        int thickness,
                        int lineType,
                        int shift)

draws the line segment (pt1, pt2) in the image

line

public static void line(opencv_core.Mat img,
                        opencv_core.Point pt1,
                        opencv_core.Point pt2,
                        opencv_core.Scalar color)

arrowedLine

public static void arrowedLine(opencv_core.Mat img,
                               opencv_core.Point pt1,
                               opencv_core.Point pt2,
                               opencv_core.Scalar color,
                               int thickness,
                               int line_type,
                               int shift,
                               double tipLength)

draws an arrow from pt1 to pt2 in the image

arrowedLine

public static void arrowedLine(opencv_core.Mat img,
                               opencv_core.Point pt1,
                               opencv_core.Point pt2,
                               opencv_core.Scalar color)

rectangle

public static void rectangle(opencv_core.Mat img,
                             opencv_core.Point pt1,
                             opencv_core.Point pt2,
                             opencv_core.Scalar color,
                             int thickness,
                             int lineType,
                             int shift)

draws the rectangle outline or a solid rectangle with the opposite corners pt1 and pt2 in the image

rectangle

public static void rectangle(opencv_core.Mat img,
                             opencv_core.Point pt1,
                             opencv_core.Point pt2,
                             opencv_core.Scalar color)

rectangle

public static void rectangle(opencv_core.Mat img,
                             opencv_core.Rect rec,
                             opencv_core.Scalar color,
                             int thickness,
                             int lineType,
                             int shift)

draws the rectangle outline or a solid rectangle covering rec in the image

rectangle

public static void rectangle(opencv_core.Mat img,
                             opencv_core.Rect rec,
                             opencv_core.Scalar color)

circle

public static void circle(opencv_core.Mat img,
                          opencv_core.Point center,
                          int radius,
                          opencv_core.Scalar color,
                          int thickness,
                          int lineType,
                          int shift)

draws the circle outline or a solid circle in the image

circle

public static void circle(opencv_core.Mat img,
                          opencv_core.Point center,
                          int radius,
                          opencv_core.Scalar color)

ellipse

public static void ellipse(opencv_core.Mat img,
                           opencv_core.Point center,
                           opencv_core.Size axes,
                           double angle,
                           double startAngle,
                           double endAngle,
                           opencv_core.Scalar color,
                           int thickness,
                           int lineType,
                           int shift)

draws an elliptic arc, ellipse sector or a rotated ellipse in the image

ellipse

public static void ellipse(opencv_core.Mat img,
                           opencv_core.Point center,
                           opencv_core.Size axes,
                           double angle,
                           double startAngle,
                           double endAngle,
                           opencv_core.Scalar color)

ellipse

public static void ellipse(opencv_core.Mat img,
                           opencv_core.RotatedRect box,
                           opencv_core.Scalar color,
                           int thickness,
                           int lineType)

draws a rotated ellipse in the image

ellipse

public static void ellipse(opencv_core.Mat img,
                           opencv_core.RotatedRect box,
                           opencv_core.Scalar color)

fillConvexPoly

public static void fillConvexPoly(opencv_core.Mat img,
                                  opencv_core.Point pts,
                                  int npts,
                                  opencv_core.Scalar color,
                                  int lineType,
                                  int shift)

draws a filled convex polygon in the image

fillConvexPoly

public static void fillConvexPoly(opencv_core.Mat img,
                                  opencv_core.Point pts,
                                  int npts,
                                  opencv_core.Scalar color)

fillConvexPoly

public static void fillConvexPoly(opencv_core.Mat img,
                                  opencv_core.Mat points,
                                  opencv_core.Scalar color,
                                  int lineType,
                                  int shift)

fillConvexPoly

public static void fillConvexPoly(opencv_core.Mat img,
                                  opencv_core.Mat points,
                                  opencv_core.Scalar color)

fillPoly

public static void fillPoly(opencv_core.Mat img,
                            PointerPointer pts,
                            IntPointer npts,
                            int ncontours,
                            opencv_core.Scalar color,
                            int lineType,
                            int shift,
                            opencv_core.Point offset)

fills an area bounded by one or more polygons

fillPoly

public static void fillPoly(opencv_core.Mat img,
                            opencv_core.Point pts,
                            IntPointer npts,
                            int ncontours,
                            opencv_core.Scalar color)

fillPoly

public static void fillPoly(opencv_core.Mat img,
                            opencv_core.Point pts,
                            IntPointer npts,
                            int ncontours,
                            opencv_core.Scalar color,
                            int lineType,
                            int shift,
                            opencv_core.Point offset)

fillPoly

public static void fillPoly(opencv_core.Mat img,
                            opencv_core.Point pts,
                            IntBuffer npts,
                            int ncontours,
                            opencv_core.Scalar color,
                            int lineType,
                            int shift,
                            opencv_core.Point offset)

fillPoly

public static void fillPoly(opencv_core.Mat img,
                            opencv_core.Point pts,
                            IntBuffer npts,
                            int ncontours,
                            opencv_core.Scalar color)

fillPoly

public static void fillPoly(opencv_core.Mat img,
                            opencv_core.Point pts,
                            int[] npts,
                            int ncontours,
                            opencv_core.Scalar color,
                            int lineType,
                            int shift,
                            opencv_core.Point offset)

fillPoly

public static void fillPoly(opencv_core.Mat img,
                            opencv_core.Point pts,
                            int[] npts,
                            int ncontours,
                            opencv_core.Scalar color)

fillPoly

public static void fillPoly(opencv_core.Mat img,
                            opencv_core.MatVector pts,
                            opencv_core.Scalar color,
                            int lineType,
                            int shift,
                            opencv_core.Point offset)

fillPoly

public static void fillPoly(opencv_core.Mat img,
                            opencv_core.MatVector pts,
                            opencv_core.Scalar color)

polylines

public static void polylines(opencv_core.Mat img,
                             PointerPointer pts,
                             IntPointer npts,
                             int ncontours,
                             boolean isClosed,
                             opencv_core.Scalar color,
                             int thickness,
                             int lineType,
                             int shift)

draws one or more polygonal curves

polylines

public static void polylines(opencv_core.Mat img,
                             opencv_core.Point pts,
                             IntPointer npts,
                             int ncontours,
                             boolean isClosed,
                             opencv_core.Scalar color)

polylines

public static void polylines(opencv_core.Mat img,
                             opencv_core.Point pts,
                             IntPointer npts,
                             int ncontours,
                             boolean isClosed,
                             opencv_core.Scalar color,
                             int thickness,
                             int lineType,
                             int shift)

polylines

public static void polylines(opencv_core.Mat img,
                             opencv_core.Point pts,
                             IntBuffer npts,
                             int ncontours,
                             boolean isClosed,
                             opencv_core.Scalar color,
                             int thickness,
                             int lineType,
                             int shift)

polylines

public static void polylines(opencv_core.Mat img,
                             opencv_core.Point pts,
                             IntBuffer npts,
                             int ncontours,
                             boolean isClosed,
                             opencv_core.Scalar color)

polylines

public static void polylines(opencv_core.Mat img,
                             opencv_core.Point pts,
                             int[] npts,
                             int ncontours,
                             boolean isClosed,
                             opencv_core.Scalar color,
                             int thickness,
                             int lineType,
                             int shift)

polylines

public static void polylines(opencv_core.Mat img,
                             opencv_core.Point pts,
                             int[] npts,
                             int ncontours,
                             boolean isClosed,
                             opencv_core.Scalar color)

polylines

public static void polylines(opencv_core.Mat img,
                             opencv_core.MatVector pts,
                             boolean isClosed,
                             opencv_core.Scalar color,
                             int thickness,
                             int lineType,
                             int shift)

polylines

public static void polylines(opencv_core.Mat img,
                             opencv_core.MatVector pts,
                             boolean isClosed,
                             opencv_core.Scalar color)

clipLine

public static boolean clipLine(opencv_core.Size imgSize,
                               opencv_core.Point pt1,
                               opencv_core.Point pt2)

clips the line segment by the rectangle Rect(0, 0, imgSize.width, imgSize.height)

clipLine

public static boolean clipLine(opencv_core.Rect imgRect,
                               opencv_core.Point pt1,
                               opencv_core.Point pt2)

clips the line segment by the rectangle imgRect

ellipse2Poly

public static void ellipse2Poly(opencv_core.Point center,
                                opencv_core.Size axes,
                                int angle,
                                int arcStart,
                                int arcEnd,
                                int delta,
                                opencv_core.Point pts)

converts elliptic arc to a polygonal curve

putText

public static void putText(opencv_core.Mat img,
                           BytePointer text,
                           opencv_core.Point org,
                           int fontFace,
                           double fontScale,
                           opencv_core.Scalar color,
                           int thickness,
                           int lineType,
                           boolean bottomLeftOrigin)

renders text string in the image

putText

public static void putText(opencv_core.Mat img,
                           BytePointer text,
                           opencv_core.Point org,
                           int fontFace,
                           double fontScale,
                           opencv_core.Scalar color)

putText

public static void putText(opencv_core.Mat img,
                           String text,
                           opencv_core.Point org,
                           int fontFace,
                           double fontScale,
                           opencv_core.Scalar color,
                           int thickness,
                           int lineType,
                           boolean bottomLeftOrigin)

putText

public static void putText(opencv_core.Mat img,
                           String text,
                           opencv_core.Point org,
                           int fontFace,
                           double fontScale,
                           opencv_core.Scalar color)

getTextSize

public static opencv_core.Size getTextSize(BytePointer text,
                                           int fontFace,
                                           double fontScale,
                                           int thickness,
                                           IntPointer baseLine)

returns bounding box of the text string

getTextSize

public static opencv_core.Size getTextSize(String text,
                                           int fontFace,
                                           double fontScale,
                                           int thickness,
                                           IntBuffer baseLine)

getTextSize

public static opencv_core.Size getTextSize(BytePointer text,
                                           int fontFace,
                                           double fontScale,
                                           int thickness,
                                           int[] baseLine)

getTextSize

public static opencv_core.Size getTextSize(String text,
                                           int fontFace,
                                           double fontScale,
                                           int thickness,
                                           IntPointer baseLine)

getTextSize

public static opencv_core.Size getTextSize(BytePointer text,
                                           int fontFace,
                                           double fontScale,
                                           int thickness,
                                           IntBuffer baseLine)

getTextSize

public static opencv_core.Size getTextSize(String text,
                                           int fontFace,
                                           double fontScale,
                                           int thickness,
                                           int[] baseLine)

getConvertElem

public static opencv_core.ConvertData getConvertElem(int fromType,
                                                     int toType)

returns the function for converting pixels from one data type to another

getConvertScaleElem

public static opencv_core.ConvertScaleData getConvertScaleElem(int fromType,
                                                               int toType)

returns the function for converting pixels from one data type to another with the optional scaling

minMaxLoc

public static void minMaxLoc(opencv_core.SparseMat a,
                             DoublePointer minVal,
                             DoublePointer maxVal,
                             IntPointer minIdx,
                             IntPointer maxIdx)

finds global minimum and maximum sparse array elements and returns their values and their locations

minMaxLoc

public static void minMaxLoc(opencv_core.SparseMat a,
                             DoublePointer minVal,
                             DoublePointer maxVal)

minMaxLoc

public static void minMaxLoc(opencv_core.SparseMat a,
                             DoubleBuffer minVal,
                             DoubleBuffer maxVal,
                             IntBuffer minIdx,
                             IntBuffer maxIdx)

minMaxLoc

public static void minMaxLoc(opencv_core.SparseMat a,
                             DoubleBuffer minVal,
                             DoubleBuffer maxVal)

minMaxLoc

public static void minMaxLoc(opencv_core.SparseMat a,
                             double[] minVal,
                             double[] maxVal,
                             int[] minIdx,
                             int[] maxIdx)

minMaxLoc

public static void minMaxLoc(opencv_core.SparseMat a,
                             double[] minVal,
                             double[] maxVal)

norm

public static double norm(opencv_core.SparseMat src,
                          int normType)

computes norm of a sparse matrix

normalize

public static void normalize(opencv_core.SparseMat src,
                             opencv_core.SparseMat dst,
                             double alpha,
                             int normType)

scales and shifts array elements so that either the specified norm (alpha) or the minimum (alpha) and maximum (beta) array values get the specified values

parallel_for_

public static void parallel_for_(opencv_core.Range range,
                                 opencv_core.ParallelLoopBody body,
                                 double nstripes)

parallel_for_

public static void parallel_for_(opencv_core.Range range,
                                 opencv_core.ParallelLoopBody body)

CV_XADD

public static int CV_XADD(IntPointer addr,
                          int delta)

CV_XADD

public static int CV_XADD(IntBuffer addr,
                          int delta)

CV_XADD

public static int CV_XADD(int[] addr,
                          int delta)

saturateCastUchar

public static byte saturateCastUchar(byte v)

saturateCastSchar

public static byte saturateCastSchar(byte v)

saturateCastUshort

public static short saturateCastUshort(byte v)

saturateCastShort

public static short saturateCastShort(byte v)

saturateCastInt

public static int saturateCastInt(byte v)

saturateCastUnsigned

public static int saturateCastUnsigned(byte v)

saturateCastUchar

public static byte saturateCastUchar(short v)

saturateCastSchar

public static byte saturateCastSchar(short v)

saturateCastUshort

public static short saturateCastUshort(short v)

saturateCastShort

public static short saturateCastShort(short v)

saturateCastInt

public static int saturateCastInt(short v)

saturateCastUnsigned

public static int saturateCastUnsigned(short v)

saturateCastUchar

public static byte saturateCastUchar(int v)

saturateCastSchar

public static byte saturateCastSchar(int v)

saturateCastUshort

public static short saturateCastUshort(int v)

saturateCastShort

public static short saturateCastShort(int v)

saturateCastInt

public static int saturateCastInt(int v)

saturateCastUnsigned

public static int saturateCastUnsigned(int v)

saturateCastUchar

public static byte saturateCastUchar(float v)

saturateCastSchar

public static byte saturateCastSchar(float v)

saturateCastUshort

public static short saturateCastUshort(float v)

saturateCastShort

public static short saturateCastShort(float v)

saturateCastInt

public static int saturateCastInt(float v)

saturateCastUnsigned

public static int saturateCastUnsigned(float v)

saturateCastUchar

public static byte saturateCastUchar(double v)

saturateCastSchar

public static byte saturateCastSchar(double v)

saturateCastUshort

public static short saturateCastUshort(double v)

saturateCastShort

public static short saturateCastShort(double v)

saturateCastInt

public static int saturateCastInt(double v)

saturateCastUnsigned

public static int saturateCastUnsigned(double v)

fast_abs
```
public static int fast_abs(byte v)
```

fast_abs
```
public static int fast_abs(short v)
```

fast_abs
```
public static int fast_abs(int v)
```

fast_abs

public static float fast_abs(float v)

fast_abs

public static double fast_abs(double v)

LU

public static int LU(FloatPointer A,
                     long astep,
                     int m,
                     FloatPointer b,
                     long bstep,
                     int n)

LU

public static int LU(FloatBuffer A,
                     long astep,
                     int m,
                     FloatBuffer b,
                     long bstep,
                     int n)

LU

public static int LU(float[] A,
                     long astep,
                     int m,
                     float[] b,
                     long bstep,
                     int n)

LU

public static int LU(DoublePointer A,
                     long astep,
                     int m,
                     DoublePointer b,
                     long bstep,
                     int n)

LU

public static int LU(DoubleBuffer A,
                     long astep,
                     int m,
                     DoubleBuffer b,
                     long bstep,
                     int n)

LU

public static int LU(double[] A,
                     long astep,
                     int m,
                     double[] b,
                     long bstep,
                     int n)

Cholesky

public static boolean Cholesky(FloatPointer A,
                               long astep,
                               int m,
                               FloatPointer b,
                               long bstep,
                               int n)

Cholesky

public static boolean Cholesky(FloatBuffer A,
                               long astep,
                               int m,
                               FloatBuffer b,
                               long bstep,
                               int n)

Cholesky

public static boolean Cholesky(float[] A,
                               long astep,
                               int m,
                               float[] b,
                               long bstep,
                               int n)

Cholesky

public static boolean Cholesky(DoublePointer A,
                               long astep,
                               int m,
                               DoublePointer b,
                               long bstep,
                               int n)

Cholesky

public static boolean Cholesky(DoubleBuffer A,
                               long astep,
                               int m,
                               DoubleBuffer b,
                               long bstep,
                               int n)

Cholesky

public static boolean Cholesky(double[] A,
                               long astep,
                               int m,
                               double[] b,
                               long bstep,
                               int n)

normL2Sqr_

public static float normL2Sqr_(FloatPointer a,
                               FloatPointer b,
                               int n)

normL2Sqr_

public static float normL2Sqr_(FloatBuffer a,
                               FloatBuffer b,
                               int n)

normL2Sqr_

public static float normL2Sqr_(float[] a,
                               float[] b,
                               int n)

normL1_

public static float normL1_(FloatPointer a,
                            FloatPointer b,
                            int n)

normL1_

public static float normL1_(FloatBuffer a,
                            FloatBuffer b,
                            int n)

normL1_

public static float normL1_(float[] a,
                            float[] b,
                            int n)

normL1_

public static int normL1_(BytePointer a,
                          BytePointer b,
                          int n)

normL1_

public static int normL1_(ByteBuffer a,
                          ByteBuffer b,
                          int n)

normL1_

public static int normL1_(byte[] a,
                          byte[] b,
                          int n)

normHamming

public static int normHamming(BytePointer a,
                              BytePointer b,
                              int n)

normHamming

public static int normHamming(ByteBuffer a,
                              ByteBuffer b,
                              int n)

normHamming

public static int normHamming(byte[] a,
                              byte[] b,
                              int n)

normHamming

public static int normHamming(BytePointer a,
                              BytePointer b,
                              int n,
                              int cellSize)

normHamming

public static int normHamming(ByteBuffer a,
                              ByteBuffer b,
                              int n,
                              int cellSize)

normHamming

public static int normHamming(byte[] a,
                              byte[] b,
                              int n,
                              int cellSize)

equals

public static boolean equals(opencv_core.Range r1,
                             opencv_core.Range r2)

notEquals

public static boolean notEquals(opencv_core.Range r1,
                                opencv_core.Range r2)

not

public static boolean not(opencv_core.Range r)

and

public static opencv_core.Range and(opencv_core.Range r1,
                                    opencv_core.Range r2)

andPut

public static opencv_core.Range andPut(opencv_core.Range r1,
                                       opencv_core.Range r2)

add

public static opencv_core.Range add(opencv_core.Range r1,
                                    int delta)

add

public static opencv_core.Range add(int delta,
                                    opencv_core.Range r1)

subtract

public static opencv_core.Range subtract(opencv_core.Range r1,
                                         int delta)

write

public static void write(opencv_core.FileStorage fs,
                         BytePointer name,
                         int value)

write

public static void write(opencv_core.FileStorage fs,
                         String name,
                         int value)

write

public static void write(opencv_core.FileStorage fs,
                         BytePointer name,
                         float value)

write

public static void write(opencv_core.FileStorage fs,
                         String name,
                         float value)

write

public static void write(opencv_core.FileStorage fs,
                         BytePointer name,
                         double value)

write

public static void write(opencv_core.FileStorage fs,
                         String name,
                         double value)

write

public static void write(opencv_core.FileStorage fs,
                         BytePointer name,
                         BytePointer value)

write

public static void write(opencv_core.FileStorage fs,
                         String name,
                         String value)

writeScalar

public static void writeScalar(opencv_core.FileStorage fs,
                               int value)

writeScalar

public static void writeScalar(opencv_core.FileStorage fs,
                               float value)

writeScalar

public static void writeScalar(opencv_core.FileStorage fs,
                               double value)

writeScalar

public static void writeScalar(opencv_core.FileStorage fs,
                               BytePointer value)

writeScalar

public static void writeScalar(opencv_core.FileStorage fs,
                               String value)

write

public static void write(opencv_core.FileStorage fs,
                         int value)

write

public static void write(opencv_core.FileStorage fs,
                         float value)

write

public static void write(opencv_core.FileStorage fs,
                         double value)

write

public static void write(opencv_core.FileStorage fs,
                         BytePointer value)

write

public static void write(opencv_core.FileStorage fs,
                         String value)

write

public static void write(opencv_core.FileStorage fs,
                         opencv_core.Range r)

write

public static void write(opencv_core.FileStorage fs,
                         BytePointer name,
                         opencv_core.Range r)

write

public static void write(opencv_core.FileStorage fs,
                         String name,
                         opencv_core.Range r)

write

public static void write(opencv_core.FileStorage fs,
                         BytePointer name,
                         opencv_core.Mat value)

write

public static void write(opencv_core.FileStorage fs,
                         String name,
                         opencv_core.Mat value)

write

public static void write(opencv_core.FileStorage fs,
                         BytePointer name,
                         opencv_core.SparseMat value)

write

public static void write(opencv_core.FileStorage fs,
                         String name,
                         opencv_core.SparseMat value)

shiftLeft

public static opencv_core.FileStorage shiftLeft(opencv_core.FileStorage fs,
                                                BytePointer str)

shiftLeft

public static opencv_core.FileStorage shiftLeft(opencv_core.FileStorage fs,
                                                String str)

shiftLeft

public static opencv_core.FileStorage shiftLeft(opencv_core.FileStorage fs,
                                                ByteBuffer value)

shiftLeft

public static opencv_core.FileStorage shiftLeft(opencv_core.FileStorage fs,
                                                byte[] value)

read

public static void read(opencv_core.FileNode node,
                        IntPointer value,
                        int default_value)

read

public static void read(opencv_core.FileNode node,
                        IntBuffer value,
                        int default_value)

read

public static void read(opencv_core.FileNode node,
                        int[] value,
                        int default_value)

read

public static void read(opencv_core.FileNode node,
                        BoolPointer value,
                        boolean default_value)

read

public static void read(opencv_core.FileNode node,
                        BytePointer value,
                        byte default_value)

read

public static void read(opencv_core.FileNode node,
                        ByteBuffer value,
                        byte default_value)

read

public static void read(opencv_core.FileNode node,
                        byte[] value,
                        byte default_value)

read

public static void read(opencv_core.FileNode node,
                        ShortPointer value,
                        short default_value)

read

public static void read(opencv_core.FileNode node,
                        ShortBuffer value,
                        short default_value)

read

public static void read(opencv_core.FileNode node,
                        short[] value,
                        short default_value)

read

public static void read(opencv_core.FileNode node,
                        FloatPointer value,
                        float default_value)

read

public static void read(opencv_core.FileNode node,
                        FloatBuffer value,
                        float default_value)

read

public static void read(opencv_core.FileNode node,
                        float[] value,
                        float default_value)

read

public static void read(opencv_core.FileNode node,
                        DoublePointer value,
                        double default_value)

read

public static void read(opencv_core.FileNode node,
                        DoubleBuffer value,
                        double default_value)

read

public static void read(opencv_core.FileNode node,
                        double[] value,
                        double default_value)

read

public static void read(opencv_core.FileNode node,
                        BytePointer value,
                        BytePointer default_value)

read

public static void read(opencv_core.FileNode node,
                        String value,
                        String default_value)

read

public static void read(opencv_core.FileNode node,
                        opencv_core.Range value,
                        opencv_core.Range default_value)

read

public static void read(opencv_core.FileNode node,
                        opencv_core.Mat mat,
                        opencv_core.Mat default_mat)

read

public static void read(opencv_core.FileNode node,
                        opencv_core.Mat mat)

read

public static void read(opencv_core.FileNode node,
                        opencv_core.SparseMat mat,
                        opencv_core.SparseMat default_mat)

read

public static void read(opencv_core.FileNode node,
                        opencv_core.SparseMat mat)

equals

public static boolean equals(opencv_core.FileNodeIterator it1,
                             opencv_core.FileNodeIterator it2)

notEquals

public static boolean notEquals(opencv_core.FileNodeIterator it1,
                                opencv_core.FileNodeIterator it2)

subtract

public static long subtract(opencv_core.FileNodeIterator it1,
                            opencv_core.FileNodeIterator it2)

lessThan

public static boolean lessThan(opencv_core.FileNodeIterator it1,
                               opencv_core.FileNodeIterator it2)

seqPush
```
public static BytePointer seqPush(opencv_core.CvSeq seq,
                                  Pointer element)
```
\ Generic implementation of QuickSort algorithm Use it as: vector<_Tp> a; ... sort(a,); The current implementation was derived from *BSD system qsort(): Copyright (c) 1992, 1993 The Regents of the University of California. All rights reserved. Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: 1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. 2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. 3. All advertising materials mentioning features or use of this software must display the following acknowledgement: This product includes software developed by the University of California, Berkeley and its contributors. 4. Neither the name of the University nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission. THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. \

seqPush

public static BytePointer seqPush(opencv_core.CvSeq seq)

seqPushFront

public static BytePointer seqPushFront(opencv_core.CvSeq seq,
                                       Pointer element)

seqPushFront

public static BytePointer seqPushFront(opencv_core.CvSeq seq)

seqPop

public static void seqPop(opencv_core.CvSeq seq,
                          Pointer element)

seqPop

public static void seqPop(opencv_core.CvSeq seq)

seqPopFront

public static void seqPopFront(opencv_core.CvSeq seq,
                               Pointer element)

seqPopFront

public static void seqPopFront(opencv_core.CvSeq seq)

seqRemove

public static void seqRemove(opencv_core.CvSeq seq,
                             int index)

clearSeq

public static void clearSeq(opencv_core.CvSeq seq)

getSeqElem

public static BytePointer getSeqElem(opencv_core.CvSeq seq,
                                     int index)

seqRemoveSlice

public static void seqRemoveSlice(opencv_core.CvSeq seq,
                                  opencv_core.CvSlice slice)

seqInsertSlice

public static void seqInsertSlice(opencv_core.CvSeq seq,
                                  int before_index,
                                  opencv_core.CvArr from_arr)

format

public static opencv_core.Formatted format(opencv_core.Mat mtx,
                                           BytePointer fmt,
                                           IntPointer params)

format

public static opencv_core.Formatted format(opencv_core.Mat mtx,
                                           BytePointer fmt)

format

public static opencv_core.Formatted format(opencv_core.Mat mtx,
                                           String fmt,
                                           IntBuffer params)

format

public static opencv_core.Formatted format(opencv_core.Mat mtx,
                                           String fmt)

format

public static opencv_core.Formatted format(opencv_core.Mat mtx,
                                           BytePointer fmt,
                                           int[] params)

format

public static opencv_core.Formatted format(opencv_core.Mat mtx,
                                           String fmt,
                                           IntPointer params)

format

public static opencv_core.Formatted format(opencv_core.Mat mtx,
                                           BytePointer fmt,
                                           IntBuffer params)

format

public static opencv_core.Formatted format(opencv_core.Mat mtx,
                                           String fmt,
                                           int[] params)

shiftLeft

public static Pointer shiftLeft(Pointer out,
                                opencv_core.Mat mtx)

\brief prints Mat to the output stream in Matlab notation use like

shiftLeft

public static Pointer shiftLeft(Pointer out,
                                opencv_core.Formatted fmtd)

\brief prints Mat to the output stream allows in the specified notation (see format) use like

cvarrToMatND

public static opencv_core.Mat cvarrToMatND(opencv_core.CvArr arr,
                                           boolean copyData,
                                           int coiMode)

Writes a Rect_ to an output stream. Format example : [640 x 480 from (10, 20)]

cvarrToMatND

public static opencv_core.Mat cvarrToMatND(opencv_core.CvArr arr)

add

public static opencv_core.MatExpr add(opencv_core.Mat a,
                                      opencv_core.Mat b)

add

public static opencv_core.MatExpr add(opencv_core.Mat a,
                                      opencv_core.Scalar s)

add

public static opencv_core.MatExpr add(opencv_core.Scalar s,
                                      opencv_core.Mat a)

add

public static opencv_core.MatExpr add(opencv_core.MatExpr e,
                                      opencv_core.Mat m)

add

public static opencv_core.MatExpr add(opencv_core.Mat m,
                                      opencv_core.MatExpr e)

add

public static opencv_core.MatExpr add(opencv_core.MatExpr e,
                                      opencv_core.Scalar s)

add

public static opencv_core.MatExpr add(opencv_core.Scalar s,
                                      opencv_core.MatExpr e)

add

public static opencv_core.MatExpr add(opencv_core.MatExpr e1,
                                      opencv_core.MatExpr e2)

subtract

public static opencv_core.MatExpr subtract(opencv_core.Mat a,
                                           opencv_core.Mat b)

subtract

public static opencv_core.MatExpr subtract(opencv_core.Mat a,
                                           opencv_core.Scalar s)

subtract

public static opencv_core.MatExpr subtract(opencv_core.Scalar s,
                                           opencv_core.Mat a)

subtract

public static opencv_core.MatExpr subtract(opencv_core.MatExpr e,
                                           opencv_core.Mat m)

subtract

public static opencv_core.MatExpr subtract(opencv_core.Mat m,
                                           opencv_core.MatExpr e)

subtract

public static opencv_core.MatExpr subtract(opencv_core.MatExpr e,
                                           opencv_core.Scalar s)

subtract

public static opencv_core.MatExpr subtract(opencv_core.Scalar s,
                                           opencv_core.MatExpr e)

subtract

public static opencv_core.MatExpr subtract(opencv_core.MatExpr e1,
                                           opencv_core.MatExpr e2)

subtract

public static opencv_core.MatExpr subtract(opencv_core.Mat m)

subtract

public static opencv_core.MatExpr subtract(opencv_core.MatExpr e)

multiply

public static opencv_core.MatExpr multiply(opencv_core.Mat a,
                                           opencv_core.Mat b)

multiply

public static opencv_core.MatExpr multiply(opencv_core.Mat a,
                                           double s)

multiply

public static opencv_core.MatExpr multiply(double s,
                                           opencv_core.Mat a)

multiply

public static opencv_core.MatExpr multiply(opencv_core.MatExpr e,
                                           opencv_core.Mat m)

multiply

public static opencv_core.MatExpr multiply(opencv_core.Mat m,
                                           opencv_core.MatExpr e)

multiply

public static opencv_core.MatExpr multiply(opencv_core.MatExpr e,
                                           double s)

multiply

public static opencv_core.MatExpr multiply(double s,
                                           opencv_core.MatExpr e)

multiply

public static opencv_core.MatExpr multiply(opencv_core.MatExpr e1,
                                           opencv_core.MatExpr e2)

divide

public static opencv_core.MatExpr divide(opencv_core.Mat a,
                                         opencv_core.Mat b)

divide

public static opencv_core.MatExpr divide(opencv_core.Mat a,
                                         double s)

divide

public static opencv_core.MatExpr divide(double s,
                                         opencv_core.Mat a)

divide

public static opencv_core.MatExpr divide(opencv_core.MatExpr e,
                                         opencv_core.Mat m)

divide

public static opencv_core.MatExpr divide(opencv_core.Mat m,
                                         opencv_core.MatExpr e)

divide

public static opencv_core.MatExpr divide(opencv_core.MatExpr e,
                                         double s)

divide

public static opencv_core.MatExpr divide(double s,
                                         opencv_core.MatExpr e)

divide

public static opencv_core.MatExpr divide(opencv_core.MatExpr e1,
                                         opencv_core.MatExpr e2)

lessThan

public static opencv_core.MatExpr lessThan(opencv_core.Mat a,
                                           opencv_core.Mat b)

lessThan

public static opencv_core.MatExpr lessThan(opencv_core.Mat a,
                                           double s)

lessThan

public static opencv_core.MatExpr lessThan(double s,
                                           opencv_core.Mat a)

lessThanEquals

public static opencv_core.MatExpr lessThanEquals(opencv_core.Mat a,
                                                 opencv_core.Mat b)

lessThanEquals

public static opencv_core.MatExpr lessThanEquals(opencv_core.Mat a,
                                                 double s)

lessThanEquals

public static opencv_core.MatExpr lessThanEquals(double s,
                                                 opencv_core.Mat a)

equals

public static opencv_core.MatExpr equals(opencv_core.Mat a,
                                         opencv_core.Mat b)

equals

public static opencv_core.MatExpr equals(opencv_core.Mat a,
                                         double s)

equals

public static opencv_core.MatExpr equals(double s,
                                         opencv_core.Mat a)

notEquals

public static opencv_core.MatExpr notEquals(opencv_core.Mat a,
                                            opencv_core.Mat b)

notEquals

public static opencv_core.MatExpr notEquals(opencv_core.Mat a,
                                            double s)

notEquals

public static opencv_core.MatExpr notEquals(double s,
                                            opencv_core.Mat a)

greaterThanEquals

public static opencv_core.MatExpr greaterThanEquals(opencv_core.Mat a,
                                                    opencv_core.Mat b)

greaterThanEquals

public static opencv_core.MatExpr greaterThanEquals(opencv_core.Mat a,
                                                    double s)

greaterThanEquals

public static opencv_core.MatExpr greaterThanEquals(double s,
                                                    opencv_core.Mat a)

greaterThan

public static opencv_core.MatExpr greaterThan(opencv_core.Mat a,
                                              opencv_core.Mat b)

greaterThan

public static opencv_core.MatExpr greaterThan(opencv_core.Mat a,
                                              double s)

greaterThan

public static opencv_core.MatExpr greaterThan(double s,
                                              opencv_core.Mat a)

min

public static opencv_core.MatExpr min(opencv_core.Mat a,
                                      opencv_core.Mat b)

min

public static opencv_core.MatExpr min(opencv_core.Mat a,
                                      double s)

min

public static opencv_core.MatExpr min(double s,
                                      opencv_core.Mat a)

max

public static opencv_core.MatExpr max(opencv_core.Mat a,
                                      opencv_core.Mat b)

max

public static opencv_core.MatExpr max(opencv_core.Mat a,
                                      double s)

max

public static opencv_core.MatExpr max(double s,
                                      opencv_core.Mat a)

and

public static opencv_core.MatExpr and(opencv_core.Mat a,
                                      opencv_core.Mat b)

and

public static opencv_core.MatExpr and(opencv_core.Mat a,
                                      opencv_core.Scalar s)

and

public static opencv_core.MatExpr and(opencv_core.Scalar s,
                                      opencv_core.Mat a)

or

public static opencv_core.MatExpr or(opencv_core.Mat a,
                                     opencv_core.Mat b)

or

public static opencv_core.MatExpr or(opencv_core.Mat a,
                                     opencv_core.Scalar s)

or

public static opencv_core.MatExpr or(opencv_core.Scalar s,
                                     opencv_core.Mat a)

xor

public static opencv_core.MatExpr xor(opencv_core.Mat a,
                                      opencv_core.Mat b)

xor

public static opencv_core.MatExpr xor(opencv_core.Mat a,
                                      opencv_core.Scalar s)

xor

public static opencv_core.MatExpr xor(opencv_core.Scalar s,
                                      opencv_core.Mat a)

not

public static opencv_core.MatExpr not(opencv_core.Mat m)

abs

public static opencv_core.MatExpr abs(opencv_core.Mat m)

abs

public static opencv_core.MatExpr abs(opencv_core.MatExpr e)

addPut

public static opencv_core.Mat addPut(opencv_core.Mat a,
                                     opencv_core.Mat b)

addPut

public static opencv_core.Mat addPut(opencv_core.Mat a,
                                     opencv_core.Scalar s)

addPut

public static opencv_core.Mat addPut(opencv_core.Mat a,
                                     opencv_core.MatExpr b)

subtractPut

public static opencv_core.Mat subtractPut(opencv_core.Mat a,
                                          opencv_core.Mat b)

subtractPut

public static opencv_core.Mat subtractPut(opencv_core.Mat a,
                                          opencv_core.Scalar s)

subtractPut

public static opencv_core.Mat subtractPut(opencv_core.Mat a,
                                          opencv_core.MatExpr b)

multiplyPut

public static opencv_core.Mat multiplyPut(opencv_core.Mat a,
                                          opencv_core.Mat b)

multiplyPut

public static opencv_core.Mat multiplyPut(opencv_core.Mat a,
                                          double s)

multiplyPut

public static opencv_core.Mat multiplyPut(opencv_core.Mat a,
                                          opencv_core.MatExpr b)

dividePut

public static opencv_core.Mat dividePut(opencv_core.Mat a,
                                        opencv_core.Mat b)

dividePut

public static opencv_core.Mat dividePut(opencv_core.Mat a,
                                        double s)

dividePut

public static opencv_core.Mat dividePut(opencv_core.Mat a,
                                        opencv_core.MatExpr b)

andPut

public static opencv_core.Mat andPut(opencv_core.Mat a,
                                     opencv_core.Mat b)

andPut

public static opencv_core.Mat andPut(opencv_core.Mat a,
                                     opencv_core.Scalar s)

orPut

public static opencv_core.Mat orPut(opencv_core.Mat a,
                                    opencv_core.Mat b)

orPut

public static opencv_core.Mat orPut(opencv_core.Mat a,
                                    opencv_core.Scalar s)

xorPut

public static opencv_core.Mat xorPut(opencv_core.Mat a,
                                     opencv_core.Mat b)

xorPut

public static opencv_core.Mat xorPut(opencv_core.Mat a,
                                     opencv_core.Scalar s)

equals

public static boolean equals(opencv_core.MatConstIterator a,
                             opencv_core.MatConstIterator b)

lessThan

public static boolean lessThan(opencv_core.MatConstIterator a,
                               opencv_core.MatConstIterator b)

greaterThan

public static boolean greaterThan(opencv_core.MatConstIterator a,
                                  opencv_core.MatConstIterator b)

lessThanEquals

public static boolean lessThanEquals(opencv_core.MatConstIterator a,
                                     opencv_core.MatConstIterator b)

greaterThanEquals

public static boolean greaterThanEquals(opencv_core.MatConstIterator a,
                                        opencv_core.MatConstIterator b)

subtract

public static long subtract(opencv_core.MatConstIterator b,
                            opencv_core.MatConstIterator a)

add

public static opencv_core.MatConstIterator add(opencv_core.MatConstIterator a,
                                               long ofs)

add

public static opencv_core.MatConstIterator add(long ofs,
                                               opencv_core.MatConstIterator a)

subtract

public static opencv_core.MatConstIterator subtract(opencv_core.MatConstIterator a,
                                                    long ofs)

equals

public static boolean equals(opencv_core.SparseMatConstIterator it1,
                             opencv_core.SparseMatConstIterator it2)

notEquals

public static boolean notEquals(opencv_core.SparseMatConstIterator it1,
                                opencv_core.SparseMatConstIterator it2)

Class opencv_core

Nested Class Summary

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

Nested classes/interfaces inherited from class org.bytedeco.javacpp.presets.opencv_core

Field Summary

Constructor Summary

Method Summary

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

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

Methods inherited from class java.lang.Object

Field Detail

CV_StsOk

CV_StsBackTrace

CV_StsError

CV_StsInternal

CV_StsNoMem

CV_StsBadArg

CV_StsBadFunc

CV_StsNoConv

CV_StsAutoTrace

CV_HeaderIsNull

CV_BadImageSize

CV_BadOffset

CV_BadDataPtr

CV_BadStep

CV_BadModelOrChSeq

CV_BadNumChannels

CV_BadNumChannel1U

CV_BadDepth

CV_BadAlphaChannel

CV_BadOrder

CV_BadOrigin

CV_BadAlign

CV_BadCallBack

CV_BadTileSize

CV_BadCOI

CV_BadROISize

CV_MaskIsTiled

CV_StsNullPtr

CV_StsVecLengthErr

CV_StsFilterStructContentErr

CV_StsKernelStructContentErr

CV_StsFilterOffsetErr

CV_StsBadSize

CV_StsDivByZero

CV_StsInplaceNotSupported

CV_StsObjectNotFound

CV_StsUnmatchedFormats

CV_StsBadFlag

CV_StsBadPoint

CV_StsBadMask

CV_StsUnmatchedSizes

CV_StsUnsupportedFormat

CV_StsOutOfRange

CV_StsParseError

CV_StsNotImplemented

CV_StsBadMemBlock

CV_StsAssert

CV_GpuNotSupported

CV_GpuApiCallError

CV_OpenGlNotSupported

CV_OpenGlApiCallError

CV_OpenCLDoubleNotSupported

CV_OpenCLInitError

CV_OpenCLNoAMDBlasFft

CV_PI

CV_LOG2

CV_RNG_COEFF

IPL_DEPTH_SIGN

IPL_DEPTH_1U

IPL_DEPTH_8U

IPL_DEPTH_16U

IPL_DEPTH_32F

IPL_DEPTH_8S

IPL_DEPTH_16S

IPL_DEPTH_32S

IPL_DATA_ORDER_PIXEL

IPL_DATA_ORDER_PLANE

IPL_ORIGIN_TL

IPL_ORIGIN_BL