opencv_core (JavaCPP Presets for OpenCV 3.4.3-1.4.3 API)

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

All Implemented Interfaces:

org.bytedeco.javacpp.LoadEnabled, org.bytedeco.javacpp.tools.InfoMapper
```
public class opencv_core
extends opencv_core
```

Nested Class Summary

Nested Classes
Modifier and Type	Class and Description
`static class`	`opencv_core.Algorithm` \brief This is a base class for all more or less complex algorithms in OpenCV
`static class`	`opencv_core.Arrays`
`static class`	`opencv_core.AutoLock`
`static class`	`opencv_core.Buffer` \cond IGNORED
`static class`	`opencv_core.BufferPool` \brief BufferPool for use with CUDA streams
`static class`	`opencv_core.BufferPoolController` \addtogroup core \{
`static class`	`opencv_core.ByteVectorVector`
`static class`	`opencv_core.Complexd`
`static class`	`opencv_core.Complexf` \addtogroup core_basic \{
`static class`	`opencv_core.ConjGradSolver` \brief This class is used to perform the non-linear non-constrained minimization of a function with known gradient,
`static class`	`opencv_core.Context`
`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.Cv16suf`
`static class`	`opencv_core.Cv32suf`
`static class`	`opencv_core.Cv64suf`
`static class`	`opencv_core.CvAttrList` \brief List of attributes.
`static class`	`opencv_core.CvBox2D` \sa RotatedRect
`static class`	`opencv_core.CvChain` Chain/Contour
`static class`	`opencv_core.CvCloneFunc`
`static class`	`opencv_core.CvCmpFunc` a < b ? -1 : a > b ? 1 : 0
`static class`	`opencv_core.CvContour`
`static class`	`opencv_core.CvErrorCallback`
`static class`	`opencv_core.CvFileNode` Basic element of the file storage - scalar or collection:
`static class`	`opencv_core.CvFileNodeHash`
`static class`	`opencv_core.CvFileStorage` "black box" file storage
`static class`	`opencv_core.CvGraph` Graph is "derived" from the set (this is set a of vertices) and includes another set (edges)
`static class`	`opencv_core.CvGraphEdge` \name 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` Line iterator state:
`static class`	`opencv_core.CvMat` Deprecated. CvMat is now obsolete; consider using Mat instead.
`static class`	`opencv_core.CvMatND` Deprecated. consider using cv::Mat instead
`static class`	`opencv_core.CvMemBlock` Memory storage
`static class`	`opencv_core.CvMemStorage`
`static class`	`opencv_core.CvMemStoragePos`
`static class`	`opencv_core.CvModuleInfo`
`static class`	`opencv_core.CvNArrayIterator` matrix iterator: used for n-ary operations on dense arrays
`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` \sa Rect_
`static class`	`opencv_core.CvReleaseFunc`
`static class`	`opencv_core.CvScalar` \sa Scalar_
`static class`	`opencv_core.CvSeq` Pointer to the first sequence block.
`static class`	`opencv_core.CvSeqBlock` Sequence
`static class`	`opencv_core.CvSeqReader` pointer to previous element
`static class`	`opencv_core.CvSeqWriter` pointer to the end of block
`static class`	`opencv_core.CvSet`
`static class`	`opencv_core.CvSetElem` \brief Set Order is not preserved.
`static class`	`opencv_core.CvSize` CvSize's & CvBox
`static class`	`opencv_core.CvSize2D32f`
`static class`	`opencv_core.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` All the keys (names) of elements in the read file storage are stored in the hash to speed up the lookup operations:
`static class`	`opencv_core.CvTermCriteria` \sa TermCriteria
`static class`	`opencv_core.CvTreeNodeIterator` Iteration through the sequence tree
`static class`	`opencv_core.CvType` \addtogroup core_c_glue \{
`static class`	`opencv_core.CvTypeInfo` \brief Type information
`static class`	`opencv_core.CvWriteFunc`
`static class`	`opencv_core.DCT2D`
`static class`	`opencv_core.Device`
`static class`	`opencv_core.DeviceInfo` \brief Class providing functionality for querying the specified GPU properties.
`static class`	`opencv_core.DFT1D`
`static class`	`opencv_core.DFT2D`
`static class`	`opencv_core.DMatch` \brief Class for matching keypoint descriptors
`static class`	`opencv_core.DMatchVector`
`static class`	`opencv_core.DMatchVectorVector`
`static class`	`opencv_core.DownhillSolver` \brief This class is used to perform the non-linear non-constrained minimization of a function,
`static class`	`opencv_core.ErrorCallback`
`static class`	`opencv_core.Event`
`static class`	`opencv_core.FileNode` \brief File Storage Node class.
`static class`	`opencv_core.FileNodeIterator` \brief used to iterate through sequences and mappings.
`static class`	`opencv_core.FileStorage` \brief XML/YAML/JSON file storage class that encapsulates all the information necessary for writing or reading data to/from a file.
`static class`	`opencv_core.Formatted` \} core_cluster
`static class`	`opencv_core.Formatter` \todo document
`static class`	`opencv_core.GpuMat` \brief Base storage class for GPU memory with reference counting.
`static class`	`opencv_core.GpuMatVector`
`static class`	`opencv_core.Hamming` replaced with CV_Assert(expr) in Debug configuration
`static class`	`opencv_core.HostMem` \brief Class with reference counting wrapping special memory type allocation functions from CUDA.
`static class`	`opencv_core.Image2D`
`static class`	`opencv_core.InstrNode` \endcond
`static class`	`opencv_core.IntDoubleMap`
`static class`	`opencv_core.IntDoublePairVector`
`static class`	`opencv_core.IntIntPair`
`static class`	`opencv_core.IntIntPairVector`
`static class`	`opencv_core.IntVectorVector`
`static class`	`opencv_core.IplConvKernel`
`static class`	`opencv_core.IplConvKernelFP`
`static class`	`opencv_core.IplImage` The IplImage is taken from the Intel Image Processing Library, in which the format is native.
`static class`	`opencv_core.IplROI`
`static class`	`opencv_core.IplTileInfo`
`static class`	`opencv_core.Kernel`
`static class`	`opencv_core.KernelArg`
`static class`	`opencv_core.KeyPoint` \brief Data structure for salient point detectors.
`static class`	`opencv_core.KeyPointVector`
`static class`	`opencv_core.KeyPointVectorVector`
`static class`	`opencv_core.LDA` \brief Linear Discriminant Analysis \todo document this class
`static class`	`opencv_core.Mat` \brief n-dimensional dense array class \anchor CVMat_Details
`static class`	`opencv_core.MatAllocator` \brief Custom array allocator
`static class`	`opencv_core.MatBytePairVector`
`static class`	`opencv_core.MatConstIterator` \brief Template sparse n-dimensional array class derived from SparseMat
`static class`	`opencv_core.MatExpr` \brief Matrix expression representation \anchor MatrixExpressions This is a list of implemented matrix operations that can be combined in arbitrary complex expressions (here A, B stand for matrices ( Mat ), s for a scalar ( Scalar ), alpha for a real-valued scalar ( double )): - Addition, subtraction, negation: `A+B`, `A-B`, `A+s`, `A-s`, `s+A`, `s-A`, `-A` - Scaling: `Aalpha` - Per-element multiplication and division: `A.mul(B)`, `A/B`, `alpha/A` - Matrix multiplication: `AB` - Transposition: `A.t()` (means A^T) - Matrix inversion and pseudo-inversion, solving linear systems and least-squares problems: `A.inv([method]) (~ A<sup>-1</sup>)`, `A.inv([method])B (~ X: AX=B)` - Comparison: `A cmpop B`, `A cmpop alpha`, `alpha cmpop A`, where cmpop* is one of `>`, `>=`, `==`, `!=`, `<=`, `<`.
`static class`	`opencv_core.MatOp`
`static class`	`opencv_core.MatSize`
`static class`	`opencv_core.MatStep`
`static class`	`opencv_core.MatVector`
`static class`	`opencv_core.MatVectorVector`
`static class`	`opencv_core.MinProblemSolver` \brief Basic interface for all solvers
`static class`	`opencv_core.Moments` \} core_basic
`static class`	`opencv_core.Mutex`
`static class`	`opencv_core.NAryMatIterator` \brief n-ary multi-dimensional array iterator.
`static class`	`opencv_core.NodeData`
`static class`	`opencv_core.NodeDataTls`
`static class`	`opencv_core.NodeDataTlsData`
`static class`	`opencv_core.NodeDataTlsVector`
`static class`	`opencv_core.OclPlatform`
`static class`	`opencv_core.ParallelLoopBody` \brief Base class for parallel data processors
`static class`	`opencv_core.Param`
`static class`	`opencv_core.PCA` \brief Principal Component Analysis
`static class`	`opencv_core.PlatformInfo`
`static class`	`opencv_core.Point` \brief Template class for 2D points specified by its coordinates `x` and `y`.
`static class`	`opencv_core.Point2d`
`static class`	`opencv_core.Point2dVector`
`static class`	`opencv_core.Point2dVectorVector`
`static class`	`opencv_core.Point2f`
`static class`	`opencv_core.Point2fVector`
`static class`	`opencv_core.Point2fVectorVector`
`static class`	`opencv_core.Point3d`
`static class`	`opencv_core.Point3f`
`static class`	`opencv_core.Point3fVector`
`static class`	`opencv_core.Point3fVectorVector`
`static class`	`opencv_core.Point3i` \brief Template class for 3D points specified by its coordinates `x`, `y` and `z`.
`static class`	`opencv_core.Point3iVector`
`static class`	`opencv_core.PointVector`
`static class`	`opencv_core.PointVectorVector`
`static class`	`opencv_core.Program`
`static class`	`opencv_core.ProgramSource`
`static class`	`opencv_core.PtrOwner`
`static class`	`opencv_core.Queue`
`static class`	`opencv_core.Range` \brief Template class specifying a continuous subsequence (slice) of a sequence.
`static class`	`opencv_core.Rect` \brief Template class for 2D rectangles
`static class`	`opencv_core.Rect2d`
`static class`	`opencv_core.Rect2dVector`
`static class`	`opencv_core.Rect2f`
`static class`	`opencv_core.RectVector`
`static class`	`opencv_core.RectVectorVector`
`static class`	`opencv_core.RefOrVoid` \} core_utils
`static class`	`opencv_core.RNG` \brief Random Number Generator
`static class`	`opencv_core.RNG_MT19937` \brief Mersenne Twister random number generator
`static class`	`opencv_core.RotatedRect` \brief The class represents rotated (i.e.
`static class`	`opencv_core.Scalar` \brief Template class for a 4-element vector derived from Vec.
`static class`	`opencv_core.Scalar4i`
`static class`	`opencv_core.ScalarVector`
`static class`	`opencv_core.Size` \brief Template class for specifying the size of an image or rectangle.
`static class`	`opencv_core.Size2d`
`static class`	`opencv_core.Size2f`
`static class`	`opencv_core.SizeVector`
`static class`	`opencv_core.SparseMat` \brief The class SparseMat represents multi-dimensional sparse numerical arrays.
`static class`	`opencv_core.SparseMatConstIterator` \brief Read-Only Sparse Matrix Iterator.
`static class`	`opencv_core.SparseMatIterator` \brief Read-write Sparse Matrix Iterator
`static class`	`opencv_core.Stream` \brief This class encapsulates a queue of asynchronous calls.
`static class`	`opencv_core.StringVector`
`static class`	`opencv_core.SVD` \brief Singular Value Decomposition
`static class`	`opencv_core.TargetArchs` \brief Class providing a set of static methods to check what NVIDIA\* card architecture the CUDA module was built for.
`static class`	`opencv_core.TermCriteria` \brief The class defining termination criteria for iterative algorithms.
`static class`	`opencv_core.Texture2D`
`static class`	`opencv_core.TickMeter` \brief a Class to measure passing time.
`static class`	`opencv_core.Timer`
`static class`	`opencv_core.TLSDataContainer`
`static class`	`opencv_core.UMat` \todo document
`static class`	`opencv_core.UMatBytePairVector`
`static class`	`opencv_core.UMatData` \brief Comma-separated Matrix Initializer
`static class`	`opencv_core.UMatVector`
`static class`	`opencv_core.WriteStructContext` \cond IGNORED

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.AbstractScalar, 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.Functor, opencv_core.Ptr, opencv_core.Str

Field Summary

Fields
Modifier and Type	Field and Description
`static int`	`__UMAT_USAGE_FLAGS_32BIT` enum cv::UMatUsageFlags
`static int`	`ACCESS_FAST` enum cv::
`static int`	`ACCESS_MASK` enum cv::
`static int`	`ACCESS_READ` enum cv::
`static int`	`ACCESS_RW` enum cv::
`static int`	`ACCESS_WRITE` enum cv::
`static int`	`BadAlign` enum cv::Error::Code
`static int`	`BadAlphaChannel` enum cv::Error::Code
`static int`	`BadCallBack` enum cv::Error::Code
`static int`	`BadCOI` enum cv::Error::Code
`static int`	`BadDataPtr` enum cv::Error::Code
`static int`	`BadDepth` enum cv::Error::Code
`static int`	`BadImageSize` enum cv::Error::Code
`static int`	`BadModelOrChSeq` enum cv::Error::Code
`static int`	`BadNumChannel1U` enum cv::Error::Code
`static int`	`BadNumChannels` enum cv::Error::Code
`static int`	`BadOffset` enum cv::Error::Code
`static int`	`BadOrder` enum cv::Error::Code
`static int`	`BadOrigin` enum cv::Error::Code
`static int`	`BadROISize` enum cv::Error::Code
`static int`	`BadStep` enum cv::Error::Code
`static int`	`BadTileSize` enum cv::Error::Code
`static int`	`BORDER_CONSTANT` enum cv::BorderTypes
`static int`	`BORDER_DEFAULT` enum cv::BorderTypes
`static int`	`BORDER_ISOLATED` enum cv::BorderTypes
`static int`	`BORDER_REFLECT` enum cv::BorderTypes
`static int`	`BORDER_REFLECT_101` enum cv::BorderTypes
`static int`	`BORDER_REFLECT101` enum cv::BorderTypes
`static int`	`BORDER_REPLICATE` enum cv::BorderTypes
`static int`	`BORDER_TRANSPARENT` enum cv::BorderTypes
`static int`	`BORDER_WRAP` enum cv::BorderTypes
`static int`	`CMP_EQ` enum cv::CmpTypes
`static int`	`CMP_GE` enum cv::CmpTypes
`static int`	`CMP_GT` enum cv::CmpTypes
`static int`	`CMP_LE` enum cv::CmpTypes
`static int`	`CMP_LT` enum cv::CmpTypes
`static int`	`CMP_NE` enum cv::CmpTypes
`static int`	`COVAR_COLS` enum cv::CovarFlags
`static int`	`COVAR_NORMAL` enum cv::CovarFlags
`static int`	`COVAR_ROWS` enum cv::CovarFlags
`static int`	`COVAR_SCALE` enum cv::CovarFlags
`static int`	`COVAR_SCRAMBLED` enum cv::CovarFlags
`static int`	`COVAR_USE_AVG` enum cv::CovarFlags
`static int`	`CPU_AVX` enum CpuFeatures
`static int`	`CPU_AVX_512BW` enum CpuFeatures
`static int`	`CPU_AVX_512CD` enum CpuFeatures
`static int`	`CPU_AVX_512DQ` enum CpuFeatures
`static int`	`CPU_AVX_512ER` enum CpuFeatures
`static int`	`CPU_AVX_512F` enum CpuFeatures
`static int`	`CPU_AVX_512IFMA` enum CpuFeatures
`static int`	`CPU_AVX_512IFMA512` enum CpuFeatures
`static int`	`CPU_AVX_512PF` enum CpuFeatures
`static int`	`CPU_AVX_512VBMI` enum CpuFeatures
`static int`	`CPU_AVX_512VL` enum CpuFeatures
`static int`	`CPU_AVX2` enum CpuFeatures
`static int`	`CPU_AVX512_SKX` enum CpuFeatures
`static int`	`CPU_FMA3` enum CpuFeatures
`static int`	`CPU_FP16` enum CpuFeatures
`static int`	`CPU_MAX_FEATURE` enum CpuFeatures
`static int`	`CPU_MMX` enum CpuFeatures
`static int`	`CPU_NEON` enum CpuFeatures
`static int`	`CPU_POPCNT` enum CpuFeatures
`static int`	`CPU_SSE` enum CpuFeatures
`static int`	`CPU_SSE2` enum CpuFeatures
`static int`	`CPU_SSE3` enum CpuFeatures
`static int`	`CPU_SSE4_1` enum CpuFeatures
`static int`	`CPU_SSE4_2` enum CpuFeatures
`static int`	`CPU_SSSE3` enum CpuFeatures
`static int`	`CPU_VSX` enum CpuFeatures
`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 double`	`CV_2PI`
`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_AUTO_STEP` \ Matrix type (CvMat) * \
`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` \anchor core_c_NormFlags \name Flags for cvNorm and cvNormalize \{
`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` \name Data types primitive types - schar - signed 1 byte integer - uchar - unsigned 1 byte integer - short - signed 2 byte integer - ushort - unsigned 2 byte integer - int - signed 4 byte integer - uint - unsigned 4 byte integer - int64 - signed 8 byte integer - uint64 - unsigned 8 byte integer \{
`static int`	`CV_CN_SHIFT`
`static int`	`CV_COVAR_COLS` flag for cvCalcCovarMatrix, all the input vectors are stored in a single matrix, as its columns
`static int`	`CV_COVAR_NORMAL` flag for cvCalcCovarMatrix, [v1-avg, v2-avg,...] * transpose([v1-avg,v2-avg,...])
`static int`	`CV_COVAR_ROWS` flag for cvCalcCovarMatrix, all the input vectors are stored in a single matrix, as its rows
`static int`	`CV_COVAR_SCALE` flag for cvCalcCovarMatrix, scale the covariance matrix coefficients by number of the vectors
`static int`	`CV_COVAR_SCRAMBLED` flag for cvCalcCovarMatrix, transpose([v1-avg, v2-avg,...]) * [v1-avg,v2-avg,...]
`static int`	`CV_COVAR_USE_AVG` flag for cvCalcCovarMatrix, do not calc average (i.e.
`static int`	`CV_CPU_AVX`
`static int`	`CV_CPU_AVX_512BW`
`static int`	`CV_CPU_AVX_512CD`
`static int`	`CV_CPU_AVX_512DQ`
`static int`	`CV_CPU_AVX_512ER`
`static int`	`CV_CPU_AVX_512F`
`static int`	`CV_CPU_AVX_512IFMA`
`static int`	`CV_CPU_AVX_512IFMA512`
`static int`	`CV_CPU_AVX_512PF`
`static int`	`CV_CPU_AVX_512VBMI`
`static int`	`CV_CPU_AVX_512VL`
`static int`	`CV_CPU_AVX2`
`static int`	`CV_CPU_AVX512_SKX`
`static int`	`CV_CPU_FMA3`
`static int`	`CV_CPU_FP16`
`static int`	`CV_CPU_MMX`
`static int`	`CV_CPU_NEON`
`static int`	`CV_CPU_NONE` \addtogroup core_utils \{
`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_CPU_VSX`
`static int`	`CV_CXX_MOVE_SEMANTICS` \ C++ Move semantics * \
`static int`	`CV_CXX_STD_ARRAY` \ C++11 std::array * \
`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` \anchor core_c_DftFlags \name Flags for cvDFT, cvDCT and cvMulSpectrums \{
`static int`	`CV_DXT_INV_SCALE`
`static int`	`CV_DXT_INVERSE`
`static int`	`CV_DXT_INVERSE_SCALE`
`static int`	`CV_DXT_MUL_CONJ` conjugate the second argument of cvMulSpectrums
`static int`	`CV_DXT_ROWS` transform each row individually
`static int`	`CV_DXT_SCALE` divide result by size of array
`static int`	`CV_ErrModeLeaf`
`static int`	`CV_ErrModeParent`
`static int`	`CV_ErrModeSilent`
`static int`	`CV_FP16_TYPE`
`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` flags for graphs
`static int`	`CV_GRAPH_FORWARD_EDGE`
`static int`	`CV_GRAPH_FORWARD_EDGE_FLAG`
`static int`	`CV_GRAPH_ITEM_VISITED_FLAG` flags for graph vertices and edges
`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` Retrieves index of a graph edge given its pointer
`static int`	`CV_HAL_BORDER_CONSTANT` \}
`static int`	`CV_HAL_BORDER_ISOLATED`
`static int`	`CV_HAL_BORDER_REFLECT`
`static int`	`CV_HAL_BORDER_REFLECT_101`
`static int`	`CV_HAL_BORDER_REPLICATE`
`static int`	`CV_HAL_BORDER_TRANSPARENT`
`static int`	`CV_HAL_BORDER_WRAP`
`static int`	`CV_HAL_CMP_EQ` \}
`static int`	`CV_HAL_CMP_GE`
`static int`	`CV_HAL_CMP_GT`
`static int`	`CV_HAL_CMP_LE`
`static int`	`CV_HAL_CMP_LT`
`static int`	`CV_HAL_CMP_NE`
`static int`	`CV_HAL_DFT_COMPLEX_OUTPUT`
`static int`	`CV_HAL_DFT_INVERSE` \}
`static int`	`CV_HAL_DFT_IS_CONTINUOUS`
`static int`	`CV_HAL_DFT_IS_INPLACE`
`static int`	`CV_HAL_DFT_REAL_OUTPUT`
`static int`	`CV_HAL_DFT_ROWS`
`static int`	`CV_HAL_DFT_SCALE`
`static int`	`CV_HAL_DFT_STAGE_COLS`
`static int`	`CV_HAL_DFT_TWO_STAGE`
`static int`	`CV_HAL_ERROR_NOT_IMPLEMENTED`
`static int`	`CV_HAL_ERROR_OK` \addtogroup core_hal_interface \{
`static int`	`CV_HAL_ERROR_UNKNOWN`
`static int`	`CV_HAL_GEMM_1_T` \}
`static int`	`CV_HAL_GEMM_2_T`
`static int`	`CV_HAL_GEMM_3_T`
`static int`	`CV_HAL_SVD_FULL_UV`
`static int`	`CV_HAL_SVD_MODIFY_A`
`static int`	`CV_HAL_SVD_NO_UV` \}
`static int`	`CV_HAL_SVD_SHORT_UV`
`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` indicates whether bin ranges are set already or not
`static int`	`CV_HIST_SPARSE`
`static int`	`CV_HIST_TREE`
`static int`	`CV_HIST_UNIFORM` should be used as a parameter only, it turns to CV_HIST_UNIFORM_FLAG of hist->type
`static int`	`CV_HIST_UNIFORM_FLAG`
`static int`	`CV_KMEANS_USE_INITIAL_LABELS` The function implements the K-means algorithm for clustering an array of sample vectors in a specified number of classes
`static int`	`CV_L1`
`static int`	`CV_L2`
`static double`	`CV_LOG2`
`static int`	`CV_LU`
`static int`	`CV_MAGIC_MASK`
`static int`	`CV_MAJOR_VERSION`
`static int`	`CV_MaskIsTiled` enum
`static int`	`CV_MAT_CN_MASK` \ Matrix type (Mat) * \
`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`
`static int`	`CV_MAX_DIM`
`static int`	`CV_MINMAX`
`static int`	`CV_MINOR_VERSION`
`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` Used only for writing structures in YAML format.
`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` not used
`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_OpenCLApiCallError` enum
`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`
`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` \anchor core_c_ReduceFlags \name Flags for cvReduce \{
`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` chain-coded curves
`static int`	`CV_SEQ_CHAIN_CONTOUR`
`static int`	`CV_SEQ_CONNECTED_COMP` sequence of the connected components
`static int`	`CV_SEQ_CONTOUR`
`static int`	`CV_SEQ_ELTYPE_BITS`
`static int`	`CV_SEQ_ELTYPE_CODE` freeman code: 0..7
`static int`	`CV_SEQ_ELTYPE_CONNECTED_COMP` connected component
`static int`	`CV_SEQ_ELTYPE_GENERIC`
`static int`	`CV_SEQ_ELTYPE_GRAPH_EDGE` &next_o, &next_d, &vtx_o, &vtx_d
`static int`	`CV_SEQ_ELTYPE_GRAPH_VERTEX` first_edge, &(x,y)
`static int`	`CV_SEQ_ELTYPE_INDEX` #(x,y)
`static int`	`CV_SEQ_ELTYPE_MASK`
`static int`	`CV_SEQ_ELTYPE_POINT` (x,y)
`static int`	`CV_SEQ_ELTYPE_POINT3D` (x,y,z)
`static int`	`CV_SEQ_ELTYPE_PPOINT` &(x,y)
`static int`	`CV_SEQ_ELTYPE_PTR`
`static int`	`CV_SEQ_ELTYPE_TRIAN_ATR` vertex of the binary tree
`static int`	`CV_SEQ_FLAG_CLOSED` flags for curves
`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` sequence of the integer numbers
`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` types of sequences
`static int`	`CV_SEQ_KIND_GRAPH` types of sparse sequences (sets)
`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` point sets
`static int`	`CV_SEQ_POINT3D_SET`
`static int`	`CV_SEQ_POLYGON`
`static int`	`CV_SEQ_POLYGON_TREE` binary tree for the contour
`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_STATIC_ANALYSIS` \ static analysys * \
`static int`	`CV_STORAGE_APPEND`
`static int`	`CV_STORAGE_BASE64`
`static int`	`CV_STORAGE_FORMAT_AUTO`
`static int`	`CV_STORAGE_FORMAT_JSON`
`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` Storage flags:
`static int`	`CV_STORAGE_WRITE`
`static int`	`CV_STORAGE_WRITE_BASE64`
`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_SUBMINOR_VERSION`
`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 String`	`CV_VERSION`
`static int`	`CV_VERSION_MAJOR` \}
`static int`	`CV_VERSION_MINOR`
`static int`	`CV_VERSION_REVISION`
`static String`	`CV_VERSION_STATUS`
`static opencv_core.CvSlice`	`CV_WHOLE_ARR`
`static opencv_core.CvSlice`	`CV_WHOLE_SEQ`
`static int`	`CV_WHOLE_SEQ_END_INDEX` CvSlice
`static String`	`cvFuncName` CV_FUNCNAME macro defines icvFuncName constant which is used by CV_ERROR macro
`static int`	`DCT_INVERSE` enum cv::DftFlags
`static int`	`DCT_ROWS` enum cv::DftFlags
`static int`	`DECOMP_CHOLESKY` enum cv::DecompTypes
`static int`	`DECOMP_EIG` enum cv::DecompTypes
`static int`	`DECOMP_LU` enum cv::DecompTypes
`static int`	`DECOMP_NORMAL` enum cv::DecompTypes
`static int`	`DECOMP_QR` enum cv::DecompTypes
`static int`	`DECOMP_SVD` enum cv::DecompTypes
`static int`	`DFT_COMPLEX_INPUT` enum cv::DftFlags
`static int`	`DFT_COMPLEX_OUTPUT` enum cv::DftFlags
`static int`	`DFT_INVERSE` enum cv::DftFlags
`static int`	`DFT_REAL_OUTPUT` enum cv::DftFlags
`static int`	`DFT_ROWS` enum cv::DftFlags
`static int`	`DFT_SCALE` enum cv::DftFlags
`static int`	`DYNAMIC_PARALLELISM` enum cv::cuda::FeatureSet
`static int`	`FEATURE_SET_COMPUTE_10` enum cv::cuda::FeatureSet
`static int`	`FEATURE_SET_COMPUTE_11` enum cv::cuda::FeatureSet
`static int`	`FEATURE_SET_COMPUTE_12` enum cv::cuda::FeatureSet
`static int`	`FEATURE_SET_COMPUTE_13` enum cv::cuda::FeatureSet
`static int`	`FEATURE_SET_COMPUTE_20` enum cv::cuda::FeatureSet
`static int`	`FEATURE_SET_COMPUTE_21` enum cv::cuda::FeatureSet
`static int`	`FEATURE_SET_COMPUTE_30` enum cv::cuda::FeatureSet
`static int`	`FEATURE_SET_COMPUTE_32` enum cv::cuda::FeatureSet
`static int`	`FEATURE_SET_COMPUTE_35` enum cv::cuda::FeatureSet
`static int`	`FEATURE_SET_COMPUTE_50` enum cv::cuda::FeatureSet
`static int`	`FILLED` enum cv::LineTypes
`static int`	`FLAGS_EXPAND_SAME_NAMES` enum cv::instr::FLAGS
`static int`	`FLAGS_MAPPING` enum cv::instr::FLAGS
`static int`	`FLAGS_NONE` enum cv::instr::FLAGS
`static int`	`FONT_HERSHEY_COMPLEX` enum cv::HersheyFonts
`static int`	`FONT_HERSHEY_COMPLEX_SMALL` enum cv::HersheyFonts
`static int`	`FONT_HERSHEY_DUPLEX` enum cv::HersheyFonts
`static int`	`FONT_HERSHEY_PLAIN` enum cv::HersheyFonts
`static int`	`FONT_HERSHEY_SCRIPT_COMPLEX` enum cv::HersheyFonts
`static int`	`FONT_HERSHEY_SCRIPT_SIMPLEX` enum cv::HersheyFonts
`static int`	`FONT_HERSHEY_SIMPLEX` enum cv::HersheyFonts
`static int`	`FONT_HERSHEY_TRIPLEX` enum cv::HersheyFonts
`static int`	`FONT_ITALIC` enum cv::HersheyFonts
`static int`	`GEMM_1_T` enum cv::GemmFlags
`static int`	`GEMM_2_T` enum cv::GemmFlags
`static int`	`GEMM_3_T` enum cv::GemmFlags
`static int`	`GLOBAL_ATOMICS` enum cv::cuda::FeatureSet
`static int`	`GpuApiCallError` enum cv::Error::Code
`static int`	`GpuNotSupported` enum cv::Error::Code
`static int`	`HeaderIsNull` enum cv::Error::Code
`static int`	`IMPL_IPP` enum cv::instr::IMPL
`static int`	`IMPL_OPENCL` enum cv::instr::IMPL
`static int`	`IMPL_PLAIN` enum cv::instr::IMPL
`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` extra border mode
`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` for storing double-precision floating point data in IplImage's
`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::KmeansFlags
`static int`	`KMEANS_RANDOM_CENTERS` enum cv::KmeansFlags
`static int`	`KMEANS_USE_INITIAL_LABELS` enum cv::KmeansFlags
`static int`	`LINE_4` enum cv::LineTypes
`static int`	`LINE_8` enum cv::LineTypes
`static int`	`LINE_AA` enum cv::LineTypes
`static int`	`MaskIsTiled` enum cv::Error::Code
`static int`	`NATIVE_DOUBLE` enum cv::cuda::FeatureSet
`static int`	`NORM_HAMMING` enum cv::NormTypes
`static int`	`NORM_HAMMING2` enum cv::NormTypes
`static int`	`NORM_INF` enum cv::NormTypes
`static int`	`NORM_L1` enum cv::NormTypes
`static int`	`NORM_L2` enum cv::NormTypes
`static int`	`NORM_L2SQR` enum cv::NormTypes
`static int`	`NORM_MINMAX` enum cv::NormTypes
`static int`	`NORM_RELATIVE` enum cv::NormTypes
`static int`	`NORM_TYPE_MASK` enum cv::NormTypes
`static int`	`OCL_VECTOR_DEFAULT` enum cv::ocl::OclVectorStrategy
`static int`	`OCL_VECTOR_MAX` enum cv::ocl::OclVectorStrategy
`static int`	`OCL_VECTOR_OWN` enum cv::ocl::OclVectorStrategy
`static int`	`OpenCLApiCallError` enum cv::Error::Code
`static int`	`OpenCLDoubleNotSupported` enum cv::Error::Code
`static int`	`OpenCLInitError` enum cv::Error::Code
`static int`	`OpenCLNoAMDBlasFft` enum cv::Error::Code
`static int`	`OPENCV_ABI_COMPATIBILITY`
`static int`	`OpenGlApiCallError` enum cv::Error::Code
`static int`	`OpenGlNotSupported` enum cv::Error::Code
`static int`	`REDUCE_AVG` enum cv::ReduceTypes
`static int`	`REDUCE_MAX` enum cv::ReduceTypes
`static int`	`REDUCE_MIN` enum cv::ReduceTypes
`static int`	`REDUCE_SUM` enum cv::ReduceTypes
`static int`	`ROTATE_180` enum cv::RotateFlags
`static int`	`ROTATE_90_CLOCKWISE` enum cv::RotateFlags
`static int`	`ROTATE_90_COUNTERCLOCKWISE` enum cv::RotateFlags
`static int`	`SHARED_ATOMICS` enum cv::cuda::FeatureSet
`static int`	`SOLVELP_MULTI` enum cv::SolveLPResult
`static int`	`SOLVELP_SINGLE` enum cv::SolveLPResult
`static int`	`SOLVELP_UNBOUNDED` enum cv::SolveLPResult
`static int`	`SOLVELP_UNFEASIBLE` enum cv::SolveLPResult
`static int`	`SORT_ASCENDING` enum cv::SortFlags
`static int`	`SORT_DESCENDING` enum cv::SortFlags
`static int`	`SORT_EVERY_COLUMN` enum cv::SortFlags
`static int`	`SORT_EVERY_ROW` enum cv::SortFlags
`static int`	`StsAssert` enum cv::Error::Code
`static int`	`StsAutoTrace` enum cv::Error::Code
`static int`	`StsBackTrace` enum cv::Error::Code
`static int`	`StsBadArg` enum cv::Error::Code
`static int`	`StsBadFlag` enum cv::Error::Code
`static int`	`StsBadFunc` enum cv::Error::Code
`static int`	`StsBadMask` enum cv::Error::Code
`static int`	`StsBadMemBlock` enum cv::Error::Code
`static int`	`StsBadPoint` enum cv::Error::Code
`static int`	`StsBadSize` enum cv::Error::Code
`static int`	`StsDivByZero` enum cv::Error::Code
`static int`	`StsError` enum cv::Error::Code
`static int`	`StsFilterOffsetErr` enum cv::Error::Code
`static int`	`StsFilterStructContentErr` enum cv::Error::Code
`static int`	`StsInplaceNotSupported` enum cv::Error::Code
`static int`	`StsInternal` enum cv::Error::Code
`static int`	`StsKernelStructContentErr` enum cv::Error::Code
`static int`	`StsNoConv` enum cv::Error::Code
`static int`	`StsNoMem` enum cv::Error::Code
`static int`	`StsNotImplemented` enum cv::Error::Code
`static int`	`StsNullPtr` enum cv::Error::Code
`static int`	`StsObjectNotFound` enum cv::Error::Code
`static int`	`StsOk` enum cv::Error::Code
`static int`	`StsOutOfRange` enum cv::Error::Code
`static int`	`StsParseError` enum cv::Error::Code
`static int`	`StsUnmatchedFormats` enum cv::Error::Code
`static int`	`StsUnmatchedSizes` enum cv::Error::Code
`static int`	`StsUnsupportedFormat` enum cv::Error::Code
`static int`	`StsVecLengthErr` enum cv::Error::Code
`static int`	`TYPE_FUN` enum cv::instr::TYPE
`static int`	`TYPE_GENERAL` enum cv::instr::TYPE
`static int`	`TYPE_MARKER` enum cv::instr::TYPE
`static int`	`TYPE_WRAPPER` enum cv::instr::TYPE
`static int`	`USAGE_ALLOCATE_DEVICE_MEMORY` enum cv::UMatUsageFlags
`static int`	`USAGE_ALLOCATE_HOST_MEMORY` enum cv::UMatUsageFlags
`static int`	`USAGE_ALLOCATE_SHARED_MEMORY` enum cv::UMatUsageFlags
`static int`	`USAGE_DEFAULT` enum cv::UMatUsageFlags
`static int`	`WARP_SHUFFLE_FUNCTIONS` enum cv::cuda::FeatureSet

Constructor Summary

Constructors
Constructor and Description

opencv_core()

Constructors
Constructor and Description
`opencv_core()`

Method Summary

All Methods Static Methods Concrete Methods Deprecated Methods
Modifier and Type	Method and Description
`static byte`	`abs(byte a)` \endcond
`static int`	`abs(int a)`
`static opencv_core.MatExpr`	`abs(opencv_core.Mat m)` \brief Calculates an absolute value of each matrix element.
`static opencv_core.MatExpr`	`abs(opencv_core.MatExpr e)` \overload
`static short`	`abs(short a)`
`static void`	`absdiff(opencv_core.GpuMat src1, opencv_core.GpuMat src2, opencv_core.GpuMat dst)`
`static void`	`absdiff(opencv_core.Mat src1, opencv_core.Mat src2, opencv_core.Mat dst)` \brief Calculates the per-element absolute difference between two arrays or between an array and a scalar.
`static void`	`absdiff(opencv_core.UMat src1, opencv_core.UMat src2, opencv_core.UMat dst)`
`static void`	`absdiff16s(short[] src1, long step1, short[] src2, long step2, short[] dst, long step, int width, int height, org.bytedeco.javacpp.Pointer arg8)`
`static void`	`absdiff16s(ShortBuffer src1, long step1, ShortBuffer src2, long step2, ShortBuffer dst, long step, int width, int height, org.bytedeco.javacpp.Pointer arg8)`
`static void`	`absdiff16s(org.bytedeco.javacpp.ShortPointer src1, long step1, org.bytedeco.javacpp.ShortPointer src2, long step2, org.bytedeco.javacpp.ShortPointer dst, long step, int width, int height, org.bytedeco.javacpp.Pointer arg8)`
`static void`	`absdiff16u(short[] src1, long step1, short[] src2, long step2, short[] dst, long step, int width, int height, org.bytedeco.javacpp.Pointer arg8)`
`static void`	`absdiff16u(ShortBuffer src1, long step1, ShortBuffer src2, long step2, ShortBuffer dst, long step, int width, int height, org.bytedeco.javacpp.Pointer arg8)`
`static void`	`absdiff16u(org.bytedeco.javacpp.ShortPointer src1, long step1, org.bytedeco.javacpp.ShortPointer src2, long step2, org.bytedeco.javacpp.ShortPointer dst, long step, int width, int height, org.bytedeco.javacpp.Pointer arg8)`
`static void`	`absdiff32f(float[] src1, long step1, float[] src2, long step2, float[] dst, long step, int width, int height, org.bytedeco.javacpp.Pointer arg8)`
`static void`	`absdiff32f(FloatBuffer src1, long step1, FloatBuffer src2, long step2, FloatBuffer dst, long step, int width, int height, org.bytedeco.javacpp.Pointer arg8)`
`static void`	`absdiff32f(org.bytedeco.javacpp.FloatPointer src1, long step1, org.bytedeco.javacpp.FloatPointer src2, long step2, org.bytedeco.javacpp.FloatPointer dst, long step, int width, int height, org.bytedeco.javacpp.Pointer arg8)`
`static void`	`absdiff32s(int[] src1, long step1, int[] src2, long step2, int[] dst, long step, int width, int height, org.bytedeco.javacpp.Pointer arg8)`
`static void`	`absdiff32s(IntBuffer src1, long step1, IntBuffer src2, long step2, IntBuffer dst, long step, int width, int height, org.bytedeco.javacpp.Pointer arg8)`
`static void`	`absdiff32s(org.bytedeco.javacpp.IntPointer src1, long step1, org.bytedeco.javacpp.IntPointer src2, long step2, org.bytedeco.javacpp.IntPointer dst, long step, int width, int height, org.bytedeco.javacpp.Pointer arg8)`
`static void`	`absdiff64f(double[] src1, long step1, double[] src2, long step2, double[] dst, long step, int width, int height, org.bytedeco.javacpp.Pointer arg8)`
`static void`	`absdiff64f(DoubleBuffer src1, long step1, DoubleBuffer src2, long step2, DoubleBuffer dst, long step, int width, int height, org.bytedeco.javacpp.Pointer arg8)`
`static void`	`absdiff64f(org.bytedeco.javacpp.DoublePointer src1, long step1, org.bytedeco.javacpp.DoublePointer src2, long step2, org.bytedeco.javacpp.DoublePointer dst, long step, int width, int height, org.bytedeco.javacpp.Pointer arg8)`
`static void`	`absdiff8s(byte[] src1, long step1, byte[] src2, long step2, byte[] dst, long step, int width, int height, org.bytedeco.javacpp.Pointer arg8)`
`static void`	`absdiff8s(ByteBuffer src1, long step1, ByteBuffer src2, long step2, ByteBuffer dst, long step, int width, int height, org.bytedeco.javacpp.Pointer arg8)`
`static void`	`absdiff8s(org.bytedeco.javacpp.BytePointer src1, long step1, org.bytedeco.javacpp.BytePointer src2, long step2, org.bytedeco.javacpp.BytePointer dst, long step, int width, int height, org.bytedeco.javacpp.Pointer arg8)`
`static void`	`absdiff8u(byte[] src1, long step1, byte[] src2, long step2, byte[] dst, long step, int width, int height, org.bytedeco.javacpp.Pointer arg8)`
`static void`	`absdiff8u(ByteBuffer src1, long step1, ByteBuffer src2, long step2, ByteBuffer dst, long step, int width, int height, org.bytedeco.javacpp.Pointer arg8)`
`static void`	`absdiff8u(org.bytedeco.javacpp.BytePointer src1, long step1, org.bytedeco.javacpp.BytePointer src2, long step2, org.bytedeco.javacpp.BytePointer dst, long step, int width, int height, org.bytedeco.javacpp.Pointer arg8)`
`static org.bytedeco.javacpp.BytePointer`	`add(byte lhs, org.bytedeco.javacpp.BytePointer rhs)`
`static org.bytedeco.javacpp.BytePointer`	`add(org.bytedeco.javacpp.BytePointer lhs, byte rhs)`
`static org.bytedeco.javacpp.BytePointer`	`add(org.bytedeco.javacpp.BytePointer lhs, org.bytedeco.javacpp.BytePointer rhs)` \relates cv::String /** \{
`static String`	`add(byte lhs, String rhs)`
`static opencv_core.Range`	`add(int delta, opencv_core.Range r1)`
`static void`	`add(opencv_core.GpuMat src1, opencv_core.GpuMat src2, opencv_core.GpuMat dst)`
`static void`	`add(opencv_core.GpuMat src1, opencv_core.GpuMat src2, opencv_core.GpuMat dst, opencv_core.GpuMat mask, int dtype)`
`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)` \} core_basic
`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)` \brief Calculates the per-element sum of two arrays or an array and a scalar.
`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 void`	`add(opencv_core.UMat src1, opencv_core.UMat src2, opencv_core.UMat dst)`
`static void`	`add(opencv_core.UMat src1, opencv_core.UMat src2, opencv_core.UMat dst, opencv_core.UMat mask, int dtype)`
`static String`	`add(String lhs, byte rhs)`
`static String`	`add(String lhs, String rhs)`
`static void`	`add16s(short[] src1, long step1, short[] src2, long step2, short[] dst, long step, int width, int height, org.bytedeco.javacpp.Pointer arg8)`
`static void`	`add16s(ShortBuffer src1, long step1, ShortBuffer src2, long step2, ShortBuffer dst, long step, int width, int height, org.bytedeco.javacpp.Pointer arg8)`
`static void`	`add16s(org.bytedeco.javacpp.ShortPointer src1, long step1, org.bytedeco.javacpp.ShortPointer src2, long step2, org.bytedeco.javacpp.ShortPointer dst, long step, int width, int height, org.bytedeco.javacpp.Pointer arg8)`
`static void`	`add16u(short[] src1, long step1, short[] src2, long step2, short[] dst, long step, int width, int height, org.bytedeco.javacpp.Pointer arg8)`
`static void`	`add16u(ShortBuffer src1, long step1, ShortBuffer src2, long step2, ShortBuffer dst, long step, int width, int height, org.bytedeco.javacpp.Pointer arg8)`
`static void`	`add16u(org.bytedeco.javacpp.ShortPointer src1, long step1, org.bytedeco.javacpp.ShortPointer src2, long step2, org.bytedeco.javacpp.ShortPointer dst, long step, int width, int height, org.bytedeco.javacpp.Pointer arg8)`
`static void`	`add32f(float[] src1, long step1, float[] src2, long step2, float[] dst, long step, int width, int height, org.bytedeco.javacpp.Pointer arg8)`
`static void`	`add32f(FloatBuffer src1, long step1, FloatBuffer src2, long step2, FloatBuffer dst, long step, int width, int height, org.bytedeco.javacpp.Pointer arg8)`
`static void`	`add32f(org.bytedeco.javacpp.FloatPointer src1, long step1, org.bytedeco.javacpp.FloatPointer src2, long step2, org.bytedeco.javacpp.FloatPointer dst, long step, int width, int height, org.bytedeco.javacpp.Pointer arg8)`
`static void`	`add32s(int[] src1, long step1, int[] src2, long step2, int[] dst, long step, int width, int height, org.bytedeco.javacpp.Pointer arg8)`
`static void`	`add32s(IntBuffer src1, long step1, IntBuffer src2, long step2, IntBuffer dst, long step, int width, int height, org.bytedeco.javacpp.Pointer arg8)`
`static void`	`add32s(org.bytedeco.javacpp.IntPointer src1, long step1, org.bytedeco.javacpp.IntPointer src2, long step2, org.bytedeco.javacpp.IntPointer dst, long step, int width, int height, org.bytedeco.javacpp.Pointer arg8)`
`static void`	`add64f(double[] src1, long step1, double[] src2, long step2, double[] dst, long step, int width, int height, org.bytedeco.javacpp.Pointer arg8)`
`static void`	`add64f(DoubleBuffer src1, long step1, DoubleBuffer src2, long step2, DoubleBuffer dst, long step, int width, int height, org.bytedeco.javacpp.Pointer arg8)`
`static void`	`add64f(org.bytedeco.javacpp.DoublePointer src1, long step1, org.bytedeco.javacpp.DoublePointer src2, long step2, org.bytedeco.javacpp.DoublePointer dst, long step, int width, int height, org.bytedeco.javacpp.Pointer arg8)`
`static void`	`add8s(byte[] src1, long step1, byte[] src2, long step2, byte[] dst, long step, int width, int height, org.bytedeco.javacpp.Pointer arg8)`
`static void`	`add8s(ByteBuffer src1, long step1, ByteBuffer src2, long step2, ByteBuffer dst, long step, int width, int height, org.bytedeco.javacpp.Pointer arg8)`
`static void`	`add8s(org.bytedeco.javacpp.BytePointer src1, long step1, org.bytedeco.javacpp.BytePointer src2, long step2, org.bytedeco.javacpp.BytePointer dst, long step, int width, int height, org.bytedeco.javacpp.Pointer arg8)`
`static void`	`add8u(byte[] src1, long step1, byte[] src2, long step2, byte[] dst, long step, int width, int height, org.bytedeco.javacpp.Pointer arg8)`
`static void`	`add8u(ByteBuffer src1, long step1, ByteBuffer src2, long step2, ByteBuffer dst, long step, int width, int height, org.bytedeco.javacpp.Pointer arg8)`
`static void`	`add8u(org.bytedeco.javacpp.BytePointer src1, long step1, org.bytedeco.javacpp.BytePointer src2, long step2, org.bytedeco.javacpp.BytePointer dst, long step, int width, int height, org.bytedeco.javacpp.Pointer arg8)`
`static opencv_core.Mat`	`addPut(opencv_core.Mat a, opencv_core.Mat b)` \cond IGNORED
`static opencv_core.Mat`	`addPut(opencv_core.Mat a, opencv_core.Scalar b)`
`static void`	`addWeighted(opencv_core.GpuMat src1, double alpha, opencv_core.GpuMat src2, double beta, double gamma, opencv_core.GpuMat dst)`
`static void`	`addWeighted(opencv_core.GpuMat src1, double alpha, opencv_core.GpuMat src2, double beta, double gamma, opencv_core.GpuMat dst, int dtype)`
`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)` \brief Calculates the weighted sum of two arrays.
`static void`	`addWeighted(opencv_core.UMat src1, double alpha, opencv_core.UMat src2, double beta, double gamma, opencv_core.UMat dst)`
`static void`	`addWeighted(opencv_core.UMat src1, double alpha, opencv_core.UMat src2, double beta, double gamma, opencv_core.UMat dst, int dtype)`
`static void`	`addWeighted16s(short[] src1, long step1, short[] src2, long step2, short[] dst, long step, int width, int height, org.bytedeco.javacpp.Pointer scalars)`
`static void`	`addWeighted16s(ShortBuffer src1, long step1, ShortBuffer src2, long step2, ShortBuffer dst, long step, int width, int height, org.bytedeco.javacpp.Pointer scalars)`
`static void`	`addWeighted16s(org.bytedeco.javacpp.ShortPointer src1, long step1, org.bytedeco.javacpp.ShortPointer src2, long step2, org.bytedeco.javacpp.ShortPointer dst, long step, int width, int height, org.bytedeco.javacpp.Pointer scalars)`
`static void`	`addWeighted16u(short[] src1, long step1, short[] src2, long step2, short[] dst, long step, int width, int height, org.bytedeco.javacpp.Pointer scalars)`
`static void`	`addWeighted16u(ShortBuffer src1, long step1, ShortBuffer src2, long step2, ShortBuffer dst, long step, int width, int height, org.bytedeco.javacpp.Pointer scalars)`
`static void`	`addWeighted16u(org.bytedeco.javacpp.ShortPointer src1, long step1, org.bytedeco.javacpp.ShortPointer src2, long step2, org.bytedeco.javacpp.ShortPointer dst, long step, int width, int height, org.bytedeco.javacpp.Pointer scalars)`
`static void`	`addWeighted32f(float[] src1, long step1, float[] src2, long step2, float[] dst, long step, int width, int height, org.bytedeco.javacpp.Pointer scalars)`
`static void`	`addWeighted32f(FloatBuffer src1, long step1, FloatBuffer src2, long step2, FloatBuffer dst, long step, int width, int height, org.bytedeco.javacpp.Pointer scalars)`
`static void`	`addWeighted32f(org.bytedeco.javacpp.FloatPointer src1, long step1, org.bytedeco.javacpp.FloatPointer src2, long step2, org.bytedeco.javacpp.FloatPointer dst, long step, int width, int height, org.bytedeco.javacpp.Pointer scalars)`
`static void`	`addWeighted32s(int[] src1, long step1, int[] src2, long step2, int[] dst, long step, int width, int height, org.bytedeco.javacpp.Pointer scalars)`
`static void`	`addWeighted32s(IntBuffer src1, long step1, IntBuffer src2, long step2, IntBuffer dst, long step, int width, int height, org.bytedeco.javacpp.Pointer scalars)`
`static void`	`addWeighted32s(org.bytedeco.javacpp.IntPointer src1, long step1, org.bytedeco.javacpp.IntPointer src2, long step2, org.bytedeco.javacpp.IntPointer dst, long step, int width, int height, org.bytedeco.javacpp.Pointer scalars)`
`static void`	`addWeighted64f(double[] src1, long step1, double[] src2, long step2, double[] dst, long step, int width, int height, org.bytedeco.javacpp.Pointer scalars)`
`static void`	`addWeighted64f(DoubleBuffer src1, long step1, DoubleBuffer src2, long step2, DoubleBuffer dst, long step, int width, int height, org.bytedeco.javacpp.Pointer scalars)`
`static void`	`addWeighted64f(org.bytedeco.javacpp.DoublePointer src1, long step1, org.bytedeco.javacpp.DoublePointer src2, long step2, org.bytedeco.javacpp.DoublePointer dst, long step, int width, int height, org.bytedeco.javacpp.Pointer scalars)`
`static void`	`addWeighted8s(byte[] src1, long step1, byte[] src2, long step2, byte[] dst, long step, int width, int height, org.bytedeco.javacpp.Pointer scalars)`
`static void`	`addWeighted8s(ByteBuffer src1, long step1, ByteBuffer src2, long step2, ByteBuffer dst, long step, int width, int height, org.bytedeco.javacpp.Pointer scalars)`
`static void`	`addWeighted8s(org.bytedeco.javacpp.BytePointer src1, long step1, org.bytedeco.javacpp.BytePointer src2, long step2, org.bytedeco.javacpp.BytePointer dst, long step, int width, int height, org.bytedeco.javacpp.Pointer scalars)`
`static void`	`addWeighted8u(byte[] src1, long step1, byte[] src2, long step2, byte[] dst, long step, int width, int height, org.bytedeco.javacpp.Pointer _scalars)`
`static void`	`addWeighted8u(ByteBuffer src1, long step1, ByteBuffer src2, long step2, ByteBuffer dst, long step, int width, int height, org.bytedeco.javacpp.Pointer _scalars)`
`static void`	`addWeighted8u(org.bytedeco.javacpp.BytePointer src1, long step1, org.bytedeco.javacpp.BytePointer src2, long step2, org.bytedeco.javacpp.BytePointer dst, long step, int width, int height, org.bytedeco.javacpp.Pointer _scalars)`
`static long`	`alignSize(long sz, int n)` \brief Aligns a buffer size to the specified number of bytes.
`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 void`	`and8u(byte[] src1, long step1, byte[] src2, long step2, byte[] dst, long step, int width, int height, org.bytedeco.javacpp.Pointer arg8)`
`static void`	`and8u(ByteBuffer src1, long step1, ByteBuffer src2, long step2, ByteBuffer dst, long step, int width, int height, org.bytedeco.javacpp.Pointer arg8)`
`static void`	`and8u(org.bytedeco.javacpp.BytePointer src1, long step1, org.bytedeco.javacpp.BytePointer src2, long step2, org.bytedeco.javacpp.BytePointer dst, long step, int width, int height, org.bytedeco.javacpp.Pointer arg8)`
`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 b)`
`static opencv_core.Range`	`andPut(opencv_core.Range r1, opencv_core.Range r2)`
`static void`	`attachContext(org.bytedeco.javacpp.BytePointer platformName, org.bytedeco.javacpp.Pointer platformID, org.bytedeco.javacpp.Pointer context, org.bytedeco.javacpp.Pointer deviceID)` \brief Attaches OpenCL context to OpenCV \note OpenCV will check if available OpenCL platform has platformName name, then assign context to OpenCV and call `clRetainContext` function.
`static void`	`attachContext(String platformName, org.bytedeco.javacpp.Pointer platformID, org.bytedeco.javacpp.Pointer context, org.bytedeco.javacpp.Pointer deviceID)`
`static void`	`batchDistance(opencv_core.GpuMat src1, opencv_core.GpuMat src2, opencv_core.GpuMat dist, int dtype, opencv_core.GpuMat nidx)`
`static void`	`batchDistance(opencv_core.GpuMat src1, opencv_core.GpuMat src2, opencv_core.GpuMat dist, int dtype, opencv_core.GpuMat nidx, int normType, int K, opencv_core.GpuMat mask, int update, boolean crosscheck)`
`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)` \brief naive nearest neighbor finder
`static void`	`batchDistance(opencv_core.UMat src1, opencv_core.UMat src2, opencv_core.UMat dist, int dtype, opencv_core.UMat nidx)`
`static void`	`batchDistance(opencv_core.UMat src1, opencv_core.UMat src2, opencv_core.UMat dist, int dtype, opencv_core.UMat nidx, int normType, int K, opencv_core.UMat mask, int update, boolean crosscheck)`
`static void`	`bitwise_and(opencv_core.GpuMat src1, opencv_core.GpuMat src2, opencv_core.GpuMat dst)`
`static void`	`bitwise_and(opencv_core.GpuMat src1, opencv_core.GpuMat src2, opencv_core.GpuMat dst, opencv_core.GpuMat mask)`
`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)` \brief computes bitwise conjunction of the two arrays (dst = src1 & src2) Calculates the per-element bit-wise conjunction of two arrays or an array and a scalar.
`static void`	`bitwise_and(opencv_core.UMat src1, opencv_core.UMat src2, opencv_core.UMat dst)`
`static void`	`bitwise_and(opencv_core.UMat src1, opencv_core.UMat src2, opencv_core.UMat dst, opencv_core.UMat mask)`
`static void`	`bitwise_not(opencv_core.GpuMat src, opencv_core.GpuMat dst)`
`static void`	`bitwise_not(opencv_core.GpuMat src, opencv_core.GpuMat dst, opencv_core.GpuMat mask)`
`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)` \brief Inverts every bit of an array.
`static void`	`bitwise_not(opencv_core.UMat src, opencv_core.UMat dst)`
`static void`	`bitwise_not(opencv_core.UMat src, opencv_core.UMat dst, opencv_core.UMat mask)`
`static void`	`bitwise_or(opencv_core.GpuMat src1, opencv_core.GpuMat src2, opencv_core.GpuMat dst)`
`static void`	`bitwise_or(opencv_core.GpuMat src1, opencv_core.GpuMat src2, opencv_core.GpuMat dst, opencv_core.GpuMat mask)`
`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)` \brief Calculates the per-element bit-wise disjunction of two arrays or an array and a scalar.
`static void`	`bitwise_or(opencv_core.UMat src1, opencv_core.UMat src2, opencv_core.UMat dst)`
`static void`	`bitwise_or(opencv_core.UMat src1, opencv_core.UMat src2, opencv_core.UMat dst, opencv_core.UMat mask)`
`static void`	`bitwise_xor(opencv_core.GpuMat src1, opencv_core.GpuMat src2, opencv_core.GpuMat dst)`
`static void`	`bitwise_xor(opencv_core.GpuMat src1, opencv_core.GpuMat src2, opencv_core.GpuMat dst, opencv_core.GpuMat mask)`
`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)` \brief Calculates the per-element bit-wise "exclusive or" operation on two arrays or an array and a scalar.
`static void`	`bitwise_xor(opencv_core.UMat src1, opencv_core.UMat src2, opencv_core.UMat dst)`
`static void`	`bitwise_xor(opencv_core.UMat src1, opencv_core.UMat src2, opencv_core.UMat dst, opencv_core.UMat mask)`
`static int`	`borderInterpolate(int p, int len, int borderType)` \} core
`static void`	`buildOptionsAddMatrixDescription(org.bytedeco.javacpp.BytePointer buildOptions, org.bytedeco.javacpp.BytePointer name, opencv_core.GpuMat _m)`
`static void`	`buildOptionsAddMatrixDescription(org.bytedeco.javacpp.BytePointer buildOptions, org.bytedeco.javacpp.BytePointer name, opencv_core.Mat _m)`
`static void`	`buildOptionsAddMatrixDescription(org.bytedeco.javacpp.BytePointer buildOptions, org.bytedeco.javacpp.BytePointer name, opencv_core.UMat _m)`
`static void`	`buildOptionsAddMatrixDescription(String buildOptions, String name, opencv_core.GpuMat _m)`
`static void`	`buildOptionsAddMatrixDescription(String buildOptions, String name, opencv_core.Mat _m)`
`static void`	`buildOptionsAddMatrixDescription(String buildOptions, String name, opencv_core.UMat _m)`
`static void`	`calcCovarMatrix(opencv_core.GpuMat samples, opencv_core.GpuMat covar, opencv_core.GpuMat mean, int flags)`
`static void`	`calcCovarMatrix(opencv_core.GpuMat samples, opencv_core.GpuMat covar, opencv_core.GpuMat mean, int flags, int ctype)`
`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)` \brief Calculates the covariance matrix of a set of vectors.
`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)` \overload \note use #COVAR_ROWS or #COVAR_COLS flag
`static void`	`calcCovarMatrix(opencv_core.UMat samples, opencv_core.UMat covar, opencv_core.UMat mean, int flags)`
`static void`	`calcCovarMatrix(opencv_core.UMat samples, opencv_core.UMat covar, opencv_core.UMat mean, int flags, int ctype)`
`static void`	`cartToPolar(opencv_core.GpuMat x, opencv_core.GpuMat y, opencv_core.GpuMat magnitude, opencv_core.GpuMat angle)`
`static void`	`cartToPolar(opencv_core.GpuMat x, opencv_core.GpuMat y, opencv_core.GpuMat magnitude, opencv_core.GpuMat angle, boolean angleInDegrees)`
`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)` \brief Calculates the magnitude and angle of 2D vectors.
`static void`	`cartToPolar(opencv_core.UMat x, opencv_core.UMat y, opencv_core.UMat magnitude, opencv_core.UMat angle)`
`static void`	`cartToPolar(opencv_core.UMat x, opencv_core.UMat y, opencv_core.UMat magnitude, opencv_core.UMat angle, boolean angleInDegrees)`
`static boolean`	`checkHardwareSupport(int feature)` \brief Returns true if the specified feature is supported by the host hardware.
`static int`	`checkOptimalVectorWidth(int[] vectorWidths, opencv_core.GpuMat src1)`
`static int`	`checkOptimalVectorWidth(int[] vectorWidths, opencv_core.GpuMat src1, opencv_core.GpuMat src2, opencv_core.GpuMat src3, opencv_core.GpuMat src4, opencv_core.GpuMat src5, opencv_core.GpuMat src6, opencv_core.GpuMat src7, opencv_core.GpuMat src8, opencv_core.GpuMat src9, int strat)`
`static int`	`checkOptimalVectorWidth(int[] vectorWidths, opencv_core.Mat src1)`
`static int`	`checkOptimalVectorWidth(int[] vectorWidths, opencv_core.Mat src1, opencv_core.Mat src2, opencv_core.Mat src3, opencv_core.Mat src4, opencv_core.Mat src5, opencv_core.Mat src6, opencv_core.Mat src7, opencv_core.Mat src8, opencv_core.Mat src9, int strat)`
`static int`	`checkOptimalVectorWidth(int[] vectorWidths, opencv_core.UMat src1)`
`static int`	`checkOptimalVectorWidth(int[] vectorWidths, opencv_core.UMat src1, opencv_core.UMat src2, opencv_core.UMat src3, opencv_core.UMat src4, opencv_core.UMat src5, opencv_core.UMat src6, opencv_core.UMat src7, opencv_core.UMat src8, opencv_core.UMat src9, int strat)`
`static int`	`checkOptimalVectorWidth(IntBuffer vectorWidths, opencv_core.GpuMat src1)`
`static int`	`checkOptimalVectorWidth(IntBuffer vectorWidths, opencv_core.GpuMat src1, opencv_core.GpuMat src2, opencv_core.GpuMat src3, opencv_core.GpuMat src4, opencv_core.GpuMat src5, opencv_core.GpuMat src6, opencv_core.GpuMat src7, opencv_core.GpuMat src8, opencv_core.GpuMat src9, int strat)`
`static int`	`checkOptimalVectorWidth(IntBuffer vectorWidths, opencv_core.Mat src1)`
`static int`	`checkOptimalVectorWidth(IntBuffer vectorWidths, opencv_core.Mat src1, opencv_core.Mat src2, opencv_core.Mat src3, opencv_core.Mat src4, opencv_core.Mat src5, opencv_core.Mat src6, opencv_core.Mat src7, opencv_core.Mat src8, opencv_core.Mat src9, int strat)`
`static int`	`checkOptimalVectorWidth(IntBuffer vectorWidths, opencv_core.UMat src1)`
`static int`	`checkOptimalVectorWidth(IntBuffer vectorWidths, opencv_core.UMat src1, opencv_core.UMat src2, opencv_core.UMat src3, opencv_core.UMat src4, opencv_core.UMat src5, opencv_core.UMat src6, opencv_core.UMat src7, opencv_core.UMat src8, opencv_core.UMat src9, int strat)`
`static int`	`checkOptimalVectorWidth(org.bytedeco.javacpp.IntPointer vectorWidths, opencv_core.GpuMat src1)`
`static int`	`checkOptimalVectorWidth(org.bytedeco.javacpp.IntPointer vectorWidths, opencv_core.GpuMat src1, opencv_core.GpuMat src2, opencv_core.GpuMat src3, opencv_core.GpuMat src4, opencv_core.GpuMat src5, opencv_core.GpuMat src6, opencv_core.GpuMat src7, opencv_core.GpuMat src8, opencv_core.GpuMat src9, int strat)`
`static int`	`checkOptimalVectorWidth(org.bytedeco.javacpp.IntPointer vectorWidths, opencv_core.Mat src1)`
`static int`	`checkOptimalVectorWidth(org.bytedeco.javacpp.IntPointer vectorWidths, opencv_core.Mat src1, opencv_core.Mat src2, opencv_core.Mat src3, opencv_core.Mat src4, opencv_core.Mat src5, opencv_core.Mat src6, opencv_core.Mat src7, opencv_core.Mat src8, opencv_core.Mat src9, int strat)`
`static int`	`checkOptimalVectorWidth(org.bytedeco.javacpp.IntPointer vectorWidths, opencv_core.UMat src1)`
`static int`	`checkOptimalVectorWidth(org.bytedeco.javacpp.IntPointer vectorWidths, opencv_core.UMat src1, opencv_core.UMat src2, opencv_core.UMat src3, opencv_core.UMat src4, opencv_core.UMat src5, opencv_core.UMat src6, opencv_core.UMat src7, opencv_core.UMat src8, opencv_core.UMat src9, int strat)`
`static boolean`	`checkRange(opencv_core.GpuMat a)`
`static boolean`	`checkRange(opencv_core.GpuMat a, boolean quiet, opencv_core.Point pos, double minVal, double maxVal)`
`static boolean`	`checkRange(opencv_core.Mat a)`
`static boolean`	`checkRange(opencv_core.Mat a, boolean quiet, opencv_core.Point pos, double minVal, double maxVal)` \brief Checks every element of an input array for invalid values.
`static boolean`	`checkRange(opencv_core.UMat a)`
`static boolean`	`checkRange(opencv_core.UMat a, boolean quiet, opencv_core.Point pos, double minVal, double maxVal)`
`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(org.bytedeco.javacpp.DoublePointer A, long astep, int m, org.bytedeco.javacpp.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(org.bytedeco.javacpp.FloatPointer A, long astep, int m, org.bytedeco.javacpp.FloatPointer b, long bstep, int n)`
`static boolean`	`Cholesky32f(float[] A, long astep, int m, float[] b, long bstep, int n)`
`static boolean`	`Cholesky32f(FloatBuffer A, long astep, int m, FloatBuffer b, long bstep, int n)`
`static boolean`	`Cholesky32f(org.bytedeco.javacpp.FloatPointer A, long astep, int m, org.bytedeco.javacpp.FloatPointer b, long bstep, int n)`
`static boolean`	`Cholesky64f(double[] A, long astep, int m, double[] b, long bstep, int n)`
`static boolean`	`Cholesky64f(DoubleBuffer A, long astep, int m, DoubleBuffer b, long bstep, int n)`
`static boolean`	`Cholesky64f(org.bytedeco.javacpp.DoublePointer A, long astep, int m, org.bytedeco.javacpp.DoublePointer b, long bstep, int n)`
`static void`	`clearSeq(opencv_core.CvSeq seq)`
`static void`	`cmp16s(short[] src1, long step1, short[] src2, long step2, byte[] dst, long step, int width, int height, org.bytedeco.javacpp.Pointer _cmpop)`
`static void`	`cmp16s(ShortBuffer src1, long step1, ShortBuffer src2, long step2, ByteBuffer dst, long step, int width, int height, org.bytedeco.javacpp.Pointer _cmpop)`
`static void`	`cmp16s(org.bytedeco.javacpp.ShortPointer src1, long step1, org.bytedeco.javacpp.ShortPointer src2, long step2, org.bytedeco.javacpp.BytePointer dst, long step, int width, int height, org.bytedeco.javacpp.Pointer _cmpop)`
`static void`	`cmp16u(short[] src1, long step1, short[] src2, long step2, byte[] dst, long step, int width, int height, org.bytedeco.javacpp.Pointer _cmpop)`
`static void`	`cmp16u(ShortBuffer src1, long step1, ShortBuffer src2, long step2, ByteBuffer dst, long step, int width, int height, org.bytedeco.javacpp.Pointer _cmpop)`
`static void`	`cmp16u(org.bytedeco.javacpp.ShortPointer src1, long step1, org.bytedeco.javacpp.ShortPointer src2, long step2, org.bytedeco.javacpp.BytePointer dst, long step, int width, int height, org.bytedeco.javacpp.Pointer _cmpop)`
`static void`	`cmp32f(float[] src1, long step1, float[] src2, long step2, byte[] dst, long step, int width, int height, org.bytedeco.javacpp.Pointer _cmpop)`
`static void`	`cmp32f(FloatBuffer src1, long step1, FloatBuffer src2, long step2, ByteBuffer dst, long step, int width, int height, org.bytedeco.javacpp.Pointer _cmpop)`
`static void`	`cmp32f(org.bytedeco.javacpp.FloatPointer src1, long step1, org.bytedeco.javacpp.FloatPointer src2, long step2, org.bytedeco.javacpp.BytePointer dst, long step, int width, int height, org.bytedeco.javacpp.Pointer _cmpop)`
`static void`	`cmp32s(int[] src1, long step1, int[] src2, long step2, byte[] dst, long step, int width, int height, org.bytedeco.javacpp.Pointer _cmpop)`
`static void`	`cmp32s(IntBuffer src1, long step1, IntBuffer src2, long step2, ByteBuffer dst, long step, int width, int height, org.bytedeco.javacpp.Pointer _cmpop)`
`static void`	`cmp32s(org.bytedeco.javacpp.IntPointer src1, long step1, org.bytedeco.javacpp.IntPointer src2, long step2, org.bytedeco.javacpp.BytePointer dst, long step, int width, int height, org.bytedeco.javacpp.Pointer _cmpop)`
`static void`	`cmp64f(double[] src1, long step1, double[] src2, long step2, byte[] dst, long step, int width, int height, org.bytedeco.javacpp.Pointer _cmpop)`
`static void`	`cmp64f(DoubleBuffer src1, long step1, DoubleBuffer src2, long step2, ByteBuffer dst, long step, int width, int height, org.bytedeco.javacpp.Pointer _cmpop)`
`static void`	`cmp64f(org.bytedeco.javacpp.DoublePointer src1, long step1, org.bytedeco.javacpp.DoublePointer src2, long step2, org.bytedeco.javacpp.BytePointer dst, long step, int width, int height, org.bytedeco.javacpp.Pointer _cmpop)`
`static void`	`cmp8s(byte[] src1, long step1, byte[] src2, long step2, byte[] dst, long step, int width, int height, org.bytedeco.javacpp.Pointer _cmpop)`
`static void`	`cmp8s(ByteBuffer src1, long step1, ByteBuffer src2, long step2, ByteBuffer dst, long step, int width, int height, org.bytedeco.javacpp.Pointer _cmpop)`
`static void`	`cmp8s(org.bytedeco.javacpp.BytePointer src1, long step1, org.bytedeco.javacpp.BytePointer src2, long step2, org.bytedeco.javacpp.BytePointer dst, long step, int width, int height, org.bytedeco.javacpp.Pointer _cmpop)`
`static void`	`cmp8u(byte[] src1, long step1, byte[] src2, long step2, byte[] dst, long step, int width, int height, org.bytedeco.javacpp.Pointer _cmpop)`
`static void`	`cmp8u(ByteBuffer src1, long step1, ByteBuffer src2, long step2, ByteBuffer dst, long step, int width, int height, org.bytedeco.javacpp.Pointer _cmpop)`
`static void`	`cmp8u(org.bytedeco.javacpp.BytePointer src1, long step1, org.bytedeco.javacpp.BytePointer src2, long step2, org.bytedeco.javacpp.BytePointer dst, long step, int width, int height, org.bytedeco.javacpp.Pointer _cmpop)`
`static void`	`compare(opencv_core.GpuMat src1, opencv_core.GpuMat src2, opencv_core.GpuMat dst, int cmpop)`
`static void`	`compare(opencv_core.Mat src1, opencv_core.Mat src2, opencv_core.Mat dst, int cmpop)` \brief Performs the per-element comparison of two arrays or an array and scalar value.
`static void`	`compare(opencv_core.UMat src1, opencv_core.UMat src2, opencv_core.UMat dst, int cmpop)`
`static void`	`completeSymm(opencv_core.GpuMat m)`
`static void`	`completeSymm(opencv_core.GpuMat m, boolean lowerToUpper)`
`static void`	`completeSymm(opencv_core.Mat m)`
`static void`	`completeSymm(opencv_core.Mat m, boolean lowerToUpper)` \brief Copies the lower or the upper half of a square matrix to its another half.
`static void`	`completeSymm(opencv_core.UMat m)`
`static void`	`completeSymm(opencv_core.UMat m, boolean lowerToUpper)`
`static void`	`convertFp16(opencv_core.GpuMat src, opencv_core.GpuMat dst)`
`static void`	`convertFp16(opencv_core.Mat src, opencv_core.Mat dst)` \brief Converts an array to half precision floating number.
`static void`	`convertFp16(opencv_core.UMat src, opencv_core.UMat dst)`
`static void`	`convertFromBuffer(org.bytedeco.javacpp.Pointer cl_mem_buffer, long step, int rows, int cols, int type, opencv_core.UMat dst)` \brief Convert OpenCL buffer to UMat \note OpenCL buffer (cl_mem_buffer) should contain 2D image data, compatible with OpenCV.
`static void`	`convertFromImage(org.bytedeco.javacpp.Pointer cl_mem_image, opencv_core.UMat dst)` \brief Convert OpenCL image2d_t to UMat \note OpenCL `image2d_t` (cl_mem_image), should be compatible with OpenCV UMat formats.
`static void`	`convertScaleAbs(opencv_core.GpuMat src, opencv_core.GpuMat dst)`
`static void`	`convertScaleAbs(opencv_core.GpuMat src, opencv_core.GpuMat dst, double alpha, double beta)`
`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)` \brief Scales, calculates absolute values, and converts the result to 8-bit.
`static void`	`convertScaleAbs(opencv_core.UMat src, opencv_core.UMat dst)`
`static void`	`convertScaleAbs(opencv_core.UMat src, opencv_core.UMat dst, double alpha, double beta)`
`static org.bytedeco.javacpp.BytePointer`	`convertTypeStr(int sdepth, int ddepth, int cn, byte[] buf)`
`static String`	`convertTypeStr(int sdepth, int ddepth, int cn, ByteBuffer buf)`
`static org.bytedeco.javacpp.BytePointer`	`convertTypeStr(int sdepth, int ddepth, int cn, org.bytedeco.javacpp.BytePointer buf)`
`static void`	`copyMakeBorder(opencv_core.GpuMat src, opencv_core.GpuMat dst, int top, int bottom, int left, int right, int borderType)`
`static void`	`copyMakeBorder(opencv_core.GpuMat src, opencv_core.GpuMat dst, int top, int bottom, int left, int right, int borderType, opencv_core.Scalar value)`
`static void`	`copyMakeBorder(opencv_core.Mat src, opencv_core.Mat dst, int top, int bottom, int left, int right, int borderType)`
`static void`	`copyMakeBorder(opencv_core.Mat src, opencv_core.Mat dst, int top, int bottom, int left, int right, int borderType, opencv_core.Scalar value)` \brief Forms a border around an image.
`static void`	`copyMakeBorder(opencv_core.UMat src, opencv_core.UMat dst, int top, int bottom, int left, int right, int borderType)`
`static void`	`copyMakeBorder(opencv_core.UMat src, opencv_core.UMat dst, int top, int bottom, int left, int right, int borderType, opencv_core.Scalar value)`
`static int`	`countNonZero(opencv_core.GpuMat src)`
`static int`	`countNonZero(opencv_core.Mat src)` \brief Counts non-zero array elements.
`static int`	`countNonZero(opencv_core.UMat src)`
`static void`	`createContinuous(int rows, int cols, int type, opencv_core.GpuMat arr)`
`static void`	`createContinuous(int rows, int cols, int type, opencv_core.Mat arr)` \brief Creates a continuous matrix.
`static void`	`createContinuous(int rows, int cols, int type, opencv_core.UMat arr)`
`static float`	`cubeRoot(float val)` \brief Computes the cube root of an 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_abs(byte x)`
`static int`	`cv_abs(short x)`
`static int`	`CV_FP16_TYPE()`
`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 String`	`CV_VERSION()`
`static void`	`cvAbsDiff(opencv_core.CvArr src1, opencv_core.CvArr src2, opencv_core.CvArr dst)` dst(x,y,c) = abs(src1(x,y,c) - src2(x,y,c))
`static void`	`cvAbsDiffS(opencv_core.CvArr src, opencv_core.CvArr dst, opencv_core.CvScalar value)` dst(x,y,c) = abs(src(x,y,c) - value(c))
`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)` dst(mask) = src1(mask) + src2(mask)
`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)` dst(mask) = src(mask) + value
`static void`	`cvAddWeighted(opencv_core.CvArr src1, double alpha, opencv_core.CvArr src2, double beta, double gamma, opencv_core.CvArr dst)` dst = src1 * alpha + src2 * beta + gamma
`static org.bytedeco.javacpp.Pointer`	`cvAlloc(long size)` `malloc` wrapper.
`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)` dst(idx) = src1(idx) & src2(idx)
`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)` dst(idx) = src(idx) & value
`static opencv_core.Mat`	`cvarrToMat(opencv_core.CvArr arr)`
`static opencv_core.Mat`	`cvarrToMat(opencv_core.CvArr arr, boolean copyData, boolean allowND, int coiMode, org.bytedeco.javacpp.Pointer buf)` \addtogroup core_c_glue \{
`static opencv_core.Mat`	`cvarrToMatND(opencv_core.CvArr arr)`
`static opencv_core.Mat`	`cvarrToMatND(opencv_core.CvArr arr, boolean copyData, int coiMode)`
`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(org.bytedeco.javacpp.BytePointer attr, opencv_core.CvAttrList next)`
`static opencv_core.CvAttrList`	`cvAttrList(org.bytedeco.javacpp.PointerPointer attr, opencv_core.CvAttrList next)` initializes CvAttrList structure
`static org.bytedeco.javacpp.BytePointer`	`cvAttrValue(opencv_core.CvAttrList attr, org.bytedeco.javacpp.BytePointer attr_name)` returns attribute value or 0 (NULL) if there is no such attribute
`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)` Calculates mean value of array elements
`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)` Calculates mean and standard deviation of pixel values
`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(org.bytedeco.javacpp.PointerPointer vects, int count, opencv_core.CvArr cov_mat, opencv_core.CvArr avg, int flags)` Calculates covariation matrix for a set of vectors
`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)` Does cartesian->polar coordinates conversion.
`static float`	`cvCbrt(float value)` Fast cubic root calculation
`static int`	`cvCeil(double value)` \brief Rounds floating-point number to the nearest integer not smaller than the original.
`static int`	`cvCeil(float value)` \overload
`static int`	`cvCeil(int value)` \overload
`static void`	`cvChangeSeqBlock(org.bytedeco.javacpp.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)` Checks array values for NaNs, Infs or simply for too large numbers (if CV_CHECK_RANGE is set).
`static int`	`cvCheckArray(opencv_core.CvArr arg1, int arg2, double arg3, double arg4)`
`static int`	`cvCheckHardwareSupport(int feature)` CPU capabilities
`static opencv_core.CvTermCriteria`	`cvCheckTermCriteria(opencv_core.CvTermCriteria criteria, double default_eps, int default_max_iters)` checks termination criteria validity and sets eps to default_eps (if it is not set), max_iter to default_max_iters (if it is not set)
`static void`	`cvClearGraph(opencv_core.CvGraph graph)` Remove all vertices and edges from the graph
`static void`	`cvClearMemStorage(opencv_core.CvMemStorage storage)` Clears memory 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, org.bytedeco.javacpp.IntPointer idx)` clears element of ND dense array, in case of sparse arrays it deletes the specified node
`static void`	`cvClearSeq(opencv_core.CvSeq seq)` Removes all the elements from the sequence.
`static void`	`cvClearSet(opencv_core.CvSet set_header)` Removes all the elements from the set
`static org.bytedeco.javacpp.Pointer`	`cvClone(org.bytedeco.javacpp.Pointer struct_ptr)` \brief Makes a clone of an object.
`static opencv_core.CvGraph`	`cvCloneGraph(opencv_core.CvGraph graph, opencv_core.CvMemStorage storage)` Creates a copy of graph
`static opencv_core.IplImage`	`cvCloneImage(opencv_core.IplImage image)` Creates a copy of IPL image (widthStep may differ)
`static opencv_core.CvMat`	`cvCloneMat(opencv_core.CvMat mat)` Creates an exact copy of the input matrix (except, may be, step value)
`static opencv_core.CvMatND`	`cvCloneMatND(opencv_core.CvMatND mat)` Creates a copy of CvMatND (except, may be, steps)
`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)` Creates a copy of CvSparseMat (except, may be, zero items)
`static void`	`cvCmp(opencv_core.CvArr src1, opencv_core.CvArr src2, opencv_core.CvArr dst, int cmp_op)` dst(idx) = src1(idx) _cmp_op_ src2(idx)
`static void`	`cvCmpS(opencv_core.CvArr src, double value, opencv_core.CvArr dst, int cmp_op)` dst(idx) = src1(idx) _cmp_op_ value
`static void`	`cvCompleteSymm(opencv_core.CvMat matrix)`
`static void`	`cvCompleteSymm(opencv_core.CvMat matrix, int LtoR)` Completes the symmetric matrix from the lower (LtoR=0) or from the upper (LtoR!=0) part
`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)` \brief Converts one array to another with optional linear transformation.
`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)` Performs linear transformation on every source array element, stores absolute value of the result: dst(x,y,c) = abs(scale*src(x,y,c)+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)` \brief Copies one array to another.
`static int`	`cvCountNonZero(opencv_core.CvArr arr)` Calculates number of non-zero pixels
`static opencv_core.CvMemStorage`	`cvCreateChildMemStorage(opencv_core.CvMemStorage parent)` Creates a memory storage that will borrow memory blocks from parent storage
`static void`	`cvCreateData(opencv_core.CvArr arr)` \brief Allocates array data
`static opencv_core.CvGraph`	`cvCreateGraph(int graph_flags, int header_size, int vtx_size, int edge_size, opencv_core.CvMemStorage storage)` Creates new graph
`static opencv_core.CvGraphScanner`	`cvCreateGraphScanner(opencv_core.CvGraph graph)`
`static opencv_core.CvGraphScanner`	`cvCreateGraphScanner(opencv_core.CvGraph graph, opencv_core.CvGraphVtx vtx, int mask)` Creates new graph scanner.
`static opencv_core.IplImage`	`cvCreateImage(opencv_core.CvSize size, int depth, int channels)` \brief Creates an image header and allocates the image data.
`static opencv_core.IplImage`	`cvCreateImageHeader(opencv_core.CvSize size, int depth, int channels)` \brief Creates an image header but does not allocate the image data.
`static opencv_core.CvMat`	`cvCreateMat(int rows, int cols, int type)` \brief Creates a matrix header and allocates the matrix data.
`static opencv_core.CvMat`	`cvCreateMatHeader(int rows, int cols, int type)` \brief Creates a matrix header but does not allocate the matrix data.
`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, org.bytedeco.javacpp.IntPointer sizes, int type)` \brief Creates the header and allocates the data for a multi-dimensional dense array.
`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, org.bytedeco.javacpp.IntPointer sizes, int type)` \brief Creates a new matrix header but does not allocate the matrix data.
`static opencv_core.CvMemStorage`	`cvCreateMemStorage()`
`static opencv_core.CvMemStorage`	`cvCreateMemStorage(int block_size)` Creates new memory storage.
`static opencv_core.CvSeq`	`cvCreateSeq(int seq_flags, long header_size, long elem_size, opencv_core.CvMemStorage storage)` Creates new empty sequence that will reside in the specified 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)` Creates a new set
`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, org.bytedeco.javacpp.IntPointer sizes, int type)` \brief Creates sparse array.
`static opencv_core.CvSparseMat`	`cvCreateSparseMat(opencv_core.SparseMat m)`
`static void`	`cvCrossProduct(opencv_core.CvArr src1, opencv_core.CvArr src2, opencv_core.CvArr dst)` \brief Calculates the cross product of two 3D vectors.
`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 org.bytedeco.javacpp.Pointer`	`cvCvtSeqToArray(opencv_core.CvSeq seq, org.bytedeco.javacpp.Pointer elements)`
`static org.bytedeco.javacpp.Pointer`	`cvCvtSeqToArray(opencv_core.CvSeq seq, org.bytedeco.javacpp.Pointer elements, opencv_core.CvSlice slice)` Copies sequence content to a continuous piece of memory
`static void`	`cvDCT(opencv_core.CvArr src, opencv_core.CvArr dst, int flags)` Discrete Cosine Transform
`static void`	`cvDecRefData(opencv_core.CvArr arr)` \brief Decrements an array data reference counter.
`static double`	`cvDet(opencv_core.CvArr mat)` Calculates determinant of input matrix
`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)` Discrete Fourier Transform: complex->complex, real->ccs (forward), ccs->real (inverse)
`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)` element-wise division/inversion with scaling: dst(idx) = src1(idx) * scale / src2(idx) or dst(idx) = scale / src2(idx) if src1 == 0
`static double`	`cvDotProduct(opencv_core.CvArr src1, opencv_core.CvArr src2)` \brief Calculates the dot product of two arrays in Euclidean metrics.
`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)` Finds eigen values and vectors of a symmetric matrix
`static opencv_core.CvSeq`	`cvEndWriteSeq(opencv_core.CvSeqWriter writer)` Closes sequence writer, updates sequence header and returns pointer to the resultant sequence (which may be useful if the sequence was created using cvStartWriteSeq))
`static void`	`cvEndWriteStruct(opencv_core.CvFileStorage fs)` \brief Finishes writing to a file node collection.
`static void`	`cvError(int status, org.bytedeco.javacpp.BytePointer func_name, org.bytedeco.javacpp.BytePointer err_msg, org.bytedeco.javacpp.BytePointer file_name, int line)` Sets error status and performs some additional actions (displaying message box, writing message to stderr, terminating application etc.) depending on the current error mode
`static void`	`cvError(int status, String func_name, String err_msg, String file_name, int line)`
`static int`	`cvErrorFromIppStatus(int ipp_status)` Maps IPP error codes to the counterparts from OpenCV
`static org.bytedeco.javacpp.BytePointer`	`cvErrorStr(int status)` Retrieves textual description of the error given its code
`static void`	`cvExp(opencv_core.CvArr src, opencv_core.CvArr dst)` Does exponention: dst(idx) = exp(src(idx)).
`static float`	`cvFastArctan(float y, float x)` Fast arctangent calculation
`static void`	`cvFFT(opencv_core.CvArr arg1, opencv_core.CvArr arg2, int arg3, int arg4)`
`static opencv_core.CvGraphEdge`	`cvFindGraphEdge(opencv_core.CvGraph graph, int start_idx, int end_idx)` Find edge connecting two vertices
`static opencv_core.CvGraphEdge`	`cvFindGraphEdgeByPtr(opencv_core.CvGraph graph, opencv_core.CvGraphVtx start_vtx, opencv_core.CvGraphVtx end_vtx)`
`static opencv_core.CvTypeInfo`	`cvFindType(org.bytedeco.javacpp.BytePointer type_name)` \brief Finds a type by its name.
`static opencv_core.CvTypeInfo`	`cvFindType(String type_name)`
`static opencv_core.CvTypeInfo`	`cvFirstType()` \brief Returns the beginning of a type list.
`static void`	`cvFlip(opencv_core.CvArr src)`
`static void`	`cvFlip(opencv_core.CvArr src, opencv_core.CvArr dst, int flip_mode)` Mirror array data around horizontal (flip=0), vertical (flip=1) or both(flip=-1) axises: cvFlip(src) flips images vertically and sequences horizontally (inplace)
`static int`	`cvFloor(double value)` \brief Rounds floating-point number to the nearest integer not larger than the original.
`static int`	`cvFloor(float value)` \overload
`static int`	`cvFloor(int value)` \overload
`static void`	`cvFlushSeqWriter(opencv_core.CvSeqWriter writer)` Updates sequence header.
`static void`	`cvFree_(org.bytedeco.javacpp.Pointer ptr)` `free` wrapper.
`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)` Extended matrix transform: dst = alphaop(A)op(B) + beta*op(C), where op(X) is X or X^T
`static opencv_core.CvScalar`	`cvGet1D(opencv_core.CvArr arr, int idx0)` \brief Return a specific array element.
`static opencv_core.CvScalar`	`cvGet2D(opencv_core.CvArr arr, int idx0, int idx1)` \overload
`static opencv_core.CvScalar`	`cvGet3D(opencv_core.CvArr arr, int idx0, int idx1, int idx2)` \overload
`static opencv_core.CvMat`	`cvGetCol(opencv_core.CvArr arr, opencv_core.CvMat submat, int col)` \overload
`static opencv_core.CvMat`	`cvGetCols(opencv_core.CvArr arr, opencv_core.CvMat submat, int start_col, int end_col)` \brief Returns one of more array columns.
`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)` \brief Returns one of array diagonals.
`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, org.bytedeco.javacpp.IntPointer sizes)` \brief Return number of array dimensions
`static int`	`cvGetDimSize(opencv_core.CvArr arr, int index)` \brief Returns array size along the specified dimension.
`static int`	`cvGetElemType(opencv_core.CvArr arr)` \brief Returns type of array elements.
`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(org.bytedeco.javacpp.BytePointer errcode_desc, org.bytedeco.javacpp.BytePointer description, org.bytedeco.javacpp.BytePointer filename, org.bytedeco.javacpp.IntPointer line)`
`static int`	`cvGetErrInfo(org.bytedeco.javacpp.PointerPointer errcode_desc, org.bytedeco.javacpp.PointerPointer description, org.bytedeco.javacpp.PointerPointer filename, org.bytedeco.javacpp.IntPointer line)` Retrieves detailed information about the last error occurred
`static int`	`cvGetErrMode()` Retrieves current error processing mode
`static int`	`cvGetErrStatus()` Get current OpenCV error status
`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)` \brief Finds a node in a map or file storage.
`static opencv_core.CvFileNode`	`cvGetFileNodeByName(opencv_core.CvFileStorage fs, opencv_core.CvFileNode map, org.bytedeco.javacpp.BytePointer name)` \brief Finds a node in a map or file storage.
`static opencv_core.CvFileNode`	`cvGetFileNodeByName(opencv_core.CvFileStorage fs, opencv_core.CvFileNode map, String name)`
`static org.bytedeco.javacpp.BytePointer`	`cvGetFileNodeName(opencv_core.CvFileNode node)` \brief Returns the name of a file node.
`static opencv_core.CvStringHashNode`	`cvGetHashedKey(opencv_core.CvFileStorage fs, org.bytedeco.javacpp.BytePointer name)`
`static opencv_core.CvStringHashNode`	`cvGetHashedKey(opencv_core.CvFileStorage fs, org.bytedeco.javacpp.BytePointer name, int len, int create_missing)` \brief Returns a unique pointer for a given name.
`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)` \brief Returns image header for arbitrary array.
`static int`	`cvGetImageCOI(opencv_core.IplImage image)` \brief Returns the index of the channel of interest.
`static opencv_core.CvRect`	`cvGetImageROI(opencv_core.IplImage image)` \brief Returns the image ROI.
`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, org.bytedeco.javacpp.IntPointer coi, int allowND)` \brief Returns matrix header for arbitrary array.
`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, org.bytedeco.javacpp.IntPointer idx)` \overload
`static opencv_core.CvSparseNode`	`cvGetNextSparseNode(opencv_core.CvSparseMatIterator mat_iterator)` \brief Returns the next sparse matrix element
`static int`	`cvGetNumThreads()` retrieve/set the number of threads used in OpenMP implementations
`static int`	`cvGetOptimalDFTSize(int size0)` Finds optimal DFT vector size >= 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, org.bytedeco.javacpp.BytePointer data)`
`static void`	`cvGetRawData(opencv_core.CvArr arr, org.bytedeco.javacpp.BytePointer data, org.bytedeco.javacpp.IntPointer step, opencv_core.CvSize roi_size)`
`static void`	`cvGetRawData(opencv_core.CvArr arr, org.bytedeco.javacpp.PointerPointer data, org.bytedeco.javacpp.IntPointer step, opencv_core.CvSize roi_size)` \brief Retrieves low-level information about the array.
`static double`	`cvGetReal1D(opencv_core.CvArr arr, int idx0)` \brief Return a specific element of single-channel 1D, 2D, 3D or nD array.
`static double`	`cvGetReal2D(opencv_core.CvArr arr, int idx0, int idx1)` \overload
`static double`	`cvGetReal3D(opencv_core.CvArr arr, int idx0, int idx1, int idx2)` \overload
`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, org.bytedeco.javacpp.IntPointer idx)` \overload
`static opencv_core.CvFileNode`	`cvGetRootFileNode(opencv_core.CvFileStorage fs)`
`static opencv_core.CvFileNode`	`cvGetRootFileNode(opencv_core.CvFileStorage fs, int stream_index)` \brief Retrieves one of the top-level nodes of the file storage.
`static opencv_core.CvMat`	`cvGetRow(opencv_core.CvArr arr, opencv_core.CvMat submat, int row)` \overload
`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)` \brief Returns array row or row span.
`static org.bytedeco.javacpp.BytePointer`	`cvGetSeqElem(opencv_core.CvSeq seq, int index)` Retrieves pointer to specified sequence element.
`static int`	`cvGetSeqReaderPos(opencv_core.CvSeqReader reader)` Returns current sequence reader position (currently observed sequence element)
`static opencv_core.CvSetElem`	`cvGetSetElem(opencv_core.CvSet set_header, int idx)` Returns a set element by index.
`static opencv_core.CvSize`	`cvGetSize(opencv_core.CvArr arr)` \brief Returns size of matrix or image ROI.
`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)` \brief Returns matrix header corresponding to the rectangular sub-array of input image or matrix.
`static int`	`cvGetThreadNum()` get index of the thread being executed
`static long`	`cvGetTickCount()` helper functions for RNG initialization and accurate time measurement: uses internal clock counter on x86
`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, org.bytedeco.javacpp.PointerPointer inserted_edge)` Link two vertices specified by indices or pointers if they are not connected or return pointer to already existing edge connecting the vertices.
`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, org.bytedeco.javacpp.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, org.bytedeco.javacpp.PointerPointer inserted_vtx)` Adds new vertex to the graph
`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)` Remove edge connecting two vertices
`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)` Removes vertex from the graph together with all incident edges
`static int`	`cvGraphRemoveVtxByPtr(opencv_core.CvGraph graph, opencv_core.CvGraphVtx vtx)`
`static int`	`cvGraphVtxDegree(opencv_core.CvGraph graph, int vtx_idx)` Count number of edges incident to the vertex
`static int`	`cvGraphVtxDegreeByPtr(opencv_core.CvGraph graph, opencv_core.CvGraphVtx vtx)`
`static int`	`cvGuiBoxReport(int status, org.bytedeco.javacpp.BytePointer func_name, org.bytedeco.javacpp.BytePointer err_msg, org.bytedeco.javacpp.BytePointer file_name, int line, org.bytedeco.javacpp.Pointer userdata)` Output to MessageBox(WIN32)
`static int`	`cvGuiBoxReport(int status, String func_name, String err_msg, String file_name, int line, org.bytedeco.javacpp.Pointer userdata)`
`static int`	`cvIncRefData(opencv_core.CvArr arr)` \brief Increments array data reference counter.
`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)` \brief Initializes an image header that was previously allocated.
`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, org.bytedeco.javacpp.Pointer data, int step)` \brief Initializes a pre-allocated matrix header.
`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, org.bytedeco.javacpp.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, org.bytedeco.javacpp.Pointer data)`
`static opencv_core.CvMatND`	`cvInitMatNDHeader(opencv_core.CvMatND mat, int dims, org.bytedeco.javacpp.IntPointer sizes, int type)`
`static opencv_core.CvMatND`	`cvInitMatNDHeader(opencv_core.CvMatND mat, int dims, org.bytedeco.javacpp.IntPointer sizes, int type, org.bytedeco.javacpp.Pointer data)` \brief Initializes a pre-allocated multi-dimensional array header.
`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, org.bytedeco.javacpp.PointerPointer arrs, opencv_core.CvArr mask, opencv_core.CvMatND stubs, opencv_core.CvNArrayIterator array_iterator, int flags)` initializes iterator that traverses through several arrays simulteneously (the function together with cvNextArraySlice is used for N-ari element-wise operations)
`static opencv_core.CvSparseNode`	`cvInitSparseMatIterator(opencv_core.CvSparseMat mat, opencv_core.CvSparseMatIterator mat_iterator)` \brief Initializes sparse array elements iterator.
`static void`	`cvInitTreeNodeIterator(opencv_core.CvTreeNodeIterator tree_iterator, org.bytedeco.javacpp.Pointer first, int max_level)`
`static void`	`cvInRange(opencv_core.CvArr src, opencv_core.CvArr lower, opencv_core.CvArr upper, opencv_core.CvArr dst)` dst(idx) = lower(idx) <= src(idx) < upper(idx)
`static void`	`cvInRangeS(opencv_core.CvArr src, opencv_core.CvScalar lower, opencv_core.CvScalar upper, opencv_core.CvArr dst)` dst(idx) = lower <= src(idx) < upper
`static void`	`cvInsertNodeIntoTree(org.bytedeco.javacpp.Pointer node, org.bytedeco.javacpp.Pointer parent, org.bytedeco.javacpp.Pointer frame)` Inserts sequence into tree with specified "parent" sequence.
`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)` Inverts matrix
`static int`	`cvIplDepth(int type)`
`static int`	`cvIsInf(double value)` \brief Determines if the argument is Infinity.
`static int`	`cvIsInf(float value)` \overload
`static int`	`cvIsNaN(double value)` \brief Determines if the argument is Not A Number.
`static int`	`cvIsNaN(float value)` \overload
`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, org.bytedeco.javacpp.LongPointer rng, int flags, opencv_core.CvArr _centers, org.bytedeco.javacpp.DoublePointer compactness)`
`static org.bytedeco.javacpp.Pointer`	`cvLoad(org.bytedeco.javacpp.BytePointer filename)`
`static org.bytedeco.javacpp.Pointer`	`cvLoad(org.bytedeco.javacpp.BytePointer filename, opencv_core.CvMemStorage memstorage, org.bytedeco.javacpp.BytePointer name, byte[] real_name)`
`static org.bytedeco.javacpp.Pointer`	`cvLoad(org.bytedeco.javacpp.BytePointer filename, opencv_core.CvMemStorage memstorage, org.bytedeco.javacpp.BytePointer name, ByteBuffer real_name)`
`static org.bytedeco.javacpp.Pointer`	`cvLoad(org.bytedeco.javacpp.BytePointer filename, opencv_core.CvMemStorage memstorage, org.bytedeco.javacpp.BytePointer name, org.bytedeco.javacpp.BytePointer real_name)`
`static org.bytedeco.javacpp.Pointer`	`cvLoad(org.bytedeco.javacpp.BytePointer filename, opencv_core.CvMemStorage memstorage, org.bytedeco.javacpp.BytePointer name, org.bytedeco.javacpp.PointerPointer real_name)` \brief Loads an object from a file.
`static org.bytedeco.javacpp.Pointer`	`cvLoad(String filename)`
`static org.bytedeco.javacpp.Pointer`	`cvLoad(String filename, opencv_core.CvMemStorage memstorage, String name, byte[] real_name)`
`static org.bytedeco.javacpp.Pointer`	`cvLoad(String filename, opencv_core.CvMemStorage memstorage, String name, ByteBuffer real_name)`
`static org.bytedeco.javacpp.Pointer`	`cvLoad(String filename, opencv_core.CvMemStorage memstorage, String name, org.bytedeco.javacpp.BytePointer real_name)`
`static void`	`cvLog(opencv_core.CvArr src, opencv_core.CvArr dst)` Calculates natural logarithms: dst(idx) = log(abs(src(idx))).
`static void`	`cvLUT(opencv_core.CvArr src, opencv_core.CvArr dst, opencv_core.CvArr lut)` Does look-up transformation.
`static double`	`cvMahalanobis(opencv_core.CvArr vec1, opencv_core.CvArr vec2, opencv_core.CvArr mat)` Calculates Mahalanobis(weighted) distance
`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, org.bytedeco.javacpp.Pointer elements, int total, opencv_core.CvSeq seq, opencv_core.CvSeqBlock block)` Creates sequence header for array.
`static opencv_core.CvMat`	`cvMat(int rows, int cols, int type)`
`static opencv_core.CvMat`	`cvMat(int rows, int cols, int type, org.bytedeco.javacpp.Pointer data)` Inline constructor.
`static opencv_core.CvMat`	`cvMat(opencv_core.Mat m)`
`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)` Matrix transform: dst = A*B + C, C is optional
`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)` dst(idx) = max(src1(idx),src2(idx))
`static void`	`cvMaxS(opencv_core.CvArr src, double value, opencv_core.CvArr dst)` dst(idx) = max(src(idx),value)
`static org.bytedeco.javacpp.Pointer`	`cvMemStorageAlloc(opencv_core.CvMemStorage storage, long size)` Allocates continuous buffer of the specified size in the storage
`static opencv_core.CvString`	`cvMemStorageAllocString(opencv_core.CvMemStorage storage, org.bytedeco.javacpp.BytePointer ptr)`
`static opencv_core.CvString`	`cvMemStorageAllocString(opencv_core.CvMemStorage storage, org.bytedeco.javacpp.BytePointer ptr, int len)` Allocates string in memory storage
`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)` Merges a set of single-channel arrays into the single multi-channel array or inserts one particular [color] plane to the array
`static double`	`cvmGet(opencv_core.CvMat mat, int row, int col)` \brief Returns the particular element of single-channel floating-point matrix.
`static void`	`cvMin(opencv_core.CvArr src1, opencv_core.CvArr src2, opencv_core.CvArr dst)` dst(idx) = min(src1(idx),src2(idx))
`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, org.bytedeco.javacpp.DoublePointer min_val, org.bytedeco.javacpp.DoublePointer max_val)`
`static void`	`cvMinMaxLoc(opencv_core.CvArr arr, org.bytedeco.javacpp.DoublePointer min_val, org.bytedeco.javacpp.DoublePointer max_val, opencv_core.CvPoint min_loc, opencv_core.CvPoint max_loc, opencv_core.CvArr mask)` Finds global minimum, maximum and their positions
`static void`	`cvMinS(opencv_core.CvArr src, double value, opencv_core.CvArr dst)` dst(idx) = min(src(idx),value)
`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, org.bytedeco.javacpp.IntPointer from_to, int pair_count)`
`static void`	`cvMixChannels(org.bytedeco.javacpp.PointerPointer src, int src_count, org.bytedeco.javacpp.PointerPointer dst, int dst_count, org.bytedeco.javacpp.IntPointer from_to, int pair_count)` Copies several channels from input arrays to certain channels of output arrays
`static void`	`cvmSet(opencv_core.CvMat mat, int row, int col, double value)` \brief Sets a specific element of a single-channel floating-point matrix.
`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)` dst(idx) = src1(idx) * src2(idx) * scale (scaled element-wise multiplication of 2 arrays)
`static void`	`cvMulSpectrums(opencv_core.CvArr src1, opencv_core.CvArr src2, opencv_core.CvArr dst, int flags)` Multiply results of DFTs: DFT(X)DFT(Y) or DFT(X)conj(DFT(Y))
`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)` Calculates (A-delta)(A-delta)^T (order=0) or (A-delta)^T(A-delta) (order=1)
`static int`	`cvNextGraphItem(opencv_core.CvGraphScanner scanner)` Get next graph element
`static int`	`cvNextNArraySlice(opencv_core.CvNArrayIterator array_iterator)` returns zero value if iteration is finished, non-zero (slice length) otherwise
`static org.bytedeco.javacpp.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)` Finds norm, difference norm or relative difference norm for an array (or two arrays)
`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)` dst(idx) = ~src(idx)
`static int`	`cvNulDevReport(int status, org.bytedeco.javacpp.BytePointer func_name, org.bytedeco.javacpp.BytePointer err_msg, org.bytedeco.javacpp.BytePointer file_name, int line, org.bytedeco.javacpp.Pointer userdata)` Output nothing
`static int`	`cvNulDevReport(int status, String func_name, String err_msg, String file_name, int line, org.bytedeco.javacpp.Pointer userdata)`
`static opencv_core.CvFileStorage`	`cvOpenFileStorage(org.bytedeco.javacpp.BytePointer filename, opencv_core.CvMemStorage memstorage, int flags)`
`static opencv_core.CvFileStorage`	`cvOpenFileStorage(org.bytedeco.javacpp.BytePointer filename, opencv_core.CvMemStorage memstorage, int flags, org.bytedeco.javacpp.BytePointer encoding)` \brief Opens file storage for reading or writing data.
`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)` dst(idx) = src1(idx) \| src2(idx)
`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)` dst(idx) = src(idx) \| value
`static void`	`cvPerspectiveTransform(opencv_core.CvArr src, opencv_core.CvArr dst, opencv_core.CvMat mat)` Does perspective transform on every element of input array
`static opencv_core.CvPoint`	`cvPoint(int x, int y)` constructs CvPoint structure.
`static opencv_core.CvPoint2D32f`	`cvPoint2D32f(double x, double y)` constructs CvPoint2D32f structure.
`static opencv_core.CvPoint2D64f`	`cvPoint2D64f(double x, double y)` constructs CvPoint2D64f structure.
`static opencv_core.CvPoint3D32f`	`cvPoint3D32f(double x, double y, double z)` constructs CvPoint3D32f structure.
`static opencv_core.CvPoint3D64f`	`cvPoint3D64f(double x, double y, double z)` constructs CvPoint3D64f structure.
`static int[]`	`cvPointFrom32f(float[] point)`
`static IntBuffer`	`cvPointFrom32f(FloatBuffer point)`
`static opencv_core.CvPoint`	`cvPointFrom32f(opencv_core.CvPoint2D32f point)` converts CvPoint2D32f to CvPoint.
`static float[]`	`cvPointTo32f(int[] point)`
`static FloatBuffer`	`cvPointTo32f(IntBuffer point)`
`static opencv_core.CvPoint2D32f`	`cvPointTo32f(opencv_core.CvPoint point)` converts CvPoint to CvPoint2D32f.
`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)` Does polar->cartesian coordinates conversion.
`static void`	`cvPow(opencv_core.CvArr src, opencv_core.CvArr dst, double power)` Does powering: dst(idx) = src(idx)^power
`static org.bytedeco.javacpp.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 org.bytedeco.javacpp.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 org.bytedeco.javacpp.BytePointer`	`cvPtr1D(opencv_core.CvArr arr, int idx0, org.bytedeco.javacpp.IntPointer type)` \brief Return pointer to a particular array element.
`static org.bytedeco.javacpp.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 org.bytedeco.javacpp.BytePointer`	`cvPtr2D(opencv_core.CvArr arr, int idx0, int idx1, org.bytedeco.javacpp.IntPointer type)` \overload
`static org.bytedeco.javacpp.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 org.bytedeco.javacpp.BytePointer`	`cvPtr3D(opencv_core.CvArr arr, int idx0, int idx1, int idx2, org.bytedeco.javacpp.IntPointer type)` \overload
`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 org.bytedeco.javacpp.BytePointer`	`cvPtrND(opencv_core.CvArr arr, org.bytedeco.javacpp.IntPointer idx)`
`static org.bytedeco.javacpp.BytePointer`	`cvPtrND(opencv_core.CvArr arr, org.bytedeco.javacpp.IntPointer idx, org.bytedeco.javacpp.IntPointer type, int create_node, org.bytedeco.javacpp.IntPointer precalc_hashval)` \overload
`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(org.bytedeco.javacpp.LongPointer rng, opencv_core.CvArr arr, int dist_type, opencv_core.CvScalar param1, opencv_core.CvScalar param2)` \brief Fills an array with random numbers and updates the RNG state.
`static int`	`cvRandInt(long[] rng)`
`static int`	`cvRandInt(LongBuffer rng)`
`static int`	`cvRandInt(org.bytedeco.javacpp.LongPointer rng)` \brief Returns a 32-bit unsigned integer and updates RNG.
`static double`	`cvRandReal(long[] rng)`
`static double`	`cvRandReal(LongBuffer rng)`
`static double`	`cvRandReal(org.bytedeco.javacpp.LongPointer rng)` \brief Returns a floating-point random number and updates 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, org.bytedeco.javacpp.LongPointer rng)`
`static void`	`cvRandShuffle(opencv_core.CvArr mat, org.bytedeco.javacpp.LongPointer rng, double iter_factor)`
`static opencv_core.CvArr`	`cvRange(opencv_core.CvArr mat, double start, double end)` Fills matrix with given range of numbers
`static void`	`cvRawDataToScalar(org.bytedeco.javacpp.Pointer data, int type, opencv_core.CvScalar scalar)`
`static org.bytedeco.javacpp.Pointer`	`cvRead(opencv_core.CvFileStorage fs, opencv_core.CvFileNode node)`
`static org.bytedeco.javacpp.Pointer`	`cvRead(opencv_core.CvFileStorage fs, opencv_core.CvFileNode node, opencv_core.CvAttrList attributes)` \brief Decodes an object and returns a pointer to it.
`static org.bytedeco.javacpp.Pointer`	`cvReadByName(opencv_core.CvFileStorage fs, opencv_core.CvFileNode map, org.bytedeco.javacpp.BytePointer name)`
`static org.bytedeco.javacpp.Pointer`	`cvReadByName(opencv_core.CvFileStorage fs, opencv_core.CvFileNode map, org.bytedeco.javacpp.BytePointer name, opencv_core.CvAttrList attributes)` \brief Finds an object by name and decodes it.
`static org.bytedeco.javacpp.Pointer`	`cvReadByName(opencv_core.CvFileStorage fs, opencv_core.CvFileNode map, String name)`
`static org.bytedeco.javacpp.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)` \brief Retrieves an integer value from a file node.
`static int`	`cvReadIntByName(opencv_core.CvFileStorage fs, opencv_core.CvFileNode map, org.bytedeco.javacpp.BytePointer name)`
`static int`	`cvReadIntByName(opencv_core.CvFileStorage fs, opencv_core.CvFileNode map, org.bytedeco.javacpp.BytePointer name, int default_value)` \brief Finds a file node and returns its 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, org.bytedeco.javacpp.Pointer dst, org.bytedeco.javacpp.BytePointer dt)` \brief Reads multiple numbers.
`static void`	`cvReadRawData(opencv_core.CvFileStorage fs, opencv_core.CvFileNode src, org.bytedeco.javacpp.Pointer dst, String dt)`
`static void`	`cvReadRawDataSlice(opencv_core.CvFileStorage fs, opencv_core.CvSeqReader reader, int count, org.bytedeco.javacpp.Pointer dst, org.bytedeco.javacpp.BytePointer dt)` \brief Initializes file node sequence reader.
`static void`	`cvReadRawDataSlice(opencv_core.CvFileStorage fs, opencv_core.CvSeqReader reader, int count, org.bytedeco.javacpp.Pointer dst, String dt)`
`static double`	`cvReadReal(opencv_core.CvFileNode node)`
`static double`	`cvReadReal(opencv_core.CvFileNode node, double default_value)` \brief Retrieves a floating-point value from a file node.
`static double`	`cvReadRealByName(opencv_core.CvFileStorage fs, opencv_core.CvFileNode map, org.bytedeco.javacpp.BytePointer name)`
`static double`	`cvReadRealByName(opencv_core.CvFileStorage fs, opencv_core.CvFileNode map, org.bytedeco.javacpp.BytePointer name, double default_value)` \brief Finds a file node and returns its 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 org.bytedeco.javacpp.BytePointer`	`cvReadString(opencv_core.CvFileNode node)`
`static org.bytedeco.javacpp.BytePointer`	`cvReadString(opencv_core.CvFileNode node, org.bytedeco.javacpp.BytePointer default_value)` \brief Retrieves a text string from a file node.
`static String`	`cvReadString(opencv_core.CvFileNode node, String default_value)`
`static org.bytedeco.javacpp.BytePointer`	`cvReadStringByName(opencv_core.CvFileStorage fs, opencv_core.CvFileNode map, org.bytedeco.javacpp.BytePointer name)`
`static org.bytedeco.javacpp.BytePointer`	`cvReadStringByName(opencv_core.CvFileStorage fs, opencv_core.CvFileNode map, org.bytedeco.javacpp.BytePointer name, org.bytedeco.javacpp.BytePointer default_value)` \brief Finds a file node by its name and returns its 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)` constructs CvRect structure.
`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, org.bytedeco.javacpp.Pointer userdata, org.bytedeco.javacpp.Pointer prev_userdata)`
`static opencv_core.CvErrorCallback`	`cvRedirectError(opencv_core.CvErrorCallback error_handler, org.bytedeco.javacpp.Pointer userdata, org.bytedeco.javacpp.PointerPointer prev_userdata)` Assigns a new error-handling function
`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 void`	`cvRegisterType(opencv_core.CvTypeInfo info)` \brief Registers a new type.
`static void`	`cvRelease(org.bytedeco.javacpp.Pointer struct_ptr)`
`static void`	`cvRelease(org.bytedeco.javacpp.PointerPointer struct_ptr)` \brief Releases an object.
`static void`	`cvReleaseData(opencv_core.CvArr arr)` \brief Releases array data.
`static void`	`cvReleaseFileStorage(opencv_core.CvFileStorage fs)`
`static void`	`cvReleaseFileStorage(org.bytedeco.javacpp.PointerPointer fs)` \brief Releases file storage.
`static void`	`cvReleaseGraphScanner(opencv_core.CvGraphScanner scanner)`
`static void`	`cvReleaseGraphScanner(org.bytedeco.javacpp.PointerPointer scanner)` Releases graph scanner.
`static void`	`cvReleaseImage(opencv_core.IplImage image)`
`static void`	`cvReleaseImage(org.bytedeco.javacpp.PointerPointer image)` \brief Deallocates the image header and the image data.
`static void`	`cvReleaseImageHeader(opencv_core.IplImage image)`
`static void`	`cvReleaseImageHeader(org.bytedeco.javacpp.PointerPointer image)` \brief Deallocates an image header.
`static void`	`cvReleaseMat(opencv_core.CvMat mat)`
`static void`	`cvReleaseMat(org.bytedeco.javacpp.PointerPointer mat)` \brief Deallocates a matrix.
`static void`	`cvReleaseMatND(opencv_core.CvMatND mat)`
`static void`	`cvReleaseMatND(org.bytedeco.javacpp.PointerPointer mat)` \brief Deallocates a multi-dimensional array.
`static void`	`cvReleaseMemStorage(opencv_core.CvMemStorage storage)`
`static void`	`cvReleaseMemStorage(org.bytedeco.javacpp.PointerPointer storage)` Releases memory storage.
`static void`	`cvReleaseSparseMat(opencv_core.CvSparseMat mat)`
`static void`	`cvReleaseSparseMat(org.bytedeco.javacpp.PointerPointer mat)` \brief Deallocates sparse array.
`static void`	`cvRemoveNodeFromTree(org.bytedeco.javacpp.Pointer node, org.bytedeco.javacpp.Pointer frame)` Removes contour from tree (together with the contour children).
`static void`	`cvRepeat(opencv_core.CvArr src, opencv_core.CvArr dst)` Repeats source 2d array several times in both horizontal and vertical direction to fill destination array
`static void`	`cvResetImageROI(opencv_core.IplImage image)` \brief Resets the image ROI to include the entire image and releases the ROI structure.
`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)` \brief Changes shape of matrix/image without copying data.
`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, org.bytedeco.javacpp.IntPointer new_sizes)` \brief Changes the shape of a multi-dimensional array without copying the data.
`static void`	`cvRestoreMemStoragePos(opencv_core.CvMemStorage storage, opencv_core.CvMemStoragePos pos)` Restore a storage "free memory" position
`static long`	`cvRNG()`
`static long`	`cvRNG(long seed)` \brief Initializes a random number generator state.
`static opencv_core.CvRect`	`cvROIToRect(opencv_core.IplROI roi)`
`static int`	`cvRound(double value)` \brief Rounds floating-point number to the nearest integer
`static int`	`cvRound(float value)` \overload
`static int`	`cvRound(int value)` \overload
`static void`	`cvSave(org.bytedeco.javacpp.BytePointer filename, org.bytedeco.javacpp.Pointer struct_ptr)`
`static void`	`cvSave(org.bytedeco.javacpp.BytePointer filename, org.bytedeco.javacpp.Pointer struct_ptr, org.bytedeco.javacpp.BytePointer name, org.bytedeco.javacpp.BytePointer comment, opencv_core.CvAttrList attributes)` \brief Saves an object to a file.
`static void`	`cvSave(String filename, org.bytedeco.javacpp.Pointer struct_ptr)`
`static void`	`cvSave(String filename, org.bytedeco.javacpp.Pointer struct_ptr, String name, String comment, opencv_core.CvAttrList attributes)`
`static void`	`cvSaveMemStoragePos(opencv_core.CvMemStorage storage, opencv_core.CvMemStoragePos pos)` Remember a storage "free memory" position
`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, org.bytedeco.javacpp.Pointer data, int type)`
`static void`	`cvScalarToRawData(opencv_core.CvScalar scalar, org.bytedeco.javacpp.Pointer data, int type, int extend_to_12)` low-level scalar <-> raw data conversion functions
`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)` dst = src1 * scale + src2
`static int`	`cvSeqElemIdx(opencv_core.CvSeq seq, org.bytedeco.javacpp.Pointer element)`
`static int`	`cvSeqElemIdx(opencv_core.CvSeq seq, org.bytedeco.javacpp.Pointer element, opencv_core.CvSeqBlock block)`
`static int`	`cvSeqElemIdx(opencv_core.CvSeq seq, org.bytedeco.javacpp.Pointer element, org.bytedeco.javacpp.PointerPointer block)` Calculates index of the specified sequence element.
`static org.bytedeco.javacpp.BytePointer`	`cvSeqInsert(opencv_core.CvSeq seq, int before_index)`
`static org.bytedeco.javacpp.BytePointer`	`cvSeqInsert(opencv_core.CvSeq seq, int before_index, org.bytedeco.javacpp.Pointer element)` Inserts a new element in the middle of sequence.
`static void`	`cvSeqInsertSlice(opencv_core.CvSeq seq, int before_index, opencv_core.CvArr from_arr)` Inserts a sequence or array into another sequence
`static void`	`cvSeqInvert(opencv_core.CvSeq seq)` Reverses order of sequence elements in-place
`static int`	`cvSeqPartition(opencv_core.CvSeq seq, opencv_core.CvMemStorage storage, opencv_core.CvSeq labels, opencv_core.CvCmpFunc is_equal, org.bytedeco.javacpp.Pointer userdata)`
`static int`	`cvSeqPartition(opencv_core.CvSeq seq, opencv_core.CvMemStorage storage, org.bytedeco.javacpp.PointerPointer labels, opencv_core.CvCmpFunc is_equal, org.bytedeco.javacpp.Pointer userdata)` Splits sequence into one or more equivalence classes using the specified criteria
`static void`	`cvSeqPop(opencv_core.CvSeq seq)`
`static void`	`cvSeqPop(opencv_core.CvSeq seq, org.bytedeco.javacpp.Pointer element)` Removes the last element from sequence and optionally saves it
`static void`	`cvSeqPopFront(opencv_core.CvSeq seq)`
`static void`	`cvSeqPopFront(opencv_core.CvSeq seq, org.bytedeco.javacpp.Pointer element)` Removes the first element from sequence and optioanally saves it
`static void`	`cvSeqPopMulti(opencv_core.CvSeq seq, org.bytedeco.javacpp.Pointer elements, int count)`
`static void`	`cvSeqPopMulti(opencv_core.CvSeq seq, org.bytedeco.javacpp.Pointer elements, int count, int in_front)` Removes several elements from the end of sequence and optionally saves them
`static org.bytedeco.javacpp.BytePointer`	`cvSeqPush(opencv_core.CvSeq seq)`
`static org.bytedeco.javacpp.BytePointer`	`cvSeqPush(opencv_core.CvSeq seq, org.bytedeco.javacpp.Pointer element)` Adds new element to the end of sequence.
`static org.bytedeco.javacpp.BytePointer`	`cvSeqPushFront(opencv_core.CvSeq seq)`
`static org.bytedeco.javacpp.BytePointer`	`cvSeqPushFront(opencv_core.CvSeq seq, org.bytedeco.javacpp.Pointer element)` Adds new element to the beginning of sequence.
`static void`	`cvSeqPushMulti(opencv_core.CvSeq seq, org.bytedeco.javacpp.Pointer elements, int count)`
`static void`	`cvSeqPushMulti(opencv_core.CvSeq seq, org.bytedeco.javacpp.Pointer elements, int count, int in_front)` Adds several new elements to the end of sequence
`static void`	`cvSeqRemove(opencv_core.CvSeq seq, int index)` Removes specified sequence element
`static void`	`cvSeqRemoveSlice(opencv_core.CvSeq seq, opencv_core.CvSlice slice)` Removes sequence slice
`static byte[]`	`cvSeqSearch(opencv_core.CvSeq seq, org.bytedeco.javacpp.Pointer elem, opencv_core.CvCmpFunc func, int is_sorted, int[] elem_idx)`
`static byte[]`	`cvSeqSearch(opencv_core.CvSeq seq, org.bytedeco.javacpp.Pointer elem, opencv_core.CvCmpFunc func, int is_sorted, int[] elem_idx, org.bytedeco.javacpp.Pointer userdata)`
`static ByteBuffer`	`cvSeqSearch(opencv_core.CvSeq seq, org.bytedeco.javacpp.Pointer elem, opencv_core.CvCmpFunc func, int is_sorted, IntBuffer elem_idx)`
`static ByteBuffer`	`cvSeqSearch(opencv_core.CvSeq seq, org.bytedeco.javacpp.Pointer elem, opencv_core.CvCmpFunc func, int is_sorted, IntBuffer elem_idx, org.bytedeco.javacpp.Pointer userdata)`
`static org.bytedeco.javacpp.BytePointer`	`cvSeqSearch(opencv_core.CvSeq seq, org.bytedeco.javacpp.Pointer elem, opencv_core.CvCmpFunc func, int is_sorted, org.bytedeco.javacpp.IntPointer elem_idx)`
`static org.bytedeco.javacpp.BytePointer`	`cvSeqSearch(opencv_core.CvSeq seq, org.bytedeco.javacpp.Pointer elem, opencv_core.CvCmpFunc func, int is_sorted, org.bytedeco.javacpp.IntPointer elem_idx, org.bytedeco.javacpp.Pointer userdata)` Finds element in a [sorted] sequence
`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)` Extracts sequence slice (with or without copying sequence elements)
`static void`	`cvSeqSort(opencv_core.CvSeq seq, opencv_core.CvCmpFunc func)`
`static void`	`cvSeqSort(opencv_core.CvSeq seq, opencv_core.CvCmpFunc func, org.bytedeco.javacpp.Pointer userdata)` Sorts sequence in-place given element comparison function
`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)` \brief Sets every element of an array to a given value.
`static void`	`cvSet1D(opencv_core.CvArr arr, int idx0, opencv_core.CvScalar value)` \brief Change the particular array element.
`static void`	`cvSet2D(opencv_core.CvArr arr, int idx0, int idx1, opencv_core.CvScalar value)` \overload
`static void`	`cvSet3D(opencv_core.CvArr arr, int idx0, int idx1, int idx2, opencv_core.CvScalar value)` \overload
`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, org.bytedeco.javacpp.PointerPointer inserted_elem)` Adds new element to the set and returns pointer to it
`static void`	`cvSetData(opencv_core.CvArr arr, org.bytedeco.javacpp.Pointer data, int step)` \brief Assigns user data to the array header.
`static int`	`cvSetErrMode(int mode)` Sets error processing mode, returns previously used mode
`static void`	`cvSetErrStatus(int status)` Sets error status silently
`static void`	`cvSetIdentity(opencv_core.CvArr mat)`
`static void`	`cvSetIdentity(opencv_core.CvArr mat, opencv_core.CvScalar value)` Makes an identity matrix (mat_ij = i == j)
`static void`	`cvSetImageCOI(opencv_core.IplImage image, int coi)` \brief Sets the channel of interest in an IplImage.
`static void`	`cvSetImageROI(opencv_core.IplImage image, opencv_core.CvRect rect)` \brief Sets an image Region Of Interest (ROI) for a given rectangle.
`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)` \brief Makes OpenCV use IPL functions for allocating IplImage and IplROI structures.
`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, org.bytedeco.javacpp.IntPointer idx, opencv_core.CvScalar value)` \overload
`static opencv_core.CvSetElem`	`cvSetNew(opencv_core.CvSet set_header)` Fast variant of cvSetAdd
`static void`	`cvSetNumThreads()`
`static void`	`cvSetNumThreads(int threads)`
`static void`	`cvSetReal1D(opencv_core.CvArr arr, int idx0, double value)` \brief Change a specific array element.
`static void`	`cvSetReal2D(opencv_core.CvArr arr, int idx0, int idx1, double value)` \overload
`static void`	`cvSetReal3D(opencv_core.CvArr arr, int idx0, int idx1, int idx2, double value)` \overload
`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, org.bytedeco.javacpp.IntPointer idx, double value)` \overload
`static void`	`cvSetRemove(opencv_core.CvSet set_header, int index)` Removes element from the set by its index
`static void`	`cvSetRemoveByPtr(opencv_core.CvSet set_header, org.bytedeco.javacpp.Pointer elem)` Removes set element given its pointer
`static void`	`cvSetSeqBlockSize(opencv_core.CvSeq seq, int delta_elems)` Changes default size (granularity) of sequence blocks.
`static void`	`cvSetSeqReaderPos(opencv_core.CvSeqReader reader, int index)`
`static void`	`cvSetSeqReaderPos(opencv_core.CvSeqReader reader, int index, int is_relative)` Changes sequence reader position.
`static void`	`cvSetZero(opencv_core.CvArr arr)` \brief Clears the array.
`static opencv_core.CvSize`	`cvSize(int width, int height)` constructs CvSize structure.
`static opencv_core.CvSize2D32f`	`cvSize2D32f(double width, double height)` constructs CvSize2D32f structure.
`static opencv_core.CvSlice`	`cvSlice(int start, int end)`
`static int`	`cvSliceLength(opencv_core.CvSlice slice, opencv_core.CvSeq seq)` Calculates length of sequence slice (with support of negative indices).
`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)` Solves linear system (src1)*(dst) = (src2) (returns 0 if src1 is a singular and CV_LU method is used)
`static int`	`cvSolveCubic(opencv_core.CvMat coeffs, opencv_core.CvMat roots)` Finds real roots of a cubic equation
`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)` Finds all real and complex roots of a polynomial equation
`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)` Splits a multi-channel array into the set of single-channel arrays or extracts particular [color] plane
`static void`	`cvStartAppendToSeq(opencv_core.CvSeq seq, opencv_core.CvSeqWriter writer)` Initializes sequence writer.
`static void`	`cvStartNextStream(opencv_core.CvFileStorage fs)` \brief Starts the next stream.
`static void`	`cvStartReadRawData(opencv_core.CvFileStorage fs, opencv_core.CvFileNode src, opencv_core.CvSeqReader reader)` \brief Initializes the file node sequence 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)` Initializes sequence reader.
`static void`	`cvStartWriteSeq(int seq_flags, int header_size, int elem_size, opencv_core.CvMemStorage storage, opencv_core.CvSeqWriter writer)` Combination of cvCreateSeq and cvStartAppendToSeq
`static void`	`cvStartWriteStruct(opencv_core.CvFileStorage fs, org.bytedeco.javacpp.BytePointer name, int struct_flags)`
`static void`	`cvStartWriteStruct(opencv_core.CvFileStorage fs, org.bytedeco.javacpp.BytePointer name, int struct_flags, org.bytedeco.javacpp.BytePointer type_name, opencv_core.CvAttrList attributes)` \brief Starts writing a new structure.
`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, org.bytedeco.javacpp.BytePointer func_name, org.bytedeco.javacpp.BytePointer err_msg, org.bytedeco.javacpp.BytePointer file_name, int line, org.bytedeco.javacpp.Pointer userdata)` Output to console(fprintf(stderr,...))
`static int`	`cvStdErrReport(int status, String func_name, String err_msg, String file_name, int line, org.bytedeco.javacpp.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)` dst(mask) = src1(mask) - src2(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)` dst(mask) = value - src(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)` dst(mask) = src(mask) - value = src(mask) + (-value)
`static opencv_core.CvScalar`	`cvSum(opencv_core.CvArr arr)` Finds sum of array elements
`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)` Performs Singular Value Back Substitution (solves A*X = B): flags must be the same as in cvSVD
`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)` Performs Singular Value Decomposition of a matrix
`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)` Calculates trace of the matrix (sum of elements on the main diagonal)
`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)` Transforms each element of source array and stores resultant vectors in destination array
`static void`	`cvTranspose(opencv_core.CvArr src, opencv_core.CvArr dst)` Tranposes matrix.
`static opencv_core.CvSeq`	`cvTreeToNodeSeq(org.bytedeco.javacpp.Pointer first, int header_size, opencv_core.CvMemStorage storage)` Gathers pointers to all the sequences, accessible from the `first`, to the single sequence
`static opencv_core.CvTypeInfo`	`cvTypeOf(org.bytedeco.javacpp.Pointer struct_ptr)` \brief Returns the type of an object.
`static void`	`cvUnregisterType(org.bytedeco.javacpp.BytePointer type_name)` \brief Unregisters the type.
`static void`	`cvUnregisterType(String type_name)`
`static int`	`cvUseOptimized(int on_off)` Loads optimized functions from IPP, MKL etc.
`static void`	`cvWrite(opencv_core.CvFileStorage fs, org.bytedeco.javacpp.BytePointer name, org.bytedeco.javacpp.Pointer ptr)`
`static void`	`cvWrite(opencv_core.CvFileStorage fs, org.bytedeco.javacpp.BytePointer name, org.bytedeco.javacpp.Pointer ptr, opencv_core.CvAttrList attributes)` \brief Writes an object to file storage.
`static void`	`cvWrite(opencv_core.CvFileStorage fs, String name, org.bytedeco.javacpp.Pointer ptr)`
`static void`	`cvWrite(opencv_core.CvFileStorage fs, String name, org.bytedeco.javacpp.Pointer ptr, opencv_core.CvAttrList attributes)`
`static void`	`cvWriteComment(opencv_core.CvFileStorage fs, org.bytedeco.javacpp.BytePointer comment, int eol_comment)` \brief Writes a comment.
`static void`	`cvWriteComment(opencv_core.CvFileStorage fs, String comment, int eol_comment)`
`static void`	`cvWriteFileNode(opencv_core.CvFileStorage fs, org.bytedeco.javacpp.BytePointer new_node_name, opencv_core.CvFileNode node, int embed)` \brief Writes a file node to another file storage.
`static void`	`cvWriteFileNode(opencv_core.CvFileStorage fs, String new_node_name, opencv_core.CvFileNode node, int embed)`
`static void`	`cvWriteInt(opencv_core.CvFileStorage fs, org.bytedeco.javacpp.BytePointer name, int value)` \brief Writes an integer value.
`static void`	`cvWriteInt(opencv_core.CvFileStorage fs, String name, int value)`
`static void`	`cvWriteRawData(opencv_core.CvFileStorage fs, org.bytedeco.javacpp.Pointer src, int len, org.bytedeco.javacpp.BytePointer dt)` \brief Writes multiple numbers.
`static void`	`cvWriteRawData(opencv_core.CvFileStorage fs, org.bytedeco.javacpp.Pointer src, int len, String dt)`
`static void`	`cvWriteRawDataBase64(opencv_core.CvFileStorage fs, org.bytedeco.javacpp.Pointer src, int len, org.bytedeco.javacpp.BytePointer dt)` \brief Writes multiple numbers in Base64.
`static void`	`cvWriteRawDataBase64(opencv_core.CvFileStorage fs, org.bytedeco.javacpp.Pointer src, int len, String dt)`
`static void`	`cvWriteReal(opencv_core.CvFileStorage fs, org.bytedeco.javacpp.BytePointer name, double value)` \brief Writes a floating-point value.
`static void`	`cvWriteReal(opencv_core.CvFileStorage fs, String name, double value)`
`static void`	`cvWriteString(opencv_core.CvFileStorage fs, org.bytedeco.javacpp.BytePointer name, org.bytedeco.javacpp.BytePointer str)`
`static void`	`cvWriteString(opencv_core.CvFileStorage fs, org.bytedeco.javacpp.BytePointer name, org.bytedeco.javacpp.BytePointer str, int quote)` \brief Writes a text string.
`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)` dst(idx) = src1(idx) ^ src2(idx)
`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)` dst(idx) = src(idx) ^ value
`static void`	`cvZero(opencv_core.CvArr arg1)`
`static void`	`dct(opencv_core.GpuMat src, opencv_core.GpuMat dst)`
`static void`	`dct(opencv_core.GpuMat src, opencv_core.GpuMat dst, int flags)`
`static void`	`dct(opencv_core.Mat src, opencv_core.Mat dst)`
`static void`	`dct(opencv_core.Mat src, opencv_core.Mat dst, int flags)` \brief Performs a forward or inverse discrete Cosine transform of 1D or 2D array.
`static void`	`dct(opencv_core.UMat src, opencv_core.UMat dst)`
`static void`	`dct(opencv_core.UMat src, opencv_core.UMat dst, int flags)`
`static double`	`determinant(opencv_core.GpuMat mtx)`
`static double`	`determinant(opencv_core.Mat mtx)` \brief Returns the determinant of a square floating-point matrix.
`static double`	`determinant(opencv_core.UMat mtx)`
`static boolean`	`deviceSupports(int feature_set)` checks whether current device supports the given feature
`static void`	`dft(opencv_core.GpuMat src, opencv_core.GpuMat dst)`
`static void`	`dft(opencv_core.GpuMat src, opencv_core.GpuMat dst, int flags, int nonzeroRows)`
`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)` \brief Performs a forward or inverse Discrete Fourier transform of a 1D or 2D floating-point array.
`static void`	`dft(opencv_core.UMat src, opencv_core.UMat dst)`
`static void`	`dft(opencv_core.UMat src, opencv_core.UMat dst, int flags, int nonzeroRows)`
`static void`	`div16s(short[] src1, long step1, short[] src2, long step2, short[] dst, long step, int width, int height, org.bytedeco.javacpp.Pointer scale)`
`static void`	`div16s(ShortBuffer src1, long step1, ShortBuffer src2, long step2, ShortBuffer dst, long step, int width, int height, org.bytedeco.javacpp.Pointer scale)`
`static void`	`div16s(org.bytedeco.javacpp.ShortPointer src1, long step1, org.bytedeco.javacpp.ShortPointer src2, long step2, org.bytedeco.javacpp.ShortPointer dst, long step, int width, int height, org.bytedeco.javacpp.Pointer scale)`
`static void`	`div16u(short[] src1, long step1, short[] src2, long step2, short[] dst, long step, int width, int height, org.bytedeco.javacpp.Pointer scale)`
`static void`	`div16u(ShortBuffer src1, long step1, ShortBuffer src2, long step2, ShortBuffer dst, long step, int width, int height, org.bytedeco.javacpp.Pointer scale)`
`static void`	`div16u(org.bytedeco.javacpp.ShortPointer src1, long step1, org.bytedeco.javacpp.ShortPointer src2, long step2, org.bytedeco.javacpp.ShortPointer dst, long step, int width, int height, org.bytedeco.javacpp.Pointer scale)`
`static void`	`div32f(float[] src1, long step1, float[] src2, long step2, float[] dst, long step, int width, int height, org.bytedeco.javacpp.Pointer scale)`
`static void`	`div32f(FloatBuffer src1, long step1, FloatBuffer src2, long step2, FloatBuffer dst, long step, int width, int height, org.bytedeco.javacpp.Pointer scale)`
`static void`	`div32f(org.bytedeco.javacpp.FloatPointer src1, long step1, org.bytedeco.javacpp.FloatPointer src2, long step2, org.bytedeco.javacpp.FloatPointer dst, long step, int width, int height, org.bytedeco.javacpp.Pointer scale)`
`static void`	`div32s(int[] src1, long step1, int[] src2, long step2, int[] dst, long step, int width, int height, org.bytedeco.javacpp.Pointer scale)`
`static void`	`div32s(IntBuffer src1, long step1, IntBuffer src2, long step2, IntBuffer dst, long step, int width, int height, org.bytedeco.javacpp.Pointer scale)`
`static void`	`div32s(org.bytedeco.javacpp.IntPointer src1, long step1, org.bytedeco.javacpp.IntPointer src2, long step2, org.bytedeco.javacpp.IntPointer dst, long step, int width, int height, org.bytedeco.javacpp.Pointer scale)`
`static void`	`div64f(double[] src1, long step1, double[] src2, long step2, double[] dst, long step, int width, int height, org.bytedeco.javacpp.Pointer scale)`
`static void`	`div64f(DoubleBuffer src1, long step1, DoubleBuffer src2, long step2, DoubleBuffer dst, long step, int width, int height, org.bytedeco.javacpp.Pointer scale)`
`static void`	`div64f(org.bytedeco.javacpp.DoublePointer src1, long step1, org.bytedeco.javacpp.DoublePointer src2, long step2, org.bytedeco.javacpp.DoublePointer dst, long step, int width, int height, org.bytedeco.javacpp.Pointer scale)`
`static void`	`div8s(byte[] src1, long step1, byte[] src2, long step2, byte[] dst, long step, int width, int height, org.bytedeco.javacpp.Pointer scale)`
`static void`	`div8s(ByteBuffer src1, long step1, ByteBuffer src2, long step2, ByteBuffer dst, long step, int width, int height, org.bytedeco.javacpp.Pointer scale)`
`static void`	`div8s(org.bytedeco.javacpp.BytePointer src1, long step1, org.bytedeco.javacpp.BytePointer src2, long step2, org.bytedeco.javacpp.BytePointer dst, long step, int width, int height, org.bytedeco.javacpp.Pointer scale)`
`static void`	`div8u(byte[] src1, long step1, byte[] src2, long step2, byte[] dst, long step, int width, int height, org.bytedeco.javacpp.Pointer scale)`
`static void`	`div8u(ByteBuffer src1, long step1, ByteBuffer src2, long step2, ByteBuffer dst, long step, int width, int height, org.bytedeco.javacpp.Pointer scale)`
`static void`	`div8u(org.bytedeco.javacpp.BytePointer src1, long step1, org.bytedeco.javacpp.BytePointer src2, long step2, org.bytedeco.javacpp.BytePointer dst, long step, int width, int height, org.bytedeco.javacpp.Pointer scale)`
`static void`	`divide(double scale, opencv_core.GpuMat src2, opencv_core.GpuMat dst)`
`static void`	`divide(double scale, opencv_core.GpuMat src2, opencv_core.GpuMat dst, int dtype)`
`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)` \overload
`static void`	`divide(double scale, opencv_core.UMat src2, opencv_core.UMat dst)`
`static void`	`divide(double scale, opencv_core.UMat src2, opencv_core.UMat dst, int dtype)`
`static void`	`divide(opencv_core.GpuMat src1, opencv_core.GpuMat src2, opencv_core.GpuMat dst)`
`static void`	`divide(opencv_core.GpuMat src1, opencv_core.GpuMat src2, opencv_core.GpuMat dst, double scale, int dtype)`
`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)` \brief Performs per-element division of two arrays or a scalar by an array.
`static void`	`divide(opencv_core.UMat src1, opencv_core.UMat src2, opencv_core.UMat dst)`
`static void`	`divide(opencv_core.UMat src1, opencv_core.UMat src2, opencv_core.UMat dst, double scale, int dtype)`
`static opencv_core.Mat`	`dividePut(opencv_core.Mat a, double b)`
`static opencv_core.Mat`	`dividePut(opencv_core.Mat a, opencv_core.Mat b)`
`static int`	`divUp(int a, int b)` \brief Integer division with result round up.
`static long`	`divUp(long a, int b)` \overload
`static double`	`doubleRand()`
`static boolean`	`eigen(opencv_core.GpuMat src, opencv_core.GpuMat eigenvalues)`
`static boolean`	`eigen(opencv_core.GpuMat src, opencv_core.GpuMat eigenvalues, opencv_core.GpuMat eigenvectors)`
`static boolean`	`eigen(opencv_core.Mat src, opencv_core.Mat eigenvalues)`
`static boolean`	`eigen(opencv_core.Mat src, opencv_core.Mat eigenvalues, opencv_core.Mat eigenvectors)` \brief Calculates eigenvalues and eigenvectors of a symmetric matrix.
`static boolean`	`eigen(opencv_core.UMat src, opencv_core.UMat eigenvalues)`
`static boolean`	`eigen(opencv_core.UMat src, opencv_core.UMat eigenvalues, opencv_core.UMat eigenvectors)`
`static void`	`eigenNonSymmetric(opencv_core.GpuMat src, opencv_core.GpuMat eigenvalues, opencv_core.GpuMat eigenvectors)`
`static void`	`eigenNonSymmetric(opencv_core.Mat src, opencv_core.Mat eigenvalues, opencv_core.Mat eigenvectors)` \brief Calculates eigenvalues and eigenvectors of a non-symmetric matrix (real eigenvalues only).
`static void`	`eigenNonSymmetric(opencv_core.UMat src, opencv_core.UMat eigenvalues, opencv_core.UMat eigenvectors)`
`static void`	`ensureSizeIsEnough(int rows, int cols, int type, opencv_core.GpuMat arr)`
`static void`	`ensureSizeIsEnough(int rows, int cols, int type, opencv_core.Mat arr)` \brief Ensures that the size of a matrix is big enough and the matrix has a proper type.
`static void`	`ensureSizeIsEnough(int rows, int cols, int type, opencv_core.UMat arr)`
`static boolean`	`equals(org.bytedeco.javacpp.BytePointer lhs, org.bytedeco.javacpp.BytePointer rhs)`
`static opencv_core.MatExpr`	`equals(double s, opencv_core.Mat a)`
`static boolean`	`equals(opencv_core.FileNodeIterator it1, opencv_core.FileNodeIterator it2)` \} FileNode
`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.NodeData lhs, opencv_core.NodeData rhs)`
`static boolean`	`equals(opencv_core.Range r1, opencv_core.Range r2)` \brief measure dissimilarity between two sample sets computes the complement of the Jaccard Index as described in .
`static boolean`	`equals(String lhs, String rhs)`
`static void`	`error(int _code, org.bytedeco.javacpp.BytePointer _err, org.bytedeco.javacpp.BytePointer _func, org.bytedeco.javacpp.BytePointer _file, int _line)` \endcond
`static void`	`error(int _code, String _err, String _func, String _file, int _line)`
`static void`	`errorNoReturn(int _code, org.bytedeco.javacpp.BytePointer _err, org.bytedeco.javacpp.BytePointer _func, org.bytedeco.javacpp.BytePointer _file, int _line)` same as cv::error, but does not return
`static void`	`errorNoReturn(int _code, String _err, String _func, String _file, int _line)`
`static void`	`exp(double[] src, double[] dst, int n)`
`static void`	`exp(DoubleBuffer src, DoubleBuffer dst, int n)`
`static void`	`exp(org.bytedeco.javacpp.DoublePointer src, org.bytedeco.javacpp.DoublePointer dst, int n)`
`static void`	`exp(float[] src, float[] dst, int n)`
`static void`	`exp(FloatBuffer src, FloatBuffer dst, int n)`
`static void`	`exp(org.bytedeco.javacpp.FloatPointer src, org.bytedeco.javacpp.FloatPointer dst, int n)`
`static void`	`exp(opencv_core.GpuMat src, opencv_core.GpuMat dst)`
`static void`	`exp(opencv_core.Mat src, opencv_core.Mat dst)` \brief Calculates the exponent of every array element.
`static void`	`exp(opencv_core.UMat src, opencv_core.UMat dst)`
`static void`	`exp32f(float[] src, float[] dst, int n)`
`static void`	`exp32f(FloatBuffer src, FloatBuffer dst, int n)`
`static void`	`exp32f(org.bytedeco.javacpp.FloatPointer src, org.bytedeco.javacpp.FloatPointer dst, int n)`
`static void`	`exp64f(double[] src, double[] dst, int n)`
`static void`	`exp64f(DoubleBuffer src, DoubleBuffer dst, int n)`
`static void`	`exp64f(org.bytedeco.javacpp.DoublePointer src, org.bytedeco.javacpp.DoublePointer dst, int n)`
`static void`	`extractChannel(opencv_core.GpuMat src, opencv_core.GpuMat dst, int coi)`
`static void`	`extractChannel(opencv_core.Mat src, opencv_core.Mat dst, int coi)` \brief Extracts a single channel from src (coi is 0-based index)
`static void`	`extractChannel(opencv_core.UMat src, opencv_core.UMat dst, int coi)`
`static void`	`extractImageCOI(opencv_core.CvArr arr, opencv_core.GpuMat coiimg)`
`static void`	`extractImageCOI(opencv_core.CvArr arr, opencv_core.GpuMat coiimg, int coi)`
`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 void`	`extractImageCOI(opencv_core.CvArr arr, opencv_core.UMat coiimg)`
`static void`	`extractImageCOI(opencv_core.CvArr arr, opencv_core.UMat coiimg, int coi)`
`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)` \brief Calculates the angle of a 2D vector in degrees.
`static void`	`fastAtan2(org.bytedeco.javacpp.FloatPointer y, org.bytedeco.javacpp.FloatPointer x, org.bytedeco.javacpp.FloatPointer dst, int n, boolean angleInDegrees)`
`static void`	`fastAtan32f(float[] y, float[] x, float[] dst, int n, boolean angleInDegrees)`
`static void`	`fastAtan32f(FloatBuffer y, FloatBuffer x, FloatBuffer dst, int n, boolean angleInDegrees)`
`static void`	`fastAtan32f(org.bytedeco.javacpp.FloatPointer y, org.bytedeco.javacpp.FloatPointer x, org.bytedeco.javacpp.FloatPointer dst, int n, boolean angleInDegrees)`
`static void`	`fastAtan64f(double[] y, double[] x, double[] dst, int n, boolean angleInDegrees)`
`static void`	`fastAtan64f(DoubleBuffer y, DoubleBuffer x, DoubleBuffer dst, int n, boolean angleInDegrees)`
`static void`	`fastAtan64f(org.bytedeco.javacpp.DoublePointer y, org.bytedeco.javacpp.DoublePointer x, org.bytedeco.javacpp.DoublePointer dst, int n, boolean angleInDegrees)`
`static void`	`fastFree(org.bytedeco.javacpp.Pointer ptr)` \brief Deallocates a memory buffer.
`static org.bytedeco.javacpp.Pointer`	`fastMalloc(long bufSize)` \addtogroup core_utils \{
`static void`	`findNonZero(opencv_core.GpuMat src, opencv_core.GpuMat idx)`
`static void`	`findNonZero(opencv_core.Mat src, opencv_core.Mat idx)` \brief Returns the list of locations of non-zero pixels
`static void`	`findNonZero(opencv_core.UMat src, opencv_core.UMat idx)`
`static void`	`finish()`
`static void`	`flip(opencv_core.GpuMat src, opencv_core.GpuMat dst, int flipCode)`
`static void`	`flip(opencv_core.Mat src, opencv_core.Mat dst, int flipCode)` \brief Flips a 2D array around vertical, horizontal, or both axes.
`static void`	`flip(opencv_core.UMat src, opencv_core.UMat dst, int flipCode)`
`static float`	`floatRand()`
`static org.bytedeco.javacpp.BytePointer`	`format(org.bytedeco.javacpp.BytePointer fmt)` \brief Returns a text string formatted using the printf-like expression.
`static opencv_core.Formatted`	`format(opencv_core.GpuMat mtx, int fmt)`
`static opencv_core.Formatted`	`format(opencv_core.Mat mtx, int fmt)`
`static opencv_core.Formatted`	`format(opencv_core.UMat mtx, int fmt)`
`static String`	`format(String fmt)`
`static void`	`gemm(opencv_core.GpuMat src1, opencv_core.GpuMat src2, double alpha, opencv_core.GpuMat src3, double beta, opencv_core.GpuMat dst)`
`static void`	`gemm(opencv_core.GpuMat src1, opencv_core.GpuMat src2, double alpha, opencv_core.GpuMat src3, double beta, opencv_core.GpuMat dst, int flags)`
`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)` \brief Performs generalized matrix multiplication.
`static void`	`gemm(opencv_core.UMat src1, opencv_core.UMat src2, double alpha, opencv_core.UMat src3, double beta, opencv_core.UMat dst)`
`static void`	`gemm(opencv_core.UMat src1, opencv_core.UMat src2, double alpha, opencv_core.UMat src3, double beta, opencv_core.UMat dst, int flags)`
`static void`	`gemm32f(float[] src1, long src1_step, float[] src2, long src2_step, float alpha, float[] src3, long src3_step, float beta, float[] dst, long dst_step, int m_a, int n_a, int n_d, int flags)`
`static void`	`gemm32f(FloatBuffer src1, long src1_step, FloatBuffer src2, long src2_step, float alpha, FloatBuffer src3, long src3_step, float beta, FloatBuffer dst, long dst_step, int m_a, int n_a, int n_d, int flags)`
`static void`	`gemm32f(org.bytedeco.javacpp.FloatPointer src1, long src1_step, org.bytedeco.javacpp.FloatPointer src2, long src2_step, float alpha, org.bytedeco.javacpp.FloatPointer src3, long src3_step, float beta, org.bytedeco.javacpp.FloatPointer dst, long dst_step, int m_a, int n_a, int n_d, int flags)`
`static void`	`gemm32fc(float[] src1, long src1_step, float[] src2, long src2_step, float alpha, float[] src3, long src3_step, float beta, float[] dst, long dst_step, int m_a, int n_a, int n_d, int flags)`
`static void`	`gemm32fc(FloatBuffer src1, long src1_step, FloatBuffer src2, long src2_step, float alpha, FloatBuffer src3, long src3_step, float beta, FloatBuffer dst, long dst_step, int m_a, int n_a, int n_d, int flags)`
`static void`	`gemm32fc(org.bytedeco.javacpp.FloatPointer src1, long src1_step, org.bytedeco.javacpp.FloatPointer src2, long src2_step, float alpha, org.bytedeco.javacpp.FloatPointer src3, long src3_step, float beta, org.bytedeco.javacpp.FloatPointer dst, long dst_step, int m_a, int n_a, int n_d, int flags)`
`static void`	`gemm64f(double[] src1, long src1_step, double[] src2, long src2_step, double alpha, double[] src3, long src3_step, double beta, double[] dst, long dst_step, int m_a, int n_a, int n_d, int flags)`
`static void`	`gemm64f(DoubleBuffer src1, long src1_step, DoubleBuffer src2, long src2_step, double alpha, DoubleBuffer src3, long src3_step, double beta, DoubleBuffer dst, long dst_step, int m_a, int n_a, int n_d, int flags)`
`static void`	`gemm64f(org.bytedeco.javacpp.DoublePointer src1, long src1_step, org.bytedeco.javacpp.DoublePointer src2, long src2_step, double alpha, org.bytedeco.javacpp.DoublePointer src3, long src3_step, double beta, org.bytedeco.javacpp.DoublePointer dst, long dst_step, int m_a, int n_a, int n_d, int flags)`
`static void`	`gemm64fc(double[] src1, long src1_step, double[] src2, long src2_step, double alpha, double[] src3, long src3_step, double beta, double[] dst, long dst_step, int m_a, int n_a, int n_d, int flags)`
`static void`	`gemm64fc(DoubleBuffer src1, long src1_step, DoubleBuffer src2, long src2_step, double alpha, DoubleBuffer src3, long src3_step, double beta, DoubleBuffer dst, long dst_step, int m_a, int n_a, int n_d, int flags)`
`static void`	`gemm64fc(org.bytedeco.javacpp.DoublePointer src1, long src1_step, org.bytedeco.javacpp.DoublePointer src2, long src2_step, double alpha, org.bytedeco.javacpp.DoublePointer src3, long src3_step, double beta, org.bytedeco.javacpp.DoublePointer dst, long dst_step, int m_a, int n_a, int n_d, int flags)`
`static org.bytedeco.javacpp.BytePointer`	`getBuildInformation()` \brief Returns full configuration time cmake output.
`static org.bytedeco.javacpp.BytePointer`	`getCPUFeaturesLine()` \brief Returns list of CPU features enabled during compilation.
`static long`	`getCPUTickCount()` \brief Returns the number of CPU ticks.
`static int`	`getCudaEnabledDeviceCount()` \addtogroup cudacore_init /** \{
`static int`	`getDevice()` \brief Returns the current device index set by cuda::setDevice or initialized by default.
`static long`	`getElemSize(int type)`
`static int`	`getFlags()`
`static org.bytedeco.javacpp.BytePointer`	`getHardwareFeatureName(int feature)` \brief Returns feature name by ID
`static org.bytedeco.javacpp.BytePointer`	`getIppErrorLocation()`
`static long`	`getIppFeatures()`
`static int`	`getIppStatus()`
`static org.bytedeco.javacpp.BytePointer`	`getIppVersion()`
`static int`	`getNumberOfCPUs()` \brief Returns the number of logical CPUs available for the process.
`static int`	`getNumThreads()` \brief Returns the number of threads used by OpenCV for parallel regions.
`static opencv_core.MatAllocator`	`getOpenCLAllocator()`
`static org.bytedeco.javacpp.BytePointer`	`getOpenCLErrorString(int errorCode)`
`static int`	`getOptimalDFTSize(int vecsize)` \brief Returns the optimal DFT size for a given vector size.
`static void`	`getPlatfomsInfo(opencv_core.PlatformInfo platform_info)`
`static org.bytedeco.javacpp.BytePointer`	`getSeqElem(opencv_core.CvSeq seq, int index)`
`static int`	`getThreadID()`
`static int`	`getThreadNum()` Deprecated. Current implementation doesn't corresponding to this documentation. The exact meaning of the return value depends on the threading framework used by OpenCV library: - `TBB` - Unsupported with current 4.1 TBB release. Maybe will be supported in future. - `OpenMP` - The thread number, within the current team, of the calling thread. - `Concurrency` - An ID for the virtual processor that the current context is executing on (0 for master thread and unique number for others, but not necessary 1,2,3,...). - `GCD` - System calling thread's ID. Never returns 0 inside parallel region. - `C=` - The index of the current parallel task. \sa setNumThreads, getNumThreads
`static long`	`getTickCount()` \brief Returns the number of ticks.
`static double`	`getTickFrequency()` \brief Returns the number of ticks per second.
`static opencv_core.InstrNode`	`getTrace()`
`static int`	`getVersionMajor()` \brief Returns major library version
`static int`	`getVersionMinor()` \brief Returns minor library version
`static int`	`getVersionRevision()` \brief Returns revision field of the library version
`static org.bytedeco.javacpp.BytePointer`	`getVersionString()` \brief Returns library version string
`static void`	`glob(org.bytedeco.javacpp.BytePointer pattern, opencv_core.StringVector result)`
`static void`	`glob(org.bytedeco.javacpp.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 boolean`	`greaterThan(org.bytedeco.javacpp.BytePointer lhs, org.bytedeco.javacpp.BytePointer rhs)`
`static opencv_core.MatExpr`	`greaterThan(double s, opencv_core.Mat a)`
`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 boolean`	`greaterThan(String lhs, String rhs)`
`static boolean`	`greaterThanEquals(org.bytedeco.javacpp.BytePointer lhs, org.bytedeco.javacpp.BytePointer rhs)`
`static opencv_core.MatExpr`	`greaterThanEquals(double s, opencv_core.Mat a)`
`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 boolean`	`greaterThanEquals(String lhs, String rhs)`
`static boolean`	`haveAmdBlas()`
`static boolean`	`haveAmdFft()`
`static boolean`	`haveOpenCL()` \addtogroup core_opencl \{
`static boolean`	`haveSVM()`
`static void`	`hconcat(opencv_core.GpuMat src1, opencv_core.GpuMat src2, opencv_core.GpuMat dst)`
`static void`	`hconcat(opencv_core.GpuMatVector src, opencv_core.GpuMat dst)`
`static void`	`hconcat(opencv_core.GpuMatVector src, opencv_core.Mat dst)`
`static void`	`hconcat(opencv_core.GpuMatVector src, opencv_core.UMat dst)`
`static void`	`hconcat(opencv_core.Mat src, long nsrc, opencv_core.GpuMat dst)`
`static void`	`hconcat(opencv_core.Mat src, long nsrc, opencv_core.Mat dst)` \brief Applies horizontal concatenation to given matrices.
`static void`	`hconcat(opencv_core.Mat src, long nsrc, opencv_core.UMat dst)`
`static void`	`hconcat(opencv_core.Mat src1, opencv_core.Mat src2, opencv_core.Mat dst)` \overload
`static void`	`hconcat(opencv_core.MatVector src, opencv_core.GpuMat dst)`
`static void`	`hconcat(opencv_core.MatVector src, opencv_core.Mat dst)` \overload
`static void`	`hconcat(opencv_core.MatVector src, opencv_core.UMat dst)`
`static void`	`hconcat(opencv_core.UMat src1, opencv_core.UMat src2, opencv_core.UMat dst)`
`static void`	`hconcat(opencv_core.UMatVector src, opencv_core.GpuMat dst)`
`static void`	`hconcat(opencv_core.UMatVector src, opencv_core.Mat dst)`
`static void`	`hconcat(opencv_core.UMatVector src, opencv_core.UMat dst)`
`static void`	`idct(opencv_core.GpuMat src, opencv_core.GpuMat dst)`
`static void`	`idct(opencv_core.GpuMat src, opencv_core.GpuMat dst, int flags)`
`static void`	`idct(opencv_core.Mat src, opencv_core.Mat dst)`
`static void`	`idct(opencv_core.Mat src, opencv_core.Mat dst, int flags)` \brief Calculates the inverse Discrete Cosine Transform of a 1D or 2D array.
`static void`	`idct(opencv_core.UMat src, opencv_core.UMat dst)`
`static void`	`idct(opencv_core.UMat src, opencv_core.UMat dst, int flags)`
`static void`	`idft(opencv_core.GpuMat src, opencv_core.GpuMat dst)`
`static void`	`idft(opencv_core.GpuMat src, opencv_core.GpuMat dst, int flags, int nonzeroRows)`
`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)` \brief Calculates the inverse Discrete Fourier Transform of a 1D or 2D array.
`static void`	`idft(opencv_core.UMat src, opencv_core.UMat dst)`
`static void`	`idft(opencv_core.UMat src, opencv_core.UMat dst, int flags, int nonzeroRows)`
`static void`	`inRange(opencv_core.GpuMat src, opencv_core.GpuMat lowerb, opencv_core.GpuMat upperb, opencv_core.GpuMat dst)`
`static void`	`inRange(opencv_core.Mat src, opencv_core.Mat lowerb, opencv_core.Mat upperb, opencv_core.Mat dst)` \brief Checks if array elements lie between the elements of two other arrays.
`static void`	`inRange(opencv_core.UMat src, opencv_core.UMat lowerb, opencv_core.UMat upperb, opencv_core.UMat dst)`
`static void`	`insertChannel(opencv_core.GpuMat src, opencv_core.GpuMat dst, int coi)`
`static void`	`insertChannel(opencv_core.Mat src, opencv_core.Mat dst, int coi)` \brief Inserts a single channel to dst (coi is 0-based index)
`static void`	`insertChannel(opencv_core.UMat src, opencv_core.UMat dst, int coi)`
`static void`	`insertImageCOI(opencv_core.GpuMat coiimg, opencv_core.CvArr arr)`
`static void`	`insertImageCOI(opencv_core.GpuMat coiimg, opencv_core.CvArr arr, int coi)`
`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 void`	`insertImageCOI(opencv_core.UMat coiimg, opencv_core.CvArr arr)`
`static void`	`insertImageCOI(opencv_core.UMat coiimg, opencv_core.CvArr arr, int coi)`
`static long`	`int64SaturateCast(byte v)`
`static long`	`int64SaturateCast(double v)`
`static long`	`int64SaturateCast(float v)`
`static long`	`int64SaturateCast(int v)`
`static long`	`int64SaturateCast(long v)`
`static long`	`int64SaturateCast(short v)`
`static int`	`intRand()` returns the next unifomly-distributed random number of the specified type
`static int`	`intSaturate(byte v)`
`static int`	`intSaturate(double v)`
`static int`	`intSaturate(float v)`
`static int`	`intSaturate(int v)`
`static int`	`intSaturate(long v)`
`static int`	`intSaturate(short v)`
`static double`	`invert(opencv_core.GpuMat src, opencv_core.GpuMat dst)`
`static double`	`invert(opencv_core.GpuMat src, opencv_core.GpuMat dst, int flags)`
`static double`	`invert(opencv_core.Mat src, opencv_core.Mat dst)`
`static double`	`invert(opencv_core.Mat src, opencv_core.Mat dst, int flags)` \brief Finds the inverse or pseudo-inverse of a matrix.
`static double`	`invert(opencv_core.UMat src, opencv_core.UMat dst)`
`static double`	`invert(opencv_core.UMat src, opencv_core.UMat dst, int flags)`
`static void`	`invSqrt(double[] src, double[] dst, int len)`
`static void`	`invSqrt(DoubleBuffer src, DoubleBuffer dst, int len)`
`static void`	`invSqrt(org.bytedeco.javacpp.DoublePointer src, org.bytedeco.javacpp.DoublePointer dst, int len)`
`static void`	`invSqrt(float[] src, float[] dst, int len)`
`static void`	`invSqrt(FloatBuffer src, FloatBuffer dst, int len)`
`static void`	`invSqrt(org.bytedeco.javacpp.FloatPointer src, org.bytedeco.javacpp.FloatPointer dst, int len)`
`static void`	`invSqrt32f(float[] src, float[] dst, int len)`
`static void`	`invSqrt32f(FloatBuffer src, FloatBuffer dst, int len)`
`static void`	`invSqrt32f(org.bytedeco.javacpp.FloatPointer src, org.bytedeco.javacpp.FloatPointer dst, int len)`
`static void`	`invSqrt64f(double[] src, double[] dst, int len)`
`static void`	`invSqrt64f(DoubleBuffer src, DoubleBuffer dst, int len)`
`static void`	`invSqrt64f(org.bytedeco.javacpp.DoublePointer src, org.bytedeco.javacpp.DoublePointer dst, int len)`
`static int`	`IPL_IMAGE_MAGIC_VAL()`
`static org.bytedeco.javacpp.BytePointer`	`kernelToStr(opencv_core.GpuMat _kernel)`
`static org.bytedeco.javacpp.BytePointer`	`kernelToStr(opencv_core.GpuMat _kernel, int ddepth, org.bytedeco.javacpp.BytePointer name)`
`static String`	`kernelToStr(opencv_core.GpuMat _kernel, int ddepth, String name)`
`static org.bytedeco.javacpp.BytePointer`	`kernelToStr(opencv_core.Mat _kernel)`
`static org.bytedeco.javacpp.BytePointer`	`kernelToStr(opencv_core.Mat _kernel, int ddepth, org.bytedeco.javacpp.BytePointer name)`
`static String`	`kernelToStr(opencv_core.Mat _kernel, int ddepth, String name)`
`static String`	`kernelToStr(opencv_core.UMat _kernel)`
`static org.bytedeco.javacpp.BytePointer`	`kernelToStr(opencv_core.UMat _kernel, int ddepth, org.bytedeco.javacpp.BytePointer name)`
`static String`	`kernelToStr(opencv_core.UMat _kernel, int ddepth, String name)`
`static double`	`kmeans(opencv_core.GpuMat data, int K, opencv_core.GpuMat bestLabels, opencv_core.TermCriteria criteria, int attempts, int flags)`
`static double`	`kmeans(opencv_core.GpuMat data, int K, opencv_core.GpuMat bestLabels, opencv_core.TermCriteria criteria, int attempts, int flags, opencv_core.GpuMat centers)`
`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)` \brief Finds centers of clusters and groups input samples around the clusters.
`static double`	`kmeans(opencv_core.UMat data, int K, opencv_core.UMat bestLabels, opencv_core.TermCriteria criteria, int attempts, int flags)`
`static double`	`kmeans(opencv_core.UMat data, int K, opencv_core.UMat bestLabels, opencv_core.TermCriteria criteria, int attempts, int flags, opencv_core.UMat centers)`
`static boolean`	`lessThan(org.bytedeco.javacpp.BytePointer lhs, org.bytedeco.javacpp.BytePointer rhs)`
`static opencv_core.MatExpr`	`lessThan(double s, opencv_core.Mat a)`
`static boolean`	`lessThan(opencv_core.FileNodeIterator it1, opencv_core.FileNodeIterator it2)`
`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 boolean`	`lessThan(String lhs, String rhs)`
`static boolean`	`lessThanEquals(org.bytedeco.javacpp.BytePointer lhs, org.bytedeco.javacpp.BytePointer rhs)`
`static opencv_core.MatExpr`	`lessThanEquals(double s, opencv_core.Mat a)`
`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 boolean`	`lessThanEquals(String lhs, String rhs)`
`static void`	`log(double[] src, double[] dst, int n)`
`static void`	`log(DoubleBuffer src, DoubleBuffer dst, int n)`
`static void`	`log(org.bytedeco.javacpp.DoublePointer src, org.bytedeco.javacpp.DoublePointer dst, int n)`
`static void`	`log(float[] src, float[] dst, int n)`
`static void`	`log(FloatBuffer src, FloatBuffer dst, int n)`
`static void`	`log(org.bytedeco.javacpp.FloatPointer src, org.bytedeco.javacpp.FloatPointer dst, int n)`
`static void`	`log(opencv_core.GpuMat src, opencv_core.GpuMat dst)`
`static void`	`log(opencv_core.Mat src, opencv_core.Mat dst)` \brief Calculates the natural logarithm of every array element.
`static void`	`log(opencv_core.UMat src, opencv_core.UMat dst)`
`static void`	`log32f(float[] src, float[] dst, int n)`
`static void`	`log32f(FloatBuffer src, FloatBuffer dst, int n)`
`static void`	`log32f(org.bytedeco.javacpp.FloatPointer src, org.bytedeco.javacpp.FloatPointer dst, int n)`
`static void`	`log64f(double[] src, double[] dst, int n)`
`static void`	`log64f(DoubleBuffer src, DoubleBuffer dst, int n)`
`static void`	`log64f(org.bytedeco.javacpp.DoublePointer src, org.bytedeco.javacpp.DoublePointer dst, int n)`
`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(org.bytedeco.javacpp.DoublePointer A, long astep, int m, org.bytedeco.javacpp.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(org.bytedeco.javacpp.FloatPointer A, long astep, int m, org.bytedeco.javacpp.FloatPointer b, long bstep, int n)` \cond IGNORED
`static int`	`LU32f(float[] A, long astep, int m, float[] b, long bstep, int n)`
`static int`	`LU32f(FloatBuffer A, long astep, int m, FloatBuffer b, long bstep, int n)`
`static int`	`LU32f(org.bytedeco.javacpp.FloatPointer A, long astep, int m, org.bytedeco.javacpp.FloatPointer b, long bstep, int n)`
`static int`	`LU64f(double[] A, long astep, int m, double[] b, long bstep, int n)`
`static int`	`LU64f(DoubleBuffer A, long astep, int m, DoubleBuffer b, long bstep, int n)`
`static int`	`LU64f(org.bytedeco.javacpp.DoublePointer A, long astep, int m, org.bytedeco.javacpp.DoublePointer b, long bstep, int n)`
`static void`	`LUT(opencv_core.GpuMat src, opencv_core.GpuMat lut, opencv_core.GpuMat dst)`
`static void`	`LUT(opencv_core.Mat src, opencv_core.Mat lut, opencv_core.Mat dst)` \brief Performs a look-up table transform of an array.
`static void`	`LUT(opencv_core.UMat src, opencv_core.UMat lut, opencv_core.UMat dst)`
`static void`	`magnitude(double[] x, double[] y, double[] dst, int n)`
`static void`	`magnitude(DoubleBuffer x, DoubleBuffer y, DoubleBuffer dst, int n)`
`static void`	`magnitude(org.bytedeco.javacpp.DoublePointer x, org.bytedeco.javacpp.DoublePointer y, org.bytedeco.javacpp.DoublePointer dst, int n)`
`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(org.bytedeco.javacpp.FloatPointer x, org.bytedeco.javacpp.FloatPointer y, org.bytedeco.javacpp.FloatPointer dst, int n)`
`static void`	`magnitude(opencv_core.GpuMat x, opencv_core.GpuMat y, opencv_core.GpuMat magnitude)`
`static void`	`magnitude(opencv_core.Mat x, opencv_core.Mat y, opencv_core.Mat magnitude)` \brief Calculates the magnitude of 2D vectors.
`static void`	`magnitude(opencv_core.UMat x, opencv_core.UMat y, opencv_core.UMat magnitude)`
`static void`	`magnitude32f(float[] x, float[] y, float[] dst, int n)`
`static void`	`magnitude32f(FloatBuffer x, FloatBuffer y, FloatBuffer dst, int n)`
`static void`	`magnitude32f(org.bytedeco.javacpp.FloatPointer x, org.bytedeco.javacpp.FloatPointer y, org.bytedeco.javacpp.FloatPointer dst, int n)`
`static void`	`magnitude64f(double[] x, double[] y, double[] dst, int n)`
`static void`	`magnitude64f(DoubleBuffer x, DoubleBuffer y, DoubleBuffer dst, int n)`
`static void`	`magnitude64f(org.bytedeco.javacpp.DoublePointer x, org.bytedeco.javacpp.DoublePointer y, org.bytedeco.javacpp.DoublePointer dst, int n)`
`static double`	`Mahalanobis(opencv_core.GpuMat v1, opencv_core.GpuMat v2, opencv_core.GpuMat icovar)`
`static double`	`Mahalanobis(opencv_core.Mat v1, opencv_core.Mat v2, opencv_core.Mat icovar)` \brief Calculates the Mahalanobis distance between two vectors.
`static double`	`Mahalanobis(opencv_core.UMat v1, opencv_core.UMat v2, opencv_core.UMat icovar)`
`static opencv_core.MatExpr`	`max(double s, opencv_core.Mat a)`
`static opencv_core.MatExpr`	`max(opencv_core.Mat a, double s)`
`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)` \overload needed to avoid conflicts with const _Tp& std::min(const _Tp&, const _Tp&, _Compare)
`static void`	`max(opencv_core.UMat src1, opencv_core.UMat src2, opencv_core.UMat dst)` \overload needed to avoid conflicts with const _Tp& std::min(const _Tp&, const _Tp&, _Compare)
`static void`	`max16s(short[] src1, long step1, short[] src2, long step2, short[] dst, long step, int width, int height, org.bytedeco.javacpp.Pointer arg8)`
`static void`	`max16s(ShortBuffer src1, long step1, ShortBuffer src2, long step2, ShortBuffer dst, long step, int width, int height, org.bytedeco.javacpp.Pointer arg8)`
`static void`	`max16s(org.bytedeco.javacpp.ShortPointer src1, long step1, org.bytedeco.javacpp.ShortPointer src2, long step2, org.bytedeco.javacpp.ShortPointer dst, long step, int width, int height, org.bytedeco.javacpp.Pointer arg8)`
`static void`	`max16u(short[] src1, long step1, short[] src2, long step2, short[] dst, long step, int width, int height, org.bytedeco.javacpp.Pointer arg8)`
`static void`	`max16u(ShortBuffer src1, long step1, ShortBuffer src2, long step2, ShortBuffer dst, long step, int width, int height, org.bytedeco.javacpp.Pointer arg8)`
`static void`	`max16u(org.bytedeco.javacpp.ShortPointer src1, long step1, org.bytedeco.javacpp.ShortPointer src2, long step2, org.bytedeco.javacpp.ShortPointer dst, long step, int width, int height, org.bytedeco.javacpp.Pointer arg8)`
`static void`	`max32f(float[] src1, long step1, float[] src2, long step2, float[] dst, long step, int width, int height, org.bytedeco.javacpp.Pointer arg8)`
`static void`	`max32f(FloatBuffer src1, long step1, FloatBuffer src2, long step2, FloatBuffer dst, long step, int width, int height, org.bytedeco.javacpp.Pointer arg8)`
`static void`	`max32f(org.bytedeco.javacpp.FloatPointer src1, long step1, org.bytedeco.javacpp.FloatPointer src2, long step2, org.bytedeco.javacpp.FloatPointer dst, long step, int width, int height, org.bytedeco.javacpp.Pointer arg8)`
`static void`	`max32s(int[] src1, long step1, int[] src2, long step2, int[] dst, long step, int width, int height, org.bytedeco.javacpp.Pointer arg8)`
`static void`	`max32s(IntBuffer src1, long step1, IntBuffer src2, long step2, IntBuffer dst, long step, int width, int height, org.bytedeco.javacpp.Pointer arg8)`
`static void`	`max32s(org.bytedeco.javacpp.IntPointer src1, long step1, org.bytedeco.javacpp.IntPointer src2, long step2, org.bytedeco.javacpp.IntPointer dst, long step, int width, int height, org.bytedeco.javacpp.Pointer arg8)`
`static void`	`max64f(double[] src1, long step1, double[] src2, long step2, double[] dst, long step, int width, int height, org.bytedeco.javacpp.Pointer arg8)`
`static void`	`max64f(DoubleBuffer src1, long step1, DoubleBuffer src2, long step2, DoubleBuffer dst, long step, int width, int height, org.bytedeco.javacpp.Pointer arg8)`
`static void`	`max64f(org.bytedeco.javacpp.DoublePointer src1, long step1, org.bytedeco.javacpp.DoublePointer src2, long step2, org.bytedeco.javacpp.DoublePointer dst, long step, int width, int height, org.bytedeco.javacpp.Pointer arg8)`
`static void`	`max8s(byte[] src1, long step1, byte[] src2, long step2, byte[] dst, long step, int width, int height, org.bytedeco.javacpp.Pointer arg8)`
`static void`	`max8s(ByteBuffer src1, long step1, ByteBuffer src2, long step2, ByteBuffer dst, long step, int width, int height, org.bytedeco.javacpp.Pointer arg8)`
`static void`	`max8s(org.bytedeco.javacpp.BytePointer src1, long step1, org.bytedeco.javacpp.BytePointer src2, long step2, org.bytedeco.javacpp.BytePointer dst, long step, int width, int height, org.bytedeco.javacpp.Pointer arg8)`
`static void`	`max8u(byte[] src1, long step1, byte[] src2, long step2, byte[] dst, long step, int width, int height, org.bytedeco.javacpp.Pointer arg8)`
`static void`	`max8u(ByteBuffer src1, long step1, ByteBuffer src2, long step2, ByteBuffer dst, long step, int width, int height, org.bytedeco.javacpp.Pointer arg8)`
`static void`	`max8u(org.bytedeco.javacpp.BytePointer src1, long step1, org.bytedeco.javacpp.BytePointer src2, long step2, org.bytedeco.javacpp.BytePointer dst, long step, int width, int height, org.bytedeco.javacpp.Pointer arg8)`
`static opencv_core.Scalar`	`mean(opencv_core.GpuMat src)`
`static opencv_core.Scalar`	`mean(opencv_core.GpuMat src, opencv_core.GpuMat mask)`
`static opencv_core.Scalar`	`mean(opencv_core.Mat src)`
`static opencv_core.Scalar`	`mean(opencv_core.Mat src, opencv_core.Mat mask)` \brief Calculates an average (mean) of array elements.
`static opencv_core.Scalar`	`mean(opencv_core.UMat src)`
`static opencv_core.Scalar`	`mean(opencv_core.UMat src, opencv_core.UMat mask)`
`static void`	`meanStdDev(opencv_core.GpuMat src, opencv_core.GpuMat mean, opencv_core.GpuMat stddev)`
`static void`	`meanStdDev(opencv_core.GpuMat src, opencv_core.GpuMat mean, opencv_core.GpuMat stddev, opencv_core.GpuMat mask)`
`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)` Calculates a mean and standard deviation of array elements.
`static void`	`meanStdDev(opencv_core.UMat src, opencv_core.UMat mean, opencv_core.UMat stddev)`
`static void`	`meanStdDev(opencv_core.UMat src, opencv_core.UMat mean, opencv_core.UMat stddev, opencv_core.UMat mask)`
`static org.bytedeco.javacpp.BytePointer`	`memopTypeToStr(int t)`
`static void`	`merge(opencv_core.GpuMatVector mv, opencv_core.GpuMat dst)`
`static void`	`merge(opencv_core.GpuMatVector mv, opencv_core.Mat dst)`
`static void`	`merge(opencv_core.GpuMatVector mv, opencv_core.UMat dst)`
`static void`	`merge(opencv_core.Mat mv, long count, opencv_core.GpuMat dst)`
`static void`	`merge(opencv_core.Mat mv, long count, opencv_core.Mat dst)` \brief Creates one multi-channel array out of several single-channel ones.
`static void`	`merge(opencv_core.Mat mv, long count, opencv_core.UMat dst)`
`static void`	`merge(opencv_core.MatVector mv, opencv_core.GpuMat dst)`
`static void`	`merge(opencv_core.MatVector mv, opencv_core.Mat dst)` \overload
`static void`	`merge(opencv_core.MatVector mv, opencv_core.UMat dst)`
`static void`	`merge(opencv_core.UMatVector mv, opencv_core.GpuMat dst)`
`static void`	`merge(opencv_core.UMatVector mv, opencv_core.Mat dst)`
`static void`	`merge(opencv_core.UMatVector mv, opencv_core.UMat dst)`
`static void`	`merge16u(org.bytedeco.javacpp.PointerPointer src, org.bytedeco.javacpp.ShortPointer dst, int len, int cn)`
`static void`	`merge16u(short[] src, short[] dst, int len, int cn)`
`static void`	`merge16u(ShortBuffer src, ShortBuffer dst, int len, int cn)`
`static void`	`merge16u(org.bytedeco.javacpp.ShortPointer src, org.bytedeco.javacpp.ShortPointer dst, int len, int cn)`
`static void`	`merge32s(int[] src, int[] dst, int len, int cn)`
`static void`	`merge32s(IntBuffer src, IntBuffer dst, int len, int cn)`
`static void`	`merge32s(org.bytedeco.javacpp.IntPointer src, org.bytedeco.javacpp.IntPointer dst, int len, int cn)`
`static void`	`merge32s(org.bytedeco.javacpp.PointerPointer src, org.bytedeco.javacpp.IntPointer dst, int len, int cn)`
`static void`	`merge64s(long[] src, long[] dst, int len, int cn)`
`static void`	`merge64s(LongBuffer src, LongBuffer dst, int len, int cn)`
`static void`	`merge64s(org.bytedeco.javacpp.LongPointer src, org.bytedeco.javacpp.LongPointer dst, int len, int cn)`
`static void`	`merge64s(org.bytedeco.javacpp.PointerPointer src, org.bytedeco.javacpp.LongPointer dst, int len, int cn)`
`static void`	`merge8u(byte[] src, byte[] dst, int len, int cn)`
`static void`	`merge8u(ByteBuffer src, ByteBuffer dst, int len, int cn)`
`static void`	`merge8u(org.bytedeco.javacpp.BytePointer src, org.bytedeco.javacpp.BytePointer dst, int len, int cn)`
`static void`	`merge8u(org.bytedeco.javacpp.PointerPointer src, org.bytedeco.javacpp.BytePointer dst, int len, int cn)`
`static opencv_core.MatExpr`	`min(double s, opencv_core.Mat a)`
`static opencv_core.MatExpr`	`min(opencv_core.Mat a, double s)`
`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)` \overload needed to avoid conflicts with const _Tp& std::min(const _Tp&, const _Tp&, _Compare)
`static void`	`min(opencv_core.UMat src1, opencv_core.UMat src2, opencv_core.UMat dst)` \overload needed to avoid conflicts with const _Tp& std::min(const _Tp&, const _Tp&, _Compare)
`static void`	`min16s(short[] src1, long step1, short[] src2, long step2, short[] dst, long step, int width, int height, org.bytedeco.javacpp.Pointer arg8)`
`static void`	`min16s(ShortBuffer src1, long step1, ShortBuffer src2, long step2, ShortBuffer dst, long step, int width, int height, org.bytedeco.javacpp.Pointer arg8)`
`static void`	`min16s(org.bytedeco.javacpp.ShortPointer src1, long step1, org.bytedeco.javacpp.ShortPointer src2, long step2, org.bytedeco.javacpp.ShortPointer dst, long step, int width, int height, org.bytedeco.javacpp.Pointer arg8)`
`static void`	`min16u(short[] src1, long step1, short[] src2, long step2, short[] dst, long step, int width, int height, org.bytedeco.javacpp.Pointer arg8)`
`static void`	`min16u(ShortBuffer src1, long step1, ShortBuffer src2, long step2, ShortBuffer dst, long step, int width, int height, org.bytedeco.javacpp.Pointer arg8)`
`static void`	`min16u(org.bytedeco.javacpp.ShortPointer src1, long step1, org.bytedeco.javacpp.ShortPointer src2, long step2, org.bytedeco.javacpp.ShortPointer dst, long step, int width, int height, org.bytedeco.javacpp.Pointer arg8)`
`static void`	`min32f(float[] src1, long step1, float[] src2, long step2, float[] dst, long step, int width, int height, org.bytedeco.javacpp.Pointer arg8)`
`static void`	`min32f(FloatBuffer src1, long step1, FloatBuffer src2, long step2, FloatBuffer dst, long step, int width, int height, org.bytedeco.javacpp.Pointer arg8)`
`static void`	`min32f(org.bytedeco.javacpp.FloatPointer src1, long step1, org.bytedeco.javacpp.FloatPointer src2, long step2, org.bytedeco.javacpp.FloatPointer dst, long step, int width, int height, org.bytedeco.javacpp.Pointer arg8)`
`static void`	`min32s(int[] src1, long step1, int[] src2, long step2, int[] dst, long step, int width, int height, org.bytedeco.javacpp.Pointer arg8)`
`static void`	`min32s(IntBuffer src1, long step1, IntBuffer src2, long step2, IntBuffer dst, long step, int width, int height, org.bytedeco.javacpp.Pointer arg8)`
`static void`	`min32s(org.bytedeco.javacpp.IntPointer src1, long step1, org.bytedeco.javacpp.IntPointer src2, long step2, org.bytedeco.javacpp.IntPointer dst, long step, int width, int height, org.bytedeco.javacpp.Pointer arg8)`
`static void`	`min64f(double[] src1, long step1, double[] src2, long step2, double[] dst, long step, int width, int height, org.bytedeco.javacpp.Pointer arg8)`
`static void`	`min64f(DoubleBuffer src1, long step1, DoubleBuffer src2, long step2, DoubleBuffer dst, long step, int width, int height, org.bytedeco.javacpp.Pointer arg8)`
`static void`	`min64f(org.bytedeco.javacpp.DoublePointer src1, long step1, org.bytedeco.javacpp.DoublePointer src2, long step2, org.bytedeco.javacpp.DoublePointer dst, long step, int width, int height, org.bytedeco.javacpp.Pointer arg8)`
`static void`	`min8s(byte[] src1, long step1, byte[] src2, long step2, byte[] dst, long step, int width, int height, org.bytedeco.javacpp.Pointer arg8)`
`static void`	`min8s(ByteBuffer src1, long step1, ByteBuffer src2, long step2, ByteBuffer dst, long step, int width, int height, org.bytedeco.javacpp.Pointer arg8)`
`static void`	`min8s(org.bytedeco.javacpp.BytePointer src1, long step1, org.bytedeco.javacpp.BytePointer src2, long step2, org.bytedeco.javacpp.BytePointer dst, long step, int width, int height, org.bytedeco.javacpp.Pointer arg8)`
`static void`	`min8u(byte[] src1, long step1, byte[] src2, long step2, byte[] dst, long step, int width, int height, org.bytedeco.javacpp.Pointer arg8)`
`static void`	`min8u(ByteBuffer src1, long step1, ByteBuffer src2, long step2, ByteBuffer dst, long step, int width, int height, org.bytedeco.javacpp.Pointer arg8)`
`static void`	`min8u(org.bytedeco.javacpp.BytePointer src1, long step1, org.bytedeco.javacpp.BytePointer src2, long step2, org.bytedeco.javacpp.BytePointer dst, long step, int width, int height, org.bytedeco.javacpp.Pointer arg8)`
`static void`	`minMaxIdx(opencv_core.GpuMat src, double[] minVal)`
`static void`	`minMaxIdx(opencv_core.GpuMat src, double[] minVal, double[] maxVal, int[] minIdx, int[] maxIdx, opencv_core.GpuMat mask)`
`static void`	`minMaxIdx(opencv_core.GpuMat src, DoubleBuffer minVal)`
`static void`	`minMaxIdx(opencv_core.GpuMat src, DoubleBuffer minVal, DoubleBuffer maxVal, IntBuffer minIdx, IntBuffer maxIdx, opencv_core.GpuMat mask)`
`static void`	`minMaxIdx(opencv_core.GpuMat src, org.bytedeco.javacpp.DoublePointer minVal)`
`static void`	`minMaxIdx(opencv_core.GpuMat src, org.bytedeco.javacpp.DoublePointer minVal, org.bytedeco.javacpp.DoublePointer maxVal, org.bytedeco.javacpp.IntPointer minIdx, org.bytedeco.javacpp.IntPointer maxIdx, opencv_core.GpuMat mask)`
`static void`	`minMaxIdx(opencv_core.Mat src, double[] minVal)`
`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)`
`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, org.bytedeco.javacpp.DoublePointer minVal)`
`static void`	`minMaxIdx(opencv_core.Mat src, org.bytedeco.javacpp.DoublePointer minVal, org.bytedeco.javacpp.DoublePointer maxVal, org.bytedeco.javacpp.IntPointer minIdx, org.bytedeco.javacpp.IntPointer maxIdx, opencv_core.Mat mask)` \brief Finds the global minimum and maximum in an array
`static void`	`minMaxIdx(opencv_core.UMat src, double[] minVal)`
`static void`	`minMaxIdx(opencv_core.UMat src, double[] minVal, double[] maxVal, int[] minIdx, int[] maxIdx, opencv_core.UMat mask)`
`static void`	`minMaxIdx(opencv_core.UMat src, DoubleBuffer minVal)`
`static void`	`minMaxIdx(opencv_core.UMat src, DoubleBuffer minVal, DoubleBuffer maxVal, IntBuffer minIdx, IntBuffer maxIdx, opencv_core.UMat mask)`
`static void`	`minMaxIdx(opencv_core.UMat src, org.bytedeco.javacpp.DoublePointer minVal)`
`static void`	`minMaxIdx(opencv_core.UMat src, org.bytedeco.javacpp.DoublePointer minVal, org.bytedeco.javacpp.DoublePointer maxVal, org.bytedeco.javacpp.IntPointer minIdx, org.bytedeco.javacpp.IntPointer maxIdx, opencv_core.UMat mask)`
`static void`	`minMaxLoc(opencv_core.GpuMat src, double[] minVal)`
`static void`	`minMaxLoc(opencv_core.GpuMat src, double[] minVal, double[] maxVal, opencv_core.Point minLoc, opencv_core.Point maxLoc, opencv_core.GpuMat mask)`
`static void`	`minMaxLoc(opencv_core.GpuMat src, DoubleBuffer minVal)`
`static void`	`minMaxLoc(opencv_core.GpuMat src, DoubleBuffer minVal, DoubleBuffer maxVal, opencv_core.Point minLoc, opencv_core.Point maxLoc, opencv_core.GpuMat mask)`
`static void`	`minMaxLoc(opencv_core.GpuMat src, org.bytedeco.javacpp.DoublePointer minVal)`
`static void`	`minMaxLoc(opencv_core.GpuMat src, org.bytedeco.javacpp.DoublePointer minVal, org.bytedeco.javacpp.DoublePointer maxVal, opencv_core.Point minLoc, opencv_core.Point maxLoc, opencv_core.GpuMat 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, org.bytedeco.javacpp.DoublePointer minVal)`
`static void`	`minMaxLoc(opencv_core.Mat src, org.bytedeco.javacpp.DoublePointer minVal, org.bytedeco.javacpp.DoublePointer maxVal, opencv_core.Point minLoc, opencv_core.Point maxLoc, opencv_core.Mat mask)` \brief Finds the global minimum and maximum in an array.
`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, org.bytedeco.javacpp.DoublePointer minVal, org.bytedeco.javacpp.DoublePointer maxVal)`
`static void`	`minMaxLoc(opencv_core.SparseMat a, org.bytedeco.javacpp.DoublePointer minVal, org.bytedeco.javacpp.DoublePointer maxVal, org.bytedeco.javacpp.IntPointer minIdx, org.bytedeco.javacpp.IntPointer maxIdx)` \overload
`static void`	`minMaxLoc(opencv_core.UMat src, double[] minVal)`
`static void`	`minMaxLoc(opencv_core.UMat src, double[] minVal, double[] maxVal, opencv_core.Point minLoc, opencv_core.Point maxLoc, opencv_core.UMat mask)`
`static void`	`minMaxLoc(opencv_core.UMat src, DoubleBuffer minVal)`
`static void`	`minMaxLoc(opencv_core.UMat src, DoubleBuffer minVal, DoubleBuffer maxVal, opencv_core.Point minLoc, opencv_core.Point maxLoc, opencv_core.UMat mask)`
`static void`	`minMaxLoc(opencv_core.UMat src, org.bytedeco.javacpp.DoublePointer minVal)`
`static void`	`minMaxLoc(opencv_core.UMat src, org.bytedeco.javacpp.DoublePointer minVal, org.bytedeco.javacpp.DoublePointer maxVal, opencv_core.Point minLoc, opencv_core.Point maxLoc, opencv_core.UMat mask)`
`static void`	`mixChannels(opencv_core.GpuMatVector src, opencv_core.GpuMatVector dst, int[] fromTo)`
`static void`	`mixChannels(opencv_core.GpuMatVector src, opencv_core.GpuMatVector dst, int[] fromTo, long npairs)`
`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, org.bytedeco.javacpp.IntPointer fromTo, long npairs)` \brief Copies specified channels from input arrays to the specified channels of output arrays.
`static void`	`mixChannels(opencv_core.MatVector src, opencv_core.MatVector dst, org.bytedeco.javacpp.IntPointer fromTo)` \overload
`static void`	`mixChannels(opencv_core.MatVector src, opencv_core.MatVector dst, org.bytedeco.javacpp.IntPointer fromTo, long npairs)` \overload
`static void`	`mixChannels(opencv_core.UMatVector src, opencv_core.UMatVector dst, IntBuffer fromTo)`
`static void`	`mixChannels(opencv_core.UMatVector src, opencv_core.UMatVector dst, IntBuffer fromTo, long npairs)`
`static void`	`mul16s(short[] src1, long step1, short[] src2, long step2, short[] dst, long step, int width, int height, org.bytedeco.javacpp.Pointer scale)`
`static void`	`mul16s(ShortBuffer src1, long step1, ShortBuffer src2, long step2, ShortBuffer dst, long step, int width, int height, org.bytedeco.javacpp.Pointer scale)`
`static void`	`mul16s(org.bytedeco.javacpp.ShortPointer src1, long step1, org.bytedeco.javacpp.ShortPointer src2, long step2, org.bytedeco.javacpp.ShortPointer dst, long step, int width, int height, org.bytedeco.javacpp.Pointer scale)`
`static void`	`mul16u(short[] src1, long step1, short[] src2, long step2, short[] dst, long step, int width, int height, org.bytedeco.javacpp.Pointer scale)`
`static void`	`mul16u(ShortBuffer src1, long step1, ShortBuffer src2, long step2, ShortBuffer dst, long step, int width, int height, org.bytedeco.javacpp.Pointer scale)`
`static void`	`mul16u(org.bytedeco.javacpp.ShortPointer src1, long step1, org.bytedeco.javacpp.ShortPointer src2, long step2, org.bytedeco.javacpp.ShortPointer dst, long step, int width, int height, org.bytedeco.javacpp.Pointer scale)`
`static void`	`mul32f(float[] src1, long step1, float[] src2, long step2, float[] dst, long step, int width, int height, org.bytedeco.javacpp.Pointer scale)`
`static void`	`mul32f(FloatBuffer src1, long step1, FloatBuffer src2, long step2, FloatBuffer dst, long step, int width, int height, org.bytedeco.javacpp.Pointer scale)`
`static void`	`mul32f(org.bytedeco.javacpp.FloatPointer src1, long step1, org.bytedeco.javacpp.FloatPointer src2, long step2, org.bytedeco.javacpp.FloatPointer dst, long step, int width, int height, org.bytedeco.javacpp.Pointer scale)`
`static void`	`mul32s(int[] src1, long step1, int[] src2, long step2, int[] dst, long step, int width, int height, org.bytedeco.javacpp.Pointer scale)`
`static void`	`mul32s(IntBuffer src1, long step1, IntBuffer src2, long step2, IntBuffer dst, long step, int width, int height, org.bytedeco.javacpp.Pointer scale)`
`static void`	`mul32s(org.bytedeco.javacpp.IntPointer src1, long step1, org.bytedeco.javacpp.IntPointer src2, long step2, org.bytedeco.javacpp.IntPointer dst, long step, int width, int height, org.bytedeco.javacpp.Pointer scale)`
`static void`	`mul64f(double[] src1, long step1, double[] src2, long step2, double[] dst, long step, int width, int height, org.bytedeco.javacpp.Pointer scale)`
`static void`	`mul64f(DoubleBuffer src1, long step1, DoubleBuffer src2, long step2, DoubleBuffer dst, long step, int width, int height, org.bytedeco.javacpp.Pointer scale)`
`static void`	`mul64f(org.bytedeco.javacpp.DoublePointer src1, long step1, org.bytedeco.javacpp.DoublePointer src2, long step2, org.bytedeco.javacpp.DoublePointer dst, long step, int width, int height, org.bytedeco.javacpp.Pointer scale)`
`static void`	`mul8s(byte[] src1, long step1, byte[] src2, long step2, byte[] dst, long step, int width, int height, org.bytedeco.javacpp.Pointer scale)`
`static void`	`mul8s(ByteBuffer src1, long step1, ByteBuffer src2, long step2, ByteBuffer dst, long step, int width, int height, org.bytedeco.javacpp.Pointer scale)`
`static void`	`mul8s(org.bytedeco.javacpp.BytePointer src1, long step1, org.bytedeco.javacpp.BytePointer src2, long step2, org.bytedeco.javacpp.BytePointer dst, long step, int width, int height, org.bytedeco.javacpp.Pointer scale)`
`static void`	`mul8u(byte[] src1, long step1, byte[] src2, long step2, byte[] dst, long step, int width, int height, org.bytedeco.javacpp.Pointer scale)`
`static void`	`mul8u(ByteBuffer src1, long step1, ByteBuffer src2, long step2, ByteBuffer dst, long step, int width, int height, org.bytedeco.javacpp.Pointer scale)`
`static void`	`mul8u(org.bytedeco.javacpp.BytePointer src1, long step1, org.bytedeco.javacpp.BytePointer src2, long step2, org.bytedeco.javacpp.BytePointer dst, long step, int width, int height, org.bytedeco.javacpp.Pointer scale)`
`static void`	`mulSpectrums(opencv_core.GpuMat a, opencv_core.GpuMat b, opencv_core.GpuMat c, int flags)`
`static void`	`mulSpectrums(opencv_core.GpuMat a, opencv_core.GpuMat b, opencv_core.GpuMat c, int flags, boolean conjB)`
`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)` \brief Performs the per-element multiplication of two Fourier spectrums.
`static void`	`mulSpectrums(opencv_core.UMat a, opencv_core.UMat b, opencv_core.UMat c, int flags)`
`static void`	`mulSpectrums(opencv_core.UMat a, opencv_core.UMat b, opencv_core.UMat c, int flags, boolean conjB)`
`static opencv_core.MatExpr`	`multiply(double s, opencv_core.Mat a)`
`static opencv_core.MatExpr`	`multiply(double s, opencv_core.MatExpr e)`
`static void`	`multiply(opencv_core.GpuMat src1, opencv_core.GpuMat src2, opencv_core.GpuMat dst)`
`static void`	`multiply(opencv_core.GpuMat src1, opencv_core.GpuMat src2, opencv_core.GpuMat dst, double scale, int dtype)`
`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)` \brief Calculates the per-element scaled product of two arrays.
`static void`	`multiply(opencv_core.UMat src1, opencv_core.UMat src2, opencv_core.UMat dst)`
`static void`	`multiply(opencv_core.UMat src1, opencv_core.UMat src2, opencv_core.UMat dst, double scale, int dtype)`
`static opencv_core.Mat`	`multiplyPut(opencv_core.Mat a, double b)`
`static opencv_core.Mat`	`multiplyPut(opencv_core.Mat a, opencv_core.Mat b)`
`static void`	`mulTransposed(opencv_core.GpuMat src, opencv_core.GpuMat dst, boolean aTa)`
`static void`	`mulTransposed(opencv_core.GpuMat src, opencv_core.GpuMat dst, boolean aTa, opencv_core.GpuMat delta, double scale, int dtype)`
`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)` \brief Calculates the product of a matrix and its transposition.
`static void`	`mulTransposed(opencv_core.UMat src, opencv_core.UMat dst, boolean aTa)`
`static void`	`mulTransposed(opencv_core.UMat src, opencv_core.UMat dst, boolean aTa, opencv_core.UMat delta, double scale, int dtype)`
`static opencv_core.Mat`	`noArray()` \brief This type is very similar to InputArray except that it is used for input/output and output function parameters.
`static double`	`norm(opencv_core.GpuMat src1)`
`static double`	`norm(opencv_core.GpuMat src1, int normType, opencv_core.GpuMat mask)`
`static double`	`norm(opencv_core.GpuMat src1, opencv_core.GpuMat src2)`
`static double`	`norm(opencv_core.GpuMat src1, opencv_core.GpuMat src2, int normType, opencv_core.GpuMat mask)`
`static double`	`norm(opencv_core.Mat src1)`
`static double`	`norm(opencv_core.Mat src1, int normType, opencv_core.Mat mask)` \brief Calculates the absolute norm of an array.
`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)` \brief Calculates an absolute difference norm or a relative difference norm.
`static double`	`norm(opencv_core.SparseMat src, int normType)` \overload
`static double`	`norm(opencv_core.UMat src1)`
`static double`	`norm(opencv_core.UMat src1, int normType, opencv_core.UMat mask)`
`static double`	`norm(opencv_core.UMat src1, opencv_core.UMat src2)`
`static double`	`norm(opencv_core.UMat src1, opencv_core.UMat src2, int normType, opencv_core.UMat mask)`
`static void`	`normalize(opencv_core.GpuMat src, opencv_core.GpuMat dst)`
`static void`	`normalize(opencv_core.GpuMat src, opencv_core.GpuMat dst, double alpha, double beta, int norm_type, int dtype, opencv_core.GpuMat mask)`
`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)` \brief Normalizes the norm or value range of an array.
`static void`	`normalize(opencv_core.SparseMat src, opencv_core.SparseMat dst, double alpha, int normType)` \overload
`static void`	`normalize(opencv_core.UMat src, opencv_core.UMat dst)`
`static void`	`normalize(opencv_core.UMat src, opencv_core.UMat dst, double alpha, double beta, int norm_type, int dtype, opencv_core.UMat mask)`
`static int`	`normHamming(byte[] a, byte[] b, int n)`
`static int`	`normHamming(byte[] a, byte[] b, int n, int cellSize)`
`static int`	`normHamming(byte[] a, int n)`
`static int`	`normHamming(byte[] a, 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(ByteBuffer a, int n)`
`static int`	`normHamming(ByteBuffer a, int n, int cellSize)`
`static int`	`normHamming(org.bytedeco.javacpp.BytePointer a, org.bytedeco.javacpp.BytePointer b, int n)`
`static int`	`normHamming(org.bytedeco.javacpp.BytePointer a, org.bytedeco.javacpp.BytePointer b, int n, int cellSize)`
`static int`	`normHamming(org.bytedeco.javacpp.BytePointer a, int n)` \addtogroup core_hal_functions \{
`static int`	`normHamming(org.bytedeco.javacpp.BytePointer a, 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_(org.bytedeco.javacpp.BytePointer a, org.bytedeco.javacpp.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_(org.bytedeco.javacpp.FloatPointer a, org.bytedeco.javacpp.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_(org.bytedeco.javacpp.FloatPointer a, org.bytedeco.javacpp.FloatPointer b, int n)`
`static opencv_core.MatExpr`	`not(opencv_core.Mat m)`
`static boolean`	`not(opencv_core.Range r)`
`static void`	`not8u(byte[] src1, long step1, byte[] src2, long step2, byte[] dst, long step, int width, int height, org.bytedeco.javacpp.Pointer arg8)`
`static void`	`not8u(ByteBuffer src1, long step1, ByteBuffer src2, long step2, ByteBuffer dst, long step, int width, int height, org.bytedeco.javacpp.Pointer arg8)`
`static void`	`not8u(org.bytedeco.javacpp.BytePointer src1, long step1, org.bytedeco.javacpp.BytePointer src2, long step2, org.bytedeco.javacpp.BytePointer dst, long step, int width, int height, org.bytedeco.javacpp.Pointer arg8)`
`static boolean`	`notEquals(org.bytedeco.javacpp.BytePointer lhs, org.bytedeco.javacpp.BytePointer rhs)`
`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(String lhs, String rhs)`
`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 void`	`or8u(byte[] src1, long step1, byte[] src2, long step2, byte[] dst, long step, int width, int height, org.bytedeco.javacpp.Pointer arg8)`
`static void`	`or8u(ByteBuffer src1, long step1, ByteBuffer src2, long step2, ByteBuffer dst, long step, int width, int height, org.bytedeco.javacpp.Pointer arg8)`
`static void`	`or8u(org.bytedeco.javacpp.BytePointer src1, long step1, org.bytedeco.javacpp.BytePointer src2, long step2, org.bytedeco.javacpp.BytePointer dst, long step, int width, int height, org.bytedeco.javacpp.Pointer arg8)`
`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 b)`
`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)` \brief Parallel data processor
`static void`	`patchNaNs(opencv_core.GpuMat a)`
`static void`	`patchNaNs(opencv_core.GpuMat a, double val)`
`static void`	`patchNaNs(opencv_core.Mat a)`
`static void`	`patchNaNs(opencv_core.Mat a, double val)` \brief converts NaN's to the given number
`static void`	`patchNaNs(opencv_core.UMat a)`
`static void`	`patchNaNs(opencv_core.UMat a, double val)`
`static void`	`PCABackProject(opencv_core.GpuMat data, opencv_core.GpuMat mean, opencv_core.GpuMat eigenvectors, opencv_core.GpuMat result)`
`static void`	`PCABackProject(opencv_core.Mat data, opencv_core.Mat mean, opencv_core.Mat eigenvectors, opencv_core.Mat result)` wrap PCA::backProject
`static void`	`PCABackProject(opencv_core.UMat data, opencv_core.UMat mean, opencv_core.UMat eigenvectors, opencv_core.UMat result)`
`static void`	`PCACompute(opencv_core.GpuMat data, opencv_core.GpuMat mean, opencv_core.GpuMat eigenvectors)`
`static void`	`PCACompute(opencv_core.GpuMat data, opencv_core.GpuMat mean, opencv_core.GpuMat eigenvectors, double retainedVariance)`
`static void`	`PCACompute(opencv_core.GpuMat data, opencv_core.GpuMat mean, opencv_core.GpuMat eigenvectors, int maxComponents)`
`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, double retainedVariance)` wrap PCA::operator()
`static void`	`PCACompute(opencv_core.Mat data, opencv_core.Mat mean, opencv_core.Mat eigenvectors, int maxComponents)` wrap PCA::operator()
`static void`	`PCACompute(opencv_core.UMat data, opencv_core.UMat mean, opencv_core.UMat eigenvectors)`
`static void`	`PCACompute(opencv_core.UMat data, opencv_core.UMat mean, opencv_core.UMat eigenvectors, double retainedVariance)`
`static void`	`PCACompute(opencv_core.UMat data, opencv_core.UMat mean, opencv_core.UMat eigenvectors, int maxComponents)`
`static void`	`PCACompute2(opencv_core.GpuMat data, opencv_core.GpuMat mean, opencv_core.GpuMat eigenvectors, opencv_core.GpuMat eigenvalues)`
`static void`	`PCACompute2(opencv_core.GpuMat data, opencv_core.GpuMat mean, opencv_core.GpuMat eigenvectors, opencv_core.GpuMat eigenvalues, double retainedVariance)`
`static void`	`PCACompute2(opencv_core.GpuMat data, opencv_core.GpuMat mean, opencv_core.GpuMat eigenvectors, opencv_core.GpuMat eigenvalues, int maxComponents)`
`static void`	`PCACompute2(opencv_core.Mat data, opencv_core.Mat mean, opencv_core.Mat eigenvectors, opencv_core.Mat eigenvalues)`
`static void`	`PCACompute2(opencv_core.Mat data, opencv_core.Mat mean, opencv_core.Mat eigenvectors, opencv_core.Mat eigenvalues, double retainedVariance)` wrap PCA::operator() and add eigenvalues output parameter
`static void`	`PCACompute2(opencv_core.Mat data, opencv_core.Mat mean, opencv_core.Mat eigenvectors, opencv_core.Mat eigenvalues, int maxComponents)` wrap PCA::operator() and add eigenvalues output parameter
`static void`	`PCACompute2(opencv_core.UMat data, opencv_core.UMat mean, opencv_core.UMat eigenvectors, opencv_core.UMat eigenvalues)`
`static void`	`PCACompute2(opencv_core.UMat data, opencv_core.UMat mean, opencv_core.UMat eigenvectors, opencv_core.UMat eigenvalues, double retainedVariance)`
`static void`	`PCACompute2(opencv_core.UMat data, opencv_core.UMat mean, opencv_core.UMat eigenvectors, opencv_core.UMat eigenvalues, int maxComponents)`
`static void`	`PCAProject(opencv_core.GpuMat data, opencv_core.GpuMat mean, opencv_core.GpuMat eigenvectors, opencv_core.GpuMat result)`
`static void`	`PCAProject(opencv_core.Mat data, opencv_core.Mat mean, opencv_core.Mat eigenvectors, opencv_core.Mat result)` wrap PCA::project
`static void`	`PCAProject(opencv_core.UMat data, opencv_core.UMat mean, opencv_core.UMat eigenvectors, opencv_core.UMat result)`
`static void`	`perspectiveTransform(opencv_core.GpuMat src, opencv_core.GpuMat dst, opencv_core.GpuMat m)`
`static void`	`perspectiveTransform(opencv_core.Mat src, opencv_core.Mat dst, opencv_core.Mat m)` \brief Performs the perspective matrix transformation of vectors.
`static void`	`perspectiveTransform(opencv_core.UMat src, opencv_core.UMat dst, opencv_core.UMat m)`
`static void`	`phase(opencv_core.GpuMat x, opencv_core.GpuMat y, opencv_core.GpuMat angle)`
`static void`	`phase(opencv_core.GpuMat x, opencv_core.GpuMat y, opencv_core.GpuMat angle, boolean angleInDegrees)`
`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)` \brief Calculates the rotation angle of 2D vectors.
`static void`	`phase(opencv_core.UMat x, opencv_core.UMat y, opencv_core.UMat angle)`
`static void`	`phase(opencv_core.UMat x, opencv_core.UMat y, opencv_core.UMat angle, boolean angleInDegrees)`
`static void`	`polarToCart(opencv_core.GpuMat magnitude, opencv_core.GpuMat angle, opencv_core.GpuMat x, opencv_core.GpuMat y)`
`static void`	`polarToCart(opencv_core.GpuMat magnitude, opencv_core.GpuMat angle, opencv_core.GpuMat x, opencv_core.GpuMat y, boolean angleInDegrees)`
`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)` \brief Calculates x and y coordinates of 2D vectors from their magnitude and angle.
`static void`	`polarToCart(opencv_core.UMat magnitude, opencv_core.UMat angle, opencv_core.UMat x, opencv_core.UMat y)`
`static void`	`polarToCart(opencv_core.UMat magnitude, opencv_core.UMat angle, opencv_core.UMat x, opencv_core.UMat y, boolean angleInDegrees)`
`static void`	`pow(opencv_core.GpuMat src, double power, opencv_core.GpuMat dst)`
`static void`	`pow(opencv_core.Mat src, double power, opencv_core.Mat dst)` \brief Raises every array element to a power.
`static void`	`pow(opencv_core.UMat src, double power, opencv_core.UMat dst)`
`static int`	`predictOptimalVectorWidth(opencv_core.GpuMat src1)`
`static int`	`predictOptimalVectorWidth(opencv_core.GpuMat src1, opencv_core.GpuMat src2, opencv_core.GpuMat src3, opencv_core.GpuMat src4, opencv_core.GpuMat src5, opencv_core.GpuMat src6, opencv_core.GpuMat src7, opencv_core.GpuMat src8, opencv_core.GpuMat src9, int strat)`
`static int`	`predictOptimalVectorWidth(opencv_core.Mat src1)`
`static int`	`predictOptimalVectorWidth(opencv_core.Mat src1, opencv_core.Mat src2, opencv_core.Mat src3, opencv_core.Mat src4, opencv_core.Mat src5, opencv_core.Mat src6, opencv_core.Mat src7, opencv_core.Mat src8, opencv_core.Mat src9, int strat)`
`static int`	`predictOptimalVectorWidth(opencv_core.UMat src1)`
`static int`	`predictOptimalVectorWidth(opencv_core.UMat src1, opencv_core.UMat src2, opencv_core.UMat src3, opencv_core.UMat src4, opencv_core.UMat src5, opencv_core.UMat src6, opencv_core.UMat src7, opencv_core.UMat src8, opencv_core.UMat src9, int strat)`
`static int`	`predictOptimalVectorWidthMax(opencv_core.GpuMat src1)`
`static int`	`predictOptimalVectorWidthMax(opencv_core.GpuMat src1, opencv_core.GpuMat src2, opencv_core.GpuMat src3, opencv_core.GpuMat src4, opencv_core.GpuMat src5, opencv_core.GpuMat src6, opencv_core.GpuMat src7, opencv_core.GpuMat src8, opencv_core.GpuMat src9)`
`static int`	`predictOptimalVectorWidthMax(opencv_core.Mat src1)`
`static int`	`predictOptimalVectorWidthMax(opencv_core.Mat src1, opencv_core.Mat src2, opencv_core.Mat src3, opencv_core.Mat src4, opencv_core.Mat src5, opencv_core.Mat src6, opencv_core.Mat src7, opencv_core.Mat src8, opencv_core.Mat src9)`
`static int`	`predictOptimalVectorWidthMax(opencv_core.UMat src1)`
`static int`	`predictOptimalVectorWidthMax(opencv_core.UMat src1, opencv_core.UMat src2, opencv_core.UMat src3, opencv_core.UMat src4, opencv_core.UMat src5, opencv_core.UMat src6, opencv_core.UMat src7, opencv_core.UMat src8, opencv_core.UMat src9)`
`static int`	`print(opencv_core.Formatted fmtd)`
`static int`	`print(opencv_core.Formatted fmtd, org.bytedeco.javacpp.Pointer stream)`
`static int`	`print(opencv_core.Mat mtx)`
`static int`	`print(opencv_core.Mat mtx, org.bytedeco.javacpp.Pointer stream)`
`static int`	`print(opencv_core.UMat mtx)`
`static int`	`print(opencv_core.UMat mtx, org.bytedeco.javacpp.Pointer stream)`
`static void`	`printCudaDeviceInfo(int device)`
`static void`	`printShortCudaDeviceInfo(int device)`
`static double`	`PSNR(opencv_core.GpuMat src1, opencv_core.GpuMat src2)`
`static double`	`PSNR(opencv_core.Mat src1, opencv_core.Mat src2)` \brief Computes the Peak Signal-to-Noise Ratio (PSNR) image quality metric.
`static double`	`PSNR(opencv_core.UMat src1, opencv_core.UMat src2)`
`static int`	`QR32f(float[] A, long astep, int m, int n, int k, float[] b, long bstep, float[] hFactors)`
`static int`	`QR32f(FloatBuffer A, long astep, int m, int n, int k, FloatBuffer b, long bstep, FloatBuffer hFactors)`
`static int`	`QR32f(org.bytedeco.javacpp.FloatPointer A, long astep, int m, int n, int k, org.bytedeco.javacpp.FloatPointer b, long bstep, org.bytedeco.javacpp.FloatPointer hFactors)`
`static int`	`QR64f(double[] A, long astep, int m, int n, int k, double[] b, long bstep, double[] hFactors)`
`static int`	`QR64f(DoubleBuffer A, long astep, int m, int n, int k, DoubleBuffer b, long bstep, DoubleBuffer hFactors)`
`static int`	`QR64f(org.bytedeco.javacpp.DoublePointer A, long astep, int m, int n, int k, org.bytedeco.javacpp.DoublePointer b, long bstep, org.bytedeco.javacpp.DoublePointer hFactors)`
`static void`	`randn(opencv_core.GpuMat dst, opencv_core.GpuMat mean, opencv_core.GpuMat stddev)`
`static void`	`randn(opencv_core.Mat dst, opencv_core.Mat mean, opencv_core.Mat stddev)` \brief Fills the array with normally distributed random numbers.
`static void`	`randn(opencv_core.UMat dst, opencv_core.UMat mean, opencv_core.UMat stddev)`
`static void`	`randShuffle(opencv_core.GpuMat dst)`
`static void`	`randShuffle(opencv_core.GpuMat dst, double iterFactor, opencv_core.RNG rng)`
`static void`	`randShuffle(opencv_core.Mat dst)`
`static void`	`randShuffle(opencv_core.Mat dst, double iterFactor, opencv_core.RNG rng)` \brief Shuffles the array elements randomly.
`static void`	`randShuffle(opencv_core.UMat dst)`
`static void`	`randShuffle(opencv_core.UMat dst, double iterFactor, opencv_core.RNG rng)`
`static void`	`randu(opencv_core.GpuMat dst, opencv_core.GpuMat low, opencv_core.GpuMat high)`
`static void`	`randu(opencv_core.Mat dst, opencv_core.Mat low, opencv_core.Mat high)` \brief Generates a single uniformly-distributed random number or an array of random numbers.
`static void`	`randu(opencv_core.UMat dst, opencv_core.UMat low, opencv_core.UMat high)`
`static void`	`read(opencv_core.FileNode node, boolean[] value, boolean default_value)`
`static void`	`read(opencv_core.FileNode node, org.bytedeco.javacpp.BoolPointer value, boolean default_value)` \} FileStorage
`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, org.bytedeco.javacpp.BytePointer value, byte default_value)`
`static void`	`read(opencv_core.FileNode node, org.bytedeco.javacpp.BytePointer value, org.bytedeco.javacpp.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, org.bytedeco.javacpp.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, org.bytedeco.javacpp.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, org.bytedeco.javacpp.IntPointer value, int default_value)` \}
`static void`	`read(opencv_core.FileNode node, opencv_core.DMatch value, opencv_core.DMatch default_value)`
`static void`	`read(opencv_core.FileNode node, opencv_core.DMatchVector matches)`
`static void`	`read(opencv_core.FileNode node, opencv_core.DMatchVector vec, opencv_core.DMatchVector default_value)`
`static void`	`read(opencv_core.FileNode node, opencv_core.KeyPoint value, opencv_core.KeyPoint default_value)`
`static void`	`read(opencv_core.FileNode node, opencv_core.KeyPointVector keypoints)`
`static void`	`read(opencv_core.FileNode node, opencv_core.KeyPointVector vec, opencv_core.KeyPointVector 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, org.bytedeco.javacpp.ShortPointer value, short default_value)`
`static void`	`read(opencv_core.FileNode node, String value, String default_value)`
`static void`	`recip16s(short[] arg0, long arg1, short[] src2, long step2, short[] dst, long step, int width, int height, org.bytedeco.javacpp.Pointer scale)`
`static void`	`recip16s(ShortBuffer arg0, long arg1, ShortBuffer src2, long step2, ShortBuffer dst, long step, int width, int height, org.bytedeco.javacpp.Pointer scale)`
`static void`	`recip16s(org.bytedeco.javacpp.ShortPointer arg0, long arg1, org.bytedeco.javacpp.ShortPointer src2, long step2, org.bytedeco.javacpp.ShortPointer dst, long step, int width, int height, org.bytedeco.javacpp.Pointer scale)`
`static void`	`recip16u(short[] arg0, long arg1, short[] src2, long step2, short[] dst, long step, int width, int height, org.bytedeco.javacpp.Pointer scale)`
`static void`	`recip16u(ShortBuffer arg0, long arg1, ShortBuffer src2, long step2, ShortBuffer dst, long step, int width, int height, org.bytedeco.javacpp.Pointer scale)`
`static void`	`recip16u(org.bytedeco.javacpp.ShortPointer arg0, long arg1, org.bytedeco.javacpp.ShortPointer src2, long step2, org.bytedeco.javacpp.ShortPointer dst, long step, int width, int height, org.bytedeco.javacpp.Pointer scale)`
`static void`	`recip32f(float[] arg0, long arg1, float[] src2, long step2, float[] dst, long step, int width, int height, org.bytedeco.javacpp.Pointer scale)`
`static void`	`recip32f(FloatBuffer arg0, long arg1, FloatBuffer src2, long step2, FloatBuffer dst, long step, int width, int height, org.bytedeco.javacpp.Pointer scale)`
`static void`	`recip32f(org.bytedeco.javacpp.FloatPointer arg0, long arg1, org.bytedeco.javacpp.FloatPointer src2, long step2, org.bytedeco.javacpp.FloatPointer dst, long step, int width, int height, org.bytedeco.javacpp.Pointer scale)`
`static void`	`recip32s(int[] arg0, long arg1, int[] src2, long step2, int[] dst, long step, int width, int height, org.bytedeco.javacpp.Pointer scale)`
`static void`	`recip32s(IntBuffer arg0, long arg1, IntBuffer src2, long step2, IntBuffer dst, long step, int width, int height, org.bytedeco.javacpp.Pointer scale)`
`static void`	`recip32s(org.bytedeco.javacpp.IntPointer arg0, long arg1, org.bytedeco.javacpp.IntPointer src2, long step2, org.bytedeco.javacpp.IntPointer dst, long step, int width, int height, org.bytedeco.javacpp.Pointer scale)`
`static void`	`recip64f(double[] arg0, long arg1, double[] src2, long step2, double[] dst, long step, int width, int height, org.bytedeco.javacpp.Pointer scale)`
`static void`	`recip64f(DoubleBuffer arg0, long arg1, DoubleBuffer src2, long step2, DoubleBuffer dst, long step, int width, int height, org.bytedeco.javacpp.Pointer scale)`
`static void`	`recip64f(org.bytedeco.javacpp.DoublePointer arg0, long arg1, org.bytedeco.javacpp.DoublePointer src2, long step2, org.bytedeco.javacpp.DoublePointer dst, long step, int width, int height, org.bytedeco.javacpp.Pointer scale)`
`static void`	`recip8s(byte[] arg0, long arg1, byte[] src2, long step2, byte[] dst, long step, int width, int height, org.bytedeco.javacpp.Pointer scale)`
`static void`	`recip8s(ByteBuffer arg0, long arg1, ByteBuffer src2, long step2, ByteBuffer dst, long step, int width, int height, org.bytedeco.javacpp.Pointer scale)`
`static void`	`recip8s(org.bytedeco.javacpp.BytePointer arg0, long arg1, org.bytedeco.javacpp.BytePointer src2, long step2, org.bytedeco.javacpp.BytePointer dst, long step, int width, int height, org.bytedeco.javacpp.Pointer scale)`
`static void`	`recip8u(byte[] arg0, long arg1, byte[] src2, long step2, byte[] dst, long step, int width, int height, org.bytedeco.javacpp.Pointer scale)`
`static void`	`recip8u(ByteBuffer arg0, long arg1, ByteBuffer src2, long step2, ByteBuffer dst, long step, int width, int height, org.bytedeco.javacpp.Pointer scale)`
`static void`	`recip8u(org.bytedeco.javacpp.BytePointer arg0, long arg1, org.bytedeco.javacpp.BytePointer src2, long step2, org.bytedeco.javacpp.BytePointer dst, long step, int width, int height, org.bytedeco.javacpp.Pointer scale)`
`static opencv_core.ErrorCallback`	`redirectError(opencv_core.ErrorCallback errCallback)`
`static opencv_core.ErrorCallback`	`redirectError(opencv_core.ErrorCallback errCallback, org.bytedeco.javacpp.Pointer userdata, org.bytedeco.javacpp.Pointer prevUserdata)`
`static opencv_core.ErrorCallback`	`redirectError(opencv_core.ErrorCallback errCallback, org.bytedeco.javacpp.Pointer userdata, org.bytedeco.javacpp.PointerPointer prevUserdata)` \brief Sets the new error handler and the optional user data.
`static void`	`reduce(opencv_core.GpuMat src, opencv_core.GpuMat dst, int dim, int rtype)`
`static void`	`reduce(opencv_core.GpuMat src, opencv_core.GpuMat dst, int dim, int rtype, int dtype)`
`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)` \brief Reduces a matrix to a vector.
`static void`	`reduce(opencv_core.UMat src, opencv_core.UMat dst, int dim, int rtype)`
`static void`	`reduce(opencv_core.UMat src, opencv_core.UMat dst, int dim, int rtype, int dtype)`
`static void`	`registerPageLocked(opencv_core.Mat m)` \brief Page-locks the memory of matrix and maps it for the device(s).
`static void`	`repeat(opencv_core.GpuMat src, int ny, int nx, opencv_core.GpuMat dst)`
`static opencv_core.Mat`	`repeat(opencv_core.Mat src, int ny, int nx)` \overload
`static void`	`repeat(opencv_core.Mat src, int ny, int nx, opencv_core.Mat dst)` \brief Fills the output array with repeated copies of the input array.
`static void`	`repeat(opencv_core.UMat src, int ny, int nx, opencv_core.UMat dst)`
`static void`	`resetDevice()` \brief Explicitly destroys and cleans up all resources associated with the current device in the current process.
`static void`	`resetTrace()`
`static void`	`rotate(opencv_core.GpuMat src, opencv_core.GpuMat dst, int rotateCode)`
`static void`	`rotate(opencv_core.Mat src, opencv_core.Mat dst, int rotateCode)` \brief Rotates a 2D array in multiples of 90 degrees.
`static void`	`rotate(opencv_core.UMat src, opencv_core.UMat dst, int rotateCode)`
`static void`	`scaleAdd(opencv_core.GpuMat src1, double alpha, opencv_core.GpuMat src2, opencv_core.GpuMat dst)`
`static void`	`scaleAdd(opencv_core.Mat src1, double alpha, opencv_core.Mat src2, opencv_core.Mat dst)` \brief Calculates the sum of a scaled array and another array.
`static void`	`scaleAdd(opencv_core.UMat src1, double alpha, opencv_core.UMat src2, opencv_core.UMat dst)`
`static byte`	`scharSaturateCast(byte v)`
`static byte`	`scharSaturateCast(double v)`
`static byte`	`scharSaturateCast(float v)`
`static byte`	`scharSaturateCast(int v)`
`static byte`	`scharSaturateCast(long v)`
`static byte`	`scharSaturateCast(short v)`
`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, org.bytedeco.javacpp.Pointer element)`
`static void`	`seqPopFront(opencv_core.CvSeq seq)`
`static void`	`seqPopFront(opencv_core.CvSeq seq, org.bytedeco.javacpp.Pointer element)`
`static org.bytedeco.javacpp.BytePointer`	`seqPush(opencv_core.CvSeq seq)`
`static org.bytedeco.javacpp.BytePointer`	`seqPush(opencv_core.CvSeq seq, org.bytedeco.javacpp.Pointer element)` STL-style Sequence Iterator inherited from the CvSeqReader structure
`static org.bytedeco.javacpp.BytePointer`	`seqPushFront(opencv_core.CvSeq seq)`
`static org.bytedeco.javacpp.BytePointer`	`seqPushFront(opencv_core.CvSeq seq, org.bytedeco.javacpp.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)` \brief Sets/resets the break-on-error mode.
`static void`	`setBufferPoolConfig(int deviceId, long stackSize, int stackCount)`
`static void`	`setBufferPoolUsage(boolean on)` BufferPool management (must be called before Stream creation)
`static void`	`setDevice(int device)` \brief Sets a device and initializes it for the current thread.
`static void`	`setFlags(int modeFlags)`
`static void`	`setIdentity(opencv_core.GpuMat mtx)`
`static void`	`setIdentity(opencv_core.GpuMat mtx, opencv_core.Scalar s)`
`static void`	`setIdentity(opencv_core.Mat mtx)`
`static void`	`setIdentity(opencv_core.Mat mtx, opencv_core.Scalar s)` \brief Initializes a scaled identity matrix.
`static void`	`setIdentity(opencv_core.UMat mtx)`
`static void`	`setIdentity(opencv_core.UMat mtx, opencv_core.Scalar s)`
`static void`	`setIppStatus(int status)`
`static void`	`setIppStatus(int status, org.bytedeco.javacpp.BytePointer funcname, org.bytedeco.javacpp.BytePointer filename, int line)`
`static void`	`setIppStatus(int status, String funcname, String filename, int line)`
`static void`	`setNumThreads(int nthreads)` \brief OpenCV will try to set the number of threads for the next parallel region.
`static void`	`setRNGSeed(int seed)` \brief Sets state of default random number generator.
`static void`	`setUseInstrumentation(boolean flag)`
`static void`	`setUseIPP_NE(boolean flag)`
`static void`	`setUseIPP(boolean flag)`
`static void`	`setUseOpenCL(boolean flag)`
`static void`	`setUseOptimized(boolean onoff)` \brief Enables or disables the optimized code.
`static org.bytedeco.javacpp.BytePointer`	`shiftLeft(org.bytedeco.javacpp.BytePointer out, opencv_core.Formatted fmtd)`
`static org.bytedeco.javacpp.BytePointer`	`shiftLeft(org.bytedeco.javacpp.BytePointer out, opencv_core.Mat mtx)`
`static opencv_core.FileStorage`	`shiftLeft(opencv_core.FileStorage fs, byte[] value)`
`static opencv_core.FileStorage`	`shiftLeft(opencv_core.FileStorage fs, ByteBuffer value)` \brief Writes data to a file storage.
`static opencv_core.FileStorage`	`shiftLeft(opencv_core.FileStorage fs, org.bytedeco.javacpp.BytePointer str)` \}
`static opencv_core.FileStorage`	`shiftLeft(opencv_core.FileStorage fs, String str)`
`static org.bytedeco.javacpp.Pointer`	`shiftLeft(org.bytedeco.javacpp.Pointer out, opencv_core.TickMeter tm)` \brief output operator
`static String`	`shiftLeft(String out, opencv_core.Formatted fmtd)`
`static String`	`shiftLeft(String out, opencv_core.Mat mtx)`
`static void`	`shiftRight(opencv_core.FileNode n, opencv_core.DMatch m)` \brief Reads DMatch from a file storage.
`static void`	`shiftRight(opencv_core.FileNode n, opencv_core.DMatchVector vec)`
`static void`	`shiftRight(opencv_core.FileNode n, opencv_core.KeyPoint kpt)` \brief Reads KeyPoint from a file storage.
`static void`	`shiftRight(opencv_core.FileNode n, opencv_core.KeyPointVector vec)`
`static short`	`shortSaturateCast(byte v)`
`static short`	`shortSaturateCast(double v)`
`static short`	`shortSaturateCast(float v)`
`static short`	`shortSaturateCast(int v)`
`static short`	`shortSaturateCast(long v)`
`static short`	`shortSaturateCast(short v)`
`static boolean`	`solve(opencv_core.GpuMat src1, opencv_core.GpuMat src2, opencv_core.GpuMat dst)`
`static boolean`	`solve(opencv_core.GpuMat src1, opencv_core.GpuMat src2, opencv_core.GpuMat dst, int flags)`
`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)` \brief Solves one or more linear systems or least-squares problems.
`static boolean`	`solve(opencv_core.UMat src1, opencv_core.UMat src2, opencv_core.UMat dst)`
`static boolean`	`solve(opencv_core.UMat src1, opencv_core.UMat src2, opencv_core.UMat dst, int flags)`
`static int`	`solveCubic(opencv_core.GpuMat coeffs, opencv_core.GpuMat roots)`
`static int`	`solveCubic(opencv_core.Mat coeffs, opencv_core.Mat roots)` \brief Finds the real roots of a cubic equation.
`static int`	`solveCubic(opencv_core.UMat coeffs, opencv_core.UMat roots)`
`static int`	`solveLP(opencv_core.Mat Func, opencv_core.Mat Constr, opencv_core.Mat z)` \brief Solve given (non-integer) linear programming problem using the Simplex Algorithm (Simplex Method).
`static double`	`solvePoly(opencv_core.GpuMat coeffs, opencv_core.GpuMat roots)`
`static double`	`solvePoly(opencv_core.GpuMat coeffs, opencv_core.GpuMat roots, int maxIters)`
`static double`	`solvePoly(opencv_core.Mat coeffs, opencv_core.Mat roots)`
`static double`	`solvePoly(opencv_core.Mat coeffs, opencv_core.Mat roots, int maxIters)` \brief Finds the real or complex roots of a polynomial equation.
`static double`	`solvePoly(opencv_core.UMat coeffs, opencv_core.UMat roots)`
`static double`	`solvePoly(opencv_core.UMat coeffs, opencv_core.UMat roots, int maxIters)`
`static void`	`sort(opencv_core.GpuMat src, opencv_core.GpuMat dst, int flags)`
`static void`	`sort(opencv_core.Mat src, opencv_core.Mat dst, int flags)` \brief Sorts each row or each column of a matrix.
`static void`	`sort(opencv_core.UMat src, opencv_core.UMat dst, int flags)`
`static void`	`sortIdx(opencv_core.GpuMat src, opencv_core.GpuMat dst, int flags)`
`static void`	`sortIdx(opencv_core.Mat src, opencv_core.Mat dst, int flags)` \brief Sorts each row or each column of a matrix.
`static void`	`sortIdx(opencv_core.UMat src, opencv_core.UMat dst, int flags)`
`static void`	`split(opencv_core.GpuMat m, opencv_core.GpuMatVector mv)`
`static void`	`split(opencv_core.GpuMat m, opencv_core.MatVector mv)`
`static void`	`split(opencv_core.GpuMat m, opencv_core.UMatVector mv)`
`static void`	`split(opencv_core.Mat m, opencv_core.GpuMatVector mv)`
`static void`	`split(opencv_core.Mat src, opencv_core.Mat mvbegin)` \brief Divides a multi-channel array into several single-channel arrays.
`static void`	`split(opencv_core.Mat m, opencv_core.MatVector mv)` \overload
`static void`	`split(opencv_core.Mat m, opencv_core.UMatVector mv)`
`static void`	`split(opencv_core.UMat m, opencv_core.GpuMatVector mv)`
`static void`	`split(opencv_core.UMat m, opencv_core.MatVector mv)`
`static void`	`split(opencv_core.UMat m, opencv_core.UMatVector mv)`
`static void`	`split16u(short[] src, short[] dst, int len, int cn)`
`static void`	`split16u(ShortBuffer src, ShortBuffer dst, int len, int cn)`
`static void`	`split16u(org.bytedeco.javacpp.ShortPointer src, org.bytedeco.javacpp.PointerPointer dst, int len, int cn)`
`static void`	`split16u(org.bytedeco.javacpp.ShortPointer src, org.bytedeco.javacpp.ShortPointer dst, int len, int cn)`
`static void`	`split32s(int[] src, int[] dst, int len, int cn)`
`static void`	`split32s(IntBuffer src, IntBuffer dst, int len, int cn)`
`static void`	`split32s(org.bytedeco.javacpp.IntPointer src, org.bytedeco.javacpp.IntPointer dst, int len, int cn)`
`static void`	`split32s(org.bytedeco.javacpp.IntPointer src, org.bytedeco.javacpp.PointerPointer dst, int len, int cn)`
`static void`	`split64s(long[] src, long[] dst, int len, int cn)`
`static void`	`split64s(LongBuffer src, LongBuffer dst, int len, int cn)`
`static void`	`split64s(org.bytedeco.javacpp.LongPointer src, org.bytedeco.javacpp.LongPointer dst, int len, int cn)`
`static void`	`split64s(org.bytedeco.javacpp.LongPointer src, org.bytedeco.javacpp.PointerPointer dst, int len, int cn)`
`static void`	`split8u(byte[] src, byte[] dst, int len, int cn)`
`static void`	`split8u(ByteBuffer src, ByteBuffer dst, int len, int cn)`
`static void`	`split8u(org.bytedeco.javacpp.BytePointer src, org.bytedeco.javacpp.BytePointer dst, int len, int cn)`
`static void`	`split8u(org.bytedeco.javacpp.BytePointer src, org.bytedeco.javacpp.PointerPointer dst, int len, int cn)`
`static void`	`sqrt(double[] src, double[] dst, int len)`
`static void`	`sqrt(DoubleBuffer src, DoubleBuffer dst, int len)`
`static void`	`sqrt(org.bytedeco.javacpp.DoublePointer src, org.bytedeco.javacpp.DoublePointer dst, int len)`
`static void`	`sqrt(float[] src, float[] dst, int len)`
`static void`	`sqrt(FloatBuffer src, FloatBuffer dst, int len)`
`static void`	`sqrt(org.bytedeco.javacpp.FloatPointer src, org.bytedeco.javacpp.FloatPointer dst, int len)`
`static void`	`sqrt(opencv_core.GpuMat src, opencv_core.GpuMat dst)`
`static void`	`sqrt(opencv_core.Mat src, opencv_core.Mat dst)` \brief Calculates a square root of array elements.
`static void`	`sqrt(opencv_core.UMat src, opencv_core.UMat dst)`
`static void`	`sqrt32f(float[] src, float[] dst, int len)`
`static void`	`sqrt32f(FloatBuffer src, FloatBuffer dst, int len)`
`static void`	`sqrt32f(org.bytedeco.javacpp.FloatPointer src, org.bytedeco.javacpp.FloatPointer dst, int len)`
`static void`	`sqrt64f(double[] src, double[] dst, int len)`
`static void`	`sqrt64f(DoubleBuffer src, DoubleBuffer dst, int len)`
`static void`	`sqrt64f(org.bytedeco.javacpp.DoublePointer src, org.bytedeco.javacpp.DoublePointer dst, int len)`
`static void`	`sub16s(short[] src1, long step1, short[] src2, long step2, short[] dst, long step, int width, int height, org.bytedeco.javacpp.Pointer arg8)`
`static void`	`sub16s(ShortBuffer src1, long step1, ShortBuffer src2, long step2, ShortBuffer dst, long step, int width, int height, org.bytedeco.javacpp.Pointer arg8)`
`static void`	`sub16s(org.bytedeco.javacpp.ShortPointer src1, long step1, org.bytedeco.javacpp.ShortPointer src2, long step2, org.bytedeco.javacpp.ShortPointer dst, long step, int width, int height, org.bytedeco.javacpp.Pointer arg8)`
`static void`	`sub16u(short[] src1, long step1, short[] src2, long step2, short[] dst, long step, int width, int height, org.bytedeco.javacpp.Pointer arg8)`
`static void`	`sub16u(ShortBuffer src1, long step1, ShortBuffer src2, long step2, ShortBuffer dst, long step, int width, int height, org.bytedeco.javacpp.Pointer arg8)`
`static void`	`sub16u(org.bytedeco.javacpp.ShortPointer src1, long step1, org.bytedeco.javacpp.ShortPointer src2, long step2, org.bytedeco.javacpp.ShortPointer dst, long step, int width, int height, org.bytedeco.javacpp.Pointer arg8)`
`static void`	`sub32f(float[] src1, long step1, float[] src2, long step2, float[] dst, long step, int width, int height, org.bytedeco.javacpp.Pointer arg8)`
`static void`	`sub32f(FloatBuffer src1, long step1, FloatBuffer src2, long step2, FloatBuffer dst, long step, int width, int height, org.bytedeco.javacpp.Pointer arg8)`
`static void`	`sub32f(org.bytedeco.javacpp.FloatPointer src1, long step1, org.bytedeco.javacpp.FloatPointer src2, long step2, org.bytedeco.javacpp.FloatPointer dst, long step, int width, int height, org.bytedeco.javacpp.Pointer arg8)`
`static void`	`sub32s(int[] src1, long step1, int[] src2, long step2, int[] dst, long step, int width, int height, org.bytedeco.javacpp.Pointer arg8)`
`static void`	`sub32s(IntBuffer src1, long step1, IntBuffer src2, long step2, IntBuffer dst, long step, int width, int height, org.bytedeco.javacpp.Pointer arg8)`
`static void`	`sub32s(org.bytedeco.javacpp.IntPointer src1, long step1, org.bytedeco.javacpp.IntPointer src2, long step2, org.bytedeco.javacpp.IntPointer dst, long step, int width, int height, org.bytedeco.javacpp.Pointer arg8)`
`static void`	`sub64f(double[] src1, long step1, double[] src2, long step2, double[] dst, long step, int width, int height, org.bytedeco.javacpp.Pointer arg8)`
`static void`	`sub64f(DoubleBuffer src1, long step1, DoubleBuffer src2, long step2, DoubleBuffer dst, long step, int width, int height, org.bytedeco.javacpp.Pointer arg8)`
`static void`	`sub64f(org.bytedeco.javacpp.DoublePointer src1, long step1, org.bytedeco.javacpp.DoublePointer src2, long step2, org.bytedeco.javacpp.DoublePointer dst, long step, int width, int height, org.bytedeco.javacpp.Pointer arg8)`
`static void`	`sub8s(byte[] src1, long step1, byte[] src2, long step2, byte[] dst, long step, int width, int height, org.bytedeco.javacpp.Pointer arg8)`
`static void`	`sub8s(ByteBuffer src1, long step1, ByteBuffer src2, long step2, ByteBuffer dst, long step, int width, int height, org.bytedeco.javacpp.Pointer arg8)`
`static void`	`sub8s(org.bytedeco.javacpp.BytePointer src1, long step1, org.bytedeco.javacpp.BytePointer src2, long step2, org.bytedeco.javacpp.BytePointer dst, long step, int width, int height, org.bytedeco.javacpp.Pointer arg8)`
`static void`	`sub8u(byte[] src1, long step1, byte[] src2, long step2, byte[] dst, long step, int width, int height, org.bytedeco.javacpp.Pointer arg8)`
`static void`	`sub8u(ByteBuffer src1, long step1, ByteBuffer src2, long step2, ByteBuffer dst, long step, int width, int height, org.bytedeco.javacpp.Pointer arg8)`
`static void`	`sub8u(org.bytedeco.javacpp.BytePointer src1, long step1, org.bytedeco.javacpp.BytePointer src2, long step2, org.bytedeco.javacpp.BytePointer dst, long step, int width, int height, org.bytedeco.javacpp.Pointer arg8)`
`static long`	`subtract(opencv_core.FileNodeIterator it1, opencv_core.FileNodeIterator it2)`
`static void`	`subtract(opencv_core.GpuMat src1, opencv_core.GpuMat src2, opencv_core.GpuMat dst)`
`static void`	`subtract(opencv_core.GpuMat src1, opencv_core.GpuMat src2, opencv_core.GpuMat dst, opencv_core.GpuMat mask, int dtype)`
`static opencv_core.MatExpr`	`subtract(opencv_core.Mat m)`
`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)` \brief Calculates the per-element difference between two arrays or array and a scalar.
`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 void`	`subtract(opencv_core.UMat src1, opencv_core.UMat src2, opencv_core.UMat dst)`
`static void`	`subtract(opencv_core.UMat src1, opencv_core.UMat src2, opencv_core.UMat dst, opencv_core.UMat mask, int dtype)`
`static opencv_core.Mat`	`subtractPut(opencv_core.Mat a, opencv_core.Mat b)`
`static opencv_core.Mat`	`subtractPut(opencv_core.Mat a, opencv_core.Scalar b)`
`static opencv_core.Scalar`	`sumElems(opencv_core.GpuMat src)`
`static opencv_core.Scalar`	`sumElems(opencv_core.Mat src)` \brief Calculates the sum of array elements.
`static opencv_core.Scalar`	`sumElems(opencv_core.UMat src)`
`static void`	`SVBackSubst(opencv_core.GpuMat w, opencv_core.GpuMat u, opencv_core.GpuMat vt, opencv_core.GpuMat rhs, opencv_core.GpuMat dst)`
`static void`	`SVBackSubst(opencv_core.Mat w, opencv_core.Mat u, opencv_core.Mat vt, opencv_core.Mat rhs, opencv_core.Mat dst)` wrap SVD::backSubst
`static void`	`SVBackSubst(opencv_core.UMat w, opencv_core.UMat u, opencv_core.UMat vt, opencv_core.UMat rhs, opencv_core.UMat dst)`
`static void`	`SVD32f(float[] At, long astep, float[] W, float[] U, long ustep, float[] Vt, long vstep, int m, int n, int flags)`
`static void`	`SVD32f(FloatBuffer At, long astep, FloatBuffer W, FloatBuffer U, long ustep, FloatBuffer Vt, long vstep, int m, int n, int flags)`
`static void`	`SVD32f(org.bytedeco.javacpp.FloatPointer At, long astep, org.bytedeco.javacpp.FloatPointer W, org.bytedeco.javacpp.FloatPointer U, long ustep, org.bytedeco.javacpp.FloatPointer Vt, long vstep, int m, int n, int flags)`
`static void`	`SVD64f(double[] At, long astep, double[] W, double[] U, long ustep, double[] Vt, long vstep, int m, int n, int flags)`
`static void`	`SVD64f(DoubleBuffer At, long astep, DoubleBuffer W, DoubleBuffer U, long ustep, DoubleBuffer Vt, long vstep, int m, int n, int flags)`
`static void`	`SVD64f(org.bytedeco.javacpp.DoublePointer At, long astep, org.bytedeco.javacpp.DoublePointer W, org.bytedeco.javacpp.DoublePointer U, long ustep, org.bytedeco.javacpp.DoublePointer Vt, long vstep, int m, int n, int flags)`
`static void`	`SVDecomp(opencv_core.GpuMat src, opencv_core.GpuMat w, opencv_core.GpuMat u, opencv_core.GpuMat vt)`
`static void`	`SVDecomp(opencv_core.GpuMat src, opencv_core.GpuMat w, opencv_core.GpuMat u, opencv_core.GpuMat vt, int flags)`
`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)` wrap SVD::compute
`static void`	`SVDecomp(opencv_core.UMat src, opencv_core.UMat w, opencv_core.UMat u, opencv_core.UMat vt)`
`static void`	`SVDecomp(opencv_core.UMat src, opencv_core.UMat w, opencv_core.UMat u, opencv_core.UMat vt, int flags)`
`static void`	`swap(org.bytedeco.javacpp.BytePointer a, org.bytedeco.javacpp.BytePointer b)` \} relates cv::String
`static void`	`swap(opencv_core.Mat a, opencv_core.Mat b)` \brief Swaps two matrices
`static void`	`swap(opencv_core.UMat a, opencv_core.UMat b)` \overload
`static void`	`swap(String a, String b)`
`static org.bytedeco.javacpp.BytePointer`	`tempfile()`
`static org.bytedeco.javacpp.BytePointer`	`tempfile(org.bytedeco.javacpp.BytePointer suffix)`
`static String`	`tempfile(String suffix)`
`static opencv_core.RNG`	`theRNG()` \brief Returns the default random number generator.
`static opencv_core.Scalar`	`trace(opencv_core.GpuMat mtx)`
`static opencv_core.Scalar`	`trace(opencv_core.Mat mtx)` \brief Returns the trace of a matrix.
`static opencv_core.Scalar`	`trace(opencv_core.UMat mtx)`
`static void`	`transform(opencv_core.GpuMat src, opencv_core.GpuMat dst, opencv_core.GpuMat m)`
`static void`	`transform(opencv_core.Mat src, opencv_core.Mat dst, opencv_core.Mat m)` \brief Performs the matrix transformation of every array element.
`static void`	`transform(opencv_core.UMat src, opencv_core.UMat dst, opencv_core.UMat m)`
`static void`	`transpose(opencv_core.GpuMat src, opencv_core.GpuMat dst)`
`static void`	`transpose(opencv_core.Mat src, opencv_core.Mat dst)` \brief Transposes a matrix.
`static void`	`transpose(opencv_core.UMat src, opencv_core.UMat dst)`
`static org.bytedeco.javacpp.BytePointer`	`typeToStr(int t)`
`static byte`	`ucharSaturateCast(byte v)` \addtogroup core_utils \{
`static byte`	`ucharSaturateCast(double v)` \overload
`static byte`	`ucharSaturateCast(float v)` \overload
`static byte`	`ucharSaturateCast(int v)` \overload
`static byte`	`ucharSaturateCast(long v)` \overload
`static byte`	`ucharSaturateCast(short v)` \overload
`static int`	`uint64SaturateCast(byte v)`
`static int`	`uint64SaturateCast(double v)`
`static int`	`uint64SaturateCast(float v)`
`static int`	`uint64SaturateCast(int v)`
`static int`	`uint64SaturateCast(long v)`
`static int`	`uint64SaturateCast(short v)`
`static void`	`unregisterPageLocked(opencv_core.Mat m)` \brief Unmaps the memory of matrix and makes it pageable again.
`static int`	`unsignedSaturateCast(byte v)`
`static int`	`unsignedSaturateCast(double v)`
`static int`	`unsignedSaturateCast(float v)`
`static int`	`unsignedSaturateCast(int v)`
`static int`	`unsignedSaturateCast(long v)`
`static int`	`unsignedSaturateCast(short v)`
`static boolean`	`useInstrumentation()`
`static boolean`	`useIPP_NE()`
`static boolean`	`useIPP()`
`static boolean`	`useOpenCL()`
`static boolean`	`useOptimized()` \brief Returns the status of optimized code usage.
`static short`	`ushortSaturateCast(byte v)`
`static short`	`ushortSaturateCast(double v)`
`static short`	`ushortSaturateCast(float v)`
`static short`	`ushortSaturateCast(int v)`
`static short`	`ushortSaturateCast(long v)`
`static short`	`ushortSaturateCast(short v)`
`static void`	`vconcat(opencv_core.GpuMat src1, opencv_core.GpuMat src2, opencv_core.GpuMat dst)`
`static void`	`vconcat(opencv_core.GpuMatVector src, opencv_core.GpuMat dst)`
`static void`	`vconcat(opencv_core.GpuMatVector src, opencv_core.Mat dst)`
`static void`	`vconcat(opencv_core.GpuMatVector src, opencv_core.UMat dst)`
`static void`	`vconcat(opencv_core.Mat src, long nsrc, opencv_core.GpuMat dst)`
`static void`	`vconcat(opencv_core.Mat src, long nsrc, opencv_core.Mat dst)` \brief Applies vertical concatenation to given matrices.
`static void`	`vconcat(opencv_core.Mat src, long nsrc, opencv_core.UMat dst)`
`static void`	`vconcat(opencv_core.Mat src1, opencv_core.Mat src2, opencv_core.Mat dst)` \overload
`static void`	`vconcat(opencv_core.MatVector src, opencv_core.GpuMat dst)`
`static void`	`vconcat(opencv_core.MatVector src, opencv_core.Mat dst)` \overload
`static void`	`vconcat(opencv_core.MatVector src, opencv_core.UMat dst)`
`static void`	`vconcat(opencv_core.UMat src1, opencv_core.UMat src2, opencv_core.UMat dst)`
`static void`	`vconcat(opencv_core.UMatVector src, opencv_core.GpuMat dst)`
`static void`	`vconcat(opencv_core.UMatVector src, opencv_core.Mat dst)`
`static void`	`vconcat(opencv_core.UMatVector src, opencv_core.UMat dst)`
`static org.bytedeco.javacpp.BytePointer`	`vecopTypeToStr(int t)`
`static void`	`write(opencv_core.FileStorage fs, org.bytedeco.javacpp.BytePointer value)`
`static void`	`write(opencv_core.FileStorage fs, org.bytedeco.javacpp.BytePointer name, org.bytedeco.javacpp.BytePointer value)`
`static void`	`write(opencv_core.FileStorage fs, org.bytedeco.javacpp.BytePointer name, double value)`
`static void`	`write(opencv_core.FileStorage fs, org.bytedeco.javacpp.BytePointer name, float value)`
`static void`	`write(opencv_core.FileStorage fs, org.bytedeco.javacpp.BytePointer name, int value)` \} core_xml
`static void`	`write(opencv_core.FileStorage fs, org.bytedeco.javacpp.BytePointer name, opencv_core.DMatch m)`
`static void`	`write(opencv_core.FileStorage fs, org.bytedeco.javacpp.BytePointer name, opencv_core.DMatchVector value)`
`static void`	`write(opencv_core.FileStorage fs, org.bytedeco.javacpp.BytePointer name, opencv_core.KeyPoint kpt)`
`static void`	`write(opencv_core.FileStorage fs, org.bytedeco.javacpp.BytePointer name, opencv_core.KeyPointVector value)`
`static void`	`write(opencv_core.FileStorage fs, org.bytedeco.javacpp.BytePointer name, opencv_core.Mat value)`
`static void`	`write(opencv_core.FileStorage fs, org.bytedeco.javacpp.BytePointer name, opencv_core.Range r)`
`static void`	`write(opencv_core.FileStorage fs, org.bytedeco.javacpp.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)` \endcond
`static void`	`write(opencv_core.FileStorage fs, opencv_core.DMatch m)`
`static void`	`write(opencv_core.FileStorage fs, opencv_core.DMatchVector vec)`
`static void`	`write(opencv_core.FileStorage fs, opencv_core.KeyPoint kpt)`
`static void`	`write(opencv_core.FileStorage fs, opencv_core.KeyPointVector vec)`
`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.DMatch m)`
`static void`	`write(opencv_core.FileStorage fs, String name, opencv_core.DMatchVector value)`
`static void`	`write(opencv_core.FileStorage fs, String name, opencv_core.KeyPoint kpt)`
`static void`	`write(opencv_core.FileStorage fs, String name, opencv_core.KeyPointVector 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, org.bytedeco.javacpp.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 void`	`xor8u(byte[] src1, long step1, byte[] src2, long step2, byte[] dst, long step, int width, int height, org.bytedeco.javacpp.Pointer arg8)`
`static void`	`xor8u(ByteBuffer src1, long step1, ByteBuffer src2, long step2, ByteBuffer dst, long step, int width, int height, org.bytedeco.javacpp.Pointer arg8)`
`static void`	`xor8u(org.bytedeco.javacpp.BytePointer src1, long step1, org.bytedeco.javacpp.BytePointer src2, long step2, org.bytedeco.javacpp.BytePointer dst, long step, int width, int height, org.bytedeco.javacpp.Pointer arg8)`
`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 b)`

Methods inherited from class org.bytedeco.javacpp.helper.opencv_core
CV_RGB, cvCalcCovarMatrix, cvInitNArrayIterator, cvMixChannels, cvNorm, RGB

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

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

Field Detail
- CV_HAL_ERROR_OK
```
public static final int CV_HAL_ERROR_OK
```
  \addtogroup core_hal_interface \{
  \name Return codes \{
  
  See Also:
  
  Constant Field Values
- CV_HAL_ERROR_NOT_IMPLEMENTED
```
public static final int CV_HAL_ERROR_NOT_IMPLEMENTED
```
  See Also:
  
  Constant Field Values
- CV_HAL_ERROR_UNKNOWN
```
public static final int CV_HAL_ERROR_UNKNOWN
```
  See Also:
  
  Constant Field Values
- CV_CN_MAX
```
public static final int CV_CN_MAX
```
  \name Data types primitive types - schar - signed 1 byte integer - uchar - unsigned 1 byte integer - short - signed 2 byte integer - ushort - unsigned 2 byte integer - int - signed 4 byte integer - uint - unsigned 4 byte integer - int64 - signed 8 byte integer - uint64 - unsigned 8 byte integer \{
  
  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_HAL_CMP_EQ
```
public static final int CV_HAL_CMP_EQ
```
  \}
  \name Comparison operation \sa cv::CmpTypes \{
  
  See Also:
  
  Constant Field Values
- CV_HAL_CMP_GT
```
public static final int CV_HAL_CMP_GT
```
  See Also:
  
  Constant Field Values
- CV_HAL_CMP_GE
```
public static final int CV_HAL_CMP_GE
```
  See Also:
  
  Constant Field Values
- CV_HAL_CMP_LT
```
public static final int CV_HAL_CMP_LT
```
  See Also:
  
  Constant Field Values
- CV_HAL_CMP_LE
```
public static final int CV_HAL_CMP_LE
```
  See Also:
  
  Constant Field Values
- CV_HAL_CMP_NE
```
public static final int CV_HAL_CMP_NE
```
  See Also:
  
  Constant Field Values
- CV_HAL_BORDER_CONSTANT
```
public static final int CV_HAL_BORDER_CONSTANT
```
  \}
  \name Border processing modes \sa cv::BorderTypes \{
  
  See Also:
  
  Constant Field Values
- CV_HAL_BORDER_REPLICATE
```
public static final int CV_HAL_BORDER_REPLICATE
```
  See Also:
  
  Constant Field Values
- CV_HAL_BORDER_REFLECT
```
public static final int CV_HAL_BORDER_REFLECT
```
  See Also:
  
  Constant Field Values
- CV_HAL_BORDER_WRAP
```
public static final int CV_HAL_BORDER_WRAP
```
  See Also:
  
  Constant Field Values
- CV_HAL_BORDER_REFLECT_101
```
public static final int CV_HAL_BORDER_REFLECT_101
```
  See Also:
  
  Constant Field Values
- CV_HAL_BORDER_TRANSPARENT
```
public static final int CV_HAL_BORDER_TRANSPARENT
```
  See Also:
  
  Constant Field Values
- CV_HAL_BORDER_ISOLATED
```
public static final int CV_HAL_BORDER_ISOLATED
```
  See Also:
  
  Constant Field Values
- CV_HAL_DFT_INVERSE
```
public static final int CV_HAL_DFT_INVERSE
```
  \}
  \name DFT flags \{
  
  See Also:
  
  Constant Field Values
- CV_HAL_DFT_SCALE
```
public static final int CV_HAL_DFT_SCALE
```
  See Also:
  
  Constant Field Values
- CV_HAL_DFT_ROWS
```
public static final int CV_HAL_DFT_ROWS
```
  See Also:
  
  Constant Field Values
- CV_HAL_DFT_COMPLEX_OUTPUT
```
public static final int CV_HAL_DFT_COMPLEX_OUTPUT
```
  See Also:
  
  Constant Field Values
- CV_HAL_DFT_REAL_OUTPUT
```
public static final int CV_HAL_DFT_REAL_OUTPUT
```
  See Also:
  
  Constant Field Values
- CV_HAL_DFT_TWO_STAGE
```
public static final int CV_HAL_DFT_TWO_STAGE
```
  See Also:
  
  Constant Field Values
- CV_HAL_DFT_STAGE_COLS
```
public static final int CV_HAL_DFT_STAGE_COLS
```
  See Also:
  
  Constant Field Values
- CV_HAL_DFT_IS_CONTINUOUS
```
public static final int CV_HAL_DFT_IS_CONTINUOUS
```
  See Also:
  
  Constant Field Values
- CV_HAL_DFT_IS_INPLACE
```
public static final int CV_HAL_DFT_IS_INPLACE
```
  See Also:
  
  Constant Field Values
- CV_HAL_SVD_NO_UV
```
public static final int CV_HAL_SVD_NO_UV
```
  \}
  \name SVD flags \{
  
  See Also:
  
  Constant Field Values
- CV_HAL_SVD_SHORT_UV
```
public static final int CV_HAL_SVD_SHORT_UV
```
  See Also:
  
  Constant Field Values
- CV_HAL_SVD_MODIFY_A
```
public static final int CV_HAL_SVD_MODIFY_A
```
  See Also:
  
  Constant Field Values
- CV_HAL_SVD_FULL_UV
```
public static final int CV_HAL_SVD_FULL_UV
```
  See Also:
  
  Constant Field Values
- CV_HAL_GEMM_1_T
```
public static final int CV_HAL_GEMM_1_T
```
  \}
  \name Gemm flags \{
  
  See Also:
  
  Constant Field Values
- CV_HAL_GEMM_2_T
```
public static final int CV_HAL_GEMM_2_T
```
  See Also:
  
  Constant Field Values
- CV_HAL_GEMM_3_T
```
public static final int CV_HAL_GEMM_3_T
```
  See Also:
  
  Constant Field Values
- CV_CPU_NONE
```
public static final int CV_CPU_NONE
```
  \addtogroup core_utils \{
  
  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_FP16
```
public static final int CV_CPU_FP16
```
  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_CPU_FMA3
```
public static final int CV_CPU_FMA3
```
  See Also:
  
  Constant Field Values
- CV_CPU_AVX_512F
```
public static final int CV_CPU_AVX_512F
```
  See Also:
  
  Constant Field Values
- CV_CPU_AVX_512BW
```
public static final int CV_CPU_AVX_512BW
```
  See Also:
  
  Constant Field Values
- CV_CPU_AVX_512CD
```
public static final int CV_CPU_AVX_512CD
```
  See Also:
  
  Constant Field Values
- CV_CPU_AVX_512DQ
```
public static final int CV_CPU_AVX_512DQ
```
  See Also:
  
  Constant Field Values
- CV_CPU_AVX_512ER
```
public static final int CV_CPU_AVX_512ER
```
  See Also:
  
  Constant Field Values
- CV_CPU_AVX_512IFMA512
```
public static final int CV_CPU_AVX_512IFMA512
```
  See Also:
  
  Constant Field Values
- CV_CPU_AVX_512IFMA
```
public static final int CV_CPU_AVX_512IFMA
```
  See Also:
  
  Constant Field Values
- CV_CPU_AVX_512PF
```
public static final int CV_CPU_AVX_512PF
```
  See Also:
  
  Constant Field Values
- CV_CPU_AVX_512VBMI
```
public static final int CV_CPU_AVX_512VBMI
```
  See Also:
  
  Constant Field Values
- CV_CPU_AVX_512VL
```
public static final int CV_CPU_AVX_512VL
```
  See Also:
  
  Constant Field Values
- CV_CPU_NEON
```
public static final int CV_CPU_NEON
```
  See Also:
  
  Constant Field Values
- CV_CPU_VSX
```
public static final int CV_CPU_VSX
```
  See Also:
  
  Constant Field Values
- CV_CPU_AVX512_SKX
```
public static final int CV_CPU_AVX512_SKX
```
  See Also:
  
  Constant Field Values
- CV_HARDWARE_MAX_FEATURE
```
public static final int CV_HARDWARE_MAX_FEATURE
```
  See Also:
  
  Constant Field Values
- CPU_MMX
```
public static final int CPU_MMX
```
  enum CpuFeatures
  
  See Also:
  
  Constant Field Values
- CPU_SSE
```
public static final int CPU_SSE
```
  enum CpuFeatures
  
  See Also:
  
  Constant Field Values
- CPU_SSE2
```
public static final int CPU_SSE2
```
  enum CpuFeatures
  
  See Also:
  
  Constant Field Values
- CPU_SSE3
```
public static final int CPU_SSE3
```
  enum CpuFeatures
  
  See Also:
  
  Constant Field Values
- CPU_SSSE3
```
public static final int CPU_SSSE3
```
  enum CpuFeatures
  
  See Also:
  
  Constant Field Values
- CPU_SSE4_1
```
public static final int CPU_SSE4_1
```
  enum CpuFeatures
  
  See Also:
  
  Constant Field Values
- CPU_SSE4_2
```
public static final int CPU_SSE4_2
```
  enum CpuFeatures
  
  See Also:
  
  Constant Field Values
- CPU_POPCNT
```
public static final int CPU_POPCNT
```
  enum CpuFeatures
  
  See Also:
  
  Constant Field Values
- CPU_FP16
```
public static final int CPU_FP16
```
  enum CpuFeatures
  
  See Also:
  
  Constant Field Values
- CPU_AVX
```
public static final int CPU_AVX
```
  enum CpuFeatures
  
  See Also:
  
  Constant Field Values
- CPU_AVX2
```
public static final int CPU_AVX2
```
  enum CpuFeatures
  
  See Also:
  
  Constant Field Values
- CPU_FMA3
```
public static final int CPU_FMA3
```
  enum CpuFeatures
  
  See Also:
  
  Constant Field Values
- CPU_AVX_512F
```
public static final int CPU_AVX_512F
```
  enum CpuFeatures
  
  See Also:
  
  Constant Field Values
- CPU_AVX_512BW
```
public static final int CPU_AVX_512BW
```
  enum CpuFeatures
  
  See Also:
  
  Constant Field Values
- CPU_AVX_512CD
```
public static final int CPU_AVX_512CD
```
  enum CpuFeatures
  
  See Also:
  
  Constant Field Values
- CPU_AVX_512DQ
```
public static final int CPU_AVX_512DQ
```
  enum CpuFeatures
  
  See Also:
  
  Constant Field Values
- CPU_AVX_512ER
```
public static final int CPU_AVX_512ER
```
  enum CpuFeatures
  
  See Also:
  
  Constant Field Values
- CPU_AVX_512IFMA512
```
public static final int CPU_AVX_512IFMA512
```
  enum CpuFeatures
  
  See Also:
  
  Constant Field Values
- CPU_AVX_512IFMA
```
public static final int CPU_AVX_512IFMA
```
  enum CpuFeatures
  
  See Also:
  
  Constant Field Values
- CPU_AVX_512PF
```
public static final int CPU_AVX_512PF
```
  enum CpuFeatures
  
  See Also:
  
  Constant Field Values
- CPU_AVX_512VBMI
```
public static final int CPU_AVX_512VBMI
```
  enum CpuFeatures
  
  See Also:
  
  Constant Field Values
- CPU_AVX_512VL
```
public static final int CPU_AVX_512VL
```
  enum CpuFeatures
  
  See Also:
  
  Constant Field Values
- CPU_NEON
```
public static final int CPU_NEON
```
  enum CpuFeatures
  
  See Also:
  
  Constant Field Values
- CPU_VSX
```
public static final int CPU_VSX
```
  enum CpuFeatures
  
  See Also:
  
  Constant Field Values
- CPU_AVX512_SKX
```
public static final int CPU_AVX512_SKX
```
  enum CpuFeatures
  
  See Also:
  
  Constant Field Values
- CPU_MAX_FEATURE
```
public static final int CPU_MAX_FEATURE
```
  enum CpuFeatures
  
  See Also:
  
  Constant Field Values
- CV_PI
```
public static final double CV_PI
```
  See Also:
  
  Constant Field Values
- CV_2PI
```
public static final double CV_2PI
```
  See Also:
  
  Constant Field Values
- CV_LOG2
```
public static final double CV_LOG2
```
  See Also:
  
  Constant Field Values
- CV_FP16_TYPE
```
public static final int CV_FP16_TYPE
```
- OPENCV_ABI_COMPATIBILITY
```
public static final int OPENCV_ABI_COMPATIBILITY
```
  See Also:
  
  Constant Field Values
- CV_MAT_CN_MASK
```
public static final int CV_MAT_CN_MASK
```
  \ Matrix type (Mat) * \
  
  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_STATIC_ANALYSIS
```
public static final int CV_STATIC_ANALYSIS
```
  \ static analysys * \
  
  See Also:
  
  Constant Field Values
- CV_CXX_MOVE_SEMANTICS
```
public static final int CV_CXX_MOVE_SEMANTICS
```
  \ C++ Move semantics * \
  
  See Also:
  
  Constant Field Values
- CV_CXX_STD_ARRAY
```
public static final int CV_CXX_STD_ARRAY
```
  \ C++11 std::array * \
  
  See Also:
  
  Constant Field Values
- CV_VERSION_MAJOR
```
public static final int CV_VERSION_MAJOR
```
  \}
  
  See Also:
  
  Constant Field Values
- CV_VERSION_MINOR
```
public static final int CV_VERSION_MINOR
```
  See Also:
  
  Constant Field Values
- CV_VERSION_REVISION
```
public static final int CV_VERSION_REVISION
```
  See Also:
  
  Constant Field Values
- CV_VERSION_STATUS
```
public static final String CV_VERSION_STATUS
```
  See Also:
  
  Constant Field Values
- CV_VERSION
```
public static final String CV_VERSION
```
- CV_MAJOR_VERSION
```
public static final int CV_MAJOR_VERSION
```
  See Also:
  
  Constant Field Values
- CV_MINOR_VERSION
```
public static final int CV_MINOR_VERSION
```
  See Also:
  
  Constant Field Values
- CV_SUBMINOR_VERSION
```
public static final int CV_SUBMINOR_VERSION
```
  See Also:
  
  Constant Field Values
- StsOk
```
public static final int StsOk
```
  enum cv::Error::Code
  
  See Also:
  
  Constant Field Values
- StsBackTrace
```
public static final int StsBackTrace
```
  enum cv::Error::Code
  
  See Also:
  
  Constant Field Values
- StsError
```
public static final int StsError
```
  enum cv::Error::Code
  
  See Also:
  
  Constant Field Values
- StsInternal
```
public static final int StsInternal
```
  enum cv::Error::Code
  
  See Also:
  
  Constant Field Values
- StsNoMem
```
public static final int StsNoMem
```
  enum cv::Error::Code
  
  See Also:
  
  Constant Field Values
- StsBadArg
```
public static final int StsBadArg
```
  enum cv::Error::Code
  
  See Also:
  
  Constant Field Values
- StsBadFunc
```
public static final int StsBadFunc
```
  enum cv::Error::Code
  
  See Also:
  
  Constant Field Values
- StsNoConv
```
public static final int StsNoConv
```
  enum cv::Error::Code
  
  See Also:
  
  Constant Field Values
- StsAutoTrace
```
public static final int StsAutoTrace
```
  enum cv::Error::Code
  
  See Also:
  
  Constant Field Values
- HeaderIsNull
```
public static final int HeaderIsNull
```
  enum cv::Error::Code
  
  See Also:
  
  Constant Field Values
- BadImageSize
```
public static final int BadImageSize
```
  enum cv::Error::Code
  
  See Also:
  
  Constant Field Values
- BadOffset
```
public static final int BadOffset
```
  enum cv::Error::Code
  
  See Also:
  
  Constant Field Values
- BadDataPtr
```
public static final int BadDataPtr
```
  enum cv::Error::Code
  
  See Also:
  
  Constant Field Values
- BadStep
```
public static final int BadStep
```
  enum cv::Error::Code
  
  See Also:
  
  Constant Field Values
- BadModelOrChSeq
```
public static final int BadModelOrChSeq
```
  enum cv::Error::Code
  
  See Also:
  
  Constant Field Values
- BadNumChannels
```
public static final int BadNumChannels
```
  enum cv::Error::Code
  
  See Also:
  
  Constant Field Values
- BadNumChannel1U
```
public static final int BadNumChannel1U
```
  enum cv::Error::Code
  
  See Also:
  
  Constant Field Values
- BadDepth
```
public static final int BadDepth
```
  enum cv::Error::Code
  
  See Also:
  
  Constant Field Values
- BadAlphaChannel
```
public static final int BadAlphaChannel
```
  enum cv::Error::Code
  
  See Also:
  
  Constant Field Values
- BadOrder
```
public static final int BadOrder
```
  enum cv::Error::Code
  
  See Also:
  
  Constant Field Values
- BadOrigin
```
public static final int BadOrigin
```
  enum cv::Error::Code
  
  See Also:
  
  Constant Field Values
- BadAlign
```
public static final int BadAlign
```
  enum cv::Error::Code
  
  See Also:
  
  Constant Field Values
- BadCallBack
```
public static final int BadCallBack
```
  enum cv::Error::Code
  
  See Also:
  
  Constant Field Values
- BadTileSize
```
public static final int BadTileSize
```
  enum cv::Error::Code
  
  See Also:
  
  Constant Field Values
- BadCOI
```
public static final int BadCOI
```
  enum cv::Error::Code
  
  See Also:
  
  Constant Field Values
- BadROISize
```
public static final int BadROISize
```
  enum cv::Error::Code
  
  See Also:
  
  Constant Field Values
- MaskIsTiled
```
public static final int MaskIsTiled
```
  enum cv::Error::Code
  
  See Also:
  
  Constant Field Values
- StsNullPtr
```
public static final int StsNullPtr
```
  enum cv::Error::Code
  
  See Also:
  
  Constant Field Values
- StsVecLengthErr
```
public static final int StsVecLengthErr
```
  enum cv::Error::Code
  
  See Also:
  
  Constant Field Values
- StsFilterStructContentErr
```
public static final int StsFilterStructContentErr
```
  enum cv::Error::Code
  
  See Also:
  
  Constant Field Values
- StsKernelStructContentErr
```
public static final int StsKernelStructContentErr
```
  enum cv::Error::Code
  
  See Also:
  
  Constant Field Values
- StsFilterOffsetErr
```
public static final int StsFilterOffsetErr
```
  enum cv::Error::Code
  
  See Also:
  
  Constant Field Values
- StsBadSize
```
public static final int StsBadSize
```
  enum cv::Error::Code
  
  See Also:
  
  Constant Field Values
- StsDivByZero
```
public static final int StsDivByZero
```
  enum cv::Error::Code
  
  See Also:
  
  Constant Field Values
- StsInplaceNotSupported
```
public static final int StsInplaceNotSupported
```
  enum cv::Error::Code
  
  See Also:
  
  Constant Field Values
- StsObjectNotFound
```
public static final int StsObjectNotFound
```
  enum cv::Error::Code
  
  See Also:
  
  Constant Field Values
- StsUnmatchedFormats
```
public static final int StsUnmatchedFormats
```
  enum cv::Error::Code
  
  See Also:
  
  Constant Field Values
- StsBadFlag
```
public static final int StsBadFlag
```
  enum cv::Error::Code
  
  See Also:
  
  Constant Field Values
- StsBadPoint
```
public static final int StsBadPoint
```
  enum cv::Error::Code
  
  See Also:
  
  Constant Field Values
- StsBadMask
```
public static final int StsBadMask
```
  enum cv::Error::Code
  
  See Also:
  
  Constant Field Values
- StsUnmatchedSizes
```
public static final int StsUnmatchedSizes
```
  enum cv::Error::Code
  
  See Also:
  
  Constant Field Values
- StsUnsupportedFormat
```
public static final int StsUnsupportedFormat
```
  enum cv::Error::Code
  
  See Also:
  
  Constant Field Values
- StsOutOfRange
```
public static final int StsOutOfRange
```
  enum cv::Error::Code
  
  See Also:
  
  Constant Field Values
- StsParseError
```
public static final int StsParseError
```
  enum cv::Error::Code
  
  See Also:
  
  Constant Field Values
- StsNotImplemented
```
public static final int StsNotImplemented
```
  enum cv::Error::Code
  
  See Also:
  
  Constant Field Values
- StsBadMemBlock
```
public static final int StsBadMemBlock
```
  enum cv::Error::Code
  
  See Also:
  
  Constant Field Values
- StsAssert
```
public static final int StsAssert
```
  enum cv::Error::Code
  
  See Also:
  
  Constant Field Values
- GpuNotSupported
```
public static final int GpuNotSupported
```
  enum cv::Error::Code
  
  See Also:
  
  Constant Field Values
- GpuApiCallError
```
public static final int GpuApiCallError
```
  enum cv::Error::Code
  
  See Also:
  
  Constant Field Values
- OpenGlNotSupported
```
public static final int OpenGlNotSupported
```
  enum cv::Error::Code
  
  See Also:
  
  Constant Field Values
- OpenGlApiCallError
```
public static final int OpenGlApiCallError
```
  enum cv::Error::Code
  
  See Also:
  
  Constant Field Values
- OpenCLApiCallError
```
public static final int OpenCLApiCallError
```
  enum cv::Error::Code
  
  See Also:
  
  Constant Field Values
- OpenCLDoubleNotSupported
```
public static final int OpenCLDoubleNotSupported
```
  enum cv::Error::Code
  
  See Also:
  
  Constant Field Values
- OpenCLInitError
```
public static final int OpenCLInitError
```
  enum cv::Error::Code
  
  See Also:
  
  Constant Field Values
- OpenCLNoAMDBlasFft
```
public static final int OpenCLNoAMDBlasFft
```
  enum cv::Error::Code
  
  See Also:
  
  Constant Field Values
- DECOMP_LU
```
public static final int DECOMP_LU
```
  enum cv::DecompTypes
  
  See Also:
  
  Constant Field Values
- DECOMP_SVD
```
public static final int DECOMP_SVD
```
  enum cv::DecompTypes
  
  See Also:
  
  Constant Field Values
- DECOMP_EIG
```
public static final int DECOMP_EIG
```
  enum cv::DecompTypes
  
  See Also:
  
  Constant Field Values
- DECOMP_CHOLESKY
```
public static final int DECOMP_CHOLESKY
```
  enum cv::DecompTypes
  
  See Also:
  
  Constant Field Values
- DECOMP_QR
```
public static final int DECOMP_QR
```
  enum cv::DecompTypes
  
  See Also:
  
  Constant Field Values
- DECOMP_NORMAL
```
public static final int DECOMP_NORMAL
```
  enum cv::DecompTypes
  
  See Also:
  
  Constant Field Values
- NORM_INF
```
public static final int NORM_INF
```
  enum cv::NormTypes
  
  See Also:
  
  Constant Field Values
- NORM_L1
```
public static final int NORM_L1
```
  enum cv::NormTypes
  
  See Also:
  
  Constant Field Values
- NORM_L2
```
public static final int NORM_L2
```
  enum cv::NormTypes
  
  See Also:
  
  Constant Field Values
- NORM_L2SQR
```
public static final int NORM_L2SQR
```
  enum cv::NormTypes
  
  See Also:
  
  Constant Field Values
- NORM_HAMMING
```
public static final int NORM_HAMMING
```
  enum cv::NormTypes
  
  See Also:
  
  Constant Field Values
- NORM_HAMMING2
```
public static final int NORM_HAMMING2
```
  enum cv::NormTypes
  
  See Also:
  
  Constant Field Values
- NORM_TYPE_MASK
```
public static final int NORM_TYPE_MASK
```
  enum cv::NormTypes
  
  See Also:
  
  Constant Field Values
- NORM_RELATIVE
```
public static final int NORM_RELATIVE
```
  enum cv::NormTypes
  
  See Also:
  
  Constant Field Values
- NORM_MINMAX
```
public static final int NORM_MINMAX
```
  enum cv::NormTypes
  
  See Also:
  
  Constant Field Values
- CMP_EQ
```
public static final int CMP_EQ
```
  enum cv::CmpTypes
  
  See Also:
  
  Constant Field Values
- CMP_GT
```
public static final int CMP_GT
```
  enum cv::CmpTypes
  
  See Also:
  
  Constant Field Values
- CMP_GE
```
public static final int CMP_GE
```
  enum cv::CmpTypes
  
  See Also:
  
  Constant Field Values
- CMP_LT
```
public static final int CMP_LT
```
  enum cv::CmpTypes
  
  See Also:
  
  Constant Field Values
- CMP_LE
```
public static final int CMP_LE
```
  enum cv::CmpTypes
  
  See Also:
  
  Constant Field Values
- CMP_NE
```
public static final int CMP_NE
```
  enum cv::CmpTypes
  
  See Also:
  
  Constant Field Values
- GEMM_1_T
```
public static final int GEMM_1_T
```
  enum cv::GemmFlags
  
  See Also:
  
  Constant Field Values
- GEMM_2_T
```
public static final int GEMM_2_T
```
  enum cv::GemmFlags
  
  See Also:
  
  Constant Field Values
- GEMM_3_T
```
public static final int GEMM_3_T
```
  enum cv::GemmFlags
  
  See Also:
  
  Constant Field Values
- DFT_INVERSE
```
public static final int DFT_INVERSE
```
  enum cv::DftFlags
  
  See Also:
  
  Constant Field Values
- DFT_SCALE
```
public static final int DFT_SCALE
```
  enum cv::DftFlags
  
  See Also:
  
  Constant Field Values
- DFT_ROWS
```
public static final int DFT_ROWS
```
  enum cv::DftFlags
  
  See Also:
  
  Constant Field Values
- DFT_COMPLEX_OUTPUT
```
public static final int DFT_COMPLEX_OUTPUT
```
  enum cv::DftFlags
  
  See Also:
  
  Constant Field Values
- DFT_REAL_OUTPUT
```
public static final int DFT_REAL_OUTPUT
```
  enum cv::DftFlags
  
  See Also:
  
  Constant Field Values
- DFT_COMPLEX_INPUT
```
public static final int DFT_COMPLEX_INPUT
```
  enum cv::DftFlags
  
  See Also:
  
  Constant Field Values
- DCT_INVERSE
```
public static final int DCT_INVERSE
```
  enum cv::DftFlags
  
  See Also:
  
  Constant Field Values
- DCT_ROWS
```
public static final int DCT_ROWS
```
  enum cv::DftFlags
  
  See Also:
  
  Constant Field Values
- BORDER_CONSTANT
```
public static final int BORDER_CONSTANT
```
  enum cv::BorderTypes
  
  See Also:
  
  Constant Field Values
- BORDER_REPLICATE
```
public static final int BORDER_REPLICATE
```
  enum cv::BorderTypes
  
  See Also:
  
  Constant Field Values
- BORDER_REFLECT
```
public static final int BORDER_REFLECT
```
  enum cv::BorderTypes
  
  See Also:
  
  Constant Field Values
- BORDER_WRAP
```
public static final int BORDER_WRAP
```
  enum cv::BorderTypes
  
  See Also:
  
  Constant Field Values
- BORDER_REFLECT_101
```
public static final int BORDER_REFLECT_101
```
  enum cv::BorderTypes
  
  See Also:
  
  Constant Field Values
- BORDER_TRANSPARENT
```
public static final int BORDER_TRANSPARENT
```
  enum cv::BorderTypes
  
  See Also:
  
  Constant Field Values
- BORDER_REFLECT101
```
public static final int BORDER_REFLECT101
```
  enum cv::BorderTypes
  
  See Also:
  
  Constant Field Values
- BORDER_DEFAULT
```
public static final int BORDER_DEFAULT
```
  enum cv::BorderTypes
  
  See Also:
  
  Constant Field Values
- BORDER_ISOLATED
```
public static final int BORDER_ISOLATED
```
  enum cv::BorderTypes
  
  See Also:
  
  Constant Field Values
- TYPE_GENERAL
```
public static final int TYPE_GENERAL
```
  enum cv::instr::TYPE
  
  See Also:
  
  Constant Field Values
- TYPE_MARKER
```
public static final int TYPE_MARKER
```
  enum cv::instr::TYPE
  
  See Also:
  
  Constant Field Values
- TYPE_WRAPPER
```
public static final int TYPE_WRAPPER
```
  enum cv::instr::TYPE
  
  See Also:
  
  Constant Field Values
- TYPE_FUN
```
public static final int TYPE_FUN
```
  enum cv::instr::TYPE
  
  See Also:
  
  Constant Field Values
- IMPL_PLAIN
```
public static final int IMPL_PLAIN
```
  enum cv::instr::IMPL
  
  See Also:
  
  Constant Field Values
- IMPL_IPP
```
public static final int IMPL_IPP
```
  enum cv::instr::IMPL
  
  See Also:
  
  Constant Field Values
- IMPL_OPENCL
```
public static final int IMPL_OPENCL
```
  enum cv::instr::IMPL
  
  See Also:
  
  Constant Field Values
- FLAGS_NONE
```
public static final int FLAGS_NONE
```
  enum cv::instr::FLAGS
  
  See Also:
  
  Constant Field Values
- FLAGS_MAPPING
```
public static final int FLAGS_MAPPING
```
  enum cv::instr::FLAGS
  
  See Also:
  
  Constant Field Values
- FLAGS_EXPAND_SAME_NAMES
```
public static final int FLAGS_EXPAND_SAME_NAMES
```
  enum cv::instr::FLAGS
  
  See Also:
  
  Constant Field Values
- 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_OpenCLApiCallError
```
public static final int CV_OpenCLApiCallError
```
  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_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
```
  extra border mode
  
  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
```
  for storing double-precision floating point data in IplImage's
  
  See Also:
  
  Constant Field Values
- CV_AUTO_STEP
```
public static final int CV_AUTO_STEP
```
  \ Matrix type (CvMat) * \
  
  See Also:
  
  Constant Field Values
- CV_WHOLE_ARR
```
public static final opencv_core.CvSlice CV_WHOLE_ARR
```
- 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_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
```
  indicates whether bin ranges are set already or not
  
  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
```
  should be used as a parameter only, it turns to CV_HIST_UNIFORM_FLAG of hist->type
  
  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
```
  CvSlice
  
  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
```
  (x,y)
- CV_SEQ_ELTYPE_CODE
```
public static final int CV_SEQ_ELTYPE_CODE
```
  freeman code: 0..7
- 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
```
  &(x,y)
  
  See Also:
  
  Constant Field Values
- CV_SEQ_ELTYPE_INDEX
```
public static final int CV_SEQ_ELTYPE_INDEX
```
  #(x,y)
- CV_SEQ_ELTYPE_GRAPH_EDGE
```
public static final int CV_SEQ_ELTYPE_GRAPH_EDGE
```
  &next_o, &next_d, &vtx_o, &vtx_d
  
  See Also:
  
  Constant Field Values
- CV_SEQ_ELTYPE_GRAPH_VERTEX
```
public static final int CV_SEQ_ELTYPE_GRAPH_VERTEX
```
  first_edge, &(x,y)
  
  See Also:
  
  Constant Field Values
- CV_SEQ_ELTYPE_TRIAN_ATR
```
public static final int CV_SEQ_ELTYPE_TRIAN_ATR
```
  vertex of the binary tree
  
  See Also:
  
  Constant Field Values
- CV_SEQ_ELTYPE_CONNECTED_COMP
```
public static final int CV_SEQ_ELTYPE_CONNECTED_COMP
```
  connected component
  
  See Also:
  
  Constant Field Values
- CV_SEQ_ELTYPE_POINT3D
```
public static final int CV_SEQ_ELTYPE_POINT3D
```
  (x,y,z)
- 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
```
  types of sequences
  
  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
```
  types of sparse sequences (sets)
  
  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
```
  flags for curves
  
  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
```
  flags for graphs
  
  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
```
  point sets
- 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
```
  chain-coded curves
- CV_SEQ_CHAIN_CONTOUR
```
public static final int CV_SEQ_CHAIN_CONTOUR
```
- CV_SEQ_POLYGON_TREE
```
public static final int CV_SEQ_POLYGON_TREE
```
  binary tree for the contour
  
  See Also:
  
  Constant Field Values
- CV_SEQ_CONNECTED_COMP
```
public static final int CV_SEQ_CONNECTED_COMP
```
  sequence of the connected components
  
  See Also:
  
  Constant Field Values
- CV_SEQ_INDEX
```
public static final int CV_SEQ_INDEX
```
  sequence of the integer numbers
- CV_STORAGE_READ
```
public static final int CV_STORAGE_READ
```
  Storage flags:
  
  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_STORAGE_FORMAT_JSON
```
public static final int CV_STORAGE_FORMAT_JSON
```
  See Also:
  
  Constant Field Values
- CV_STORAGE_BASE64
```
public static final int CV_STORAGE_BASE64
```
  See Also:
  
  Constant Field Values
- CV_STORAGE_WRITE_BASE64
```
public static final int CV_STORAGE_WRITE_BASE64
```
  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
```
  not used
  
  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
```
  Used only for writing structures in YAML format.
  
  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
```
  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
```
  flag for cvCalcCovarMatrix, transpose([v1-avg, v2-avg,...]) * [v1-avg,v2-avg,...]
  
  See Also:
  
  Constant Field Values
- CV_COVAR_NORMAL
```
public static final int CV_COVAR_NORMAL
```
  flag for cvCalcCovarMatrix, [v1-avg, v2-avg,...] * transpose([v1-avg,v2-avg,...])
  
  See Also:
  
  Constant Field Values
- CV_COVAR_USE_AVG
```
public static final int CV_COVAR_USE_AVG
```
  flag for cvCalcCovarMatrix, do not calc average (i.e. mean vector) - use the input vector instead (useful for calculating covariance matrix by parts)
  
  See Also:
  
  Constant Field Values
- CV_COVAR_SCALE
```
public static final int CV_COVAR_SCALE
```
  flag for cvCalcCovarMatrix, scale the covariance matrix coefficients by number of the vectors
  
  See Also:
  
  Constant Field Values
- CV_COVAR_ROWS
```
public static final int CV_COVAR_ROWS
```
  flag for cvCalcCovarMatrix, all the input vectors are stored in a single matrix, as its rows
  
  See Also:
  
  Constant Field Values
- CV_COVAR_COLS
```
public static final int CV_COVAR_COLS
```
  flag for cvCalcCovarMatrix, all the input vectors are stored in a single matrix, as its columns
  
  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
```
  \anchor core_c_NormFlags \name Flags for cvNorm and cvNormalize \{
  
  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
```
  \anchor core_c_ReduceFlags \name Flags for cvReduce \{
  
  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
```
  \anchor core_c_DftFlags \name Flags for cvDFT, cvDCT and cvMulSpectrums \{
  
  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
```
  divide result by size of array
  
  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
```
  transform each row individually
  
  See Also:
  
  Constant Field Values
- CV_DXT_MUL_CONJ
```
public static final int CV_DXT_MUL_CONJ
```
  conjugate the second argument of cvMulSpectrums
  
  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
```
  Retrieves index of a graph edge given its pointer
  
  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
```
  flags for graph vertices and edges
  
  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_KMEANS_USE_INITIAL_LABELS
```
public static final int CV_KMEANS_USE_INITIAL_LABELS
```
  The function implements the K-means algorithm for clustering an array of sample vectors in a specified number of classes
  
  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
```
  CV_FUNCNAME macro defines icvFuncName constant which is used by CV_ERROR macro
  
  See Also:
  
  Constant Field Values
- SORT_EVERY_ROW
```
public static final int SORT_EVERY_ROW
```
  enum cv::SortFlags
  
  See Also:
  
  Constant Field Values
- SORT_EVERY_COLUMN
```
public static final int SORT_EVERY_COLUMN
```
  enum cv::SortFlags
  
  See Also:
  
  Constant Field Values
- SORT_ASCENDING
```
public static final int SORT_ASCENDING
```
  enum cv::SortFlags
  
  See Also:
  
  Constant Field Values
- SORT_DESCENDING
```
public static final int SORT_DESCENDING
```
  enum cv::SortFlags
  
  See Also:
  
  Constant Field Values
- COVAR_SCRAMBLED
```
public static final int COVAR_SCRAMBLED
```
  enum cv::CovarFlags
  
  See Also:
  
  Constant Field Values
- COVAR_NORMAL
```
public static final int COVAR_NORMAL
```
  enum cv::CovarFlags
  
  See Also:
  
  Constant Field Values
- COVAR_USE_AVG
```
public static final int COVAR_USE_AVG
```
  enum cv::CovarFlags
  
  See Also:
  
  Constant Field Values
- COVAR_SCALE
```
public static final int COVAR_SCALE
```
  enum cv::CovarFlags
  
  See Also:
  
  Constant Field Values
- COVAR_ROWS
```
public static final int COVAR_ROWS
```
  enum cv::CovarFlags
  
  See Also:
  
  Constant Field Values
- COVAR_COLS
```
public static final int COVAR_COLS
```
  enum cv::CovarFlags
  
  See Also:
  
  Constant Field Values
- KMEANS_RANDOM_CENTERS
```
public static final int KMEANS_RANDOM_CENTERS
```
  enum cv::KmeansFlags
  
  See Also:
  
  Constant Field Values
- KMEANS_PP_CENTERS
```
public static final int KMEANS_PP_CENTERS
```
  enum cv::KmeansFlags
  
  See Also:
  
  Constant Field Values
- KMEANS_USE_INITIAL_LABELS
```
public static final int KMEANS_USE_INITIAL_LABELS
```
  enum cv::KmeansFlags
  
  See Also:
  
  Constant Field Values
- FILLED
```
public static final int FILLED
```
  enum cv::LineTypes
  
  See Also:
  
  Constant Field Values
- LINE_4
```
public static final int LINE_4
```
  enum cv::LineTypes
  
  See Also:
  
  Constant Field Values
- LINE_8
```
public static final int LINE_8
```
  enum cv::LineTypes
  
  See Also:
  
  Constant Field Values
- LINE_AA
```
public static final int LINE_AA
```
  enum cv::LineTypes
  
  See Also:
  
  Constant Field Values
- FONT_HERSHEY_SIMPLEX
```
public static final int FONT_HERSHEY_SIMPLEX
```
  enum cv::HersheyFonts
  
  See Also:
  
  Constant Field Values
- FONT_HERSHEY_PLAIN
```
public static final int FONT_HERSHEY_PLAIN
```
  enum cv::HersheyFonts
  
  See Also:
  
  Constant Field Values
- FONT_HERSHEY_DUPLEX
```
public static final int FONT_HERSHEY_DUPLEX
```
  enum cv::HersheyFonts
  
  See Also:
  
  Constant Field Values
- FONT_HERSHEY_COMPLEX
```
public static final int FONT_HERSHEY_COMPLEX
```
  enum cv::HersheyFonts
  
  See Also:
  
  Constant Field Values
- FONT_HERSHEY_TRIPLEX
```
public static final int FONT_HERSHEY_TRIPLEX
```
  enum cv::HersheyFonts
  
  See Also:
  
  Constant Field Values
- FONT_HERSHEY_COMPLEX_SMALL
```
public static final int FONT_HERSHEY_COMPLEX_SMALL
```
  enum cv::HersheyFonts
  
  See Also:
  
  Constant Field Values
- FONT_HERSHEY_SCRIPT_SIMPLEX
```
public static final int FONT_HERSHEY_SCRIPT_SIMPLEX
```
  enum cv::HersheyFonts
  
  See Also:
  
  Constant Field Values
- FONT_HERSHEY_SCRIPT_COMPLEX
```
public static final int FONT_HERSHEY_SCRIPT_COMPLEX
```
  enum cv::HersheyFonts
  
  See Also:
  
  Constant Field Values
- FONT_ITALIC
```
public static final int FONT_ITALIC
```
  enum cv::HersheyFonts
  
  See Also:
  
  Constant Field Values
- REDUCE_SUM
```
public static final int REDUCE_SUM
```
  enum cv::ReduceTypes
  
  See Also:
  
  Constant Field Values
- REDUCE_AVG
```
public static final int REDUCE_AVG
```
  enum cv::ReduceTypes
  
  See Also:
  
  Constant Field Values
- REDUCE_MAX
```
public static final int REDUCE_MAX
```
  enum cv::ReduceTypes
  
  See Also:
  
  Constant Field Values
- REDUCE_MIN
```
public static final int REDUCE_MIN
```
  enum cv::ReduceTypes
  
  See Also:
  
  Constant Field Values
- ROTATE_90_CLOCKWISE
```
public static final int ROTATE_90_CLOCKWISE
```
  enum cv::RotateFlags
  
  See Also:
  
  Constant Field Values
- ROTATE_180
```
public static final int ROTATE_180
```
  enum cv::RotateFlags
  
  See Also:
  
  Constant Field Values
- ROTATE_90_COUNTERCLOCKWISE
```
public static final int ROTATE_90_COUNTERCLOCKWISE
```
  enum cv::RotateFlags
  
  See Also:
  
  Constant Field Values
- FEATURE_SET_COMPUTE_10
```
public static final int FEATURE_SET_COMPUTE_10
```
  enum cv::cuda::FeatureSet
  
  See Also:
  
  Constant Field Values
- FEATURE_SET_COMPUTE_11
```
public static final int FEATURE_SET_COMPUTE_11
```
  enum cv::cuda::FeatureSet
  
  See Also:
  
  Constant Field Values
- FEATURE_SET_COMPUTE_12
```
public static final int FEATURE_SET_COMPUTE_12
```
  enum cv::cuda::FeatureSet
  
  See Also:
  
  Constant Field Values
- FEATURE_SET_COMPUTE_13
```
public static final int FEATURE_SET_COMPUTE_13
```
  enum cv::cuda::FeatureSet
  
  See Also:
  
  Constant Field Values
- FEATURE_SET_COMPUTE_20
```
public static final int FEATURE_SET_COMPUTE_20
```
  enum cv::cuda::FeatureSet
  
  See Also:
  
  Constant Field Values
- FEATURE_SET_COMPUTE_21
```
public static final int FEATURE_SET_COMPUTE_21
```
  enum cv::cuda::FeatureSet
  
  See Also:
  
  Constant Field Values
- FEATURE_SET_COMPUTE_30
```
public static final int FEATURE_SET_COMPUTE_30
```
  enum cv::cuda::FeatureSet
  
  See Also:
  
  Constant Field Values
- FEATURE_SET_COMPUTE_32
```
public static final int FEATURE_SET_COMPUTE_32
```
  enum cv::cuda::FeatureSet
  
  See Also:
  
  Constant Field Values
- FEATURE_SET_COMPUTE_35
```
public static final int FEATURE_SET_COMPUTE_35
```
  enum cv::cuda::FeatureSet
  
  See Also:
  
  Constant Field Values
- FEATURE_SET_COMPUTE_50
```
public static final int FEATURE_SET_COMPUTE_50
```
  enum cv::cuda::FeatureSet
  
  See Also:
  
  Constant Field Values
- GLOBAL_ATOMICS
```
public static final int GLOBAL_ATOMICS
```
  enum cv::cuda::FeatureSet
  
  See Also:
  
  Constant Field Values
- SHARED_ATOMICS
```
public static final int SHARED_ATOMICS
```
  enum cv::cuda::FeatureSet
  
  See Also:
  
  Constant Field Values
- NATIVE_DOUBLE
```
public static final int NATIVE_DOUBLE
```
  enum cv::cuda::FeatureSet
  
  See Also:
  
  Constant Field Values
- WARP_SHUFFLE_FUNCTIONS
```
public static final int WARP_SHUFFLE_FUNCTIONS
```
  enum cv::cuda::FeatureSet
  
  See Also:
  
  Constant Field Values
- DYNAMIC_PARALLELISM
```
public static final int DYNAMIC_PARALLELISM
```
  enum cv::cuda::FeatureSet
  
  See Also:
  
  Constant Field Values
- OCL_VECTOR_OWN
```
public static final int OCL_VECTOR_OWN
```
  enum cv::ocl::OclVectorStrategy
  
  See Also:
  
  Constant Field Values
- OCL_VECTOR_MAX
```
public static final int OCL_VECTOR_MAX
```
  enum cv::ocl::OclVectorStrategy
  
  See Also:
  
  Constant Field Values
- OCL_VECTOR_DEFAULT
```
public static final int OCL_VECTOR_DEFAULT
```
  enum cv::ocl::OclVectorStrategy
  
  See Also:
  
  Constant Field Values
- ACCESS_READ
```
public static final int ACCESS_READ
```
  enum cv::
  
  See Also:
  
  Constant Field Values
- ACCESS_WRITE
```
public static final int ACCESS_WRITE
```
  enum cv::
  
  See Also:
  
  Constant Field Values
- ACCESS_RW
```
public static final int ACCESS_RW
```
  enum cv::
  
  See Also:
  
  Constant Field Values
- ACCESS_MASK
```
public static final int ACCESS_MASK
```
  enum cv::
  
  See Also:
  
  Constant Field Values
- ACCESS_FAST
```
public static final int ACCESS_FAST
```
  enum cv::
  
  See Also:
  
  Constant Field Values
- USAGE_DEFAULT
```
public static final int USAGE_DEFAULT
```
  enum cv::UMatUsageFlags
  
  See Also:
  
  Constant Field Values
- USAGE_ALLOCATE_HOST_MEMORY
```
public static final int USAGE_ALLOCATE_HOST_MEMORY
```
  enum cv::UMatUsageFlags
  
  See Also:
  
  Constant Field Values
- USAGE_ALLOCATE_DEVICE_MEMORY
```
public static final int USAGE_ALLOCATE_DEVICE_MEMORY
```
  enum cv::UMatUsageFlags
  
  See Also:
  
  Constant Field Values
- USAGE_ALLOCATE_SHARED_MEMORY
```
public static final int USAGE_ALLOCATE_SHARED_MEMORY
```
  enum cv::UMatUsageFlags
  
  See Also:
  
  Constant Field Values
- __UMAT_USAGE_FLAGS_32BIT
```
public static final int __UMAT_USAGE_FLAGS_32BIT
```
  enum cv::UMatUsageFlags
  
  See Also:
  
  Constant Field Values
- SOLVELP_UNBOUNDED
```
public static final int SOLVELP_UNBOUNDED
```
  enum cv::SolveLPResult
  
  See Also:
  
  Constant Field Values
- SOLVELP_UNFEASIBLE
```
public static final int SOLVELP_UNFEASIBLE
```
  enum cv::SolveLPResult
  
  See Also:
  
  Constant Field Values
- SOLVELP_SINGLE
```
public static final int SOLVELP_SINGLE
```
  enum cv::SolveLPResult
  
  See Also:
  
  Constant Field Values
- SOLVELP_MULTI
```
public static final int SOLVELP_MULTI
```
  enum cv::SolveLPResult
  
  See Also:
  
  Constant Field Values

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

Method Detail

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_FP16_TYPE

@MemberGetter
public static int CV_FP16_TYPE()

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)

normHamming

@Namespace(value="cv::hal")
public static int normHamming(@Cast(value="const uchar*")
                                                          org.bytedeco.javacpp.BytePointer a,
                                                          int n)

\addtogroup core_hal_functions \{

normHamming

@Namespace(value="cv::hal")
public static int normHamming(@Cast(value="const uchar*")
                                                          ByteBuffer a,
                                                          int n)

normHamming

@Namespace(value="cv::hal")
public static int normHamming(@Cast(value="const uchar*")
                                                          byte[] a,
                                                          int n)

normHamming

@Namespace(value="cv::hal")
public static int normHamming(@Cast(value="const uchar*")
                                                          org.bytedeco.javacpp.BytePointer a,
                                                          @Cast(value="const uchar*")
                                                          org.bytedeco.javacpp.BytePointer b,
                                                          int n)

normHamming

@Namespace(value="cv::hal")
public static int normHamming(@Cast(value="const uchar*")
                                                          ByteBuffer a,
                                                          @Cast(value="const uchar*")
                                                          ByteBuffer b,
                                                          int n)

normHamming

@Namespace(value="cv::hal")
public static int normHamming(@Cast(value="const uchar*")
                                                          byte[] a,
                                                          @Cast(value="const uchar*")
                                                          byte[] b,
                                                          int n)

normHamming

@Namespace(value="cv::hal")
public static int normHamming(@Cast(value="const uchar*")
                                                          org.bytedeco.javacpp.BytePointer a,
                                                          int n,
                                                          int cellSize)

normHamming

@Namespace(value="cv::hal")
public static int normHamming(@Cast(value="const uchar*")
                                                          ByteBuffer a,
                                                          int n,
                                                          int cellSize)

normHamming

@Namespace(value="cv::hal")
public static int normHamming(@Cast(value="const uchar*")
                                                          byte[] a,
                                                          int n,
                                                          int cellSize)

normHamming

@Namespace(value="cv::hal")
public static int normHamming(@Cast(value="const uchar*")
                                                          org.bytedeco.javacpp.BytePointer a,
                                                          @Cast(value="const uchar*")
                                                          org.bytedeco.javacpp.BytePointer b,
                                                          int n,
                                                          int cellSize)

normHamming

@Namespace(value="cv::hal")
public static int normHamming(@Cast(value="const uchar*")
                                                          ByteBuffer a,
                                                          @Cast(value="const uchar*")
                                                          ByteBuffer b,
                                                          int n,
                                                          int cellSize)

normHamming

@Namespace(value="cv::hal")
public static int normHamming(@Cast(value="const uchar*")
                                                          byte[] a,
                                                          @Cast(value="const uchar*")
                                                          byte[] b,
                                                          int n,
                                                          int cellSize)

LU32f

@Namespace(value="cv::hal")
public static int LU32f(org.bytedeco.javacpp.FloatPointer A,
                                                    @Cast(value="size_t")
                                                    long astep,
                                                    int m,
                                                    org.bytedeco.javacpp.FloatPointer b,
                                                    @Cast(value="size_t")
                                                    long bstep,
                                                    int n)

LU32f

@Namespace(value="cv::hal")
public static int LU32f(FloatBuffer A,
                                                    @Cast(value="size_t")
                                                    long astep,
                                                    int m,
                                                    FloatBuffer b,
                                                    @Cast(value="size_t")
                                                    long bstep,
                                                    int n)

LU32f

@Namespace(value="cv::hal")
public static int LU32f(float[] A,
                                                    @Cast(value="size_t")
                                                    long astep,
                                                    int m,
                                                    float[] b,
                                                    @Cast(value="size_t")
                                                    long bstep,
                                                    int n)

LU64f

@Namespace(value="cv::hal")
public static int LU64f(org.bytedeco.javacpp.DoublePointer A,
                                                    @Cast(value="size_t")
                                                    long astep,
                                                    int m,
                                                    org.bytedeco.javacpp.DoublePointer b,
                                                    @Cast(value="size_t")
                                                    long bstep,
                                                    int n)

LU64f

@Namespace(value="cv::hal")
public static int LU64f(DoubleBuffer A,
                                                    @Cast(value="size_t")
                                                    long astep,
                                                    int m,
                                                    DoubleBuffer b,
                                                    @Cast(value="size_t")
                                                    long bstep,
                                                    int n)

LU64f

@Namespace(value="cv::hal")
public static int LU64f(double[] A,
                                                    @Cast(value="size_t")
                                                    long astep,
                                                    int m,
                                                    double[] b,
                                                    @Cast(value="size_t")
                                                    long bstep,
                                                    int n)

Cholesky32f

@Namespace(value="cv::hal")
 @Cast(value="bool")
public static boolean Cholesky32f(org.bytedeco.javacpp.FloatPointer A,
                                                                                   @Cast(value="size_t")
                                                                                   long astep,
                                                                                   int m,
                                                                                   org.bytedeco.javacpp.FloatPointer b,
                                                                                   @Cast(value="size_t")
                                                                                   long bstep,
                                                                                   int n)

Cholesky32f

@Namespace(value="cv::hal")
 @Cast(value="bool")
public static boolean Cholesky32f(FloatBuffer A,
                                                                                   @Cast(value="size_t")
                                                                                   long astep,
                                                                                   int m,
                                                                                   FloatBuffer b,
                                                                                   @Cast(value="size_t")
                                                                                   long bstep,
                                                                                   int n)

Cholesky32f

@Namespace(value="cv::hal")
 @Cast(value="bool")
public static boolean Cholesky32f(float[] A,
                                                                                   @Cast(value="size_t")
                                                                                   long astep,
                                                                                   int m,
                                                                                   float[] b,
                                                                                   @Cast(value="size_t")
                                                                                   long bstep,
                                                                                   int n)

Cholesky64f

@Namespace(value="cv::hal")
 @Cast(value="bool")
public static boolean Cholesky64f(org.bytedeco.javacpp.DoublePointer A,
                                                                                   @Cast(value="size_t")
                                                                                   long astep,
                                                                                   int m,
                                                                                   org.bytedeco.javacpp.DoublePointer b,
                                                                                   @Cast(value="size_t")
                                                                                   long bstep,
                                                                                   int n)

Cholesky64f

@Namespace(value="cv::hal")
 @Cast(value="bool")
public static boolean Cholesky64f(DoubleBuffer A,
                                                                                   @Cast(value="size_t")
                                                                                   long astep,
                                                                                   int m,
                                                                                   DoubleBuffer b,
                                                                                   @Cast(value="size_t")
                                                                                   long bstep,
                                                                                   int n)

Cholesky64f

@Namespace(value="cv::hal")
 @Cast(value="bool")
public static boolean Cholesky64f(double[] A,
                                                                                   @Cast(value="size_t")
                                                                                   long astep,
                                                                                   int m,
                                                                                   double[] b,
                                                                                   @Cast(value="size_t")
                                                                                   long bstep,
                                                                                   int n)

SVD32f

@Namespace(value="cv::hal")
public static void SVD32f(org.bytedeco.javacpp.FloatPointer At,
                                                      @Cast(value="size_t")
                                                      long astep,
                                                      org.bytedeco.javacpp.FloatPointer W,
                                                      org.bytedeco.javacpp.FloatPointer U,
                                                      @Cast(value="size_t")
                                                      long ustep,
                                                      org.bytedeco.javacpp.FloatPointer Vt,
                                                      @Cast(value="size_t")
                                                      long vstep,
                                                      int m,
                                                      int n,
                                                      int flags)

SVD32f

@Namespace(value="cv::hal")
public static void SVD32f(FloatBuffer At,
                                                      @Cast(value="size_t")
                                                      long astep,
                                                      FloatBuffer W,
                                                      FloatBuffer U,
                                                      @Cast(value="size_t")
                                                      long ustep,
                                                      FloatBuffer Vt,
                                                      @Cast(value="size_t")
                                                      long vstep,
                                                      int m,
                                                      int n,
                                                      int flags)

SVD32f

@Namespace(value="cv::hal")
public static void SVD32f(float[] At,
                                                      @Cast(value="size_t")
                                                      long astep,
                                                      float[] W,
                                                      float[] U,
                                                      @Cast(value="size_t")
                                                      long ustep,
                                                      float[] Vt,
                                                      @Cast(value="size_t")
                                                      long vstep,
                                                      int m,
                                                      int n,
                                                      int flags)

SVD64f

@Namespace(value="cv::hal")
public static void SVD64f(org.bytedeco.javacpp.DoublePointer At,
                                                      @Cast(value="size_t")
                                                      long astep,
                                                      org.bytedeco.javacpp.DoublePointer W,
                                                      org.bytedeco.javacpp.DoublePointer U,
                                                      @Cast(value="size_t")
                                                      long ustep,
                                                      org.bytedeco.javacpp.DoublePointer Vt,
                                                      @Cast(value="size_t")
                                                      long vstep,
                                                      int m,
                                                      int n,
                                                      int flags)

SVD64f

@Namespace(value="cv::hal")
public static void SVD64f(DoubleBuffer At,
                                                      @Cast(value="size_t")
                                                      long astep,
                                                      DoubleBuffer W,
                                                      DoubleBuffer U,
                                                      @Cast(value="size_t")
                                                      long ustep,
                                                      DoubleBuffer Vt,
                                                      @Cast(value="size_t")
                                                      long vstep,
                                                      int m,
                                                      int n,
                                                      int flags)

SVD64f

@Namespace(value="cv::hal")
public static void SVD64f(double[] At,
                                                      @Cast(value="size_t")
                                                      long astep,
                                                      double[] W,
                                                      double[] U,
                                                      @Cast(value="size_t")
                                                      long ustep,
                                                      double[] Vt,
                                                      @Cast(value="size_t")
                                                      long vstep,
                                                      int m,
                                                      int n,
                                                      int flags)

QR32f

@Namespace(value="cv::hal")
public static int QR32f(org.bytedeco.javacpp.FloatPointer A,
                                                    @Cast(value="size_t")
                                                    long astep,
                                                    int m,
                                                    int n,
                                                    int k,
                                                    org.bytedeco.javacpp.FloatPointer b,
                                                    @Cast(value="size_t")
                                                    long bstep,
                                                    org.bytedeco.javacpp.FloatPointer hFactors)

QR32f

@Namespace(value="cv::hal")
public static int QR32f(FloatBuffer A,
                                                    @Cast(value="size_t")
                                                    long astep,
                                                    int m,
                                                    int n,
                                                    int k,
                                                    FloatBuffer b,
                                                    @Cast(value="size_t")
                                                    long bstep,
                                                    FloatBuffer hFactors)

QR32f

@Namespace(value="cv::hal")
public static int QR32f(float[] A,
                                                    @Cast(value="size_t")
                                                    long astep,
                                                    int m,
                                                    int n,
                                                    int k,
                                                    float[] b,
                                                    @Cast(value="size_t")
                                                    long bstep,
                                                    float[] hFactors)

QR64f

@Namespace(value="cv::hal")
public static int QR64f(org.bytedeco.javacpp.DoublePointer A,
                                                    @Cast(value="size_t")
                                                    long astep,
                                                    int m,
                                                    int n,
                                                    int k,
                                                    org.bytedeco.javacpp.DoublePointer b,
                                                    @Cast(value="size_t")
                                                    long bstep,
                                                    org.bytedeco.javacpp.DoublePointer hFactors)

QR64f

@Namespace(value="cv::hal")
public static int QR64f(DoubleBuffer A,
                                                    @Cast(value="size_t")
                                                    long astep,
                                                    int m,
                                                    int n,
                                                    int k,
                                                    DoubleBuffer b,
                                                    @Cast(value="size_t")
                                                    long bstep,
                                                    DoubleBuffer hFactors)

QR64f

@Namespace(value="cv::hal")
public static int QR64f(double[] A,
                                                    @Cast(value="size_t")
                                                    long astep,
                                                    int m,
                                                    int n,
                                                    int k,
                                                    double[] b,
                                                    @Cast(value="size_t")
                                                    long bstep,
                                                    double[] hFactors)

gemm32f

@Namespace(value="cv::hal")
public static void gemm32f(@Const
                                                       org.bytedeco.javacpp.FloatPointer src1,
                                                       @Cast(value="size_t")
                                                       long src1_step,
                                                       @Const
                                                       org.bytedeco.javacpp.FloatPointer src2,
                                                       @Cast(value="size_t")
                                                       long src2_step,
                                                       float alpha,
                                                       @Const
                                                       org.bytedeco.javacpp.FloatPointer src3,
                                                       @Cast(value="size_t")
                                                       long src3_step,
                                                       float beta,
                                                       org.bytedeco.javacpp.FloatPointer dst,
                                                       @Cast(value="size_t")
                                                       long dst_step,
                                                       int m_a,
                                                       int n_a,
                                                       int n_d,
                                                       int flags)

gemm32f

@Namespace(value="cv::hal")
public static void gemm32f(@Const
                                                       FloatBuffer src1,
                                                       @Cast(value="size_t")
                                                       long src1_step,
                                                       @Const
                                                       FloatBuffer src2,
                                                       @Cast(value="size_t")
                                                       long src2_step,
                                                       float alpha,
                                                       @Const
                                                       FloatBuffer src3,
                                                       @Cast(value="size_t")
                                                       long src3_step,
                                                       float beta,
                                                       FloatBuffer dst,
                                                       @Cast(value="size_t")
                                                       long dst_step,
                                                       int m_a,
                                                       int n_a,
                                                       int n_d,
                                                       int flags)

gemm32f

@Namespace(value="cv::hal")
public static void gemm32f(@Const
                                                       float[] src1,
                                                       @Cast(value="size_t")
                                                       long src1_step,
                                                       @Const
                                                       float[] src2,
                                                       @Cast(value="size_t")
                                                       long src2_step,
                                                       float alpha,
                                                       @Const
                                                       float[] src3,
                                                       @Cast(value="size_t")
                                                       long src3_step,
                                                       float beta,
                                                       float[] dst,
                                                       @Cast(value="size_t")
                                                       long dst_step,
                                                       int m_a,
                                                       int n_a,
                                                       int n_d,
                                                       int flags)

gemm64f

@Namespace(value="cv::hal")
public static void gemm64f(@Const
                                                       org.bytedeco.javacpp.DoublePointer src1,
                                                       @Cast(value="size_t")
                                                       long src1_step,
                                                       @Const
                                                       org.bytedeco.javacpp.DoublePointer src2,
                                                       @Cast(value="size_t")
                                                       long src2_step,
                                                       double alpha,
                                                       @Const
                                                       org.bytedeco.javacpp.DoublePointer src3,
                                                       @Cast(value="size_t")
                                                       long src3_step,
                                                       double beta,
                                                       org.bytedeco.javacpp.DoublePointer dst,
                                                       @Cast(value="size_t")
                                                       long dst_step,
                                                       int m_a,
                                                       int n_a,
                                                       int n_d,
                                                       int flags)

gemm64f

@Namespace(value="cv::hal")
public static void gemm64f(@Const
                                                       DoubleBuffer src1,
                                                       @Cast(value="size_t")
                                                       long src1_step,
                                                       @Const
                                                       DoubleBuffer src2,
                                                       @Cast(value="size_t")
                                                       long src2_step,
                                                       double alpha,
                                                       @Const
                                                       DoubleBuffer src3,
                                                       @Cast(value="size_t")
                                                       long src3_step,
                                                       double beta,
                                                       DoubleBuffer dst,
                                                       @Cast(value="size_t")
                                                       long dst_step,
                                                       int m_a,
                                                       int n_a,
                                                       int n_d,
                                                       int flags)

gemm64f

@Namespace(value="cv::hal")
public static void gemm64f(@Const
                                                       double[] src1,
                                                       @Cast(value="size_t")
                                                       long src1_step,
                                                       @Const
                                                       double[] src2,
                                                       @Cast(value="size_t")
                                                       long src2_step,
                                                       double alpha,
                                                       @Const
                                                       double[] src3,
                                                       @Cast(value="size_t")
                                                       long src3_step,
                                                       double beta,
                                                       double[] dst,
                                                       @Cast(value="size_t")
                                                       long dst_step,
                                                       int m_a,
                                                       int n_a,
                                                       int n_d,
                                                       int flags)

gemm32fc

@Namespace(value="cv::hal")
public static void gemm32fc(@Const
                                                        org.bytedeco.javacpp.FloatPointer src1,
                                                        @Cast(value="size_t")
                                                        long src1_step,
                                                        @Const
                                                        org.bytedeco.javacpp.FloatPointer src2,
                                                        @Cast(value="size_t")
                                                        long src2_step,
                                                        float alpha,
                                                        @Const
                                                        org.bytedeco.javacpp.FloatPointer src3,
                                                        @Cast(value="size_t")
                                                        long src3_step,
                                                        float beta,
                                                        org.bytedeco.javacpp.FloatPointer dst,
                                                        @Cast(value="size_t")
                                                        long dst_step,
                                                        int m_a,
                                                        int n_a,
                                                        int n_d,
                                                        int flags)

gemm32fc

@Namespace(value="cv::hal")
public static void gemm32fc(@Const
                                                        FloatBuffer src1,
                                                        @Cast(value="size_t")
                                                        long src1_step,
                                                        @Const
                                                        FloatBuffer src2,
                                                        @Cast(value="size_t")
                                                        long src2_step,
                                                        float alpha,
                                                        @Const
                                                        FloatBuffer src3,
                                                        @Cast(value="size_t")
                                                        long src3_step,
                                                        float beta,
                                                        FloatBuffer dst,
                                                        @Cast(value="size_t")
                                                        long dst_step,
                                                        int m_a,
                                                        int n_a,
                                                        int n_d,
                                                        int flags)

gemm32fc

@Namespace(value="cv::hal")
public static void gemm32fc(@Const
                                                        float[] src1,
                                                        @Cast(value="size_t")
                                                        long src1_step,
                                                        @Const
                                                        float[] src2,
                                                        @Cast(value="size_t")
                                                        long src2_step,
                                                        float alpha,
                                                        @Const
                                                        float[] src3,
                                                        @Cast(value="size_t")
                                                        long src3_step,
                                                        float beta,
                                                        float[] dst,
                                                        @Cast(value="size_t")
                                                        long dst_step,
                                                        int m_a,
                                                        int n_a,
                                                        int n_d,
                                                        int flags)

gemm64fc

@Namespace(value="cv::hal")
public static void gemm64fc(@Const
                                                        org.bytedeco.javacpp.DoublePointer src1,
                                                        @Cast(value="size_t")
                                                        long src1_step,
                                                        @Const
                                                        org.bytedeco.javacpp.DoublePointer src2,
                                                        @Cast(value="size_t")
                                                        long src2_step,
                                                        double alpha,
                                                        @Const
                                                        org.bytedeco.javacpp.DoublePointer src3,
                                                        @Cast(value="size_t")
                                                        long src3_step,
                                                        double beta,
                                                        org.bytedeco.javacpp.DoublePointer dst,
                                                        @Cast(value="size_t")
                                                        long dst_step,
                                                        int m_a,
                                                        int n_a,
                                                        int n_d,
                                                        int flags)

gemm64fc

@Namespace(value="cv::hal")
public static void gemm64fc(@Const
                                                        DoubleBuffer src1,
                                                        @Cast(value="size_t")
                                                        long src1_step,
                                                        @Const
                                                        DoubleBuffer src2,
                                                        @Cast(value="size_t")
                                                        long src2_step,
                                                        double alpha,
                                                        @Const
                                                        DoubleBuffer src3,
                                                        @Cast(value="size_t")
                                                        long src3_step,
                                                        double beta,
                                                        DoubleBuffer dst,
                                                        @Cast(value="size_t")
                                                        long dst_step,
                                                        int m_a,
                                                        int n_a,
                                                        int n_d,
                                                        int flags)

gemm64fc

@Namespace(value="cv::hal")
public static void gemm64fc(@Const
                                                        double[] src1,
                                                        @Cast(value="size_t")
                                                        long src1_step,
                                                        @Const
                                                        double[] src2,
                                                        @Cast(value="size_t")
                                                        long src2_step,
                                                        double alpha,
                                                        @Const
                                                        double[] src3,
                                                        @Cast(value="size_t")
                                                        long src3_step,
                                                        double beta,
                                                        double[] dst,
                                                        @Cast(value="size_t")
                                                        long dst_step,
                                                        int m_a,
                                                        int n_a,
                                                        int n_d,
                                                        int flags)

normL1_

@Namespace(value="cv::hal")
public static int normL1_(@Cast(value="const uchar*")
                                                      org.bytedeco.javacpp.BytePointer a,
                                                      @Cast(value="const uchar*")
                                                      org.bytedeco.javacpp.BytePointer b,
                                                      int n)

normL1_

@Namespace(value="cv::hal")
public static int normL1_(@Cast(value="const uchar*")
                                                      ByteBuffer a,
                                                      @Cast(value="const uchar*")
                                                      ByteBuffer b,
                                                      int n)

normL1_

@Namespace(value="cv::hal")
public static int normL1_(@Cast(value="const uchar*")
                                                      byte[] a,
                                                      @Cast(value="const uchar*")
                                                      byte[] b,
                                                      int n)

normL1_

@Namespace(value="cv::hal")
public static float normL1_(@Const
                                                        org.bytedeco.javacpp.FloatPointer a,
                                                        @Const
                                                        org.bytedeco.javacpp.FloatPointer b,
                                                        int n)

normL1_

@Namespace(value="cv::hal")
public static float normL1_(@Const
                                                        FloatBuffer a,
                                                        @Const
                                                        FloatBuffer b,
                                                        int n)

normL1_

@Namespace(value="cv::hal")
public static float normL1_(@Const
                                                        float[] a,
                                                        @Const
                                                        float[] b,
                                                        int n)

normL2Sqr_

@Namespace(value="cv::hal")
public static float normL2Sqr_(@Const
                                                           org.bytedeco.javacpp.FloatPointer a,
                                                           @Const
                                                           org.bytedeco.javacpp.FloatPointer b,
                                                           int n)

normL2Sqr_

@Namespace(value="cv::hal")
public static float normL2Sqr_(@Const
                                                           FloatBuffer a,
                                                           @Const
                                                           FloatBuffer b,
                                                           int n)

normL2Sqr_

@Namespace(value="cv::hal")
public static float normL2Sqr_(@Const
                                                           float[] a,
                                                           @Const
                                                           float[] b,
                                                           int n)

exp32f

@Namespace(value="cv::hal")
public static void exp32f(@Const
                                                      org.bytedeco.javacpp.FloatPointer src,
                                                      org.bytedeco.javacpp.FloatPointer dst,
                                                      int n)

exp32f

@Namespace(value="cv::hal")
public static void exp32f(@Const
                                                      FloatBuffer src,
                                                      FloatBuffer dst,
                                                      int n)

exp32f

@Namespace(value="cv::hal")
public static void exp32f(@Const
                                                      float[] src,
                                                      float[] dst,
                                                      int n)

exp64f

@Namespace(value="cv::hal")
public static void exp64f(@Const
                                                      org.bytedeco.javacpp.DoublePointer src,
                                                      org.bytedeco.javacpp.DoublePointer dst,
                                                      int n)

exp64f

@Namespace(value="cv::hal")
public static void exp64f(@Const
                                                      DoubleBuffer src,
                                                      DoubleBuffer dst,
                                                      int n)

exp64f

@Namespace(value="cv::hal")
public static void exp64f(@Const
                                                      double[] src,
                                                      double[] dst,
                                                      int n)

log32f

@Namespace(value="cv::hal")
public static void log32f(@Const
                                                      org.bytedeco.javacpp.FloatPointer src,
                                                      org.bytedeco.javacpp.FloatPointer dst,
                                                      int n)

log32f

@Namespace(value="cv::hal")
public static void log32f(@Const
                                                      FloatBuffer src,
                                                      FloatBuffer dst,
                                                      int n)

log32f

@Namespace(value="cv::hal")
public static void log32f(@Const
                                                      float[] src,
                                                      float[] dst,
                                                      int n)

log64f

@Namespace(value="cv::hal")
public static void log64f(@Const
                                                      org.bytedeco.javacpp.DoublePointer src,
                                                      org.bytedeco.javacpp.DoublePointer dst,
                                                      int n)

log64f

@Namespace(value="cv::hal")
public static void log64f(@Const
                                                      DoubleBuffer src,
                                                      DoubleBuffer dst,
                                                      int n)

log64f

@Namespace(value="cv::hal")
public static void log64f(@Const
                                                      double[] src,
                                                      double[] dst,
                                                      int n)

fastAtan32f

@Namespace(value="cv::hal")
public static void fastAtan32f(@Const
                                                           org.bytedeco.javacpp.FloatPointer y,
                                                           @Const
                                                           org.bytedeco.javacpp.FloatPointer x,
                                                           org.bytedeco.javacpp.FloatPointer dst,
                                                           int n,
                                                           @Cast(value="bool")
                                                           boolean angleInDegrees)

fastAtan32f

@Namespace(value="cv::hal")
public static void fastAtan32f(@Const
                                                           FloatBuffer y,
                                                           @Const
                                                           FloatBuffer x,
                                                           FloatBuffer dst,
                                                           int n,
                                                           @Cast(value="bool")
                                                           boolean angleInDegrees)

fastAtan32f

@Namespace(value="cv::hal")
public static void fastAtan32f(@Const
                                                           float[] y,
                                                           @Const
                                                           float[] x,
                                                           float[] dst,
                                                           int n,
                                                           @Cast(value="bool")
                                                           boolean angleInDegrees)

fastAtan64f

@Namespace(value="cv::hal")
public static void fastAtan64f(@Const
                                                           org.bytedeco.javacpp.DoublePointer y,
                                                           @Const
                                                           org.bytedeco.javacpp.DoublePointer x,
                                                           org.bytedeco.javacpp.DoublePointer dst,
                                                           int n,
                                                           @Cast(value="bool")
                                                           boolean angleInDegrees)

fastAtan64f

@Namespace(value="cv::hal")
public static void fastAtan64f(@Const
                                                           DoubleBuffer y,
                                                           @Const
                                                           DoubleBuffer x,
                                                           DoubleBuffer dst,
                                                           int n,
                                                           @Cast(value="bool")
                                                           boolean angleInDegrees)

fastAtan64f

@Namespace(value="cv::hal")
public static void fastAtan64f(@Const
                                                           double[] y,
                                                           @Const
                                                           double[] x,
                                                           double[] dst,
                                                           int n,
                                                           @Cast(value="bool")
                                                           boolean angleInDegrees)

magnitude32f

@Namespace(value="cv::hal")
public static void magnitude32f(@Const
                                                            org.bytedeco.javacpp.FloatPointer x,
                                                            @Const
                                                            org.bytedeco.javacpp.FloatPointer y,
                                                            org.bytedeco.javacpp.FloatPointer dst,
                                                            int n)

magnitude32f

@Namespace(value="cv::hal")
public static void magnitude32f(@Const
                                                            FloatBuffer x,
                                                            @Const
                                                            FloatBuffer y,
                                                            FloatBuffer dst,
                                                            int n)

magnitude32f

@Namespace(value="cv::hal")
public static void magnitude32f(@Const
                                                            float[] x,
                                                            @Const
                                                            float[] y,
                                                            float[] dst,
                                                            int n)

magnitude64f

@Namespace(value="cv::hal")
public static void magnitude64f(@Const
                                                            org.bytedeco.javacpp.DoublePointer x,
                                                            @Const
                                                            org.bytedeco.javacpp.DoublePointer y,
                                                            org.bytedeco.javacpp.DoublePointer dst,
                                                            int n)

magnitude64f

@Namespace(value="cv::hal")
public static void magnitude64f(@Const
                                                            DoubleBuffer x,
                                                            @Const
                                                            DoubleBuffer y,
                                                            DoubleBuffer dst,
                                                            int n)

magnitude64f

@Namespace(value="cv::hal")
public static void magnitude64f(@Const
                                                            double[] x,
                                                            @Const
                                                            double[] y,
                                                            double[] dst,
                                                            int n)

sqrt32f

@Namespace(value="cv::hal")
public static void sqrt32f(@Const
                                                       org.bytedeco.javacpp.FloatPointer src,
                                                       org.bytedeco.javacpp.FloatPointer dst,
                                                       int len)

sqrt32f

@Namespace(value="cv::hal")
public static void sqrt32f(@Const
                                                       FloatBuffer src,
                                                       FloatBuffer dst,
                                                       int len)

sqrt32f

@Namespace(value="cv::hal")
public static void sqrt32f(@Const
                                                       float[] src,
                                                       float[] dst,
                                                       int len)

sqrt64f

@Namespace(value="cv::hal")
public static void sqrt64f(@Const
                                                       org.bytedeco.javacpp.DoublePointer src,
                                                       org.bytedeco.javacpp.DoublePointer dst,
                                                       int len)

sqrt64f

@Namespace(value="cv::hal")
public static void sqrt64f(@Const
                                                       DoubleBuffer src,
                                                       DoubleBuffer dst,
                                                       int len)

sqrt64f

@Namespace(value="cv::hal")
public static void sqrt64f(@Const
                                                       double[] src,
                                                       double[] dst,
                                                       int len)

invSqrt32f

@Namespace(value="cv::hal")
public static void invSqrt32f(@Const
                                                          org.bytedeco.javacpp.FloatPointer src,
                                                          org.bytedeco.javacpp.FloatPointer dst,
                                                          int len)

invSqrt32f

@Namespace(value="cv::hal")
public static void invSqrt32f(@Const
                                                          FloatBuffer src,
                                                          FloatBuffer dst,
                                                          int len)

invSqrt32f

@Namespace(value="cv::hal")
public static void invSqrt32f(@Const
                                                          float[] src,
                                                          float[] dst,
                                                          int len)

invSqrt64f

@Namespace(value="cv::hal")
public static void invSqrt64f(@Const
                                                          org.bytedeco.javacpp.DoublePointer src,
                                                          org.bytedeco.javacpp.DoublePointer dst,
                                                          int len)

invSqrt64f

@Namespace(value="cv::hal")
public static void invSqrt64f(@Const
                                                          DoubleBuffer src,
                                                          DoubleBuffer dst,
                                                          int len)

invSqrt64f

@Namespace(value="cv::hal")
public static void invSqrt64f(@Const
                                                          double[] src,
                                                          double[] dst,
                                                          int len)

split8u

@Namespace(value="cv::hal")
public static void split8u(@Cast(value="const uchar*")
                                                       org.bytedeco.javacpp.BytePointer src,
                                                       @Cast(value="uchar**")
                                                       org.bytedeco.javacpp.PointerPointer dst,
                                                       int len,
                                                       int cn)

split8u

@Namespace(value="cv::hal")
public static void split8u(@Cast(value="const uchar*")
                                                       org.bytedeco.javacpp.BytePointer src,
                                                       @Cast(value="uchar**") @ByPtrPtr
                                                       org.bytedeco.javacpp.BytePointer dst,
                                                       int len,
                                                       int cn)

split8u

@Namespace(value="cv::hal")
public static void split8u(@Cast(value="const uchar*")
                                                       ByteBuffer src,
                                                       @Cast(value="uchar**") @ByPtrPtr
                                                       ByteBuffer dst,
                                                       int len,
                                                       int cn)

split8u

@Namespace(value="cv::hal")
public static void split8u(@Cast(value="const uchar*")
                                                       byte[] src,
                                                       @Cast(value="uchar**") @ByPtrPtr
                                                       byte[] dst,
                                                       int len,
                                                       int cn)

split16u

@Namespace(value="cv::hal")
public static void split16u(@Cast(value="const ushort*")
                                                        org.bytedeco.javacpp.ShortPointer src,
                                                        @Cast(value="ushort**")
                                                        org.bytedeco.javacpp.PointerPointer dst,
                                                        int len,
                                                        int cn)

split16u

@Namespace(value="cv::hal")
public static void split16u(@Cast(value="const ushort*")
                                                        org.bytedeco.javacpp.ShortPointer src,
                                                        @Cast(value="ushort**") @ByPtrPtr
                                                        org.bytedeco.javacpp.ShortPointer dst,
                                                        int len,
                                                        int cn)

split16u

@Namespace(value="cv::hal")
public static void split16u(@Cast(value="const ushort*")
                                                        ShortBuffer src,
                                                        @Cast(value="ushort**") @ByPtrPtr
                                                        ShortBuffer dst,
                                                        int len,
                                                        int cn)

split16u

@Namespace(value="cv::hal")
public static void split16u(@Cast(value="const ushort*")
                                                        short[] src,
                                                        @Cast(value="ushort**") @ByPtrPtr
                                                        short[] dst,
                                                        int len,
                                                        int cn)

split32s

@Namespace(value="cv::hal")
public static void split32s(@Const
                                                        org.bytedeco.javacpp.IntPointer src,
                                                        @Cast(value="int**")
                                                        org.bytedeco.javacpp.PointerPointer dst,
                                                        int len,
                                                        int cn)

split32s

@Namespace(value="cv::hal")
public static void split32s(@Const
                                                        org.bytedeco.javacpp.IntPointer src,
                                                        @ByPtrPtr
                                                        org.bytedeco.javacpp.IntPointer dst,
                                                        int len,
                                                        int cn)

split32s

@Namespace(value="cv::hal")
public static void split32s(@Const
                                                        IntBuffer src,
                                                        @ByPtrPtr
                                                        IntBuffer dst,
                                                        int len,
                                                        int cn)

split32s

@Namespace(value="cv::hal")
public static void split32s(@Const
                                                        int[] src,
                                                        @ByPtrPtr
                                                        int[] dst,
                                                        int len,
                                                        int cn)

split64s

@Namespace(value="cv::hal")
public static void split64s(@Cast(value="const int64*")
                                                        org.bytedeco.javacpp.LongPointer src,
                                                        @Cast(value="int64**")
                                                        org.bytedeco.javacpp.PointerPointer dst,
                                                        int len,
                                                        int cn)

split64s

@Namespace(value="cv::hal")
public static void split64s(@Cast(value="const int64*")
                                                        org.bytedeco.javacpp.LongPointer src,
                                                        @Cast(value="int64**") @ByPtrPtr
                                                        org.bytedeco.javacpp.LongPointer dst,
                                                        int len,
                                                        int cn)

split64s

@Namespace(value="cv::hal")
public static void split64s(@Cast(value="const int64*")
                                                        LongBuffer src,
                                                        @Cast(value="int64**") @ByPtrPtr
                                                        LongBuffer dst,
                                                        int len,
                                                        int cn)

split64s

@Namespace(value="cv::hal")
public static void split64s(@Cast(value="const int64*")
                                                        long[] src,
                                                        @Cast(value="int64**") @ByPtrPtr
                                                        long[] dst,
                                                        int len,
                                                        int cn)

merge8u

@Namespace(value="cv::hal")
public static void merge8u(@Cast(value="const uchar**")
                                                       org.bytedeco.javacpp.PointerPointer src,
                                                       @Cast(value="uchar*")
                                                       org.bytedeco.javacpp.BytePointer dst,
                                                       int len,
                                                       int cn)

merge8u

@Namespace(value="cv::hal")
public static void merge8u(@Cast(value="const uchar**") @ByPtrPtr
                                                       org.bytedeco.javacpp.BytePointer src,
                                                       @Cast(value="uchar*")
                                                       org.bytedeco.javacpp.BytePointer dst,
                                                       int len,
                                                       int cn)

merge8u

@Namespace(value="cv::hal")
public static void merge8u(@Cast(value="const uchar**") @ByPtrPtr
                                                       ByteBuffer src,
                                                       @Cast(value="uchar*")
                                                       ByteBuffer dst,
                                                       int len,
                                                       int cn)

merge8u

@Namespace(value="cv::hal")
public static void merge8u(@Cast(value="const uchar**") @ByPtrPtr
                                                       byte[] src,
                                                       @Cast(value="uchar*")
                                                       byte[] dst,
                                                       int len,
                                                       int cn)

merge16u

@Namespace(value="cv::hal")
public static void merge16u(@Cast(value="const ushort**")
                                                        org.bytedeco.javacpp.PointerPointer src,
                                                        @Cast(value="ushort*")
                                                        org.bytedeco.javacpp.ShortPointer dst,
                                                        int len,
                                                        int cn)

merge16u

@Namespace(value="cv::hal")
public static void merge16u(@Cast(value="const ushort**") @ByPtrPtr
                                                        org.bytedeco.javacpp.ShortPointer src,
                                                        @Cast(value="ushort*")
                                                        org.bytedeco.javacpp.ShortPointer dst,
                                                        int len,
                                                        int cn)

merge16u

@Namespace(value="cv::hal")
public static void merge16u(@Cast(value="const ushort**") @ByPtrPtr
                                                        ShortBuffer src,
                                                        @Cast(value="ushort*")
                                                        ShortBuffer dst,
                                                        int len,
                                                        int cn)

merge16u

@Namespace(value="cv::hal")
public static void merge16u(@Cast(value="const ushort**") @ByPtrPtr
                                                        short[] src,
                                                        @Cast(value="ushort*")
                                                        short[] dst,
                                                        int len,
                                                        int cn)

merge32s

@Namespace(value="cv::hal")
public static void merge32s(@Cast(value="const int**")
                                                        org.bytedeco.javacpp.PointerPointer src,
                                                        org.bytedeco.javacpp.IntPointer dst,
                                                        int len,
                                                        int cn)

merge32s

@Namespace(value="cv::hal")
public static void merge32s(@Const @ByPtrPtr
                                                        org.bytedeco.javacpp.IntPointer src,
                                                        org.bytedeco.javacpp.IntPointer dst,
                                                        int len,
                                                        int cn)

merge32s

@Namespace(value="cv::hal")
public static void merge32s(@Const @ByPtrPtr
                                                        IntBuffer src,
                                                        IntBuffer dst,
                                                        int len,
                                                        int cn)

merge32s

@Namespace(value="cv::hal")
public static void merge32s(@Const @ByPtrPtr
                                                        int[] src,
                                                        int[] dst,
                                                        int len,
                                                        int cn)

merge64s

@Namespace(value="cv::hal")
public static void merge64s(@Cast(value="const int64**")
                                                        org.bytedeco.javacpp.PointerPointer src,
                                                        @Cast(value="int64*")
                                                        org.bytedeco.javacpp.LongPointer dst,
                                                        int len,
                                                        int cn)

merge64s

@Namespace(value="cv::hal")
public static void merge64s(@Cast(value="const int64**") @ByPtrPtr
                                                        org.bytedeco.javacpp.LongPointer src,
                                                        @Cast(value="int64*")
                                                        org.bytedeco.javacpp.LongPointer dst,
                                                        int len,
                                                        int cn)

merge64s

@Namespace(value="cv::hal")
public static void merge64s(@Cast(value="const int64**") @ByPtrPtr
                                                        LongBuffer src,
                                                        @Cast(value="int64*")
                                                        LongBuffer dst,
                                                        int len,
                                                        int cn)

merge64s

@Namespace(value="cv::hal")
public static void merge64s(@Cast(value="const int64**") @ByPtrPtr
                                                        long[] src,
                                                        @Cast(value="int64*")
                                                        long[] dst,
                                                        int len,
                                                        int cn)

add8u

@Namespace(value="cv::hal")
public static void add8u(@Cast(value="const uchar*")
                                                     org.bytedeco.javacpp.BytePointer src1,
                                                     @Cast(value="size_t")
                                                     long step1,
                                                     @Cast(value="const uchar*")
                                                     org.bytedeco.javacpp.BytePointer src2,
                                                     @Cast(value="size_t")
                                                     long step2,
                                                     @Cast(value="uchar*")
                                                     org.bytedeco.javacpp.BytePointer dst,
                                                     @Cast(value="size_t")
                                                     long step,
                                                     int width,
                                                     int height,
                                                     org.bytedeco.javacpp.Pointer arg8)

add8u

@Namespace(value="cv::hal")
public static void add8u(@Cast(value="const uchar*")
                                                     ByteBuffer src1,
                                                     @Cast(value="size_t")
                                                     long step1,
                                                     @Cast(value="const uchar*")
                                                     ByteBuffer src2,
                                                     @Cast(value="size_t")
                                                     long step2,
                                                     @Cast(value="uchar*")
                                                     ByteBuffer dst,
                                                     @Cast(value="size_t")
                                                     long step,
                                                     int width,
                                                     int height,
                                                     org.bytedeco.javacpp.Pointer arg8)

add8u

@Namespace(value="cv::hal")
public static void add8u(@Cast(value="const uchar*")
                                                     byte[] src1,
                                                     @Cast(value="size_t")
                                                     long step1,
                                                     @Cast(value="const uchar*")
                                                     byte[] src2,
                                                     @Cast(value="size_t")
                                                     long step2,
                                                     @Cast(value="uchar*")
                                                     byte[] dst,
                                                     @Cast(value="size_t")
                                                     long step,
                                                     int width,
                                                     int height,
                                                     org.bytedeco.javacpp.Pointer arg8)

add8s

@Namespace(value="cv::hal")
public static void add8s(@Cast(value="const schar*")
                                                     org.bytedeco.javacpp.BytePointer src1,
                                                     @Cast(value="size_t")
                                                     long step1,
                                                     @Cast(value="const schar*")
                                                     org.bytedeco.javacpp.BytePointer src2,
                                                     @Cast(value="size_t")
                                                     long step2,
                                                     @Cast(value="schar*")
                                                     org.bytedeco.javacpp.BytePointer dst,
                                                     @Cast(value="size_t")
                                                     long step,
                                                     int width,
                                                     int height,
                                                     org.bytedeco.javacpp.Pointer arg8)

add8s

@Namespace(value="cv::hal")
public static void add8s(@Cast(value="const schar*")
                                                     ByteBuffer src1,
                                                     @Cast(value="size_t")
                                                     long step1,
                                                     @Cast(value="const schar*")
                                                     ByteBuffer src2,
                                                     @Cast(value="size_t")
                                                     long step2,
                                                     @Cast(value="schar*")
                                                     ByteBuffer dst,
                                                     @Cast(value="size_t")
                                                     long step,
                                                     int width,
                                                     int height,
                                                     org.bytedeco.javacpp.Pointer arg8)

add8s

@Namespace(value="cv::hal")
public static void add8s(@Cast(value="const schar*")
                                                     byte[] src1,
                                                     @Cast(value="size_t")
                                                     long step1,
                                                     @Cast(value="const schar*")
                                                     byte[] src2,
                                                     @Cast(value="size_t")
                                                     long step2,
                                                     @Cast(value="schar*")
                                                     byte[] dst,
                                                     @Cast(value="size_t")
                                                     long step,
                                                     int width,
                                                     int height,
                                                     org.bytedeco.javacpp.Pointer arg8)

add16u

@Namespace(value="cv::hal")
public static void add16u(@Cast(value="const ushort*")
                                                      org.bytedeco.javacpp.ShortPointer src1,
                                                      @Cast(value="size_t")
                                                      long step1,
                                                      @Cast(value="const ushort*")
                                                      org.bytedeco.javacpp.ShortPointer src2,
                                                      @Cast(value="size_t")
                                                      long step2,
                                                      @Cast(value="ushort*")
                                                      org.bytedeco.javacpp.ShortPointer dst,
                                                      @Cast(value="size_t")
                                                      long step,
                                                      int width,
                                                      int height,
                                                      org.bytedeco.javacpp.Pointer arg8)

add16u

@Namespace(value="cv::hal")
public static void add16u(@Cast(value="const ushort*")
                                                      ShortBuffer src1,
                                                      @Cast(value="size_t")
                                                      long step1,
                                                      @Cast(value="const ushort*")
                                                      ShortBuffer src2,
                                                      @Cast(value="size_t")
                                                      long step2,
                                                      @Cast(value="ushort*")
                                                      ShortBuffer dst,
                                                      @Cast(value="size_t")
                                                      long step,
                                                      int width,
                                                      int height,
                                                      org.bytedeco.javacpp.Pointer arg8)

add16u

@Namespace(value="cv::hal")
public static void add16u(@Cast(value="const ushort*")
                                                      short[] src1,
                                                      @Cast(value="size_t")
                                                      long step1,
                                                      @Cast(value="const ushort*")
                                                      short[] src2,
                                                      @Cast(value="size_t")
                                                      long step2,
                                                      @Cast(value="ushort*")
                                                      short[] dst,
                                                      @Cast(value="size_t")
                                                      long step,
                                                      int width,
                                                      int height,
                                                      org.bytedeco.javacpp.Pointer arg8)

add16s

@Namespace(value="cv::hal")
public static void add16s(@Const
                                                      org.bytedeco.javacpp.ShortPointer src1,
                                                      @Cast(value="size_t")
                                                      long step1,
                                                      @Const
                                                      org.bytedeco.javacpp.ShortPointer src2,
                                                      @Cast(value="size_t")
                                                      long step2,
                                                      org.bytedeco.javacpp.ShortPointer dst,
                                                      @Cast(value="size_t")
                                                      long step,
                                                      int width,
                                                      int height,
                                                      org.bytedeco.javacpp.Pointer arg8)

add16s

@Namespace(value="cv::hal")
public static void add16s(@Const
                                                      ShortBuffer src1,
                                                      @Cast(value="size_t")
                                                      long step1,
                                                      @Const
                                                      ShortBuffer src2,
                                                      @Cast(value="size_t")
                                                      long step2,
                                                      ShortBuffer dst,
                                                      @Cast(value="size_t")
                                                      long step,
                                                      int width,
                                                      int height,
                                                      org.bytedeco.javacpp.Pointer arg8)

add16s

@Namespace(value="cv::hal")
public static void add16s(@Const
                                                      short[] src1,
                                                      @Cast(value="size_t")
                                                      long step1,
                                                      @Const
                                                      short[] src2,
                                                      @Cast(value="size_t")
                                                      long step2,
                                                      short[] dst,
                                                      @Cast(value="size_t")
                                                      long step,
                                                      int width,
                                                      int height,
                                                      org.bytedeco.javacpp.Pointer arg8)

add32s

@Namespace(value="cv::hal")
public static void add32s(@Const
                                                      org.bytedeco.javacpp.IntPointer src1,
                                                      @Cast(value="size_t")
                                                      long step1,
                                                      @Const
                                                      org.bytedeco.javacpp.IntPointer src2,
                                                      @Cast(value="size_t")
                                                      long step2,
                                                      org.bytedeco.javacpp.IntPointer dst,
                                                      @Cast(value="size_t")
                                                      long step,
                                                      int width,
                                                      int height,
                                                      org.bytedeco.javacpp.Pointer arg8)

add32s

@Namespace(value="cv::hal")
public static void add32s(@Const
                                                      IntBuffer src1,
                                                      @Cast(value="size_t")
                                                      long step1,
                                                      @Const
                                                      IntBuffer src2,
                                                      @Cast(value="size_t")
                                                      long step2,
                                                      IntBuffer dst,
                                                      @Cast(value="size_t")
                                                      long step,
                                                      int width,
                                                      int height,
                                                      org.bytedeco.javacpp.Pointer arg8)

add32s

@Namespace(value="cv::hal")
public static void add32s(@Const
                                                      int[] src1,
                                                      @Cast(value="size_t")
                                                      long step1,
                                                      @Const
                                                      int[] src2,
                                                      @Cast(value="size_t")
                                                      long step2,
                                                      int[] dst,
                                                      @Cast(value="size_t")
                                                      long step,
                                                      int width,
                                                      int height,
                                                      org.bytedeco.javacpp.Pointer arg8)

add32f

@Namespace(value="cv::hal")
public static void add32f(@Const
                                                      org.bytedeco.javacpp.FloatPointer src1,
                                                      @Cast(value="size_t")
                                                      long step1,
                                                      @Const
                                                      org.bytedeco.javacpp.FloatPointer src2,
                                                      @Cast(value="size_t")
                                                      long step2,
                                                      org.bytedeco.javacpp.FloatPointer dst,
                                                      @Cast(value="size_t")
                                                      long step,
                                                      int width,
                                                      int height,
                                                      org.bytedeco.javacpp.Pointer arg8)

add32f

@Namespace(value="cv::hal")
public static void add32f(@Const
                                                      FloatBuffer src1,
                                                      @Cast(value="size_t")
                                                      long step1,
                                                      @Const
                                                      FloatBuffer src2,
                                                      @Cast(value="size_t")
                                                      long step2,
                                                      FloatBuffer dst,
                                                      @Cast(value="size_t")
                                                      long step,
                                                      int width,
                                                      int height,
                                                      org.bytedeco.javacpp.Pointer arg8)

add32f

@Namespace(value="cv::hal")
public static void add32f(@Const
                                                      float[] src1,
                                                      @Cast(value="size_t")
                                                      long step1,
                                                      @Const
                                                      float[] src2,
                                                      @Cast(value="size_t")
                                                      long step2,
                                                      float[] dst,
                                                      @Cast(value="size_t")
                                                      long step,
                                                      int width,
                                                      int height,
                                                      org.bytedeco.javacpp.Pointer arg8)

add64f

@Namespace(value="cv::hal")
public static void add64f(@Const
                                                      org.bytedeco.javacpp.DoublePointer src1,
                                                      @Cast(value="size_t")
                                                      long step1,
                                                      @Const
                                                      org.bytedeco.javacpp.DoublePointer src2,
                                                      @Cast(value="size_t")
                                                      long step2,
                                                      org.bytedeco.javacpp.DoublePointer dst,
                                                      @Cast(value="size_t")
                                                      long step,
                                                      int width,
                                                      int height,
                                                      org.bytedeco.javacpp.Pointer arg8)

add64f

@Namespace(value="cv::hal")
public static void add64f(@Const
                                                      DoubleBuffer src1,
                                                      @Cast(value="size_t")
                                                      long step1,
                                                      @Const
                                                      DoubleBuffer src2,
                                                      @Cast(value="size_t")
                                                      long step2,
                                                      DoubleBuffer dst,
                                                      @Cast(value="size_t")
                                                      long step,
                                                      int width,
                                                      int height,
                                                      org.bytedeco.javacpp.Pointer arg8)

add64f

@Namespace(value="cv::hal")
public static void add64f(@Const
                                                      double[] src1,
                                                      @Cast(value="size_t")
                                                      long step1,
                                                      @Const
                                                      double[] src2,
                                                      @Cast(value="size_t")
                                                      long step2,
                                                      double[] dst,
                                                      @Cast(value="size_t")
                                                      long step,
                                                      int width,
                                                      int height,
                                                      org.bytedeco.javacpp.Pointer arg8)

sub8u

@Namespace(value="cv::hal")
public static void sub8u(@Cast(value="const uchar*")
                                                     org.bytedeco.javacpp.BytePointer src1,
                                                     @Cast(value="size_t")
                                                     long step1,
                                                     @Cast(value="const uchar*")
                                                     org.bytedeco.javacpp.BytePointer src2,
                                                     @Cast(value="size_t")
                                                     long step2,
                                                     @Cast(value="uchar*")
                                                     org.bytedeco.javacpp.BytePointer dst,
                                                     @Cast(value="size_t")
                                                     long step,
                                                     int width,
                                                     int height,
                                                     org.bytedeco.javacpp.Pointer arg8)

sub8u

@Namespace(value="cv::hal")
public static void sub8u(@Cast(value="const uchar*")
                                                     ByteBuffer src1,
                                                     @Cast(value="size_t")
                                                     long step1,
                                                     @Cast(value="const uchar*")
                                                     ByteBuffer src2,
                                                     @Cast(value="size_t")
                                                     long step2,
                                                     @Cast(value="uchar*")
                                                     ByteBuffer dst,
                                                     @Cast(value="size_t")
                                                     long step,
                                                     int width,
                                                     int height,
                                                     org.bytedeco.javacpp.Pointer arg8)

sub8u

@Namespace(value="cv::hal")
public static void sub8u(@Cast(value="const uchar*")
                                                     byte[] src1,
                                                     @Cast(value="size_t")
                                                     long step1,
                                                     @Cast(value="const uchar*")
                                                     byte[] src2,
                                                     @Cast(value="size_t")
                                                     long step2,
                                                     @Cast(value="uchar*")
                                                     byte[] dst,
                                                     @Cast(value="size_t")
                                                     long step,
                                                     int width,
                                                     int height,
                                                     org.bytedeco.javacpp.Pointer arg8)

sub8s

@Namespace(value="cv::hal")
public static void sub8s(@Cast(value="const schar*")
                                                     org.bytedeco.javacpp.BytePointer src1,
                                                     @Cast(value="size_t")
                                                     long step1,
                                                     @Cast(value="const schar*")
                                                     org.bytedeco.javacpp.BytePointer src2,
                                                     @Cast(value="size_t")
                                                     long step2,
                                                     @Cast(value="schar*")
                                                     org.bytedeco.javacpp.BytePointer dst,
                                                     @Cast(value="size_t")
                                                     long step,
                                                     int width,
                                                     int height,
                                                     org.bytedeco.javacpp.Pointer arg8)

sub8s

@Namespace(value="cv::hal")
public static void sub8s(@Cast(value="const schar*")
                                                     ByteBuffer src1,
                                                     @Cast(value="size_t")
                                                     long step1,
                                                     @Cast(value="const schar*")
                                                     ByteBuffer src2,
                                                     @Cast(value="size_t")
                                                     long step2,
                                                     @Cast(value="schar*")
                                                     ByteBuffer dst,
                                                     @Cast(value="size_t")
                                                     long step,
                                                     int width,
                                                     int height,
                                                     org.bytedeco.javacpp.Pointer arg8)

sub8s

@Namespace(value="cv::hal")
public static void sub8s(@Cast(value="const schar*")
                                                     byte[] src1,
                                                     @Cast(value="size_t")
                                                     long step1,
                                                     @Cast(value="const schar*")
                                                     byte[] src2,
                                                     @Cast(value="size_t")
                                                     long step2,
                                                     @Cast(value="schar*")
                                                     byte[] dst,
                                                     @Cast(value="size_t")
                                                     long step,
                                                     int width,
                                                     int height,
                                                     org.bytedeco.javacpp.Pointer arg8)

sub16u

@Namespace(value="cv::hal")
public static void sub16u(@Cast(value="const ushort*")
                                                      org.bytedeco.javacpp.ShortPointer src1,
                                                      @Cast(value="size_t")
                                                      long step1,
                                                      @Cast(value="const ushort*")
                                                      org.bytedeco.javacpp.ShortPointer src2,
                                                      @Cast(value="size_t")
                                                      long step2,
                                                      @Cast(value="ushort*")
                                                      org.bytedeco.javacpp.ShortPointer dst,
                                                      @Cast(value="size_t")
                                                      long step,
                                                      int width,
                                                      int height,
                                                      org.bytedeco.javacpp.Pointer arg8)

sub16u

@Namespace(value="cv::hal")
public static void sub16u(@Cast(value="const ushort*")
                                                      ShortBuffer src1,
                                                      @Cast(value="size_t")
                                                      long step1,
                                                      @Cast(value="const ushort*")
                                                      ShortBuffer src2,
                                                      @Cast(value="size_t")
                                                      long step2,
                                                      @Cast(value="ushort*")
                                                      ShortBuffer dst,
                                                      @Cast(value="size_t")
                                                      long step,
                                                      int width,
                                                      int height,
                                                      org.bytedeco.javacpp.Pointer arg8)

sub16u

@Namespace(value="cv::hal")
public static void sub16u(@Cast(value="const ushort*")
                                                      short[] src1,
                                                      @Cast(value="size_t")
                                                      long step1,
                                                      @Cast(value="const ushort*")
                                                      short[] src2,
                                                      @Cast(value="size_t")
                                                      long step2,
                                                      @Cast(value="ushort*")
                                                      short[] dst,
                                                      @Cast(value="size_t")
                                                      long step,
                                                      int width,
                                                      int height,
                                                      org.bytedeco.javacpp.Pointer arg8)

sub16s

@Namespace(value="cv::hal")
public static void sub16s(@Const
                                                      org.bytedeco.javacpp.ShortPointer src1,
                                                      @Cast(value="size_t")
                                                      long step1,
                                                      @Const
                                                      org.bytedeco.javacpp.ShortPointer src2,
                                                      @Cast(value="size_t")
                                                      long step2,
                                                      org.bytedeco.javacpp.ShortPointer dst,
                                                      @Cast(value="size_t")
                                                      long step,
                                                      int width,
                                                      int height,
                                                      org.bytedeco.javacpp.Pointer arg8)

sub16s

@Namespace(value="cv::hal")
public static void sub16s(@Const
                                                      ShortBuffer src1,
                                                      @Cast(value="size_t")
                                                      long step1,
                                                      @Const
                                                      ShortBuffer src2,
                                                      @Cast(value="size_t")
                                                      long step2,
                                                      ShortBuffer dst,
                                                      @Cast(value="size_t")
                                                      long step,
                                                      int width,
                                                      int height,
                                                      org.bytedeco.javacpp.Pointer arg8)

sub16s

@Namespace(value="cv::hal")
public static void sub16s(@Const
                                                      short[] src1,
                                                      @Cast(value="size_t")
                                                      long step1,
                                                      @Const
                                                      short[] src2,
                                                      @Cast(value="size_t")
                                                      long step2,
                                                      short[] dst,
                                                      @Cast(value="size_t")
                                                      long step,
                                                      int width,
                                                      int height,
                                                      org.bytedeco.javacpp.Pointer arg8)

sub32s

@Namespace(value="cv::hal")
public static void sub32s(@Const
                                                      org.bytedeco.javacpp.IntPointer src1,
                                                      @Cast(value="size_t")
                                                      long step1,
                                                      @Const
                                                      org.bytedeco.javacpp.IntPointer src2,
                                                      @Cast(value="size_t")
                                                      long step2,
                                                      org.bytedeco.javacpp.IntPointer dst,
                                                      @Cast(value="size_t")
                                                      long step,
                                                      int width,
                                                      int height,
                                                      org.bytedeco.javacpp.Pointer arg8)

sub32s

@Namespace(value="cv::hal")
public static void sub32s(@Const
                                                      IntBuffer src1,
                                                      @Cast(value="size_t")
                                                      long step1,
                                                      @Const
                                                      IntBuffer src2,
                                                      @Cast(value="size_t")
                                                      long step2,
                                                      IntBuffer dst,
                                                      @Cast(value="size_t")
                                                      long step,
                                                      int width,
                                                      int height,
                                                      org.bytedeco.javacpp.Pointer arg8)

sub32s

@Namespace(value="cv::hal")
public static void sub32s(@Const
                                                      int[] src1,
                                                      @Cast(value="size_t")
                                                      long step1,
                                                      @Const
                                                      int[] src2,
                                                      @Cast(value="size_t")
                                                      long step2,
                                                      int[] dst,
                                                      @Cast(value="size_t")
                                                      long step,
                                                      int width,
                                                      int height,
                                                      org.bytedeco.javacpp.Pointer arg8)

sub32f

@Namespace(value="cv::hal")
public static void sub32f(@Const
                                                      org.bytedeco.javacpp.FloatPointer src1,
                                                      @Cast(value="size_t")
                                                      long step1,
                                                      @Const
                                                      org.bytedeco.javacpp.FloatPointer src2,
                                                      @Cast(value="size_t")
                                                      long step2,
                                                      org.bytedeco.javacpp.FloatPointer dst,
                                                      @Cast(value="size_t")
                                                      long step,
                                                      int width,
                                                      int height,
                                                      org.bytedeco.javacpp.Pointer arg8)

sub32f

@Namespace(value="cv::hal")
public static void sub32f(@Const
                                                      FloatBuffer src1,
                                                      @Cast(value="size_t")
                                                      long step1,
                                                      @Const
                                                      FloatBuffer src2,
                                                      @Cast(value="size_t")
                                                      long step2,
                                                      FloatBuffer dst,
                                                      @Cast(value="size_t")
                                                      long step,
                                                      int width,
                                                      int height,
                                                      org.bytedeco.javacpp.Pointer arg8)

sub32f

@Namespace(value="cv::hal")
public static void sub32f(@Const
                                                      float[] src1,
                                                      @Cast(value="size_t")
                                                      long step1,
                                                      @Const
                                                      float[] src2,
                                                      @Cast(value="size_t")
                                                      long step2,
                                                      float[] dst,
                                                      @Cast(value="size_t")
                                                      long step,
                                                      int width,
                                                      int height,
                                                      org.bytedeco.javacpp.Pointer arg8)

sub64f

@Namespace(value="cv::hal")
public static void sub64f(@Const
                                                      org.bytedeco.javacpp.DoublePointer src1,
                                                      @Cast(value="size_t")
                                                      long step1,
                                                      @Const
                                                      org.bytedeco.javacpp.DoublePointer src2,
                                                      @Cast(value="size_t")
                                                      long step2,
                                                      org.bytedeco.javacpp.DoublePointer dst,
                                                      @Cast(value="size_t")
                                                      long step,
                                                      int width,
                                                      int height,
                                                      org.bytedeco.javacpp.Pointer arg8)

sub64f

@Namespace(value="cv::hal")
public static void sub64f(@Const
                                                      DoubleBuffer src1,
                                                      @Cast(value="size_t")
                                                      long step1,
                                                      @Const
                                                      DoubleBuffer src2,
                                                      @Cast(value="size_t")
                                                      long step2,
                                                      DoubleBuffer dst,
                                                      @Cast(value="size_t")
                                                      long step,
                                                      int width,
                                                      int height,
                                                      org.bytedeco.javacpp.Pointer arg8)

sub64f

@Namespace(value="cv::hal")
public static void sub64f(@Const
                                                      double[] src1,
                                                      @Cast(value="size_t")
                                                      long step1,
                                                      @Const
                                                      double[] src2,
                                                      @Cast(value="size_t")
                                                      long step2,
                                                      double[] dst,
                                                      @Cast(value="size_t")
                                                      long step,
                                                      int width,
                                                      int height,
                                                      org.bytedeco.javacpp.Pointer arg8)

max8u

@Namespace(value="cv::hal")
public static void max8u(@Cast(value="const uchar*")
                                                     org.bytedeco.javacpp.BytePointer src1,
                                                     @Cast(value="size_t")
                                                     long step1,
                                                     @Cast(value="const uchar*")
                                                     org.bytedeco.javacpp.BytePointer src2,
                                                     @Cast(value="size_t")
                                                     long step2,
                                                     @Cast(value="uchar*")
                                                     org.bytedeco.javacpp.BytePointer dst,
                                                     @Cast(value="size_t")
                                                     long step,
                                                     int width,
                                                     int height,
                                                     org.bytedeco.javacpp.Pointer arg8)

max8u

@Namespace(value="cv::hal")
public static void max8u(@Cast(value="const uchar*")
                                                     ByteBuffer src1,
                                                     @Cast(value="size_t")
                                                     long step1,
                                                     @Cast(value="const uchar*")
                                                     ByteBuffer src2,
                                                     @Cast(value="size_t")
                                                     long step2,
                                                     @Cast(value="uchar*")
                                                     ByteBuffer dst,
                                                     @Cast(value="size_t")
                                                     long step,
                                                     int width,
                                                     int height,
                                                     org.bytedeco.javacpp.Pointer arg8)

max8u

@Namespace(value="cv::hal")
public static void max8u(@Cast(value="const uchar*")
                                                     byte[] src1,
                                                     @Cast(value="size_t")
                                                     long step1,
                                                     @Cast(value="const uchar*")
                                                     byte[] src2,
                                                     @Cast(value="size_t")
                                                     long step2,
                                                     @Cast(value="uchar*")
                                                     byte[] dst,
                                                     @Cast(value="size_t")
                                                     long step,
                                                     int width,
                                                     int height,
                                                     org.bytedeco.javacpp.Pointer arg8)

max8s

@Namespace(value="cv::hal")
public static void max8s(@Cast(value="const schar*")
                                                     org.bytedeco.javacpp.BytePointer src1,
                                                     @Cast(value="size_t")
                                                     long step1,
                                                     @Cast(value="const schar*")
                                                     org.bytedeco.javacpp.BytePointer src2,
                                                     @Cast(value="size_t")
                                                     long step2,
                                                     @Cast(value="schar*")
                                                     org.bytedeco.javacpp.BytePointer dst,
                                                     @Cast(value="size_t")
                                                     long step,
                                                     int width,
                                                     int height,
                                                     org.bytedeco.javacpp.Pointer arg8)

max8s

@Namespace(value="cv::hal")
public static void max8s(@Cast(value="const schar*")
                                                     ByteBuffer src1,
                                                     @Cast(value="size_t")
                                                     long step1,
                                                     @Cast(value="const schar*")
                                                     ByteBuffer src2,
                                                     @Cast(value="size_t")
                                                     long step2,
                                                     @Cast(value="schar*")
                                                     ByteBuffer dst,
                                                     @Cast(value="size_t")
                                                     long step,
                                                     int width,
                                                     int height,
                                                     org.bytedeco.javacpp.Pointer arg8)

max8s

@Namespace(value="cv::hal")
public static void max8s(@Cast(value="const schar*")
                                                     byte[] src1,
                                                     @Cast(value="size_t")
                                                     long step1,
                                                     @Cast(value="const schar*")
                                                     byte[] src2,
                                                     @Cast(value="size_t")
                                                     long step2,
                                                     @Cast(value="schar*")
                                                     byte[] dst,
                                                     @Cast(value="size_t")
                                                     long step,
                                                     int width,
                                                     int height,
                                                     org.bytedeco.javacpp.Pointer arg8)

max16u

@Namespace(value="cv::hal")
public static void max16u(@Cast(value="const ushort*")
                                                      org.bytedeco.javacpp.ShortPointer src1,
                                                      @Cast(value="size_t")
                                                      long step1,
                                                      @Cast(value="const ushort*")
                                                      org.bytedeco.javacpp.ShortPointer src2,
                                                      @Cast(value="size_t")
                                                      long step2,
                                                      @Cast(value="ushort*")
                                                      org.bytedeco.javacpp.ShortPointer dst,
                                                      @Cast(value="size_t")
                                                      long step,
                                                      int width,
                                                      int height,
                                                      org.bytedeco.javacpp.Pointer arg8)

max16u

@Namespace(value="cv::hal")
public static void max16u(@Cast(value="const ushort*")
                                                      ShortBuffer src1,
                                                      @Cast(value="size_t")
                                                      long step1,
                                                      @Cast(value="const ushort*")
                                                      ShortBuffer src2,
                                                      @Cast(value="size_t")
                                                      long step2,
                                                      @Cast(value="ushort*")
                                                      ShortBuffer dst,
                                                      @Cast(value="size_t")
                                                      long step,
                                                      int width,
                                                      int height,
                                                      org.bytedeco.javacpp.Pointer arg8)

max16u

@Namespace(value="cv::hal")
public static void max16u(@Cast(value="const ushort*")
                                                      short[] src1,
                                                      @Cast(value="size_t")
                                                      long step1,
                                                      @Cast(value="const ushort*")
                                                      short[] src2,
                                                      @Cast(value="size_t")
                                                      long step2,
                                                      @Cast(value="ushort*")
                                                      short[] dst,
                                                      @Cast(value="size_t")
                                                      long step,
                                                      int width,
                                                      int height,
                                                      org.bytedeco.javacpp.Pointer arg8)

max16s

@Namespace(value="cv::hal")
public static void max16s(@Const
                                                      org.bytedeco.javacpp.ShortPointer src1,
                                                      @Cast(value="size_t")
                                                      long step1,
                                                      @Const
                                                      org.bytedeco.javacpp.ShortPointer src2,
                                                      @Cast(value="size_t")
                                                      long step2,
                                                      org.bytedeco.javacpp.ShortPointer dst,
                                                      @Cast(value="size_t")
                                                      long step,
                                                      int width,
                                                      int height,
                                                      org.bytedeco.javacpp.Pointer arg8)

max16s

@Namespace(value="cv::hal")
public static void max16s(@Const
                                                      ShortBuffer src1,
                                                      @Cast(value="size_t")
                                                      long step1,
                                                      @Const
                                                      ShortBuffer src2,
                                                      @Cast(value="size_t")
                                                      long step2,
                                                      ShortBuffer dst,
                                                      @Cast(value="size_t")
                                                      long step,
                                                      int width,
                                                      int height,
                                                      org.bytedeco.javacpp.Pointer arg8)

max16s

@Namespace(value="cv::hal")
public static void max16s(@Const
                                                      short[] src1,
                                                      @Cast(value="size_t")
                                                      long step1,
                                                      @Const
                                                      short[] src2,
                                                      @Cast(value="size_t")
                                                      long step2,
                                                      short[] dst,
                                                      @Cast(value="size_t")
                                                      long step,
                                                      int width,
                                                      int height,
                                                      org.bytedeco.javacpp.Pointer arg8)

max32s

@Namespace(value="cv::hal")
public static void max32s(@Const
                                                      org.bytedeco.javacpp.IntPointer src1,
                                                      @Cast(value="size_t")
                                                      long step1,
                                                      @Const
                                                      org.bytedeco.javacpp.IntPointer src2,
                                                      @Cast(value="size_t")
                                                      long step2,
                                                      org.bytedeco.javacpp.IntPointer dst,
                                                      @Cast(value="size_t")
                                                      long step,
                                                      int width,
                                                      int height,
                                                      org.bytedeco.javacpp.Pointer arg8)

max32s

@Namespace(value="cv::hal")
public static void max32s(@Const
                                                      IntBuffer src1,
                                                      @Cast(value="size_t")
                                                      long step1,
                                                      @Const
                                                      IntBuffer src2,
                                                      @Cast(value="size_t")
                                                      long step2,
                                                      IntBuffer dst,
                                                      @Cast(value="size_t")
                                                      long step,
                                                      int width,
                                                      int height,
                                                      org.bytedeco.javacpp.Pointer arg8)

max32s

@Namespace(value="cv::hal")
public static void max32s(@Const
                                                      int[] src1,
                                                      @Cast(value="size_t")
                                                      long step1,
                                                      @Const
                                                      int[] src2,
                                                      @Cast(value="size_t")
                                                      long step2,
                                                      int[] dst,
                                                      @Cast(value="size_t")
                                                      long step,
                                                      int width,
                                                      int height,
                                                      org.bytedeco.javacpp.Pointer arg8)

max32f

@Namespace(value="cv::hal")
public static void max32f(@Const
                                                      org.bytedeco.javacpp.FloatPointer src1,
                                                      @Cast(value="size_t")
                                                      long step1,
                                                      @Const
                                                      org.bytedeco.javacpp.FloatPointer src2,
                                                      @Cast(value="size_t")
                                                      long step2,
                                                      org.bytedeco.javacpp.FloatPointer dst,
                                                      @Cast(value="size_t")
                                                      long step,
                                                      int width,
                                                      int height,
                                                      org.bytedeco.javacpp.Pointer arg8)

max32f

@Namespace(value="cv::hal")
public static void max32f(@Const
                                                      FloatBuffer src1,
                                                      @Cast(value="size_t")
                                                      long step1,
                                                      @Const
                                                      FloatBuffer src2,
                                                      @Cast(value="size_t")
                                                      long step2,
                                                      FloatBuffer dst,
                                                      @Cast(value="size_t")
                                                      long step,
                                                      int width,
                                                      int height,
                                                      org.bytedeco.javacpp.Pointer arg8)

max32f

@Namespace(value="cv::hal")
public static void max32f(@Const
                                                      float[] src1,
                                                      @Cast(value="size_t")
                                                      long step1,
                                                      @Const
                                                      float[] src2,
                                                      @Cast(value="size_t")
                                                      long step2,
                                                      float[] dst,
                                                      @Cast(value="size_t")
                                                      long step,
                                                      int width,
                                                      int height,
                                                      org.bytedeco.javacpp.Pointer arg8)

max64f

@Namespace(value="cv::hal")
public static void max64f(@Const
                                                      org.bytedeco.javacpp.DoublePointer src1,
                                                      @Cast(value="size_t")
                                                      long step1,
                                                      @Const
                                                      org.bytedeco.javacpp.DoublePointer src2,
                                                      @Cast(value="size_t")
                                                      long step2,
                                                      org.bytedeco.javacpp.DoublePointer dst,
                                                      @Cast(value="size_t")
                                                      long step,
                                                      int width,
                                                      int height,
                                                      org.bytedeco.javacpp.Pointer arg8)

max64f

@Namespace(value="cv::hal")
public static void max64f(@Const
                                                      DoubleBuffer src1,
                                                      @Cast(value="size_t")
                                                      long step1,
                                                      @Const
                                                      DoubleBuffer src2,
                                                      @Cast(value="size_t")
                                                      long step2,
                                                      DoubleBuffer dst,
                                                      @Cast(value="size_t")
                                                      long step,
                                                      int width,
                                                      int height,
                                                      org.bytedeco.javacpp.Pointer arg8)

max64f

@Namespace(value="cv::hal")
public static void max64f(@Const
                                                      double[] src1,
                                                      @Cast(value="size_t")
                                                      long step1,
                                                      @Const
                                                      double[] src2,
                                                      @Cast(value="size_t")
                                                      long step2,
                                                      double[] dst,
                                                      @Cast(value="size_t")
                                                      long step,
                                                      int width,
                                                      int height,
                                                      org.bytedeco.javacpp.Pointer arg8)

min8u

@Namespace(value="cv::hal")
public static void min8u(@Cast(value="const uchar*")
                                                     org.bytedeco.javacpp.BytePointer src1,
                                                     @Cast(value="size_t")
                                                     long step1,
                                                     @Cast(value="const uchar*")
                                                     org.bytedeco.javacpp.BytePointer src2,
                                                     @Cast(value="size_t")
                                                     long step2,
                                                     @Cast(value="uchar*")
                                                     org.bytedeco.javacpp.BytePointer dst,
                                                     @Cast(value="size_t")
                                                     long step,
                                                     int width,
                                                     int height,
                                                     org.bytedeco.javacpp.Pointer arg8)

min8u

@Namespace(value="cv::hal")
public static void min8u(@Cast(value="const uchar*")
                                                     ByteBuffer src1,
                                                     @Cast(value="size_t")
                                                     long step1,
                                                     @Cast(value="const uchar*")
                                                     ByteBuffer src2,
                                                     @Cast(value="size_t")
                                                     long step2,
                                                     @Cast(value="uchar*")
                                                     ByteBuffer dst,
                                                     @Cast(value="size_t")
                                                     long step,
                                                     int width,
                                                     int height,
                                                     org.bytedeco.javacpp.Pointer arg8)

min8u

@Namespace(value="cv::hal")
public static void min8u(@Cast(value="const uchar*")
                                                     byte[] src1,
                                                     @Cast(value="size_t")
                                                     long step1,
                                                     @Cast(value="const uchar*")
                                                     byte[] src2,
                                                     @Cast(value="size_t")
                                                     long step2,
                                                     @Cast(value="uchar*")
                                                     byte[] dst,
                                                     @Cast(value="size_t")
                                                     long step,
                                                     int width,
                                                     int height,
                                                     org.bytedeco.javacpp.Pointer arg8)

min8s

@Namespace(value="cv::hal")
public static void min8s(@Cast(value="const schar*")
                                                     org.bytedeco.javacpp.BytePointer src1,
                                                     @Cast(value="size_t")
                                                     long step1,
                                                     @Cast(value="const schar*")
                                                     org.bytedeco.javacpp.BytePointer src2,
                                                     @Cast(value="size_t")
                                                     long step2,
                                                     @Cast(value="schar*")
                                                     org.bytedeco.javacpp.BytePointer dst,
                                                     @Cast(value="size_t")
                                                     long step,
                                                     int width,
                                                     int height,
                                                     org.bytedeco.javacpp.Pointer arg8)

min8s

@Namespace(value="cv::hal")
public static void min8s(@Cast(value="const schar*")
                                                     ByteBuffer src1,
                                                     @Cast(value="size_t")
                                                     long step1,
                                                     @Cast(value="const schar*")
                                                     ByteBuffer src2,
                                                     @Cast(value="size_t")
                                                     long step2,
                                                     @Cast(value="schar*")
                                                     ByteBuffer dst,
                                                     @Cast(value="size_t")
                                                     long step,
                                                     int width,
                                                     int height,
                                                     org.bytedeco.javacpp.Pointer arg8)

min8s

@Namespace(value="cv::hal")
public static void min8s(@Cast(value="const schar*")
                                                     byte[] src1,
                                                     @Cast(value="size_t")
                                                     long step1,
                                                     @Cast(value="const schar*")
                                                     byte[] src2,
                                                     @Cast(value="size_t")
                                                     long step2,
                                                     @Cast(value="schar*")
                                                     byte[] dst,
                                                     @Cast(value="size_t")
                                                     long step,
                                                     int width,
                                                     int height,
                                                     org.bytedeco.javacpp.Pointer arg8)

min16u

@Namespace(value="cv::hal")
public static void min16u(@Cast(value="const ushort*")
                                                      org.bytedeco.javacpp.ShortPointer src1,
                                                      @Cast(value="size_t")
                                                      long step1,
                                                      @Cast(value="const ushort*")
                                                      org.bytedeco.javacpp.ShortPointer src2,
                                                      @Cast(value="size_t")
                                                      long step2,
                                                      @Cast(value="ushort*")
                                                      org.bytedeco.javacpp.ShortPointer dst,
                                                      @Cast(value="size_t")
                                                      long step,
                                                      int width,
                                                      int height,
                                                      org.bytedeco.javacpp.Pointer arg8)

min16u

@Namespace(value="cv::hal")
public static void min16u(@Cast(value="const ushort*")
                                                      ShortBuffer src1,
                                                      @Cast(value="size_t")
                                                      long step1,
                                                      @Cast(value="const ushort*")
                                                      ShortBuffer src2,
                                                      @Cast(value="size_t")
                                                      long step2,
                                                      @Cast(value="ushort*")
                                                      ShortBuffer dst,
                                                      @Cast(value="size_t")
                                                      long step,
                                                      int width,
                                                      int height,
                                                      org.bytedeco.javacpp.Pointer arg8)

min16u

@Namespace(value="cv::hal")
public static void min16u(@Cast(value="const ushort*")
                                                      short[] src1,
                                                      @Cast(value="size_t")
                                                      long step1,
                                                      @Cast(value="const ushort*")
                                                      short[] src2,
                                                      @Cast(value="size_t")
                                                      long step2,
                                                      @Cast(value="ushort*")
                                                      short[] dst,
                                                      @Cast(value="size_t")
                                                      long step,
                                                      int width,
                                                      int height,
                                                      org.bytedeco.javacpp.Pointer arg8)

min16s

@Namespace(value="cv::hal")
public static void min16s(@Const
                                                      org.bytedeco.javacpp.ShortPointer src1,
                                                      @Cast(value="size_t")
                                                      long step1,
                                                      @Const
                                                      org.bytedeco.javacpp.ShortPointer src2,
                                                      @Cast(value="size_t")
                                                      long step2,
                                                      org.bytedeco.javacpp.ShortPointer dst,
                                                      @Cast(value="size_t")
                                                      long step,
                                                      int width,
                                                      int height,
                                                      org.bytedeco.javacpp.Pointer arg8)

min16s

@Namespace(value="cv::hal")
public static void min16s(@Const
                                                      ShortBuffer src1,
                                                      @Cast(value="size_t")
                                                      long step1,
                                                      @Const
                                                      ShortBuffer src2,
                                                      @Cast(value="size_t")
                                                      long step2,
                                                      ShortBuffer dst,
                                                      @Cast(value="size_t")
                                                      long step,
                                                      int width,
                                                      int height,
                                                      org.bytedeco.javacpp.Pointer arg8)

min16s

@Namespace(value="cv::hal")
public static void min16s(@Const
                                                      short[] src1,
                                                      @Cast(value="size_t")
                                                      long step1,
                                                      @Const
                                                      short[] src2,
                                                      @Cast(value="size_t")
                                                      long step2,
                                                      short[] dst,
                                                      @Cast(value="size_t")
                                                      long step,
                                                      int width,
                                                      int height,
                                                      org.bytedeco.javacpp.Pointer arg8)

min32s

@Namespace(value="cv::hal")
public static void min32s(@Const
                                                      org.bytedeco.javacpp.IntPointer src1,
                                                      @Cast(value="size_t")
                                                      long step1,
                                                      @Const
                                                      org.bytedeco.javacpp.IntPointer src2,
                                                      @Cast(value="size_t")
                                                      long step2,
                                                      org.bytedeco.javacpp.IntPointer dst,
                                                      @Cast(value="size_t")
                                                      long step,
                                                      int width,
                                                      int height,
                                                      org.bytedeco.javacpp.Pointer arg8)

min32s

@Namespace(value="cv::hal")
public static void min32s(@Const
                                                      IntBuffer src1,
                                                      @Cast(value="size_t")
                                                      long step1,
                                                      @Const
                                                      IntBuffer src2,
                                                      @Cast(value="size_t")
                                                      long step2,
                                                      IntBuffer dst,
                                                      @Cast(value="size_t")
                                                      long step,
                                                      int width,
                                                      int height,
                                                      org.bytedeco.javacpp.Pointer arg8)

min32s

@Namespace(value="cv::hal")
public static void min32s(@Const
                                                      int[] src1,
                                                      @Cast(value="size_t")
                                                      long step1,
                                                      @Const
                                                      int[] src2,
                                                      @Cast(value="size_t")
                                                      long step2,
                                                      int[] dst,
                                                      @Cast(value="size_t")
                                                      long step,
                                                      int width,
                                                      int height,
                                                      org.bytedeco.javacpp.Pointer arg8)

min32f

@Namespace(value="cv::hal")
public static void min32f(@Const
                                                      org.bytedeco.javacpp.FloatPointer src1,
                                                      @Cast(value="size_t")
                                                      long step1,
                                                      @Const
                                                      org.bytedeco.javacpp.FloatPointer src2,
                                                      @Cast(value="size_t")
                                                      long step2,
                                                      org.bytedeco.javacpp.FloatPointer dst,
                                                      @Cast(value="size_t")
                                                      long step,
                                                      int width,
                                                      int height,
                                                      org.bytedeco.javacpp.Pointer arg8)

min32f

@Namespace(value="cv::hal")
public static void min32f(@Const
                                                      FloatBuffer src1,
                                                      @Cast(value="size_t")
                                                      long step1,
                                                      @Const
                                                      FloatBuffer src2,
                                                      @Cast(value="size_t")
                                                      long step2,
                                                      FloatBuffer dst,
                                                      @Cast(value="size_t")
                                                      long step,
                                                      int width,
                                                      int height,
                                                      org.bytedeco.javacpp.Pointer arg8)

min32f

@Namespace(value="cv::hal")
public static void min32f(@Const
                                                      float[] src1,
                                                      @Cast(value="size_t")
                                                      long step1,
                                                      @Const
                                                      float[] src2,
                                                      @Cast(value="size_t")
                                                      long step2,
                                                      float[] dst,
                                                      @Cast(value="size_t")
                                                      long step,
                                                      int width,
                                                      int height,
                                                      org.bytedeco.javacpp.Pointer arg8)

min64f

@Namespace(value="cv::hal")
public static void min64f(@Const
                                                      org.bytedeco.javacpp.DoublePointer src1,
                                                      @Cast(value="size_t")
                                                      long step1,
                                                      @Const
                                                      org.bytedeco.javacpp.DoublePointer src2,
                                                      @Cast(value="size_t")
                                                      long step2,
                                                      org.bytedeco.javacpp.DoublePointer dst,
                                                      @Cast(value="size_t")
                                                      long step,
                                                      int width,
                                                      int height,
                                                      org.bytedeco.javacpp.Pointer arg8)

min64f

@Namespace(value="cv::hal")
public static void min64f(@Const
                                                      DoubleBuffer src1,
                                                      @Cast(value="size_t")
                                                      long step1,
                                                      @Const
                                                      DoubleBuffer src2,
                                                      @Cast(value="size_t")
                                                      long step2,
                                                      DoubleBuffer dst,
                                                      @Cast(value="size_t")
                                                      long step,
                                                      int width,
                                                      int height,
                                                      org.bytedeco.javacpp.Pointer arg8)

min64f

@Namespace(value="cv::hal")
public static void min64f(@Const
                                                      double[] src1,
                                                      @Cast(value="size_t")
                                                      long step1,
                                                      @Const
                                                      double[] src2,
                                                      @Cast(value="size_t")
                                                      long step2,
                                                      double[] dst,
                                                      @Cast(value="size_t")
                                                      long step,
                                                      int width,
                                                      int height,
                                                      org.bytedeco.javacpp.Pointer arg8)

absdiff8u

@Namespace(value="cv::hal")
public static void absdiff8u(@Cast(value="const uchar*")
                                                         org.bytedeco.javacpp.BytePointer src1,
                                                         @Cast(value="size_t")
                                                         long step1,
                                                         @Cast(value="const uchar*")
                                                         org.bytedeco.javacpp.BytePointer src2,
                                                         @Cast(value="size_t")
                                                         long step2,
                                                         @Cast(value="uchar*")
                                                         org.bytedeco.javacpp.BytePointer dst,
                                                         @Cast(value="size_t")
                                                         long step,
                                                         int width,
                                                         int height,
                                                         org.bytedeco.javacpp.Pointer arg8)

absdiff8u

@Namespace(value="cv::hal")
public static void absdiff8u(@Cast(value="const uchar*")
                                                         ByteBuffer src1,
                                                         @Cast(value="size_t")
                                                         long step1,
                                                         @Cast(value="const uchar*")
                                                         ByteBuffer src2,
                                                         @Cast(value="size_t")
                                                         long step2,
                                                         @Cast(value="uchar*")
                                                         ByteBuffer dst,
                                                         @Cast(value="size_t")
                                                         long step,
                                                         int width,
                                                         int height,
                                                         org.bytedeco.javacpp.Pointer arg8)

absdiff8u

@Namespace(value="cv::hal")
public static void absdiff8u(@Cast(value="const uchar*")
                                                         byte[] src1,
                                                         @Cast(value="size_t")
                                                         long step1,
                                                         @Cast(value="const uchar*")
                                                         byte[] src2,
                                                         @Cast(value="size_t")
                                                         long step2,
                                                         @Cast(value="uchar*")
                                                         byte[] dst,
                                                         @Cast(value="size_t")
                                                         long step,
                                                         int width,
                                                         int height,
                                                         org.bytedeco.javacpp.Pointer arg8)

absdiff8s

@Namespace(value="cv::hal")
public static void absdiff8s(@Cast(value="const schar*")
                                                         org.bytedeco.javacpp.BytePointer src1,
                                                         @Cast(value="size_t")
                                                         long step1,
                                                         @Cast(value="const schar*")
                                                         org.bytedeco.javacpp.BytePointer src2,
                                                         @Cast(value="size_t")
                                                         long step2,
                                                         @Cast(value="schar*")
                                                         org.bytedeco.javacpp.BytePointer dst,
                                                         @Cast(value="size_t")
                                                         long step,
                                                         int width,
                                                         int height,
                                                         org.bytedeco.javacpp.Pointer arg8)

absdiff8s

@Namespace(value="cv::hal")
public static void absdiff8s(@Cast(value="const schar*")
                                                         ByteBuffer src1,
                                                         @Cast(value="size_t")
                                                         long step1,
                                                         @Cast(value="const schar*")
                                                         ByteBuffer src2,
                                                         @Cast(value="size_t")
                                                         long step2,
                                                         @Cast(value="schar*")
                                                         ByteBuffer dst,
                                                         @Cast(value="size_t")
                                                         long step,
                                                         int width,
                                                         int height,
                                                         org.bytedeco.javacpp.Pointer arg8)

absdiff8s

@Namespace(value="cv::hal")
public static void absdiff8s(@Cast(value="const schar*")
                                                         byte[] src1,
                                                         @Cast(value="size_t")
                                                         long step1,
                                                         @Cast(value="const schar*")
                                                         byte[] src2,
                                                         @Cast(value="size_t")
                                                         long step2,
                                                         @Cast(value="schar*")
                                                         byte[] dst,
                                                         @Cast(value="size_t")
                                                         long step,
                                                         int width,
                                                         int height,
                                                         org.bytedeco.javacpp.Pointer arg8)

absdiff16u

@Namespace(value="cv::hal")
public static void absdiff16u(@Cast(value="const ushort*")
                                                          org.bytedeco.javacpp.ShortPointer src1,
                                                          @Cast(value="size_t")
                                                          long step1,
                                                          @Cast(value="const ushort*")
                                                          org.bytedeco.javacpp.ShortPointer src2,
                                                          @Cast(value="size_t")
                                                          long step2,
                                                          @Cast(value="ushort*")
                                                          org.bytedeco.javacpp.ShortPointer dst,
                                                          @Cast(value="size_t")
                                                          long step,
                                                          int width,
                                                          int height,
                                                          org.bytedeco.javacpp.Pointer arg8)

absdiff16u

@Namespace(value="cv::hal")
public static void absdiff16u(@Cast(value="const ushort*")
                                                          ShortBuffer src1,
                                                          @Cast(value="size_t")
                                                          long step1,
                                                          @Cast(value="const ushort*")
                                                          ShortBuffer src2,
                                                          @Cast(value="size_t")
                                                          long step2,
                                                          @Cast(value="ushort*")
                                                          ShortBuffer dst,
                                                          @Cast(value="size_t")
                                                          long step,
                                                          int width,
                                                          int height,
                                                          org.bytedeco.javacpp.Pointer arg8)

absdiff16u

@Namespace(value="cv::hal")
public static void absdiff16u(@Cast(value="const ushort*")
                                                          short[] src1,
                                                          @Cast(value="size_t")
                                                          long step1,
                                                          @Cast(value="const ushort*")
                                                          short[] src2,
                                                          @Cast(value="size_t")
                                                          long step2,
                                                          @Cast(value="ushort*")
                                                          short[] dst,
                                                          @Cast(value="size_t")
                                                          long step,
                                                          int width,
                                                          int height,
                                                          org.bytedeco.javacpp.Pointer arg8)

absdiff16s

@Namespace(value="cv::hal")
public static void absdiff16s(@Const
                                                          org.bytedeco.javacpp.ShortPointer src1,
                                                          @Cast(value="size_t")
                                                          long step1,
                                                          @Const
                                                          org.bytedeco.javacpp.ShortPointer src2,
                                                          @Cast(value="size_t")
                                                          long step2,
                                                          org.bytedeco.javacpp.ShortPointer dst,
                                                          @Cast(value="size_t")
                                                          long step,
                                                          int width,
                                                          int height,
                                                          org.bytedeco.javacpp.Pointer arg8)

absdiff16s

@Namespace(value="cv::hal")
public static void absdiff16s(@Const
                                                          ShortBuffer src1,
                                                          @Cast(value="size_t")
                                                          long step1,
                                                          @Const
                                                          ShortBuffer src2,
                                                          @Cast(value="size_t")
                                                          long step2,
                                                          ShortBuffer dst,
                                                          @Cast(value="size_t")
                                                          long step,
                                                          int width,
                                                          int height,
                                                          org.bytedeco.javacpp.Pointer arg8)

absdiff16s

@Namespace(value="cv::hal")
public static void absdiff16s(@Const
                                                          short[] src1,
                                                          @Cast(value="size_t")
                                                          long step1,
                                                          @Const
                                                          short[] src2,
                                                          @Cast(value="size_t")
                                                          long step2,
                                                          short[] dst,
                                                          @Cast(value="size_t")
                                                          long step,
                                                          int width,
                                                          int height,
                                                          org.bytedeco.javacpp.Pointer arg8)

absdiff32s

@Namespace(value="cv::hal")
public static void absdiff32s(@Const
                                                          org.bytedeco.javacpp.IntPointer src1,
                                                          @Cast(value="size_t")
                                                          long step1,
                                                          @Const
                                                          org.bytedeco.javacpp.IntPointer src2,
                                                          @Cast(value="size_t")
                                                          long step2,
                                                          org.bytedeco.javacpp.IntPointer dst,
                                                          @Cast(value="size_t")
                                                          long step,
                                                          int width,
                                                          int height,
                                                          org.bytedeco.javacpp.Pointer arg8)

absdiff32s

@Namespace(value="cv::hal")
public static void absdiff32s(@Const
                                                          IntBuffer src1,
                                                          @Cast(value="size_t")
                                                          long step1,
                                                          @Const
                                                          IntBuffer src2,
                                                          @Cast(value="size_t")
                                                          long step2,
                                                          IntBuffer dst,
                                                          @Cast(value="size_t")
                                                          long step,
                                                          int width,
                                                          int height,
                                                          org.bytedeco.javacpp.Pointer arg8)

absdiff32s

@Namespace(value="cv::hal")
public static void absdiff32s(@Const
                                                          int[] src1,
                                                          @Cast(value="size_t")
                                                          long step1,
                                                          @Const
                                                          int[] src2,
                                                          @Cast(value="size_t")
                                                          long step2,
                                                          int[] dst,
                                                          @Cast(value="size_t")
                                                          long step,
                                                          int width,
                                                          int height,
                                                          org.bytedeco.javacpp.Pointer arg8)

absdiff32f

@Namespace(value="cv::hal")
public static void absdiff32f(@Const
                                                          org.bytedeco.javacpp.FloatPointer src1,
                                                          @Cast(value="size_t")
                                                          long step1,
                                                          @Const
                                                          org.bytedeco.javacpp.FloatPointer src2,
                                                          @Cast(value="size_t")
                                                          long step2,
                                                          org.bytedeco.javacpp.FloatPointer dst,
                                                          @Cast(value="size_t")
                                                          long step,
                                                          int width,
                                                          int height,
                                                          org.bytedeco.javacpp.Pointer arg8)

absdiff32f

@Namespace(value="cv::hal")
public static void absdiff32f(@Const
                                                          FloatBuffer src1,
                                                          @Cast(value="size_t")
                                                          long step1,
                                                          @Const
                                                          FloatBuffer src2,
                                                          @Cast(value="size_t")
                                                          long step2,
                                                          FloatBuffer dst,
                                                          @Cast(value="size_t")
                                                          long step,
                                                          int width,
                                                          int height,
                                                          org.bytedeco.javacpp.Pointer arg8)

absdiff32f

@Namespace(value="cv::hal")
public static void absdiff32f(@Const
                                                          float[] src1,
                                                          @Cast(value="size_t")
                                                          long step1,
                                                          @Const
                                                          float[] src2,
                                                          @Cast(value="size_t")
                                                          long step2,
                                                          float[] dst,
                                                          @Cast(value="size_t")
                                                          long step,
                                                          int width,
                                                          int height,
                                                          org.bytedeco.javacpp.Pointer arg8)

absdiff64f

@Namespace(value="cv::hal")
public static void absdiff64f(@Const
                                                          org.bytedeco.javacpp.DoublePointer src1,
                                                          @Cast(value="size_t")
                                                          long step1,
                                                          @Const
                                                          org.bytedeco.javacpp.DoublePointer src2,
                                                          @Cast(value="size_t")
                                                          long step2,
                                                          org.bytedeco.javacpp.DoublePointer dst,
                                                          @Cast(value="size_t")
                                                          long step,
                                                          int width,
                                                          int height,
                                                          org.bytedeco.javacpp.Pointer arg8)

absdiff64f

@Namespace(value="cv::hal")
public static void absdiff64f(@Const
                                                          DoubleBuffer src1,
                                                          @Cast(value="size_t")
                                                          long step1,
                                                          @Const
                                                          DoubleBuffer src2,
                                                          @Cast(value="size_t")
                                                          long step2,
                                                          DoubleBuffer dst,
                                                          @Cast(value="size_t")
                                                          long step,
                                                          int width,
                                                          int height,
                                                          org.bytedeco.javacpp.Pointer arg8)

absdiff64f

@Namespace(value="cv::hal")
public static void absdiff64f(@Const
                                                          double[] src1,
                                                          @Cast(value="size_t")
                                                          long step1,
                                                          @Const
                                                          double[] src2,
                                                          @Cast(value="size_t")
                                                          long step2,
                                                          double[] dst,
                                                          @Cast(value="size_t")
                                                          long step,
                                                          int width,
                                                          int height,
                                                          org.bytedeco.javacpp.Pointer arg8)

and8u

@Namespace(value="cv::hal")
public static void and8u(@Cast(value="const uchar*")
                                                     org.bytedeco.javacpp.BytePointer src1,
                                                     @Cast(value="size_t")
                                                     long step1,
                                                     @Cast(value="const uchar*")
                                                     org.bytedeco.javacpp.BytePointer src2,
                                                     @Cast(value="size_t")
                                                     long step2,
                                                     @Cast(value="uchar*")
                                                     org.bytedeco.javacpp.BytePointer dst,
                                                     @Cast(value="size_t")
                                                     long step,
                                                     int width,
                                                     int height,
                                                     org.bytedeco.javacpp.Pointer arg8)

and8u

@Namespace(value="cv::hal")
public static void and8u(@Cast(value="const uchar*")
                                                     ByteBuffer src1,
                                                     @Cast(value="size_t")
                                                     long step1,
                                                     @Cast(value="const uchar*")
                                                     ByteBuffer src2,
                                                     @Cast(value="size_t")
                                                     long step2,
                                                     @Cast(value="uchar*")
                                                     ByteBuffer dst,
                                                     @Cast(value="size_t")
                                                     long step,
                                                     int width,
                                                     int height,
                                                     org.bytedeco.javacpp.Pointer arg8)

and8u

@Namespace(value="cv::hal")
public static void and8u(@Cast(value="const uchar*")
                                                     byte[] src1,
                                                     @Cast(value="size_t")
                                                     long step1,
                                                     @Cast(value="const uchar*")
                                                     byte[] src2,
                                                     @Cast(value="size_t")
                                                     long step2,
                                                     @Cast(value="uchar*")
                                                     byte[] dst,
                                                     @Cast(value="size_t")
                                                     long step,
                                                     int width,
                                                     int height,
                                                     org.bytedeco.javacpp.Pointer arg8)

or8u

@Namespace(value="cv::hal")
public static void or8u(@Cast(value="const uchar*")
                                                    org.bytedeco.javacpp.BytePointer src1,
                                                    @Cast(value="size_t")
                                                    long step1,
                                                    @Cast(value="const uchar*")
                                                    org.bytedeco.javacpp.BytePointer src2,
                                                    @Cast(value="size_t")
                                                    long step2,
                                                    @Cast(value="uchar*")
                                                    org.bytedeco.javacpp.BytePointer dst,
                                                    @Cast(value="size_t")
                                                    long step,
                                                    int width,
                                                    int height,
                                                    org.bytedeco.javacpp.Pointer arg8)

or8u

@Namespace(value="cv::hal")
public static void or8u(@Cast(value="const uchar*")
                                                    ByteBuffer src1,
                                                    @Cast(value="size_t")
                                                    long step1,
                                                    @Cast(value="const uchar*")
                                                    ByteBuffer src2,
                                                    @Cast(value="size_t")
                                                    long step2,
                                                    @Cast(value="uchar*")
                                                    ByteBuffer dst,
                                                    @Cast(value="size_t")
                                                    long step,
                                                    int width,
                                                    int height,
                                                    org.bytedeco.javacpp.Pointer arg8)

or8u

@Namespace(value="cv::hal")
public static void or8u(@Cast(value="const uchar*")
                                                    byte[] src1,
                                                    @Cast(value="size_t")
                                                    long step1,
                                                    @Cast(value="const uchar*")
                                                    byte[] src2,
                                                    @Cast(value="size_t")
                                                    long step2,
                                                    @Cast(value="uchar*")
                                                    byte[] dst,
                                                    @Cast(value="size_t")
                                                    long step,
                                                    int width,
                                                    int height,
                                                    org.bytedeco.javacpp.Pointer arg8)

xor8u

@Namespace(value="cv::hal")
public static void xor8u(@Cast(value="const uchar*")
                                                     org.bytedeco.javacpp.BytePointer src1,
                                                     @Cast(value="size_t")
                                                     long step1,
                                                     @Cast(value="const uchar*")
                                                     org.bytedeco.javacpp.BytePointer src2,
                                                     @Cast(value="size_t")
                                                     long step2,
                                                     @Cast(value="uchar*")
                                                     org.bytedeco.javacpp.BytePointer dst,
                                                     @Cast(value="size_t")
                                                     long step,
                                                     int width,
                                                     int height,
                                                     org.bytedeco.javacpp.Pointer arg8)

xor8u

@Namespace(value="cv::hal")
public static void xor8u(@Cast(value="const uchar*")
                                                     ByteBuffer src1,
                                                     @Cast(value="size_t")
                                                     long step1,
                                                     @Cast(value="const uchar*")
                                                     ByteBuffer src2,
                                                     @Cast(value="size_t")
                                                     long step2,
                                                     @Cast(value="uchar*")
                                                     ByteBuffer dst,
                                                     @Cast(value="size_t")
                                                     long step,
                                                     int width,
                                                     int height,
                                                     org.bytedeco.javacpp.Pointer arg8)

xor8u

@Namespace(value="cv::hal")
public static void xor8u(@Cast(value="const uchar*")
                                                     byte[] src1,
                                                     @Cast(value="size_t")
                                                     long step1,
                                                     @Cast(value="const uchar*")
                                                     byte[] src2,
                                                     @Cast(value="size_t")
                                                     long step2,
                                                     @Cast(value="uchar*")
                                                     byte[] dst,
                                                     @Cast(value="size_t")
                                                     long step,
                                                     int width,
                                                     int height,
                                                     org.bytedeco.javacpp.Pointer arg8)

not8u

@Namespace(value="cv::hal")
public static void not8u(@Cast(value="const uchar*")
                                                     org.bytedeco.javacpp.BytePointer src1,
                                                     @Cast(value="size_t")
                                                     long step1,
                                                     @Cast(value="const uchar*")
                                                     org.bytedeco.javacpp.BytePointer src2,
                                                     @Cast(value="size_t")
                                                     long step2,
                                                     @Cast(value="uchar*")
                                                     org.bytedeco.javacpp.BytePointer dst,
                                                     @Cast(value="size_t")
                                                     long step,
                                                     int width,
                                                     int height,
                                                     org.bytedeco.javacpp.Pointer arg8)

not8u

@Namespace(value="cv::hal")
public static void not8u(@Cast(value="const uchar*")
                                                     ByteBuffer src1,
                                                     @Cast(value="size_t")
                                                     long step1,
                                                     @Cast(value="const uchar*")
                                                     ByteBuffer src2,
                                                     @Cast(value="size_t")
                                                     long step2,
                                                     @Cast(value="uchar*")
                                                     ByteBuffer dst,
                                                     @Cast(value="size_t")
                                                     long step,
                                                     int width,
                                                     int height,
                                                     org.bytedeco.javacpp.Pointer arg8)

not8u

@Namespace(value="cv::hal")
public static void not8u(@Cast(value="const uchar*")
                                                     byte[] src1,
                                                     @Cast(value="size_t")
                                                     long step1,
                                                     @Cast(value="const uchar*")
                                                     byte[] src2,
                                                     @Cast(value="size_t")
                                                     long step2,
                                                     @Cast(value="uchar*")
                                                     byte[] dst,
                                                     @Cast(value="size_t")
                                                     long step,
                                                     int width,
                                                     int height,
                                                     org.bytedeco.javacpp.Pointer arg8)

cmp8u

@Namespace(value="cv::hal")
public static void cmp8u(@Cast(value="const uchar*")
                                                     org.bytedeco.javacpp.BytePointer src1,
                                                     @Cast(value="size_t")
                                                     long step1,
                                                     @Cast(value="const uchar*")
                                                     org.bytedeco.javacpp.BytePointer src2,
                                                     @Cast(value="size_t")
                                                     long step2,
                                                     @Cast(value="uchar*")
                                                     org.bytedeco.javacpp.BytePointer dst,
                                                     @Cast(value="size_t")
                                                     long step,
                                                     int width,
                                                     int height,
                                                     org.bytedeco.javacpp.Pointer _cmpop)

cmp8u

@Namespace(value="cv::hal")
public static void cmp8u(@Cast(value="const uchar*")
                                                     ByteBuffer src1,
                                                     @Cast(value="size_t")
                                                     long step1,
                                                     @Cast(value="const uchar*")
                                                     ByteBuffer src2,
                                                     @Cast(value="size_t")
                                                     long step2,
                                                     @Cast(value="uchar*")
                                                     ByteBuffer dst,
                                                     @Cast(value="size_t")
                                                     long step,
                                                     int width,
                                                     int height,
                                                     org.bytedeco.javacpp.Pointer _cmpop)

cmp8u

@Namespace(value="cv::hal")
public static void cmp8u(@Cast(value="const uchar*")
                                                     byte[] src1,
                                                     @Cast(value="size_t")
                                                     long step1,
                                                     @Cast(value="const uchar*")
                                                     byte[] src2,
                                                     @Cast(value="size_t")
                                                     long step2,
                                                     @Cast(value="uchar*")
                                                     byte[] dst,
                                                     @Cast(value="size_t")
                                                     long step,
                                                     int width,
                                                     int height,
                                                     org.bytedeco.javacpp.Pointer _cmpop)

cmp8s

@Namespace(value="cv::hal")
public static void cmp8s(@Cast(value="const schar*")
                                                     org.bytedeco.javacpp.BytePointer src1,
                                                     @Cast(value="size_t")
                                                     long step1,
                                                     @Cast(value="const schar*")
                                                     org.bytedeco.javacpp.BytePointer src2,
                                                     @Cast(value="size_t")
                                                     long step2,
                                                     @Cast(value="uchar*")
                                                     org.bytedeco.javacpp.BytePointer dst,
                                                     @Cast(value="size_t")
                                                     long step,
                                                     int width,
                                                     int height,
                                                     org.bytedeco.javacpp.Pointer _cmpop)

cmp8s

@Namespace(value="cv::hal")
public static void cmp8s(@Cast(value="const schar*")
                                                     ByteBuffer src1,
                                                     @Cast(value="size_t")
                                                     long step1,
                                                     @Cast(value="const schar*")
                                                     ByteBuffer src2,
                                                     @Cast(value="size_t")
                                                     long step2,
                                                     @Cast(value="uchar*")
                                                     ByteBuffer dst,
                                                     @Cast(value="size_t")
                                                     long step,
                                                     int width,
                                                     int height,
                                                     org.bytedeco.javacpp.Pointer _cmpop)

cmp8s

@Namespace(value="cv::hal")
public static void cmp8s(@Cast(value="const schar*")
                                                     byte[] src1,
                                                     @Cast(value="size_t")
                                                     long step1,
                                                     @Cast(value="const schar*")
                                                     byte[] src2,
                                                     @Cast(value="size_t")
                                                     long step2,
                                                     @Cast(value="uchar*")
                                                     byte[] dst,
                                                     @Cast(value="size_t")
                                                     long step,
                                                     int width,
                                                     int height,
                                                     org.bytedeco.javacpp.Pointer _cmpop)

cmp16u

@Namespace(value="cv::hal")
public static void cmp16u(@Cast(value="const ushort*")
                                                      org.bytedeco.javacpp.ShortPointer src1,
                                                      @Cast(value="size_t")
                                                      long step1,
                                                      @Cast(value="const ushort*")
                                                      org.bytedeco.javacpp.ShortPointer src2,
                                                      @Cast(value="size_t")
                                                      long step2,
                                                      @Cast(value="uchar*")
                                                      org.bytedeco.javacpp.BytePointer dst,
                                                      @Cast(value="size_t")
                                                      long step,
                                                      int width,
                                                      int height,
                                                      org.bytedeco.javacpp.Pointer _cmpop)

cmp16u

@Namespace(value="cv::hal")
public static void cmp16u(@Cast(value="const ushort*")
                                                      ShortBuffer src1,
                                                      @Cast(value="size_t")
                                                      long step1,
                                                      @Cast(value="const ushort*")
                                                      ShortBuffer src2,
                                                      @Cast(value="size_t")
                                                      long step2,
                                                      @Cast(value="uchar*")
                                                      ByteBuffer dst,
                                                      @Cast(value="size_t")
                                                      long step,
                                                      int width,
                                                      int height,
                                                      org.bytedeco.javacpp.Pointer _cmpop)

cmp16u

@Namespace(value="cv::hal")
public static void cmp16u(@Cast(value="const ushort*")
                                                      short[] src1,
                                                      @Cast(value="size_t")
                                                      long step1,
                                                      @Cast(value="const ushort*")
                                                      short[] src2,
                                                      @Cast(value="size_t")
                                                      long step2,
                                                      @Cast(value="uchar*")
                                                      byte[] dst,
                                                      @Cast(value="size_t")
                                                      long step,
                                                      int width,
                                                      int height,
                                                      org.bytedeco.javacpp.Pointer _cmpop)

cmp16s

@Namespace(value="cv::hal")
public static void cmp16s(@Const
                                                      org.bytedeco.javacpp.ShortPointer src1,
                                                      @Cast(value="size_t")
                                                      long step1,
                                                      @Const
                                                      org.bytedeco.javacpp.ShortPointer src2,
                                                      @Cast(value="size_t")
                                                      long step2,
                                                      @Cast(value="uchar*")
                                                      org.bytedeco.javacpp.BytePointer dst,
                                                      @Cast(value="size_t")
                                                      long step,
                                                      int width,
                                                      int height,
                                                      org.bytedeco.javacpp.Pointer _cmpop)

cmp16s

@Namespace(value="cv::hal")
public static void cmp16s(@Const
                                                      ShortBuffer src1,
                                                      @Cast(value="size_t")
                                                      long step1,
                                                      @Const
                                                      ShortBuffer src2,
                                                      @Cast(value="size_t")
                                                      long step2,
                                                      @Cast(value="uchar*")
                                                      ByteBuffer dst,
                                                      @Cast(value="size_t")
                                                      long step,
                                                      int width,
                                                      int height,
                                                      org.bytedeco.javacpp.Pointer _cmpop)

cmp16s

@Namespace(value="cv::hal")
public static void cmp16s(@Const
                                                      short[] src1,
                                                      @Cast(value="size_t")
                                                      long step1,
                                                      @Const
                                                      short[] src2,
                                                      @Cast(value="size_t")
                                                      long step2,
                                                      @Cast(value="uchar*")
                                                      byte[] dst,
                                                      @Cast(value="size_t")
                                                      long step,
                                                      int width,
                                                      int height,
                                                      org.bytedeco.javacpp.Pointer _cmpop)

cmp32s

@Namespace(value="cv::hal")
public static void cmp32s(@Const
                                                      org.bytedeco.javacpp.IntPointer src1,
                                                      @Cast(value="size_t")
                                                      long step1,
                                                      @Const
                                                      org.bytedeco.javacpp.IntPointer src2,
                                                      @Cast(value="size_t")
                                                      long step2,
                                                      @Cast(value="uchar*")
                                                      org.bytedeco.javacpp.BytePointer dst,
                                                      @Cast(value="size_t")
                                                      long step,
                                                      int width,
                                                      int height,
                                                      org.bytedeco.javacpp.Pointer _cmpop)

cmp32s

@Namespace(value="cv::hal")
public static void cmp32s(@Const
                                                      IntBuffer src1,
                                                      @Cast(value="size_t")
                                                      long step1,
                                                      @Const
                                                      IntBuffer src2,
                                                      @Cast(value="size_t")
                                                      long step2,
                                                      @Cast(value="uchar*")
                                                      ByteBuffer dst,
                                                      @Cast(value="size_t")
                                                      long step,
                                                      int width,
                                                      int height,
                                                      org.bytedeco.javacpp.Pointer _cmpop)

cmp32s

@Namespace(value="cv::hal")
public static void cmp32s(@Const
                                                      int[] src1,
                                                      @Cast(value="size_t")
                                                      long step1,
                                                      @Const
                                                      int[] src2,
                                                      @Cast(value="size_t")
                                                      long step2,
                                                      @Cast(value="uchar*")
                                                      byte[] dst,
                                                      @Cast(value="size_t")
                                                      long step,
                                                      int width,
                                                      int height,
                                                      org.bytedeco.javacpp.Pointer _cmpop)

cmp32f

@Namespace(value="cv::hal")
public static void cmp32f(@Const
                                                      org.bytedeco.javacpp.FloatPointer src1,
                                                      @Cast(value="size_t")
                                                      long step1,
                                                      @Const
                                                      org.bytedeco.javacpp.FloatPointer src2,
                                                      @Cast(value="size_t")
                                                      long step2,
                                                      @Cast(value="uchar*")
                                                      org.bytedeco.javacpp.BytePointer dst,
                                                      @Cast(value="size_t")
                                                      long step,
                                                      int width,
                                                      int height,
                                                      org.bytedeco.javacpp.Pointer _cmpop)

cmp32f

@Namespace(value="cv::hal")
public static void cmp32f(@Const
                                                      FloatBuffer src1,
                                                      @Cast(value="size_t")
                                                      long step1,
                                                      @Const
                                                      FloatBuffer src2,
                                                      @Cast(value="size_t")
                                                      long step2,
                                                      @Cast(value="uchar*")
                                                      ByteBuffer dst,
                                                      @Cast(value="size_t")
                                                      long step,
                                                      int width,
                                                      int height,
                                                      org.bytedeco.javacpp.Pointer _cmpop)

cmp32f

@Namespace(value="cv::hal")
public static void cmp32f(@Const
                                                      float[] src1,
                                                      @Cast(value="size_t")
                                                      long step1,
                                                      @Const
                                                      float[] src2,
                                                      @Cast(value="size_t")
                                                      long step2,
                                                      @Cast(value="uchar*")
                                                      byte[] dst,
                                                      @Cast(value="size_t")
                                                      long step,
                                                      int width,
                                                      int height,
                                                      org.bytedeco.javacpp.Pointer _cmpop)

cmp64f

@Namespace(value="cv::hal")
public static void cmp64f(@Const
                                                      org.bytedeco.javacpp.DoublePointer src1,
                                                      @Cast(value="size_t")
                                                      long step1,
                                                      @Const
                                                      org.bytedeco.javacpp.DoublePointer src2,
                                                      @Cast(value="size_t")
                                                      long step2,
                                                      @Cast(value="uchar*")
                                                      org.bytedeco.javacpp.BytePointer dst,
                                                      @Cast(value="size_t")
                                                      long step,
                                                      int width,
                                                      int height,
                                                      org.bytedeco.javacpp.Pointer _cmpop)

cmp64f

@Namespace(value="cv::hal")
public static void cmp64f(@Const
                                                      DoubleBuffer src1,
                                                      @Cast(value="size_t")
                                                      long step1,
                                                      @Const
                                                      DoubleBuffer src2,
                                                      @Cast(value="size_t")
                                                      long step2,
                                                      @Cast(value="uchar*")
                                                      ByteBuffer dst,
                                                      @Cast(value="size_t")
                                                      long step,
                                                      int width,
                                                      int height,
                                                      org.bytedeco.javacpp.Pointer _cmpop)

cmp64f

@Namespace(value="cv::hal")
public static void cmp64f(@Const
                                                      double[] src1,
                                                      @Cast(value="size_t")
                                                      long step1,
                                                      @Const
                                                      double[] src2,
                                                      @Cast(value="size_t")
                                                      long step2,
                                                      @Cast(value="uchar*")
                                                      byte[] dst,
                                                      @Cast(value="size_t")
                                                      long step,
                                                      int width,
                                                      int height,
                                                      org.bytedeco.javacpp.Pointer _cmpop)

mul8u

@Namespace(value="cv::hal")
public static void mul8u(@Cast(value="const uchar*")
                                                     org.bytedeco.javacpp.BytePointer src1,
                                                     @Cast(value="size_t")
                                                     long step1,
                                                     @Cast(value="const uchar*")
                                                     org.bytedeco.javacpp.BytePointer src2,
                                                     @Cast(value="size_t")
                                                     long step2,
                                                     @Cast(value="uchar*")
                                                     org.bytedeco.javacpp.BytePointer dst,
                                                     @Cast(value="size_t")
                                                     long step,
                                                     int width,
                                                     int height,
                                                     org.bytedeco.javacpp.Pointer scale)

mul8u

@Namespace(value="cv::hal")
public static void mul8u(@Cast(value="const uchar*")
                                                     ByteBuffer src1,
                                                     @Cast(value="size_t")
                                                     long step1,
                                                     @Cast(value="const uchar*")
                                                     ByteBuffer src2,
                                                     @Cast(value="size_t")
                                                     long step2,
                                                     @Cast(value="uchar*")
                                                     ByteBuffer dst,
                                                     @Cast(value="size_t")
                                                     long step,
                                                     int width,
                                                     int height,
                                                     org.bytedeco.javacpp.Pointer scale)

mul8u

@Namespace(value="cv::hal")
public static void mul8u(@Cast(value="const uchar*")
                                                     byte[] src1,
                                                     @Cast(value="size_t")
                                                     long step1,
                                                     @Cast(value="const uchar*")
                                                     byte[] src2,
                                                     @Cast(value="size_t")
                                                     long step2,
                                                     @Cast(value="uchar*")
                                                     byte[] dst,
                                                     @Cast(value="size_t")
                                                     long step,
                                                     int width,
                                                     int height,
                                                     org.bytedeco.javacpp.Pointer scale)

mul8s

@Namespace(value="cv::hal")
public static void mul8s(@Cast(value="const schar*")
                                                     org.bytedeco.javacpp.BytePointer src1,
                                                     @Cast(value="size_t")
                                                     long step1,
                                                     @Cast(value="const schar*")
                                                     org.bytedeco.javacpp.BytePointer src2,
                                                     @Cast(value="size_t")
                                                     long step2,
                                                     @Cast(value="schar*")
                                                     org.bytedeco.javacpp.BytePointer dst,
                                                     @Cast(value="size_t")
                                                     long step,
                                                     int width,
                                                     int height,
                                                     org.bytedeco.javacpp.Pointer scale)

mul8s

@Namespace(value="cv::hal")
public static void mul8s(@Cast(value="const schar*")
                                                     ByteBuffer src1,
                                                     @Cast(value="size_t")
                                                     long step1,
                                                     @Cast(value="const schar*")
                                                     ByteBuffer src2,
                                                     @Cast(value="size_t")
                                                     long step2,
                                                     @Cast(value="schar*")
                                                     ByteBuffer dst,
                                                     @Cast(value="size_t")
                                                     long step,
                                                     int width,
                                                     int height,
                                                     org.bytedeco.javacpp.Pointer scale)

mul8s

@Namespace(value="cv::hal")
public static void mul8s(@Cast(value="const schar*")
                                                     byte[] src1,
                                                     @Cast(value="size_t")
                                                     long step1,
                                                     @Cast(value="const schar*")
                                                     byte[] src2,
                                                     @Cast(value="size_t")
                                                     long step2,
                                                     @Cast(value="schar*")
                                                     byte[] dst,
                                                     @Cast(value="size_t")
                                                     long step,
                                                     int width,
                                                     int height,
                                                     org.bytedeco.javacpp.Pointer scale)

mul16u

@Namespace(value="cv::hal")
public static void mul16u(@Cast(value="const ushort*")
                                                      org.bytedeco.javacpp.ShortPointer src1,
                                                      @Cast(value="size_t")
                                                      long step1,
                                                      @Cast(value="const ushort*")
                                                      org.bytedeco.javacpp.ShortPointer src2,
                                                      @Cast(value="size_t")
                                                      long step2,
                                                      @Cast(value="ushort*")
                                                      org.bytedeco.javacpp.ShortPointer dst,
                                                      @Cast(value="size_t")
                                                      long step,
                                                      int width,
                                                      int height,
                                                      org.bytedeco.javacpp.Pointer scale)

mul16u

@Namespace(value="cv::hal")
public static void mul16u(@Cast(value="const ushort*")
                                                      ShortBuffer src1,
                                                      @Cast(value="size_t")
                                                      long step1,
                                                      @Cast(value="const ushort*")
                                                      ShortBuffer src2,
                                                      @Cast(value="size_t")
                                                      long step2,
                                                      @Cast(value="ushort*")
                                                      ShortBuffer dst,
                                                      @Cast(value="size_t")
                                                      long step,
                                                      int width,
                                                      int height,
                                                      org.bytedeco.javacpp.Pointer scale)

mul16u

@Namespace(value="cv::hal")
public static void mul16u(@Cast(value="const ushort*")
                                                      short[] src1,
                                                      @Cast(value="size_t")
                                                      long step1,
                                                      @Cast(value="const ushort*")
                                                      short[] src2,
                                                      @Cast(value="size_t")
                                                      long step2,
                                                      @Cast(value="ushort*")
                                                      short[] dst,
                                                      @Cast(value="size_t")
                                                      long step,
                                                      int width,
                                                      int height,
                                                      org.bytedeco.javacpp.Pointer scale)

mul16s

@Namespace(value="cv::hal")
public static void mul16s(@Const
                                                      org.bytedeco.javacpp.ShortPointer src1,
                                                      @Cast(value="size_t")
                                                      long step1,
                                                      @Const
                                                      org.bytedeco.javacpp.ShortPointer src2,
                                                      @Cast(value="size_t")
                                                      long step2,
                                                      org.bytedeco.javacpp.ShortPointer dst,
                                                      @Cast(value="size_t")
                                                      long step,
                                                      int width,
                                                      int height,
                                                      org.bytedeco.javacpp.Pointer scale)

mul16s

@Namespace(value="cv::hal")
public static void mul16s(@Const
                                                      ShortBuffer src1,
                                                      @Cast(value="size_t")
                                                      long step1,
                                                      @Const
                                                      ShortBuffer src2,
                                                      @Cast(value="size_t")
                                                      long step2,
                                                      ShortBuffer dst,
                                                      @Cast(value="size_t")
                                                      long step,
                                                      int width,
                                                      int height,
                                                      org.bytedeco.javacpp.Pointer scale)

mul16s

@Namespace(value="cv::hal")
public static void mul16s(@Const
                                                      short[] src1,
                                                      @Cast(value="size_t")
                                                      long step1,
                                                      @Const
                                                      short[] src2,
                                                      @Cast(value="size_t")
                                                      long step2,
                                                      short[] dst,
                                                      @Cast(value="size_t")
                                                      long step,
                                                      int width,
                                                      int height,
                                                      org.bytedeco.javacpp.Pointer scale)

mul32s

@Namespace(value="cv::hal")
public static void mul32s(@Const
                                                      org.bytedeco.javacpp.IntPointer src1,
                                                      @Cast(value="size_t")
                                                      long step1,
                                                      @Const
                                                      org.bytedeco.javacpp.IntPointer src2,
                                                      @Cast(value="size_t")
                                                      long step2,
                                                      org.bytedeco.javacpp.IntPointer dst,
                                                      @Cast(value="size_t")
                                                      long step,
                                                      int width,
                                                      int height,
                                                      org.bytedeco.javacpp.Pointer scale)

mul32s

@Namespace(value="cv::hal")
public static void mul32s(@Const
                                                      IntBuffer src1,
                                                      @Cast(value="size_t")
                                                      long step1,
                                                      @Const
                                                      IntBuffer src2,
                                                      @Cast(value="size_t")
                                                      long step2,
                                                      IntBuffer dst,
                                                      @Cast(value="size_t")
                                                      long step,
                                                      int width,
                                                      int height,
                                                      org.bytedeco.javacpp.Pointer scale)

mul32s

@Namespace(value="cv::hal")
public static void mul32s(@Const
                                                      int[] src1,
                                                      @Cast(value="size_t")
                                                      long step1,
                                                      @Const
                                                      int[] src2,
                                                      @Cast(value="size_t")
                                                      long step2,
                                                      int[] dst,
                                                      @Cast(value="size_t")
                                                      long step,
                                                      int width,
                                                      int height,
                                                      org.bytedeco.javacpp.Pointer scale)

mul32f

@Namespace(value="cv::hal")
public static void mul32f(@Const
                                                      org.bytedeco.javacpp.FloatPointer src1,
                                                      @Cast(value="size_t")
                                                      long step1,
                                                      @Const
                                                      org.bytedeco.javacpp.FloatPointer src2,
                                                      @Cast(value="size_t")
                                                      long step2,
                                                      org.bytedeco.javacpp.FloatPointer dst,
                                                      @Cast(value="size_t")
                                                      long step,
                                                      int width,
                                                      int height,
                                                      org.bytedeco.javacpp.Pointer scale)

mul32f

@Namespace(value="cv::hal")
public static void mul32f(@Const
                                                      FloatBuffer src1,
                                                      @Cast(value="size_t")
                                                      long step1,
                                                      @Const
                                                      FloatBuffer src2,
                                                      @Cast(value="size_t")
                                                      long step2,
                                                      FloatBuffer dst,
                                                      @Cast(value="size_t")
                                                      long step,
                                                      int width,
                                                      int height,
                                                      org.bytedeco.javacpp.Pointer scale)

mul32f

@Namespace(value="cv::hal")
public static void mul32f(@Const
                                                      float[] src1,
                                                      @Cast(value="size_t")
                                                      long step1,
                                                      @Const
                                                      float[] src2,
                                                      @Cast(value="size_t")
                                                      long step2,
                                                      float[] dst,
                                                      @Cast(value="size_t")
                                                      long step,
                                                      int width,
                                                      int height,
                                                      org.bytedeco.javacpp.Pointer scale)

mul64f

@Namespace(value="cv::hal")
public static void mul64f(@Const
                                                      org.bytedeco.javacpp.DoublePointer src1,
                                                      @Cast(value="size_t")
                                                      long step1,
                                                      @Const
                                                      org.bytedeco.javacpp.DoublePointer src2,
                                                      @Cast(value="size_t")
                                                      long step2,
                                                      org.bytedeco.javacpp.DoublePointer dst,
                                                      @Cast(value="size_t")
                                                      long step,
                                                      int width,
                                                      int height,
                                                      org.bytedeco.javacpp.Pointer scale)

mul64f

@Namespace(value="cv::hal")
public static void mul64f(@Const
                                                      DoubleBuffer src1,
                                                      @Cast(value="size_t")
                                                      long step1,
                                                      @Const
                                                      DoubleBuffer src2,
                                                      @Cast(value="size_t")
                                                      long step2,
                                                      DoubleBuffer dst,
                                                      @Cast(value="size_t")
                                                      long step,
                                                      int width,
                                                      int height,
                                                      org.bytedeco.javacpp.Pointer scale)

mul64f

@Namespace(value="cv::hal")
public static void mul64f(@Const
                                                      double[] src1,
                                                      @Cast(value="size_t")
                                                      long step1,
                                                      @Const
                                                      double[] src2,
                                                      @Cast(value="size_t")
                                                      long step2,
                                                      double[] dst,
                                                      @Cast(value="size_t")
                                                      long step,
                                                      int width,
                                                      int height,
                                                      org.bytedeco.javacpp.Pointer scale)

div8u

@Namespace(value="cv::hal")
public static void div8u(@Cast(value="const uchar*")
                                                     org.bytedeco.javacpp.BytePointer src1,
                                                     @Cast(value="size_t")
                                                     long step1,
                                                     @Cast(value="const uchar*")
                                                     org.bytedeco.javacpp.BytePointer src2,
                                                     @Cast(value="size_t")
                                                     long step2,
                                                     @Cast(value="uchar*")
                                                     org.bytedeco.javacpp.BytePointer dst,
                                                     @Cast(value="size_t")
                                                     long step,
                                                     int width,
                                                     int height,
                                                     org.bytedeco.javacpp.Pointer scale)

div8u

@Namespace(value="cv::hal")
public static void div8u(@Cast(value="const uchar*")
                                                     ByteBuffer src1,
                                                     @Cast(value="size_t")
                                                     long step1,
                                                     @Cast(value="const uchar*")
                                                     ByteBuffer src2,
                                                     @Cast(value="size_t")
                                                     long step2,
                                                     @Cast(value="uchar*")
                                                     ByteBuffer dst,
                                                     @Cast(value="size_t")
                                                     long step,
                                                     int width,
                                                     int height,
                                                     org.bytedeco.javacpp.Pointer scale)

div8u

@Namespace(value="cv::hal")
public static void div8u(@Cast(value="const uchar*")
                                                     byte[] src1,
                                                     @Cast(value="size_t")
                                                     long step1,
                                                     @Cast(value="const uchar*")
                                                     byte[] src2,
                                                     @Cast(value="size_t")
                                                     long step2,
                                                     @Cast(value="uchar*")
                                                     byte[] dst,
                                                     @Cast(value="size_t")
                                                     long step,
                                                     int width,
                                                     int height,
                                                     org.bytedeco.javacpp.Pointer scale)

div8s

@Namespace(value="cv::hal")
public static void div8s(@Cast(value="const schar*")
                                                     org.bytedeco.javacpp.BytePointer src1,
                                                     @Cast(value="size_t")
                                                     long step1,
                                                     @Cast(value="const schar*")
                                                     org.bytedeco.javacpp.BytePointer src2,
                                                     @Cast(value="size_t")
                                                     long step2,
                                                     @Cast(value="schar*")
                                                     org.bytedeco.javacpp.BytePointer dst,
                                                     @Cast(value="size_t")
                                                     long step,
                                                     int width,
                                                     int height,
                                                     org.bytedeco.javacpp.Pointer scale)

div8s

@Namespace(value="cv::hal")
public static void div8s(@Cast(value="const schar*")
                                                     ByteBuffer src1,
                                                     @Cast(value="size_t")
                                                     long step1,
                                                     @Cast(value="const schar*")
                                                     ByteBuffer src2,
                                                     @Cast(value="size_t")
                                                     long step2,
                                                     @Cast(value="schar*")
                                                     ByteBuffer dst,
                                                     @Cast(value="size_t")
                                                     long step,
                                                     int width,
                                                     int height,
                                                     org.bytedeco.javacpp.Pointer scale)

div8s

@Namespace(value="cv::hal")
public static void div8s(@Cast(value="const schar*")
                                                     byte[] src1,
                                                     @Cast(value="size_t")
                                                     long step1,
                                                     @Cast(value="const schar*")
                                                     byte[] src2,
                                                     @Cast(value="size_t")
                                                     long step2,
                                                     @Cast(value="schar*")
                                                     byte[] dst,
                                                     @Cast(value="size_t")
                                                     long step,
                                                     int width,
                                                     int height,
                                                     org.bytedeco.javacpp.Pointer scale)

div16u

@Namespace(value="cv::hal")
public static void div16u(@Cast(value="const ushort*")
                                                      org.bytedeco.javacpp.ShortPointer src1,
                                                      @Cast(value="size_t")
                                                      long step1,
                                                      @Cast(value="const ushort*")
                                                      org.bytedeco.javacpp.ShortPointer src2,
                                                      @Cast(value="size_t")
                                                      long step2,
                                                      @Cast(value="ushort*")
                                                      org.bytedeco.javacpp.ShortPointer dst,
                                                      @Cast(value="size_t")
                                                      long step,
                                                      int width,
                                                      int height,
                                                      org.bytedeco.javacpp.Pointer scale)

div16u

@Namespace(value="cv::hal")
public static void div16u(@Cast(value="const ushort*")
                                                      ShortBuffer src1,
                                                      @Cast(value="size_t")
                                                      long step1,
                                                      @Cast(value="const ushort*")
                                                      ShortBuffer src2,
                                                      @Cast(value="size_t")
                                                      long step2,
                                                      @Cast(value="ushort*")
                                                      ShortBuffer dst,
                                                      @Cast(value="size_t")
                                                      long step,
                                                      int width,
                                                      int height,
                                                      org.bytedeco.javacpp.Pointer scale)

div16u

@Namespace(value="cv::hal")
public static void div16u(@Cast(value="const ushort*")
                                                      short[] src1,
                                                      @Cast(value="size_t")
                                                      long step1,
                                                      @Cast(value="const ushort*")
                                                      short[] src2,
                                                      @Cast(value="size_t")
                                                      long step2,
                                                      @Cast(value="ushort*")
                                                      short[] dst,
                                                      @Cast(value="size_t")
                                                      long step,
                                                      int width,
                                                      int height,
                                                      org.bytedeco.javacpp.Pointer scale)

div16s

@Namespace(value="cv::hal")
public static void div16s(@Const
                                                      org.bytedeco.javacpp.ShortPointer src1,
                                                      @Cast(value="size_t")
                                                      long step1,
                                                      @Const
                                                      org.bytedeco.javacpp.ShortPointer src2,
                                                      @Cast(value="size_t")
                                                      long step2,
                                                      org.bytedeco.javacpp.ShortPointer dst,
                                                      @Cast(value="size_t")
                                                      long step,
                                                      int width,
                                                      int height,
                                                      org.bytedeco.javacpp.Pointer scale)

div16s

@Namespace(value="cv::hal")
public static void div16s(@Const
                                                      ShortBuffer src1,
                                                      @Cast(value="size_t")
                                                      long step1,
                                                      @Const
                                                      ShortBuffer src2,
                                                      @Cast(value="size_t")
                                                      long step2,
                                                      ShortBuffer dst,
                                                      @Cast(value="size_t")
                                                      long step,
                                                      int width,
                                                      int height,
                                                      org.bytedeco.javacpp.Pointer scale)

div16s

@Namespace(value="cv::hal")
public static void div16s(@Const
                                                      short[] src1,
                                                      @Cast(value="size_t")
                                                      long step1,
                                                      @Const
                                                      short[] src2,
                                                      @Cast(value="size_t")
                                                      long step2,
                                                      short[] dst,
                                                      @Cast(value="size_t")
                                                      long step,
                                                      int width,
                                                      int height,
                                                      org.bytedeco.javacpp.Pointer scale)

div32s

@Namespace(value="cv::hal")
public static void div32s(@Const
                                                      org.bytedeco.javacpp.IntPointer src1,
                                                      @Cast(value="size_t")
                                                      long step1,
                                                      @Const
                                                      org.bytedeco.javacpp.IntPointer src2,
                                                      @Cast(value="size_t")
                                                      long step2,
                                                      org.bytedeco.javacpp.IntPointer dst,
                                                      @Cast(value="size_t")
                                                      long step,
                                                      int width,
                                                      int height,
                                                      org.bytedeco.javacpp.Pointer scale)

div32s

@Namespace(value="cv::hal")
public static void div32s(@Const
                                                      IntBuffer src1,
                                                      @Cast(value="size_t")
                                                      long step1,
                                                      @Const
                                                      IntBuffer src2,
                                                      @Cast(value="size_t")
                                                      long step2,
                                                      IntBuffer dst,
                                                      @Cast(value="size_t")
                                                      long step,
                                                      int width,
                                                      int height,
                                                      org.bytedeco.javacpp.Pointer scale)

div32s

@Namespace(value="cv::hal")
public static void div32s(@Const
                                                      int[] src1,
                                                      @Cast(value="size_t")
                                                      long step1,
                                                      @Const
                                                      int[] src2,
                                                      @Cast(value="size_t")
                                                      long step2,
                                                      int[] dst,
                                                      @Cast(value="size_t")
                                                      long step,
                                                      int width,
                                                      int height,
                                                      org.bytedeco.javacpp.Pointer scale)

div32f

@Namespace(value="cv::hal")
public static void div32f(@Const
                                                      org.bytedeco.javacpp.FloatPointer src1,
                                                      @Cast(value="size_t")
                                                      long step1,
                                                      @Const
                                                      org.bytedeco.javacpp.FloatPointer src2,
                                                      @Cast(value="size_t")
                                                      long step2,
                                                      org.bytedeco.javacpp.FloatPointer dst,
                                                      @Cast(value="size_t")
                                                      long step,
                                                      int width,
                                                      int height,
                                                      org.bytedeco.javacpp.Pointer scale)

div32f

@Namespace(value="cv::hal")
public static void div32f(@Const
                                                      FloatBuffer src1,
                                                      @Cast(value="size_t")
                                                      long step1,
                                                      @Const
                                                      FloatBuffer src2,
                                                      @Cast(value="size_t")
                                                      long step2,
                                                      FloatBuffer dst,
                                                      @Cast(value="size_t")
                                                      long step,
                                                      int width,
                                                      int height,
                                                      org.bytedeco.javacpp.Pointer scale)

div32f

@Namespace(value="cv::hal")
public static void div32f(@Const
                                                      float[] src1,
                                                      @Cast(value="size_t")
                                                      long step1,
                                                      @Const
                                                      float[] src2,
                                                      @Cast(value="size_t")
                                                      long step2,
                                                      float[] dst,
                                                      @Cast(value="size_t")
                                                      long step,
                                                      int width,
                                                      int height,
                                                      org.bytedeco.javacpp.Pointer scale)

div64f

@Namespace(value="cv::hal")
public static void div64f(@Const
                                                      org.bytedeco.javacpp.DoublePointer src1,
                                                      @Cast(value="size_t")
                                                      long step1,
                                                      @Const
                                                      org.bytedeco.javacpp.DoublePointer src2,
                                                      @Cast(value="size_t")
                                                      long step2,
                                                      org.bytedeco.javacpp.DoublePointer dst,
                                                      @Cast(value="size_t")
                                                      long step,
                                                      int width,
                                                      int height,
                                                      org.bytedeco.javacpp.Pointer scale)

div64f

@Namespace(value="cv::hal")
public static void div64f(@Const
                                                      DoubleBuffer src1,
                                                      @Cast(value="size_t")
                                                      long step1,
                                                      @Const
                                                      DoubleBuffer src2,
                                                      @Cast(value="size_t")
                                                      long step2,
                                                      DoubleBuffer dst,
                                                      @Cast(value="size_t")
                                                      long step,
                                                      int width,
                                                      int height,
                                                      org.bytedeco.javacpp.Pointer scale)

div64f

@Namespace(value="cv::hal")
public static void div64f(@Const
                                                      double[] src1,
                                                      @Cast(value="size_t")
                                                      long step1,
                                                      @Const
                                                      double[] src2,
                                                      @Cast(value="size_t")
                                                      long step2,
                                                      double[] dst,
                                                      @Cast(value="size_t")
                                                      long step,
                                                      int width,
                                                      int height,
                                                      org.bytedeco.javacpp.Pointer scale)

recip8u

@Namespace(value="cv::hal")
public static void recip8u(@Cast(value="const uchar*")
                                                       org.bytedeco.javacpp.BytePointer arg0,
                                                       @Cast(value="size_t")
                                                       long arg1,
                                                       @Cast(value="const uchar*")
                                                       org.bytedeco.javacpp.BytePointer src2,
                                                       @Cast(value="size_t")
                                                       long step2,
                                                       @Cast(value="uchar*")
                                                       org.bytedeco.javacpp.BytePointer dst,
                                                       @Cast(value="size_t")
                                                       long step,
                                                       int width,
                                                       int height,
                                                       org.bytedeco.javacpp.Pointer scale)

recip8u

@Namespace(value="cv::hal")
public static void recip8u(@Cast(value="const uchar*")
                                                       ByteBuffer arg0,
                                                       @Cast(value="size_t")
                                                       long arg1,
                                                       @Cast(value="const uchar*")
                                                       ByteBuffer src2,
                                                       @Cast(value="size_t")
                                                       long step2,
                                                       @Cast(value="uchar*")
                                                       ByteBuffer dst,
                                                       @Cast(value="size_t")
                                                       long step,
                                                       int width,
                                                       int height,
                                                       org.bytedeco.javacpp.Pointer scale)

recip8u

@Namespace(value="cv::hal")
public static void recip8u(@Cast(value="const uchar*")
                                                       byte[] arg0,
                                                       @Cast(value="size_t")
                                                       long arg1,
                                                       @Cast(value="const uchar*")
                                                       byte[] src2,
                                                       @Cast(value="size_t")
                                                       long step2,
                                                       @Cast(value="uchar*")
                                                       byte[] dst,
                                                       @Cast(value="size_t")
                                                       long step,
                                                       int width,
                                                       int height,
                                                       org.bytedeco.javacpp.Pointer scale)

recip8s

@Namespace(value="cv::hal")
public static void recip8s(@Cast(value="const schar*")
                                                       org.bytedeco.javacpp.BytePointer arg0,
                                                       @Cast(value="size_t")
                                                       long arg1,
                                                       @Cast(value="const schar*")
                                                       org.bytedeco.javacpp.BytePointer src2,
                                                       @Cast(value="size_t")
                                                       long step2,
                                                       @Cast(value="schar*")
                                                       org.bytedeco.javacpp.BytePointer dst,
                                                       @Cast(value="size_t")
                                                       long step,
                                                       int width,
                                                       int height,
                                                       org.bytedeco.javacpp.Pointer scale)

recip8s

@Namespace(value="cv::hal")
public static void recip8s(@Cast(value="const schar*")
                                                       ByteBuffer arg0,
                                                       @Cast(value="size_t")
                                                       long arg1,
                                                       @Cast(value="const schar*")
                                                       ByteBuffer src2,
                                                       @Cast(value="size_t")
                                                       long step2,
                                                       @Cast(value="schar*")
                                                       ByteBuffer dst,
                                                       @Cast(value="size_t")
                                                       long step,
                                                       int width,
                                                       int height,
                                                       org.bytedeco.javacpp.Pointer scale)

recip8s

@Namespace(value="cv::hal")
public static void recip8s(@Cast(value="const schar*")
                                                       byte[] arg0,
                                                       @Cast(value="size_t")
                                                       long arg1,
                                                       @Cast(value="const schar*")
                                                       byte[] src2,
                                                       @Cast(value="size_t")
                                                       long step2,
                                                       @Cast(value="schar*")
                                                       byte[] dst,
                                                       @Cast(value="size_t")
                                                       long step,
                                                       int width,
                                                       int height,
                                                       org.bytedeco.javacpp.Pointer scale)

recip16u

@Namespace(value="cv::hal")
public static void recip16u(@Cast(value="const ushort*")
                                                        org.bytedeco.javacpp.ShortPointer arg0,
                                                        @Cast(value="size_t")
                                                        long arg1,
                                                        @Cast(value="const ushort*")
                                                        org.bytedeco.javacpp.ShortPointer src2,
                                                        @Cast(value="size_t")
                                                        long step2,
                                                        @Cast(value="ushort*")
                                                        org.bytedeco.javacpp.ShortPointer dst,
                                                        @Cast(value="size_t")
                                                        long step,
                                                        int width,
                                                        int height,
                                                        org.bytedeco.javacpp.Pointer scale)

recip16u

@Namespace(value="cv::hal")
public static void recip16u(@Cast(value="const ushort*")
                                                        ShortBuffer arg0,
                                                        @Cast(value="size_t")
                                                        long arg1,
                                                        @Cast(value="const ushort*")
                                                        ShortBuffer src2,
                                                        @Cast(value="size_t")
                                                        long step2,
                                                        @Cast(value="ushort*")
                                                        ShortBuffer dst,
                                                        @Cast(value="size_t")
                                                        long step,
                                                        int width,
                                                        int height,
                                                        org.bytedeco.javacpp.Pointer scale)

recip16u

@Namespace(value="cv::hal")
public static void recip16u(@Cast(value="const ushort*")
                                                        short[] arg0,
                                                        @Cast(value="size_t")
                                                        long arg1,
                                                        @Cast(value="const ushort*")
                                                        short[] src2,
                                                        @Cast(value="size_t")
                                                        long step2,
                                                        @Cast(value="ushort*")
                                                        short[] dst,
                                                        @Cast(value="size_t")
                                                        long step,
                                                        int width,
                                                        int height,
                                                        org.bytedeco.javacpp.Pointer scale)

recip16s

@Namespace(value="cv::hal")
public static void recip16s(@Const
                                                        org.bytedeco.javacpp.ShortPointer arg0,
                                                        @Cast(value="size_t")
                                                        long arg1,
                                                        @Const
                                                        org.bytedeco.javacpp.ShortPointer src2,
                                                        @Cast(value="size_t")
                                                        long step2,
                                                        org.bytedeco.javacpp.ShortPointer dst,
                                                        @Cast(value="size_t")
                                                        long step,
                                                        int width,
                                                        int height,
                                                        org.bytedeco.javacpp.Pointer scale)

recip16s

@Namespace(value="cv::hal")
public static void recip16s(@Const
                                                        ShortBuffer arg0,
                                                        @Cast(value="size_t")
                                                        long arg1,
                                                        @Const
                                                        ShortBuffer src2,
                                                        @Cast(value="size_t")
                                                        long step2,
                                                        ShortBuffer dst,
                                                        @Cast(value="size_t")
                                                        long step,
                                                        int width,
                                                        int height,
                                                        org.bytedeco.javacpp.Pointer scale)

recip16s

@Namespace(value="cv::hal")
public static void recip16s(@Const
                                                        short[] arg0,
                                                        @Cast(value="size_t")
                                                        long arg1,
                                                        @Const
                                                        short[] src2,
                                                        @Cast(value="size_t")
                                                        long step2,
                                                        short[] dst,
                                                        @Cast(value="size_t")
                                                        long step,
                                                        int width,
                                                        int height,
                                                        org.bytedeco.javacpp.Pointer scale)

recip32s

@Namespace(value="cv::hal")
public static void recip32s(@Const
                                                        org.bytedeco.javacpp.IntPointer arg0,
                                                        @Cast(value="size_t")
                                                        long arg1,
                                                        @Const
                                                        org.bytedeco.javacpp.IntPointer src2,
                                                        @Cast(value="size_t")
                                                        long step2,
                                                        org.bytedeco.javacpp.IntPointer dst,
                                                        @Cast(value="size_t")
                                                        long step,
                                                        int width,
                                                        int height,
                                                        org.bytedeco.javacpp.Pointer scale)

recip32s

@Namespace(value="cv::hal")
public static void recip32s(@Const
                                                        IntBuffer arg0,
                                                        @Cast(value="size_t")
                                                        long arg1,
                                                        @Const
                                                        IntBuffer src2,
                                                        @Cast(value="size_t")
                                                        long step2,
                                                        IntBuffer dst,
                                                        @Cast(value="size_t")
                                                        long step,
                                                        int width,
                                                        int height,
                                                        org.bytedeco.javacpp.Pointer scale)

recip32s

@Namespace(value="cv::hal")
public static void recip32s(@Const
                                                        int[] arg0,
                                                        @Cast(value="size_t")
                                                        long arg1,
                                                        @Const
                                                        int[] src2,
                                                        @Cast(value="size_t")
                                                        long step2,
                                                        int[] dst,
                                                        @Cast(value="size_t")
                                                        long step,
                                                        int width,
                                                        int height,
                                                        org.bytedeco.javacpp.Pointer scale)

recip32f

@Namespace(value="cv::hal")
public static void recip32f(@Const
                                                        org.bytedeco.javacpp.FloatPointer arg0,
                                                        @Cast(value="size_t")
                                                        long arg1,
                                                        @Const
                                                        org.bytedeco.javacpp.FloatPointer src2,
                                                        @Cast(value="size_t")
                                                        long step2,
                                                        org.bytedeco.javacpp.FloatPointer dst,
                                                        @Cast(value="size_t")
                                                        long step,
                                                        int width,
                                                        int height,
                                                        org.bytedeco.javacpp.Pointer scale)

recip32f

@Namespace(value="cv::hal")
public static void recip32f(@Const
                                                        FloatBuffer arg0,
                                                        @Cast(value="size_t")
                                                        long arg1,
                                                        @Const
                                                        FloatBuffer src2,
                                                        @Cast(value="size_t")
                                                        long step2,
                                                        FloatBuffer dst,
                                                        @Cast(value="size_t")
                                                        long step,
                                                        int width,
                                                        int height,
                                                        org.bytedeco.javacpp.Pointer scale)

recip32f

@Namespace(value="cv::hal")
public static void recip32f(@Const
                                                        float[] arg0,
                                                        @Cast(value="size_t")
                                                        long arg1,
                                                        @Const
                                                        float[] src2,
                                                        @Cast(value="size_t")
                                                        long step2,
                                                        float[] dst,
                                                        @Cast(value="size_t")
                                                        long step,
                                                        int width,
                                                        int height,
                                                        org.bytedeco.javacpp.Pointer scale)

recip64f

@Namespace(value="cv::hal")
public static void recip64f(@Const
                                                        org.bytedeco.javacpp.DoublePointer arg0,
                                                        @Cast(value="size_t")
                                                        long arg1,
                                                        @Const
                                                        org.bytedeco.javacpp.DoublePointer src2,
                                                        @Cast(value="size_t")
                                                        long step2,
                                                        org.bytedeco.javacpp.DoublePointer dst,
                                                        @Cast(value="size_t")
                                                        long step,
                                                        int width,
                                                        int height,
                                                        org.bytedeco.javacpp.Pointer scale)

recip64f

@Namespace(value="cv::hal")
public static void recip64f(@Const
                                                        DoubleBuffer arg0,
                                                        @Cast(value="size_t")
                                                        long arg1,
                                                        @Const
                                                        DoubleBuffer src2,
                                                        @Cast(value="size_t")
                                                        long step2,
                                                        DoubleBuffer dst,
                                                        @Cast(value="size_t")
                                                        long step,
                                                        int width,
                                                        int height,
                                                        org.bytedeco.javacpp.Pointer scale)

recip64f

@Namespace(value="cv::hal")
public static void recip64f(@Const
                                                        double[] arg0,
                                                        @Cast(value="size_t")
                                                        long arg1,
                                                        @Const
                                                        double[] src2,
                                                        @Cast(value="size_t")
                                                        long step2,
                                                        double[] dst,
                                                        @Cast(value="size_t")
                                                        long step,
                                                        int width,
                                                        int height,
                                                        org.bytedeco.javacpp.Pointer scale)

addWeighted8u

@Namespace(value="cv::hal")
public static void addWeighted8u(@Cast(value="const uchar*")
                                                             org.bytedeco.javacpp.BytePointer src1,
                                                             @Cast(value="size_t")
                                                             long step1,
                                                             @Cast(value="const uchar*")
                                                             org.bytedeco.javacpp.BytePointer src2,
                                                             @Cast(value="size_t")
                                                             long step2,
                                                             @Cast(value="uchar*")
                                                             org.bytedeco.javacpp.BytePointer dst,
                                                             @Cast(value="size_t")
                                                             long step,
                                                             int width,
                                                             int height,
                                                             org.bytedeco.javacpp.Pointer _scalars)

addWeighted8u

@Namespace(value="cv::hal")
public static void addWeighted8u(@Cast(value="const uchar*")
                                                             ByteBuffer src1,
                                                             @Cast(value="size_t")
                                                             long step1,
                                                             @Cast(value="const uchar*")
                                                             ByteBuffer src2,
                                                             @Cast(value="size_t")
                                                             long step2,
                                                             @Cast(value="uchar*")
                                                             ByteBuffer dst,
                                                             @Cast(value="size_t")
                                                             long step,
                                                             int width,
                                                             int height,
                                                             org.bytedeco.javacpp.Pointer _scalars)

addWeighted8u

@Namespace(value="cv::hal")
public static void addWeighted8u(@Cast(value="const uchar*")
                                                             byte[] src1,
                                                             @Cast(value="size_t")
                                                             long step1,
                                                             @Cast(value="const uchar*")
                                                             byte[] src2,
                                                             @Cast(value="size_t")
                                                             long step2,
                                                             @Cast(value="uchar*")
                                                             byte[] dst,
                                                             @Cast(value="size_t")
                                                             long step,
                                                             int width,
                                                             int height,
                                                             org.bytedeco.javacpp.Pointer _scalars)

addWeighted8s

@Namespace(value="cv::hal")
public static void addWeighted8s(@Cast(value="const schar*")
                                                             org.bytedeco.javacpp.BytePointer src1,
                                                             @Cast(value="size_t")
                                                             long step1,
                                                             @Cast(value="const schar*")
                                                             org.bytedeco.javacpp.BytePointer src2,
                                                             @Cast(value="size_t")
                                                             long step2,
                                                             @Cast(value="schar*")
                                                             org.bytedeco.javacpp.BytePointer dst,
                                                             @Cast(value="size_t")
                                                             long step,
                                                             int width,
                                                             int height,
                                                             org.bytedeco.javacpp.Pointer scalars)

addWeighted8s

@Namespace(value="cv::hal")
public static void addWeighted8s(@Cast(value="const schar*")
                                                             ByteBuffer src1,
                                                             @Cast(value="size_t")
                                                             long step1,
                                                             @Cast(value="const schar*")
                                                             ByteBuffer src2,
                                                             @Cast(value="size_t")
                                                             long step2,
                                                             @Cast(value="schar*")
                                                             ByteBuffer dst,
                                                             @Cast(value="size_t")
                                                             long step,
                                                             int width,
                                                             int height,
                                                             org.bytedeco.javacpp.Pointer scalars)

addWeighted8s

@Namespace(value="cv::hal")
public static void addWeighted8s(@Cast(value="const schar*")
                                                             byte[] src1,
                                                             @Cast(value="size_t")
                                                             long step1,
                                                             @Cast(value="const schar*")
                                                             byte[] src2,
                                                             @Cast(value="size_t")
                                                             long step2,
                                                             @Cast(value="schar*")
                                                             byte[] dst,
                                                             @Cast(value="size_t")
                                                             long step,
                                                             int width,
                                                             int height,
                                                             org.bytedeco.javacpp.Pointer scalars)

addWeighted16u

@Namespace(value="cv::hal")
public static void addWeighted16u(@Cast(value="const ushort*")
                                                              org.bytedeco.javacpp.ShortPointer src1,
                                                              @Cast(value="size_t")
                                                              long step1,
                                                              @Cast(value="const ushort*")
                                                              org.bytedeco.javacpp.ShortPointer src2,
                                                              @Cast(value="size_t")
                                                              long step2,
                                                              @Cast(value="ushort*")
                                                              org.bytedeco.javacpp.ShortPointer dst,
                                                              @Cast(value="size_t")
                                                              long step,
                                                              int width,
                                                              int height,
                                                              org.bytedeco.javacpp.Pointer scalars)

addWeighted16u

@Namespace(value="cv::hal")
public static void addWeighted16u(@Cast(value="const ushort*")
                                                              ShortBuffer src1,
                                                              @Cast(value="size_t")
                                                              long step1,
                                                              @Cast(value="const ushort*")
                                                              ShortBuffer src2,
                                                              @Cast(value="size_t")
                                                              long step2,
                                                              @Cast(value="ushort*")
                                                              ShortBuffer dst,
                                                              @Cast(value="size_t")
                                                              long step,
                                                              int width,
                                                              int height,
                                                              org.bytedeco.javacpp.Pointer scalars)

addWeighted16u

@Namespace(value="cv::hal")
public static void addWeighted16u(@Cast(value="const ushort*")
                                                              short[] src1,
                                                              @Cast(value="size_t")
                                                              long step1,
                                                              @Cast(value="const ushort*")
                                                              short[] src2,
                                                              @Cast(value="size_t")
                                                              long step2,
                                                              @Cast(value="ushort*")
                                                              short[] dst,
                                                              @Cast(value="size_t")
                                                              long step,
                                                              int width,
                                                              int height,
                                                              org.bytedeco.javacpp.Pointer scalars)

addWeighted16s

@Namespace(value="cv::hal")
public static void addWeighted16s(@Const
                                                              org.bytedeco.javacpp.ShortPointer src1,
                                                              @Cast(value="size_t")
                                                              long step1,
                                                              @Const
                                                              org.bytedeco.javacpp.ShortPointer src2,
                                                              @Cast(value="size_t")
                                                              long step2,
                                                              org.bytedeco.javacpp.ShortPointer dst,
                                                              @Cast(value="size_t")
                                                              long step,
                                                              int width,
                                                              int height,
                                                              org.bytedeco.javacpp.Pointer scalars)

addWeighted16s

@Namespace(value="cv::hal")
public static void addWeighted16s(@Const
                                                              ShortBuffer src1,
                                                              @Cast(value="size_t")
                                                              long step1,
                                                              @Const
                                                              ShortBuffer src2,
                                                              @Cast(value="size_t")
                                                              long step2,
                                                              ShortBuffer dst,
                                                              @Cast(value="size_t")
                                                              long step,
                                                              int width,
                                                              int height,
                                                              org.bytedeco.javacpp.Pointer scalars)

addWeighted16s

@Namespace(value="cv::hal")
public static void addWeighted16s(@Const
                                                              short[] src1,
                                                              @Cast(value="size_t")
                                                              long step1,
                                                              @Const
                                                              short[] src2,
                                                              @Cast(value="size_t")
                                                              long step2,
                                                              short[] dst,
                                                              @Cast(value="size_t")
                                                              long step,
                                                              int width,
                                                              int height,
                                                              org.bytedeco.javacpp.Pointer scalars)

addWeighted32s

@Namespace(value="cv::hal")
public static void addWeighted32s(@Const
                                                              org.bytedeco.javacpp.IntPointer src1,
                                                              @Cast(value="size_t")
                                                              long step1,
                                                              @Const
                                                              org.bytedeco.javacpp.IntPointer src2,
                                                              @Cast(value="size_t")
                                                              long step2,
                                                              org.bytedeco.javacpp.IntPointer dst,
                                                              @Cast(value="size_t")
                                                              long step,
                                                              int width,
                                                              int height,
                                                              org.bytedeco.javacpp.Pointer scalars)

addWeighted32s

@Namespace(value="cv::hal")
public static void addWeighted32s(@Const
                                                              IntBuffer src1,
                                                              @Cast(value="size_t")
                                                              long step1,
                                                              @Const
                                                              IntBuffer src2,
                                                              @Cast(value="size_t")
                                                              long step2,
                                                              IntBuffer dst,
                                                              @Cast(value="size_t")
                                                              long step,
                                                              int width,
                                                              int height,
                                                              org.bytedeco.javacpp.Pointer scalars)

addWeighted32s

@Namespace(value="cv::hal")
public static void addWeighted32s(@Const
                                                              int[] src1,
                                                              @Cast(value="size_t")
                                                              long step1,
                                                              @Const
                                                              int[] src2,
                                                              @Cast(value="size_t")
                                                              long step2,
                                                              int[] dst,
                                                              @Cast(value="size_t")
                                                              long step,
                                                              int width,
                                                              int height,
                                                              org.bytedeco.javacpp.Pointer scalars)

addWeighted32f

@Namespace(value="cv::hal")
public static void addWeighted32f(@Const
                                                              org.bytedeco.javacpp.FloatPointer src1,
                                                              @Cast(value="size_t")
                                                              long step1,
                                                              @Const
                                                              org.bytedeco.javacpp.FloatPointer src2,
                                                              @Cast(value="size_t")
                                                              long step2,
                                                              org.bytedeco.javacpp.FloatPointer dst,
                                                              @Cast(value="size_t")
                                                              long step,
                                                              int width,
                                                              int height,
                                                              org.bytedeco.javacpp.Pointer scalars)

addWeighted32f

@Namespace(value="cv::hal")
public static void addWeighted32f(@Const
                                                              FloatBuffer src1,
                                                              @Cast(value="size_t")
                                                              long step1,
                                                              @Const
                                                              FloatBuffer src2,
                                                              @Cast(value="size_t")
                                                              long step2,
                                                              FloatBuffer dst,
                                                              @Cast(value="size_t")
                                                              long step,
                                                              int width,
                                                              int height,
                                                              org.bytedeco.javacpp.Pointer scalars)

addWeighted32f

@Namespace(value="cv::hal")
public static void addWeighted32f(@Const
                                                              float[] src1,
                                                              @Cast(value="size_t")
                                                              long step1,
                                                              @Const
                                                              float[] src2,
                                                              @Cast(value="size_t")
                                                              long step2,
                                                              float[] dst,
                                                              @Cast(value="size_t")
                                                              long step,
                                                              int width,
                                                              int height,
                                                              org.bytedeco.javacpp.Pointer scalars)

addWeighted64f

@Namespace(value="cv::hal")
public static void addWeighted64f(@Const
                                                              org.bytedeco.javacpp.DoublePointer src1,
                                                              @Cast(value="size_t")
                                                              long step1,
                                                              @Const
                                                              org.bytedeco.javacpp.DoublePointer src2,
                                                              @Cast(value="size_t")
                                                              long step2,
                                                              org.bytedeco.javacpp.DoublePointer dst,
                                                              @Cast(value="size_t")
                                                              long step,
                                                              int width,
                                                              int height,
                                                              org.bytedeco.javacpp.Pointer scalars)

addWeighted64f

@Namespace(value="cv::hal")
public static void addWeighted64f(@Const
                                                              DoubleBuffer src1,
                                                              @Cast(value="size_t")
                                                              long step1,
                                                              @Const
                                                              DoubleBuffer src2,
                                                              @Cast(value="size_t")
                                                              long step2,
                                                              DoubleBuffer dst,
                                                              @Cast(value="size_t")
                                                              long step,
                                                              int width,
                                                              int height,
                                                              org.bytedeco.javacpp.Pointer scalars)

addWeighted64f

@Namespace(value="cv::hal")
public static void addWeighted64f(@Const
                                                              double[] src1,
                                                              @Cast(value="size_t")
                                                              long step1,
                                                              @Const
                                                              double[] src2,
                                                              @Cast(value="size_t")
                                                              long step2,
                                                              double[] dst,
                                                              @Cast(value="size_t")
                                                              long step,
                                                              int width,
                                                              int height,
                                                              org.bytedeco.javacpp.Pointer scalars)

LU

@Namespace(value="cv::hal")
public static int LU(org.bytedeco.javacpp.FloatPointer A,
                                                 @Cast(value="size_t")
                                                 long astep,
                                                 int m,
                                                 org.bytedeco.javacpp.FloatPointer b,
                                                 @Cast(value="size_t")
                                                 long bstep,
                                                 int n)

\cond IGNORED

LU

@Namespace(value="cv::hal")
public static int LU(FloatBuffer A,
                                                 @Cast(value="size_t")
                                                 long astep,
                                                 int m,
                                                 FloatBuffer b,
                                                 @Cast(value="size_t")
                                                 long bstep,
                                                 int n)

LU

@Namespace(value="cv::hal")
public static int LU(float[] A,
                                                 @Cast(value="size_t")
                                                 long astep,
                                                 int m,
                                                 float[] b,
                                                 @Cast(value="size_t")
                                                 long bstep,
                                                 int n)

LU

@Namespace(value="cv::hal")
public static int LU(org.bytedeco.javacpp.DoublePointer A,
                                                 @Cast(value="size_t")
                                                 long astep,
                                                 int m,
                                                 org.bytedeco.javacpp.DoublePointer b,
                                                 @Cast(value="size_t")
                                                 long bstep,
                                                 int n)

LU

@Namespace(value="cv::hal")
public static int LU(DoubleBuffer A,
                                                 @Cast(value="size_t")
                                                 long astep,
                                                 int m,
                                                 DoubleBuffer b,
                                                 @Cast(value="size_t")
                                                 long bstep,
                                                 int n)

LU

@Namespace(value="cv::hal")
public static int LU(double[] A,
                                                 @Cast(value="size_t")
                                                 long astep,
                                                 int m,
                                                 double[] b,
                                                 @Cast(value="size_t")
                                                 long bstep,
                                                 int n)

Cholesky

@Namespace(value="cv::hal")
 @Cast(value="bool")
public static boolean Cholesky(org.bytedeco.javacpp.FloatPointer A,
                                                                                @Cast(value="size_t")
                                                                                long astep,
                                                                                int m,
                                                                                org.bytedeco.javacpp.FloatPointer b,
                                                                                @Cast(value="size_t")
                                                                                long bstep,
                                                                                int n)

Cholesky

@Namespace(value="cv::hal")
 @Cast(value="bool")
public static boolean Cholesky(FloatBuffer A,
                                                                                @Cast(value="size_t")
                                                                                long astep,
                                                                                int m,
                                                                                FloatBuffer b,
                                                                                @Cast(value="size_t")
                                                                                long bstep,
                                                                                int n)

Cholesky

@Namespace(value="cv::hal")
 @Cast(value="bool")
public static boolean Cholesky(float[] A,
                                                                                @Cast(value="size_t")
                                                                                long astep,
                                                                                int m,
                                                                                float[] b,
                                                                                @Cast(value="size_t")
                                                                                long bstep,
                                                                                int n)

Cholesky

@Namespace(value="cv::hal")
 @Cast(value="bool")
public static boolean Cholesky(org.bytedeco.javacpp.DoublePointer A,
                                                                                @Cast(value="size_t")
                                                                                long astep,
                                                                                int m,
                                                                                org.bytedeco.javacpp.DoublePointer b,
                                                                                @Cast(value="size_t")
                                                                                long bstep,
                                                                                int n)

Cholesky

@Namespace(value="cv::hal")
 @Cast(value="bool")
public static boolean Cholesky(DoubleBuffer A,
                                                                                @Cast(value="size_t")
                                                                                long astep,
                                                                                int m,
                                                                                DoubleBuffer b,
                                                                                @Cast(value="size_t")
                                                                                long bstep,
                                                                                int n)

Cholesky

@Namespace(value="cv::hal")
 @Cast(value="bool")
public static boolean Cholesky(double[] A,
                                                                                @Cast(value="size_t")
                                                                                long astep,
                                                                                int m,
                                                                                double[] b,
                                                                                @Cast(value="size_t")
                                                                                long bstep,
                                                                                int n)

exp

@Namespace(value="cv::hal")
public static void exp(@Const
                                                   org.bytedeco.javacpp.FloatPointer src,
                                                   org.bytedeco.javacpp.FloatPointer dst,
                                                   int n)

exp

@Namespace(value="cv::hal")
public static void exp(@Const
                                                   FloatBuffer src,
                                                   FloatBuffer dst,
                                                   int n)

exp

@Namespace(value="cv::hal")
public static void exp(@Const
                                                   float[] src,
                                                   float[] dst,
                                                   int n)

exp

@Namespace(value="cv::hal")
public static void exp(@Const
                                                   org.bytedeco.javacpp.DoublePointer src,
                                                   org.bytedeco.javacpp.DoublePointer dst,
                                                   int n)

exp

@Namespace(value="cv::hal")
public static void exp(@Const
                                                   DoubleBuffer src,
                                                   DoubleBuffer dst,
                                                   int n)

exp

@Namespace(value="cv::hal")
public static void exp(@Const
                                                   double[] src,
                                                   double[] dst,
                                                   int n)

log

@Namespace(value="cv::hal")
public static void log(@Const
                                                   org.bytedeco.javacpp.FloatPointer src,
                                                   org.bytedeco.javacpp.FloatPointer dst,
                                                   int n)

log

@Namespace(value="cv::hal")
public static void log(@Const
                                                   FloatBuffer src,
                                                   FloatBuffer dst,
                                                   int n)

log

@Namespace(value="cv::hal")
public static void log(@Const
                                                   float[] src,
                                                   float[] dst,
                                                   int n)

log

@Namespace(value="cv::hal")
public static void log(@Const
                                                   org.bytedeco.javacpp.DoublePointer src,
                                                   org.bytedeco.javacpp.DoublePointer dst,
                                                   int n)

log

@Namespace(value="cv::hal")
public static void log(@Const
                                                   DoubleBuffer src,
                                                   DoubleBuffer dst,
                                                   int n)

log

@Namespace(value="cv::hal")
public static void log(@Const
                                                   double[] src,
                                                   double[] dst,
                                                   int n)

fastAtan2

@Namespace(value="cv::hal")
public static void fastAtan2(@Const
                                                         org.bytedeco.javacpp.FloatPointer y,
                                                         @Const
                                                         org.bytedeco.javacpp.FloatPointer x,
                                                         org.bytedeco.javacpp.FloatPointer dst,
                                                         int n,
                                                         @Cast(value="bool")
                                                         boolean angleInDegrees)

fastAtan2

@Namespace(value="cv::hal")
public static void fastAtan2(@Const
                                                         FloatBuffer y,
                                                         @Const
                                                         FloatBuffer x,
                                                         FloatBuffer dst,
                                                         int n,
                                                         @Cast(value="bool")
                                                         boolean angleInDegrees)

fastAtan2

@Namespace(value="cv::hal")
public static void fastAtan2(@Const
                                                         float[] y,
                                                         @Const
                                                         float[] x,
                                                         float[] dst,
                                                         int n,
                                                         @Cast(value="bool")
                                                         boolean angleInDegrees)

magnitude

@Namespace(value="cv::hal")
public static void magnitude(@Const
                                                         org.bytedeco.javacpp.FloatPointer x,
                                                         @Const
                                                         org.bytedeco.javacpp.FloatPointer y,
                                                         org.bytedeco.javacpp.FloatPointer dst,
                                                         int n)

magnitude

@Namespace(value="cv::hal")
public static void magnitude(@Const
                                                         FloatBuffer x,
                                                         @Const
                                                         FloatBuffer y,
                                                         FloatBuffer dst,
                                                         int n)

magnitude

@Namespace(value="cv::hal")
public static void magnitude(@Const
                                                         float[] x,
                                                         @Const
                                                         float[] y,
                                                         float[] dst,
                                                         int n)

magnitude

@Namespace(value="cv::hal")
public static void magnitude(@Const
                                                         org.bytedeco.javacpp.DoublePointer x,
                                                         @Const
                                                         org.bytedeco.javacpp.DoublePointer y,
                                                         org.bytedeco.javacpp.DoublePointer dst,
                                                         int n)

magnitude

@Namespace(value="cv::hal")
public static void magnitude(@Const
                                                         DoubleBuffer x,
                                                         @Const
                                                         DoubleBuffer y,
                                                         DoubleBuffer dst,
                                                         int n)

magnitude

@Namespace(value="cv::hal")
public static void magnitude(@Const
                                                         double[] x,
                                                         @Const
                                                         double[] y,
                                                         double[] dst,
                                                         int n)

sqrt

@Namespace(value="cv::hal")
public static void sqrt(@Const
                                                    org.bytedeco.javacpp.FloatPointer src,
                                                    org.bytedeco.javacpp.FloatPointer dst,
                                                    int len)

sqrt

@Namespace(value="cv::hal")
public static void sqrt(@Const
                                                    FloatBuffer src,
                                                    FloatBuffer dst,
                                                    int len)

sqrt

@Namespace(value="cv::hal")
public static void sqrt(@Const
                                                    float[] src,
                                                    float[] dst,
                                                    int len)

sqrt

@Namespace(value="cv::hal")
public static void sqrt(@Const
                                                    org.bytedeco.javacpp.DoublePointer src,
                                                    org.bytedeco.javacpp.DoublePointer dst,
                                                    int len)

sqrt

@Namespace(value="cv::hal")
public static void sqrt(@Const
                                                    DoubleBuffer src,
                                                    DoubleBuffer dst,
                                                    int len)

sqrt

@Namespace(value="cv::hal")
public static void sqrt(@Const
                                                    double[] src,
                                                    double[] dst,
                                                    int len)

invSqrt

@Namespace(value="cv::hal")
public static void invSqrt(@Const
                                                       org.bytedeco.javacpp.FloatPointer src,
                                                       org.bytedeco.javacpp.FloatPointer dst,
                                                       int len)

invSqrt

@Namespace(value="cv::hal")
public static void invSqrt(@Const
                                                       FloatBuffer src,
                                                       FloatBuffer dst,
                                                       int len)

invSqrt

@Namespace(value="cv::hal")
public static void invSqrt(@Const
                                                       float[] src,
                                                       float[] dst,
                                                       int len)

invSqrt

@Namespace(value="cv::hal")
public static void invSqrt(@Const
                                                       org.bytedeco.javacpp.DoublePointer src,
                                                       org.bytedeco.javacpp.DoublePointer dst,
                                                       int len)

invSqrt

@Namespace(value="cv::hal")
public static void invSqrt(@Const
                                                       DoubleBuffer src,
                                                       DoubleBuffer dst,
                                                       int len)

invSqrt

@Namespace(value="cv::hal")
public static void invSqrt(@Const
                                                       double[] src,
                                                       double[] dst,
                                                       int len)

cvRound
```
public static int cvRound(double value)
```
\brief Rounds floating-point number to the nearest integer

Parameters:

value - floating-point number. If the value is outside of INT_MIN ... INT_MAX range, the result is not defined.

cvFloor
```
public static int cvFloor(double value)
```
\brief Rounds floating-point number to the nearest integer not larger than the original.
The function computes an integer i such that: \f[i \le \texttt{value} < i+1\f]

Parameters:

value - floating-point number. If the value is outside of INT_MIN ... INT_MAX range, the result is not defined.

cvCeil
```
public static int cvCeil(double value)
```
\brief Rounds floating-point number to the nearest integer not smaller than the original.
The function computes an integer i such that: \f[i \le \texttt{value} < i+1\f]

Parameters:

value - floating-point number. If the value is outside of INT_MIN ... INT_MAX range, the result is not defined.

cvIsNaN
```
public static int cvIsNaN(double value)
```
\brief Determines if the argument is Not A Number.

Parameters:

value - The input floating-point value
The function returns 1 if the argument is Not A Number (as defined by IEEE754 standard), 0 otherwise.

cvIsInf
```
public static int cvIsInf(double value)
```
\brief Determines if the argument is Infinity.

Parameters:

value - The input floating-point value
The function returns 1 if the argument is a plus or minus infinity (as defined by IEEE754 standard) and 0 otherwise.

cvRound

public static int cvRound(float value)

\overload

cvRound
```
public static int cvRound(int value)
```
\overload

cvFloor

public static int cvFloor(float value)

\overload

cvFloor
```
public static int cvFloor(int value)
```
\overload

cvCeil

public static int cvCeil(float value)

\overload

cvCeil
```
public static int cvCeil(int value)
```
\overload

cvIsNaN

public static int cvIsNaN(float value)

\overload

cvIsInf

public static int cvIsInf(float value)

\overload

ucharSaturateCast
```
@Namespace(value="cv")
 @Cast(value="uchar")
 @Name(value="saturate_cast<uchar>")
public static byte ucharSaturateCast(@Cast(value="uchar")
                                                                                                                       byte v)
```
\addtogroup core_utils \{
/////////////// saturate_cast (used in image & signal processing) ///////////////////
/** \brief Template function for accurate conversion from one primitive type to another.
The function saturate_cast resembles the standard C++ cast operations, such as static_cast\() and others. It perform an efficient and accurate conversion from one primitive type to another (see the introduction chapter). saturate in the name means that when the input value v is out of the range of the target type, the result is not formed just by taking low bits of the input, but instead the value is clipped. For example:
```
 uchar a = saturate_cast<uchar>(-100); // a = 0 (UCHAR_MIN)
 short b = saturate_cast<short>(33333.33333); // b = 32767 (SHRT_MAX)
 
```
Such clipping is done when the target type is unsigned char , signed char , unsigned short or signed short . For 32-bit integers, no clipping is done.
When the parameter is a floating-point value and the target type is an integer (8-, 16- or 32-bit), the floating-point value is first rounded to the nearest integer and then clipped if needed (when the target type is 8- or 16-bit).
This operation is used in the simplest or most complex image processing functions in OpenCV.
Parameters:

v - Function parameter. \sa add, subtract, multiply, divide, Mat::convertTo

scharSaturateCast

@Namespace(value="cv")
 @Cast(value="schar")
 @Name(value="saturate_cast<schar>")
public static byte scharSaturateCast(@Cast(value="uchar")
                                                                                                                       byte v)

ushortSaturateCast

@Namespace(value="cv")
 @Cast(value="ushort")
 @Name(value="saturate_cast<ushort>")
public static short ushortSaturateCast(@Cast(value="uchar")
                                                                                                                           byte v)

shortSaturateCast

@Namespace(value="cv")
 @Name(value="saturate_cast<short>")
public static short shortSaturateCast(@Cast(value="uchar")
                                                                                                  byte v)

intSaturate

@Namespace(value="cv")
 @Name(value="saturate_cast<int>")
public static int intSaturate(@Cast(value="uchar")
                                                                                        byte v)

unsignedSaturateCast

@Namespace(value="cv")
 @Cast(value="unsigned")
 @Name(value="saturate_cast<unsigned>")
public static int unsignedSaturateCast(@Cast(value="uchar")
                                                                                                                               byte v)

uint64SaturateCast

@Namespace(value="cv")
 @Cast(value="uint64")
 @Name(value="saturate_cast<uint64>")
public static int uint64SaturateCast(@Cast(value="uchar")
                                                                                                                         byte v)

int64SaturateCast

@Namespace(value="cv")
 @Cast(value="int64")
 @Name(value="saturate_cast<int64>")
public static long int64SaturateCast(@Cast(value="uchar")
                                                                                                                       byte v)

ucharSaturateCast

@Namespace(value="cv")
 @Cast(value="uchar")
 @Name(value="saturate_cast<uchar>")
public static byte ucharSaturateCast(@Cast(value="ushort")
                                                                                                                       short v)

\overload

scharSaturateCast

@Namespace(value="cv")
 @Cast(value="schar")
 @Name(value="saturate_cast<schar>")
public static byte scharSaturateCast(@Cast(value="ushort")
                                                                                                                       short v)

ushortSaturateCast

@Namespace(value="cv")
 @Cast(value="ushort")
 @Name(value="saturate_cast<ushort>")
public static short ushortSaturateCast(@Cast(value="ushort")
                                                                                                                           short v)

shortSaturateCast

@Namespace(value="cv")
 @Name(value="saturate_cast<short>")
public static short shortSaturateCast(@Cast(value="ushort")
                                                                                                  short v)

intSaturate

@Namespace(value="cv")
 @Name(value="saturate_cast<int>")
public static int intSaturate(@Cast(value="ushort")
                                                                                        short v)

unsignedSaturateCast

@Namespace(value="cv")
 @Cast(value="unsigned")
 @Name(value="saturate_cast<unsigned>")
public static int unsignedSaturateCast(@Cast(value="ushort")
                                                                                                                               short v)

uint64SaturateCast

@Namespace(value="cv")
 @Cast(value="uint64")
 @Name(value="saturate_cast<uint64>")
public static int uint64SaturateCast(@Cast(value="ushort")
                                                                                                                         short v)

int64SaturateCast

@Namespace(value="cv")
 @Cast(value="int64")
 @Name(value="saturate_cast<int64>")
public static long int64SaturateCast(@Cast(value="ushort")
                                                                                                                       short v)

ucharSaturateCast

@Namespace(value="cv")
 @Cast(value="uchar")
 @Name(value="saturate_cast<uchar>")
public static byte ucharSaturateCast(@Cast(value="unsigned")
                                                                                                                       int v)

\overload

scharSaturateCast

@Namespace(value="cv")
 @Cast(value="schar")
 @Name(value="saturate_cast<schar>")
public static byte scharSaturateCast(@Cast(value="unsigned")
                                                                                                                       int v)

ushortSaturateCast

@Namespace(value="cv")
 @Cast(value="ushort")
 @Name(value="saturate_cast<ushort>")
public static short ushortSaturateCast(@Cast(value="unsigned")
                                                                                                                           int v)

shortSaturateCast

@Namespace(value="cv")
 @Name(value="saturate_cast<short>")
public static short shortSaturateCast(@Cast(value="unsigned")
                                                                                                  int v)

intSaturate

@Namespace(value="cv")
 @Name(value="saturate_cast<int>")
public static int intSaturate(@Cast(value="unsigned")
                                                                                        int v)

unsignedSaturateCast

@Namespace(value="cv")
 @Cast(value="unsigned")
 @Name(value="saturate_cast<unsigned>")
public static int unsignedSaturateCast(@Cast(value="unsigned")
                                                                                                                               int v)

uint64SaturateCast

@Namespace(value="cv")
 @Cast(value="uint64")
 @Name(value="saturate_cast<uint64>")
public static int uint64SaturateCast(@Cast(value="unsigned")
                                                                                                                         int v)

int64SaturateCast

@Namespace(value="cv")
 @Cast(value="int64")
 @Name(value="saturate_cast<int64>")
public static long int64SaturateCast(@Cast(value="unsigned")
                                                                                                                       int v)

ucharSaturateCast

@Namespace(value="cv")
 @Cast(value="uchar")
 @Name(value="saturate_cast<uchar>")
public static byte ucharSaturateCast(float v)

\overload

scharSaturateCast

@Namespace(value="cv")
 @Cast(value="schar")
 @Name(value="saturate_cast<schar>")
public static byte scharSaturateCast(float v)

ushortSaturateCast

@Namespace(value="cv")
 @Cast(value="ushort")
 @Name(value="saturate_cast<ushort>")
public static short ushortSaturateCast(float v)

shortSaturateCast

@Namespace(value="cv")
 @Name(value="saturate_cast<short>")
public static short shortSaturateCast(float v)

intSaturate

@Namespace(value="cv")
 @Name(value="saturate_cast<int>")
public static int intSaturate(float v)

unsignedSaturateCast

@Namespace(value="cv")
 @Cast(value="unsigned")
 @Name(value="saturate_cast<unsigned>")
public static int unsignedSaturateCast(float v)

uint64SaturateCast

@Namespace(value="cv")
 @Cast(value="uint64")
 @Name(value="saturate_cast<uint64>")
public static int uint64SaturateCast(float v)

int64SaturateCast

@Namespace(value="cv")
 @Cast(value="int64")
 @Name(value="saturate_cast<int64>")
public static long int64SaturateCast(float v)

ucharSaturateCast

@Namespace(value="cv")
 @Cast(value="uchar")
 @Name(value="saturate_cast<uchar>")
public static byte ucharSaturateCast(double v)

\overload

scharSaturateCast

@Namespace(value="cv")
 @Cast(value="schar")
 @Name(value="saturate_cast<schar>")
public static byte scharSaturateCast(double v)

ushortSaturateCast

@Namespace(value="cv")
 @Cast(value="ushort")
 @Name(value="saturate_cast<ushort>")
public static short ushortSaturateCast(double v)

shortSaturateCast

@Namespace(value="cv")
 @Name(value="saturate_cast<short>")
public static short shortSaturateCast(double v)

intSaturate

@Namespace(value="cv")
 @Name(value="saturate_cast<int>")
public static int intSaturate(double v)

unsignedSaturateCast

@Namespace(value="cv")
 @Cast(value="unsigned")
 @Name(value="saturate_cast<unsigned>")
public static int unsignedSaturateCast(double v)

uint64SaturateCast

@Namespace(value="cv")
 @Cast(value="uint64")
 @Name(value="saturate_cast<uint64>")
public static int uint64SaturateCast(double v)

int64SaturateCast

@Namespace(value="cv")
 @Cast(value="int64")
 @Name(value="saturate_cast<int64>")
public static long int64SaturateCast(double v)

ucharSaturateCast

@Namespace(value="cv")
 @Cast(value="uchar")
 @Name(value="saturate_cast<uchar>")
public static byte ucharSaturateCast(@Cast(value="int64")
                                                                                                                       long v)

\overload

scharSaturateCast

@Namespace(value="cv")
 @Cast(value="schar")
 @Name(value="saturate_cast<schar>")
public static byte scharSaturateCast(@Cast(value="int64")
                                                                                                                       long v)

ushortSaturateCast

@Namespace(value="cv")
 @Cast(value="ushort")
 @Name(value="saturate_cast<ushort>")
public static short ushortSaturateCast(@Cast(value="int64")
                                                                                                                           long v)

shortSaturateCast

@Namespace(value="cv")
 @Name(value="saturate_cast<short>")
public static short shortSaturateCast(@Cast(value="int64")
                                                                                                  long v)

intSaturate

@Namespace(value="cv")
 @Name(value="saturate_cast<int>")
public static int intSaturate(@Cast(value="int64")
                                                                                        long v)

unsignedSaturateCast

@Namespace(value="cv")
 @Cast(value="unsigned")
 @Name(value="saturate_cast<unsigned>")
public static int unsignedSaturateCast(@Cast(value="int64")
                                                                                                                               long v)

uint64SaturateCast

@Namespace(value="cv")
 @Cast(value="uint64")
 @Name(value="saturate_cast<uint64>")
public static int uint64SaturateCast(@Cast(value="int64")
                                                                                                                         long v)

int64SaturateCast

@Namespace(value="cv")
 @Cast(value="int64")
 @Name(value="saturate_cast<int64>")
public static long int64SaturateCast(@Cast(value="int64")
                                                                                                                       long v)

CV_VERSION

@MemberGetter
public static String CV_VERSION()

error

@Namespace(value="cv")
public static void error(int _code,
                                                @opencv_core.Str
                                                org.bytedeco.javacpp.BytePointer _err,
                                                @Cast(value="const char*")
                                                org.bytedeco.javacpp.BytePointer _func,
                                                @Cast(value="const char*")
                                                org.bytedeco.javacpp.BytePointer _file,
                                                int _line)

\endcond

/** \brief Signals an error and raises the exception.

By default the function prints information about the error to stderr, then it either stops if setBreakOnError() had been called before or raises the exception. It is possible to alternate error processing by using redirectError().

Parameters:: _code - - error code (Error::Code); _err - - error description; _func - - function name. Available only when the compiler supports getting it; _file - - source file name where the error has occurred; _line - - line number in the source file where the error has occurred
See Also:: CV_Error, CV_Error_, CV_Assert, CV_DbgAssert

error

@Namespace(value="cv")
public static void error(int _code,
                                                @opencv_core.Str
                                                String _err,
                                                String _func,
                                                String _file,
                                                int _line)

errorNoReturn

@Namespace(value="cv")
public static void errorNoReturn(int _code,
                                                        @opencv_core.Str
                                                        org.bytedeco.javacpp.BytePointer _err,
                                                        @Cast(value="const char*")
                                                        org.bytedeco.javacpp.BytePointer _func,
                                                        @Cast(value="const char*")
                                                        org.bytedeco.javacpp.BytePointer _file,
                                                        int _line)

same as cv::error, but does not return

errorNoReturn

@Namespace(value="cv")
public static void errorNoReturn(int _code,
                                                        @opencv_core.Str
                                                        String _err,
                                                        String _func,
                                                        String _file,
                                                        int _line)

cv_abs

@Namespace(value="cv")
public static int cv_abs(@Cast(value="uchar")
                                                byte x)

cv_abs

@Namespace(value="cv")
public static int cv_abs(@Cast(value="ushort")
                                                short x)

cubeRoot
```
@Namespace(value="cv")
public static float cubeRoot(float val)
```
\brief Computes the cube root of an argument.
The function cubeRoot computes \f$\sqrt[3]{\texttt{val}}\f$. Negative arguments are handled correctly. NaN and Inf are not handled. The accuracy approaches the maximum possible accuracy for single-precision data.

Parameters:

val - A function argument.

fastAtan2
```
@Namespace(value="cv")
public static float fastAtan2(float y,
                                                     float x)
```
\brief Calculates the angle of a 2D vector in degrees.
The function fastAtan2 calculates the full-range angle of an input 2D vector. The angle is measured in degrees and varies from 0 to 360 degrees. The accuracy is about 0.3 degrees.

Parameters:

x - x-coordinate of the vector.

y - y-coordinate of the vector.

getIppFeatures

@Namespace(value="cv::ipp")
 @Cast(value="unsigned long long")
public static long getIppFeatures()

setIppStatus

@Namespace(value="cv::ipp")
public static void setIppStatus(int status,
                                                            @Cast(value="const char*")
                                                            org.bytedeco.javacpp.BytePointer funcname,
                                                            @Cast(value="const char*")
                                                            org.bytedeco.javacpp.BytePointer filename,
                                                            int line)

setIppStatus

@Namespace(value="cv::ipp")
public static void setIppStatus(int status)

setIppStatus

@Namespace(value="cv::ipp")
public static void setIppStatus(int status,
                                                            String funcname,
                                                            String filename,
                                                            int line)

getIppStatus

@Namespace(value="cv::ipp")
public static int getIppStatus()

getIppErrorLocation

@Namespace(value="cv::ipp")
 @opencv_core.Str
public static org.bytedeco.javacpp.BytePointer getIppErrorLocation()

useIPP

@Namespace(value="cv::ipp")
 @Cast(value="bool")
public static boolean useIPP()

setUseIPP

@Namespace(value="cv::ipp")
public static void setUseIPP(@Cast(value="bool")
                                                         boolean flag)

getIppVersion

@Namespace(value="cv::ipp")
 @opencv_core.Str
public static org.bytedeco.javacpp.BytePointer getIppVersion()

useIPP_NE

@Namespace(value="cv::ipp")
 @Cast(value="bool")
public static boolean useIPP_NE()

setUseIPP_NE

@Namespace(value="cv::ipp")
public static void setUseIPP_NE(@Cast(value="bool")
                                                            boolean flag)

abs

@Namespace(value="cv")
 @Cast(value="uchar")
public static byte abs(@Cast(value="uchar")
                                                                    byte a)

\endcond

\} core_utils

abs

@Namespace(value="cv")
 @Cast(value="ushort")
public static short abs(@Cast(value="ushort")
                                                                      short a)

abs

@Namespace(value="cv")
 @Cast(value="unsigned")
public static int abs(@Cast(value="unsigned")
                                                                      int a)

fastMalloc
```
@Namespace(value="cv")
public static org.bytedeco.javacpp.Pointer fastMalloc(@Cast(value="size_t")
                                                                             long bufSize)
```
\addtogroup core_utils \{
//////////////////////////// memory management functions ////////////////////////////
/** \brief Allocates an aligned memory buffer.
The function allocates the buffer of the specified size and returns it. When the buffer size is 16 bytes or more, the returned buffer is aligned to 16 bytes.

Parameters:

bufSize - Allocated buffer size.

fastFree
```
@Namespace(value="cv")
public static void fastFree(org.bytedeco.javacpp.Pointer ptr)
```
\brief Deallocates a memory buffer.
The function deallocates the buffer allocated with fastMalloc . If NULL pointer is passed, the function does nothing. C version of the function clears the pointer *pptr* to avoid problems with double memory deallocation.

Parameters:

ptr - Pointer to the allocated buffer.

add

@Namespace(value="cv")
 @opencv_core.Str
 @Name(value="operator +")
public static org.bytedeco.javacpp.BytePointer add(@opencv_core.Str
                                                                                                                       org.bytedeco.javacpp.BytePointer lhs,
                                                                                                                       @opencv_core.Str
                                                                                                                       org.bytedeco.javacpp.BytePointer rhs)

\relates cv::String /** \{

add

@Namespace(value="cv")
 @opencv_core.Str
 @Name(value="operator +")
public static String add(@opencv_core.Str
                                                                                             String lhs,
                                                                                             @opencv_core.Str
                                                                                             String rhs)

add

@Namespace(value="cv")
 @opencv_core.Str
 @Name(value="operator +")
public static org.bytedeco.javacpp.BytePointer add(@opencv_core.Str
                                                                                                                       org.bytedeco.javacpp.BytePointer lhs,
                                                                                                                       @Cast(value="char")
                                                                                                                       byte rhs)

add

@Namespace(value="cv")
 @opencv_core.Str
 @Name(value="operator +")
public static String add(@opencv_core.Str
                                                                                             String lhs,
                                                                                             @Cast(value="char")
                                                                                             byte rhs)

add

@Namespace(value="cv")
 @opencv_core.Str
 @Name(value="operator +")
public static org.bytedeco.javacpp.BytePointer add(@Cast(value="char")
                                                                                                                       byte lhs,
                                                                                                                       @opencv_core.Str
                                                                                                                       org.bytedeco.javacpp.BytePointer rhs)

add

@Namespace(value="cv")
 @opencv_core.Str
 @Name(value="operator +")
public static String add(@Cast(value="char")
                                                                                             byte lhs,
                                                                                             @opencv_core.Str
                                                                                             String rhs)

equals

@Namespace(value="cv")
 @Cast(value="bool")
 @Name(value="operator ==")
public static boolean equals(@opencv_core.Str
                                                                                                     org.bytedeco.javacpp.BytePointer lhs,
                                                                                                     @opencv_core.Str
                                                                                                     org.bytedeco.javacpp.BytePointer rhs)

equals

@Namespace(value="cv")
 @Cast(value="bool")
 @Name(value="operator ==")
public static boolean equals(@opencv_core.Str
                                                                                                     String lhs,
                                                                                                     @opencv_core.Str
                                                                                                     String rhs)

notEquals

@Namespace(value="cv")
 @Cast(value="bool")
 @Name(value="operator !=")
public static boolean notEquals(@opencv_core.Str
                                                                                                        org.bytedeco.javacpp.BytePointer lhs,
                                                                                                        @opencv_core.Str
                                                                                                        org.bytedeco.javacpp.BytePointer rhs)

notEquals

@Namespace(value="cv")
 @Cast(value="bool")
 @Name(value="operator !=")
public static boolean notEquals(@opencv_core.Str
                                                                                                        String lhs,
                                                                                                        @opencv_core.Str
                                                                                                        String rhs)

lessThan

@Namespace(value="cv")
 @Cast(value="bool")
 @Name(value="operator <")
public static boolean lessThan(@opencv_core.Str
                                                                                                      org.bytedeco.javacpp.BytePointer lhs,
                                                                                                      @opencv_core.Str
                                                                                                      org.bytedeco.javacpp.BytePointer rhs)

lessThan

@Namespace(value="cv")
 @Cast(value="bool")
 @Name(value="operator <")
public static boolean lessThan(@opencv_core.Str
                                                                                                      String lhs,
                                                                                                      @opencv_core.Str
                                                                                                      String rhs)

lessThanEquals

@Namespace(value="cv")
 @Cast(value="bool")
 @Name(value="operator <=")
public static boolean lessThanEquals(@opencv_core.Str
                                                                                                             org.bytedeco.javacpp.BytePointer lhs,
                                                                                                             @opencv_core.Str
                                                                                                             org.bytedeco.javacpp.BytePointer rhs)

lessThanEquals

@Namespace(value="cv")
 @Cast(value="bool")
 @Name(value="operator <=")
public static boolean lessThanEquals(@opencv_core.Str
                                                                                                             String lhs,
                                                                                                             @opencv_core.Str
                                                                                                             String rhs)

greaterThan

@Namespace(value="cv")
 @Cast(value="bool")
 @Name(value="operator >")
public static boolean greaterThan(@opencv_core.Str
                                                                                                         org.bytedeco.javacpp.BytePointer lhs,
                                                                                                         @opencv_core.Str
                                                                                                         org.bytedeco.javacpp.BytePointer rhs)

greaterThan

@Namespace(value="cv")
 @Cast(value="bool")
 @Name(value="operator >")
public static boolean greaterThan(@opencv_core.Str
                                                                                                         String lhs,
                                                                                                         @opencv_core.Str
                                                                                                         String rhs)

greaterThanEquals

@Namespace(value="cv")
 @Cast(value="bool")
 @Name(value="operator >=")
public static boolean greaterThanEquals(@opencv_core.Str
                                                                                                                org.bytedeco.javacpp.BytePointer lhs,
                                                                                                                @opencv_core.Str
                                                                                                                org.bytedeco.javacpp.BytePointer rhs)

greaterThanEquals

@Namespace(value="cv")
 @Cast(value="bool")
 @Name(value="operator >=")
public static boolean greaterThanEquals(@opencv_core.Str
                                                                                                                String lhs,
                                                                                                                @opencv_core.Str
                                                                                                                String rhs)

swap

@Namespace(value="std")
public static void swap(@opencv_core.Str
                                                org.bytedeco.javacpp.BytePointer a,
                                                @opencv_core.Str
                                                org.bytedeco.javacpp.BytePointer b)

\} relates cv::String

swap

@Namespace(value="std")
public static void swap(@opencv_core.Str
                                                String a,
                                                @opencv_core.Str
                                                String b)

setBreakOnError
```
@Namespace(value="cv")
 @Cast(value="bool")
public static boolean setBreakOnError(@Cast(value="bool")
                                                                                  boolean flag)
```
\brief 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.

Returns:

the previous state

redirectError

@Namespace(value="cv")
public static opencv_core.ErrorCallback redirectError(opencv_core.ErrorCallback errCallback,
                                                                             org.bytedeco.javacpp.Pointer userdata,
                                                                             @Cast(value="void**")
                                                                             org.bytedeco.javacpp.PointerPointer prevUserdata)

\brief Sets the new error handler and the optional user data.

The function sets the new error handler, called from cv::error().

Parameters:: errCallback - the new error handler. If NULL, the default error handler is used.; userdata - the optional user data pointer, passed to the callback.; prevUserdata - the optional output parameter where the previous user data pointer is stored
Returns:: the previous error handler

redirectError

@Namespace(value="cv")
public static opencv_core.ErrorCallback redirectError(opencv_core.ErrorCallback errCallback)

redirectError

@Namespace(value="cv")
public static opencv_core.ErrorCallback redirectError(opencv_core.ErrorCallback errCallback,
                                                                             org.bytedeco.javacpp.Pointer userdata,
                                                                             @Cast(value="void**") @ByPtrPtr
                                                                             org.bytedeco.javacpp.Pointer prevUserdata)

tempfile

@Namespace(value="cv")
 @opencv_core.Str
public static org.bytedeco.javacpp.BytePointer tempfile(@Cast(value="const char*")
                                                                                                 org.bytedeco.javacpp.BytePointer suffix)

tempfile

@Namespace(value="cv")
 @opencv_core.Str
public static org.bytedeco.javacpp.BytePointer tempfile()

tempfile

@Namespace(value="cv")
 @opencv_core.Str
public static String tempfile(String suffix)

glob

@Namespace(value="cv")
public static void glob(@opencv_core.Str
                                               org.bytedeco.javacpp.BytePointer pattern,
                                               @ByRef
                                               opencv_core.StringVector result,
                                               @Cast(value="bool")
                                               boolean recursive)

glob

@Namespace(value="cv")
public static void glob(@opencv_core.Str
                                               org.bytedeco.javacpp.BytePointer pattern,
                                               @ByRef
                                               opencv_core.StringVector result)

glob

@Namespace(value="cv")
public static void glob(@opencv_core.Str
                                               String pattern,
                                               @ByRef
                                               opencv_core.StringVector result,
                                               @Cast(value="bool")
                                               boolean recursive)

glob

@Namespace(value="cv")
public static void glob(@opencv_core.Str
                                               String pattern,
                                               @ByRef
                                               opencv_core.StringVector result)

setNumThreads
```
@Namespace(value="cv")
public static void setNumThreads(int nthreads)
```
\brief OpenCV will try to set the number of threads for the next parallel region.
If threads == 0, OpenCV will disable threading optimizations and run all it's functions sequentially. Passing threads \< 0 will reset threads number to system default. This function must be called outside of parallel region.
OpenCV will try to run its functions with specified threads number, but some behaviour differs from framework: - TBB - User-defined parallel constructions will run with the same threads number, if another is not specified. If later on user creates his own scheduler, OpenCV will use it. - OpenMP - No special defined behaviour. - Concurrency - If threads == 1, OpenCV will disable threading optimizations and run its functions sequentially. - GCD - Supports only values \<= 0. - C= - No special defined behaviour.

Parameters:

nthreads - Number of threads used by OpenCV. \sa getNumThreads, getThreadNum

getNumThreads
```
@Namespace(value="cv")
public static int getNumThreads()
```
\brief Returns the number of threads used by OpenCV for parallel regions.
Always returns 1 if OpenCV is built without threading support.
The exact meaning of return value depends on the threading framework used by OpenCV library: - TBB - The number of threads, that OpenCV will try to use for parallel regions. If there is any tbb::thread_scheduler_init in user code conflicting with OpenCV, then function returns default number of threads used by TBB library. - OpenMP - An upper bound on the number of threads that could be used to form a new team. - Concurrency - The number of threads, that OpenCV will try to use for parallel regions. - GCD - Unsupported; returns the GCD thread pool limit (512) for compatibility. - C= - The number of threads, that OpenCV will try to use for parallel regions, if before called setNumThreads with threads \> 0, otherwise returns the number of logical CPUs, available for the process. \sa setNumThreads, getThreadNum

getThreadNum
```
@Namespace(value="cv")
public static int getThreadNum()
```
Deprecated. Current implementation doesn't corresponding to this documentation.
The exact meaning of the return value depends on the threading framework used by OpenCV library: - TBB - Unsupported with current 4.1 TBB release. Maybe will be supported in future. - OpenMP - The thread number, within the current team, of the calling thread. - Concurrency - An ID for the virtual processor that the current context is executing on (0 for master thread and unique number for others, but not necessary 1,2,3,...). - GCD - System calling thread's ID. Never returns 0 inside parallel region. - C= - The index of the current parallel task. \sa setNumThreads, getNumThreads

\brief Returns the index of the currently executed thread within the current parallel region. Always returns 0 if called outside of parallel region.

getBuildInformation
```
@Namespace(value="cv")
 @opencv_core.Str
public static org.bytedeco.javacpp.BytePointer getBuildInformation()
```
\brief Returns full configuration time cmake output.
Returned value is raw cmake output including version control system revision, compiler version, compiler flags, enabled modules and third party libraries, etc. Output format depends on target architecture.

getVersionString
```
@Namespace(value="cv")
 @opencv_core.Str
public static org.bytedeco.javacpp.BytePointer getVersionString()
```
\brief Returns library version string
For example "3.4.1-dev".
\sa getMajorVersion, getMinorVersion, getRevisionVersion

getVersionMajor

@Namespace(value="cv")
public static int getVersionMajor()

\brief Returns major library version

getVersionMinor

@Namespace(value="cv")
public static int getVersionMinor()

\brief Returns minor library version

getVersionRevision
```
@Namespace(value="cv")
public static int getVersionRevision()
```
\brief Returns revision field of the library version

getTickCount
```
@Namespace(value="cv")
 @Cast(value="int64")
public static long getTickCount()
```
\brief Returns the number of ticks.
The function returns the number of ticks after the certain event (for example, when the machine was turned on). It can be used to initialize RNG or to measure a function execution time by reading the tick count before and after the function call. \sa getTickFrequency, TickMeter

getTickFrequency
```
@Namespace(value="cv")
public static double getTickFrequency()
```
\brief Returns the number of ticks per second.
The function returns the number of ticks per second. That is, the following code computes the execution time in seconds:
```
    double t = (double)getTickCount();
    // do something ...
    t = ((double)getTickCount() - t)/getTickFrequency();
```
\sa getTickCount, TickMeter

shiftLeft

@Namespace(value="cv")
 @Cast(value="std::ostream*")
 @ByRef
 @Name(value="operator <<")
public static org.bytedeco.javacpp.Pointer shiftLeft(@Cast(value="std::ostream*") @ByRef
                                                                                                                                              org.bytedeco.javacpp.Pointer out,
                                                                                                                                              @Const @ByRef
                                                                                                                                              opencv_core.TickMeter tm)

\brief output operator


TickMeter tm;
tm.start();
// do something ...
tm.stop();
std::cout << tm;

getCPUTickCount
```
@Namespace(value="cv")
 @Cast(value="int64")
public static long getCPUTickCount()
```
\brief Returns the number of CPU ticks.
The function returns the current number of CPU ticks on some architectures (such as x86, x64, PowerPC). On other platforms the function is equivalent to getTickCount. It can also be used for very accurate time measurements, as well as for RNG initialization. Note that in case of multi-CPU systems a thread, from which getCPUTickCount is called, can be suspended and resumed at another CPU with its own counter. So, theoretically (and practically) the subsequent calls to the function do not necessary return the monotonously increasing values. Also, since a modern CPU varies the CPU frequency depending on the load, the number of CPU clocks spent in some code cannot be directly converted to time units. Therefore, getTickCount is generally a preferable solution for measuring execution time.

checkHardwareSupport
```
@Namespace(value="cv")
 @Cast(value="bool")
public static boolean checkHardwareSupport(int feature)
```
\brief Returns true if the specified feature is supported by the host hardware.
The function returns true if the host hardware supports the specified feature. When user calls setUseOptimized(false), the subsequent calls to checkHardwareSupport() will return false until setUseOptimized(true) is called. This way user can dynamically switch on and off the optimized code in OpenCV.

Parameters:

feature - The feature of interest, one of cv::CpuFeatures

getHardwareFeatureName

@Namespace(value="cv")
 @opencv_core.Str
public static org.bytedeco.javacpp.BytePointer getHardwareFeatureName(int feature)

\brief Returns feature name by ID

Returns empty string if feature is not defined

getCPUFeaturesLine
```
@Namespace(value="cv")
 @StdString
public static org.bytedeco.javacpp.BytePointer getCPUFeaturesLine()
```
\brief Returns list of CPU features enabled during compilation.
Returned value is a string containing space separated list of CPU features with following markers:
- no markers - baseline features - prefix * - features enabled in dispatcher - suffix ? - features enabled but not available in HW
Example: SSE SSE2 SSE3 *SSE4.1 *SSE4.2 *FP16 *AVX *AVX2 *AVX512-SKX?

getNumberOfCPUs
```
@Namespace(value="cv")
public static int getNumberOfCPUs()
```
\brief Returns the number of logical CPUs available for the process.

alignSize
```
@Namespace(value="cv")
 @Cast(value="size_t")
public static long alignSize(@Cast(value="size_t")
                                                                           long sz,
                                                                           int n)
```
\brief Aligns a buffer size to the specified number of bytes.
The function returns the minimum number that is greater than or equal to sz and is divisible by n : \f[\texttt{(sz + n-1) & -n}\f]

Parameters:

sz - Buffer size to align.

n - Alignment size that must be a power of two.

divUp

@Namespace(value="cv")
public static int divUp(int a,
                                               @Cast(value="unsigned int")
                                               int b)

\brief Integer division with result round up.

Use this function instead of ceil((float)a / b) expressions.

\sa alignSize

divUp

@Namespace(value="cv")
 @Cast(value="size_t")
public static long divUp(@Cast(value="size_t")
                                                                       long a,
                                                                       @Cast(value="unsigned int")
                                                                       int b)

\overload

setUseOptimized
```
@Namespace(value="cv")
public static void setUseOptimized(@Cast(value="bool")
                                                          boolean onoff)
```
\brief Enables or disables the optimized code.
The function can be used to dynamically turn on and off optimized code (code that uses SSE2, AVX, and other instructions on the platforms that support it). It sets a global flag that is further checked by OpenCV functions. Since the flag is not checked in the inner OpenCV loops, it is only safe to call the function on the very top level in your application where you can be sure that no other OpenCV function is currently executed.
By default, the optimized code is enabled unless you disable it in CMake. The current status can be retrieved using useOptimized.

Parameters:

onoff - The boolean flag specifying whether the optimized code should be used (onoff=true) or not (onoff=false).

useOptimized
```
@Namespace(value="cv")
 @Cast(value="bool")
public static boolean useOptimized()
```
\brief Returns the status of optimized code usage.
The function returns true if the optimized code is enabled. Otherwise, it returns false.

getElemSize

@Namespace(value="cv")
 @Cast(value="size_t")
public static long getElemSize(int type)

parallel_for_

@Namespace(value="cv")
public static void parallel_for_(@Const @ByRef
                                                        opencv_core.Range range,
                                                        @Const @ByRef
                                                        opencv_core.ParallelLoopBody body,
                                                        double nstripes)

\brief Parallel data processor

parallel_for_

@Namespace(value="cv")
public static void parallel_for_(@Const @ByRef
                                                        opencv_core.Range range,
                                                        @Const @ByRef
                                                        opencv_core.ParallelLoopBody body)

equals

@Namespace(value="cv::instr")
 @Cast(value="bool")
 @Name(value="operator ==")
public static boolean equals(@Const @ByRef
                                                                                                            opencv_core.NodeData lhs,
                                                                                                            @Const @ByRef
                                                                                                            opencv_core.NodeData rhs)

getTrace

@Namespace(value="cv::instr")
public static opencv_core.InstrNode getTrace()

useInstrumentation

@Namespace(value="cv::instr")
 @Cast(value="bool")
public static boolean useInstrumentation()

setUseInstrumentation

@Namespace(value="cv::instr")
public static void setUseInstrumentation(@Cast(value="bool")
                                                                       boolean flag)

resetTrace

@Namespace(value="cv::instr")
public static void resetTrace()

setFlags

@Namespace(value="cv::instr")
public static void setFlags(@Cast(value="cv::instr::FLAGS")
                                                          int modeFlags)

getFlags

@Namespace(value="cv::instr")
 @Cast(value="cv::instr::FLAGS")
public static int getFlags()

getThreadID

@Namespace(value="cv::utils")
public static int getThreadID()

cvRNG
```
@Cast(value="CvRNG")
public static long cvRNG(@Cast(value="int64")
                                              long seed)
```
\brief Initializes a random number generator state.
The function initializes a random number generator and returns the state. The pointer to the state can be then passed to the cvRandInt, cvRandReal and cvRandArr functions. In the current implementation a multiply-with-carry generator is used.

Parameters:

seed - 64-bit value used to initiate a random sequence \sa the C++ class RNG replaced CvRNG.

cvRNG

@Cast(value="CvRNG")
public static long cvRNG()

cvRandInt
```
@Cast(value="unsigned")
public static int cvRandInt(@Cast(value="CvRNG*")
                                                    org.bytedeco.javacpp.LongPointer rng)
```
\brief Returns a 32-bit unsigned integer and updates RNG.
The function returns a uniformly-distributed random 32-bit unsigned integer and updates the RNG state. It is similar to the rand() function from the C runtime library, except that OpenCV functions always generates a 32-bit random number, regardless of the platform.

Parameters:

rng - CvRNG state initialized by cvRNG.

cvRandInt

@Cast(value="unsigned")
public static int cvRandInt(@Cast(value="CvRNG*")
                                                    LongBuffer rng)

cvRandInt

@Cast(value="unsigned")
public static int cvRandInt(@Cast(value="CvRNG*")
                                                    long[] rng)

cvRandReal
```
public static double cvRandReal(@Cast(value="CvRNG*")
                                org.bytedeco.javacpp.LongPointer rng)
```
\brief Returns a floating-point random number and updates RNG.
The function returns a uniformly-distributed random floating-point number between 0 and 1 (1 is not included).

Parameters:

rng - RNG state initialized by cvRNG

cvRandReal

public static double cvRandReal(@Cast(value="CvRNG*")
                                LongBuffer rng)

cvRandReal

public static double cvRandReal(@Cast(value="CvRNG*")
                                long[] rng)

IPL_IMAGE_MAGIC_VAL

@MemberGetter
public static int IPL_IMAGE_MAGIC_VAL()

cvMat

@ByVal
public static opencv_core.CvMat cvMat(@Const @ByRef
                                             opencv_core.Mat m)

cvMat

@ByVal
public static opencv_core.CvMat cvMat(int rows,
                                             int cols,
                                             int type,
                                             org.bytedeco.javacpp.Pointer data)

Inline constructor. No data is allocated internally!!! (Use together with cvCreateData, or use cvCreateMat instead to get a matrix with allocated data):

cvMat

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

cvmGet
```
public static double cvmGet(@Const
                            opencv_core.CvMat mat,
                            int row,
                            int col)
```
\brief Returns the particular element of single-channel floating-point matrix.
The function is a fast replacement for cvGetReal2D in the case of single-channel floating-point matrices. It is faster because it is inline, it does fewer checks for array type and array element type, and it checks for the row and column ranges only in debug mode.

Parameters:

mat - Input matrix

row - The zero-based index of row

col - The zero-based index of column

cvmSet
```
public static void cvmSet(opencv_core.CvMat mat,
                          int row,
                          int col,
                          double value)
```
\brief Sets a specific element of a single-channel floating-point matrix.
The function is a fast replacement for cvSetReal2D in the case of single-channel floating-point matrices. It is faster because it is inline, it does fewer checks for array type and array element type, and it checks for the row and column ranges only in debug mode.

Parameters:

mat - The matrix

row - The zero-based index of row

col - The zero-based index of column

value - The new value of the matrix element

cvIplDepth

public static int cvIplDepth(int type)

cvCreateSparseMat

public static opencv_core.CvSparseMat cvCreateSparseMat(@Const @ByRef
                                                        opencv_core.SparseMat m)

cvRect

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

constructs CvRect structure.

cvRectToROI

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

cvROIToRect

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

cvTermCriteria

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

cvPoint

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

constructs CvPoint structure.

cvPoint2D32f

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

constructs CvPoint2D32f structure.

cvPointTo32f

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

converts CvPoint to CvPoint2D32f.

cvPointTo32f

@ByVal
 @Cast(value="CvPoint2D32f*")
public static FloatBuffer cvPointTo32f(@ByVal @Cast(value="CvPoint*")
                                                                            IntBuffer point)

cvPointTo32f

@ByVal
 @Cast(value="CvPoint2D32f*")
public static float[] cvPointTo32f(@ByVal @Cast(value="CvPoint*")
                                                                        int[] point)

cvPointFrom32f

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

converts CvPoint2D32f to CvPoint.

cvPointFrom32f

@ByVal
 @Cast(value="CvPoint*")
public static IntBuffer cvPointFrom32f(@ByVal @Cast(value="CvPoint2D32f*")
                                                                       FloatBuffer point)

cvPointFrom32f

@ByVal
 @Cast(value="CvPoint*")
public static int[] cvPointFrom32f(@ByVal @Cast(value="CvPoint2D32f*")
                                                                   float[] point)

cvPoint3D32f

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

constructs CvPoint3D32f structure.

cvPoint2D64f

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

constructs CvPoint2D64f structure.

cvPoint3D64f

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

constructs CvPoint3D64f structure.

cvSize

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

constructs CvSize structure.

cvSize2D32f

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

constructs CvSize2D32f structure.

cvSlice

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

cvScalar

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

cvScalar

@ByVal
public static opencv_core.CvScalar cvScalar(double val0)

cvRealScalar

@ByVal
public static opencv_core.CvScalar cvRealScalar(double val0)

cvScalarAll

@ByVal
public static opencv_core.CvScalar cvScalarAll(double val0123)

CV_SET_ELEM_FREE_FLAG

@MemberGetter
public static int CV_SET_ELEM_FREE_FLAG()

cvAttrList

@ByVal
public static opencv_core.CvAttrList cvAttrList(@Cast(value="const char**")
                                                       org.bytedeco.javacpp.PointerPointer attr,
                                                       opencv_core.CvAttrList next)

initializes CvAttrList structure

cvAttrList

@ByVal
public static opencv_core.CvAttrList cvAttrList()

cvAttrList

@ByVal
public static opencv_core.CvAttrList cvAttrList(@Cast(value="const char**") @ByPtrPtr
                                                       org.bytedeco.javacpp.BytePointer attr,
                                                       opencv_core.CvAttrList next)

cvAttrList

@ByVal
public static opencv_core.CvAttrList cvAttrList(@Cast(value="const char**") @ByPtrPtr
                                                       ByteBuffer attr,
                                                       opencv_core.CvAttrList next)

cvAttrList

@ByVal
public static opencv_core.CvAttrList cvAttrList(@Cast(value="const char**") @ByPtrPtr
                                                       byte[] attr,
                                                       opencv_core.CvAttrList next)

cvAlloc
```
public static org.bytedeco.javacpp.Pointer cvAlloc(@Cast(value="size_t")
                                                   long size)
```
malloc wrapper. If there is no enough memory, the function (as well as other OpenCV functions that call cvAlloc) raises an error.

cvFree_
```
public static void cvFree_(org.bytedeco.javacpp.Pointer ptr)
```
free wrapper. Here and further all the memory releasing functions (that all call cvFree) take double pointer in order to to clear pointer to the data after releasing it. Passing pointer to NULL pointer is Ok: nothing happens in this case

cvCreateImageHeader

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

\brief Creates an image header but does not allocate the image data.

Parameters:: size - Image width and height; depth - Image depth (see cvCreateImage ); channels - Number of channels (see cvCreateImage )

cvInitImageHeader

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

\brief Initializes an image header that was previously allocated.

The returned IplImage\* points to the initialized header.

Parameters:: image - Image header to initialize; size - Image width and height; depth - Image depth (see cvCreateImage ); channels - Number of channels (see cvCreateImage ); origin - Top-left IPL_ORIGIN_TL or bottom-left IPL_ORIGIN_BL; align - Alignment for image rows, typically 4 or 8 bytes

cvInitImageHeader

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

cvCreateImage

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

\brief Creates an image header and allocates the image data.

This function call is equivalent to the following code:


    header = cvCreateImageHeader(size, depth, channels);
    cvCreateData(header);

Parameters:: size - Image width and height; depth - Bit depth of image elements. See IplImage for valid depths.; channels - Number of channels per pixel. See IplImage for details. This function only creates images with interleaved channels.

cvReleaseImageHeader

public static void cvReleaseImageHeader(@Cast(value="IplImage**")
                                        org.bytedeco.javacpp.PointerPointer image)

\brief Deallocates an image header.

This call is an analogue of :


    if(image )
    {
        iplDeallocate(*image, IPL_IMAGE_HEADER | IPL_IMAGE_ROI);
image = 0;
    }

but it does not use IPL functions by default (see the CV_TURN_ON_IPL_COMPATIBILITY macro).

Parameters:: image - Double pointer to the image header

cvReleaseImageHeader

public static void cvReleaseImageHeader(@ByPtrPtr
                                        opencv_core.IplImage image)

cvReleaseImage

public static void cvReleaseImage(@Cast(value="IplImage**")
                                  org.bytedeco.javacpp.PointerPointer image)

\brief Deallocates the image header and the image data.

This call is a shortened form of :


    if(*image )
    {
        cvReleaseData(*image);
        cvReleaseImageHeader(image);
    }

Parameters:: image - Double pointer to the image header

cvReleaseImage

public static void cvReleaseImage(@ByPtrPtr
                                  opencv_core.IplImage image)

cvCloneImage

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

Creates a copy of IPL image (widthStep may differ)

cvSetImageCOI
```
public static void cvSetImageCOI(opencv_core.IplImage image,
                                 int coi)
```
\brief Sets the channel of interest in an IplImage.
If the ROI is set to NULL and the coi is *not* 0, the ROI is allocated. Most OpenCV functions do not* support the COI setting, so to process an individual image/matrix channel one may copy (via cvCopy or cvSplit) the channel to a separate image/matrix, process it and then copy the result back (via cvCopy or cvMerge) if needed.

Parameters:

image - A pointer to the image header

coi - The channel of interest. 0 - all channels are selected, 1 - first channel is selected, etc. Note that the channel indices become 1-based.

cvGetImageCOI
```
public static int cvGetImageCOI(@Const
                                opencv_core.IplImage image)
```
\brief Returns the index of the channel of interest.
Returns the channel of interest of in an IplImage. Returned values correspond to the coi in cvSetImageCOI.

Parameters:

image - A pointer to the image header

cvSetImageROI
```
public static void cvSetImageROI(opencv_core.IplImage image,
                                 @ByVal
                                 opencv_core.CvRect rect)
```
\brief Sets an image Region Of Interest (ROI) for a given rectangle.
If the original image ROI was NULL and the rect is not the whole image, the ROI structure is allocated.
Most OpenCV functions support the use of ROI and treat the image rectangle as a separate image. For example, all of the pixel coordinates are counted from the top-left (or bottom-left) corner of the ROI, not the original image.

Parameters:

image - A pointer to the image header

rect - The ROI rectangle

cvResetImageROI
```
public static void cvResetImageROI(opencv_core.IplImage image)
```
\brief Resets the image ROI to include the entire image and releases the ROI structure.
This produces a similar result to the following, but in addition it releases the ROI structure. :
```
    cvSetImageROI(image, cvRect(0, 0, image->width, image->height ));
    cvSetImageCOI(image, 0);
```
Parameters:

image - A pointer to the image header

cvGetImageROI

@ByVal
public static opencv_core.CvRect cvGetImageROI(@Const
                                                      opencv_core.IplImage image)

\brief Returns the image ROI.

If there is no ROI set, cvRect(0,0,image-\>width,image-\>height) is returned.

Parameters:: image - A pointer to the image header

cvCreateMatHeader
```
public static opencv_core.CvMat cvCreateMatHeader(int rows,
                                                  int cols,
                                                  int type)
```
\brief Creates a matrix header but does not allocate the matrix data.
The function allocates a new matrix header and returns a pointer to it. The matrix data can then be allocated using cvCreateData or set explicitly to user-allocated data via cvSetData.

Parameters:

rows - Number of rows in the matrix

cols - Number of columns in the matrix

type - Type of the matrix elements, see cvCreateMat

cvInitMatHeader

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

\brief Initializes a pre-allocated matrix header.

This function is often used to process raw data with OpenCV matrix functions. For example, the following code computes the matrix product of two matrices, stored as ordinary arrays:


    double a[] = { 1, 2, 3, 4,
                   5, 6, 7, 8,
                   9, 10, 11, 12 };

    double b[] = { 1, 5, 9,
                   2, 6, 10,
                   3, 7, 11,
                   4, 8, 12 };

    double c[9];
    CvMat Ma, Mb, Mc ;

    cvInitMatHeader(&Ma, 3, 4, CV_64FC1, a);
    cvInitMatHeader(&Mb, 4, 3, CV_64FC1, b);
    cvInitMatHeader(&Mc, 3, 3, CV_64FC1, c);

    cvMatMulAdd(&Ma, &Mb, 0, &Mc);
    // the c array now contains the product of a (3x4) and b (4x3)

Parameters:: mat - A pointer to the matrix header to be initialized; rows - Number of rows in the matrix; cols - Number of columns in the matrix; type - Type of the matrix elements, see cvCreateMat .; data - Optional: data pointer assigned to the matrix header; step - Optional: full row width in bytes of the assigned data. By default, the minimal possible step is used which assumes there are no gaps between subsequent rows of the matrix.

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)
```
\brief Creates a matrix header and allocates the matrix data.
The function call is equivalent to the following code:
```
    CvMat* mat = cvCreateMatHeader(rows, cols, type);
    cvCreateData(mat);
```
Parameters:

rows - Number of rows in the matrix

cols - Number of columns in the matrix

type - The type of the matrix elements in the form CV_\\C\ , where S=signed, U=unsigned, F=float. For example, CV _ 8UC1 means the elements are 8-bit unsigned and the there is 1 channel, and CV _ 32SC2 means the elements are 32-bit signed and there are 2 channels.

cvReleaseMat
```
public static void cvReleaseMat(@Cast(value="CvMat**")
                                org.bytedeco.javacpp.PointerPointer mat)
```
\brief Deallocates a matrix.
The function decrements the matrix data reference counter and deallocates matrix header. If the data reference counter is 0, it also deallocates the data. :
```
    if(*mat )
        cvDecRefData(*mat);
    cvFree((void**)mat);
```
Parameters:

mat - Double pointer to the matrix

cvReleaseMat

public static void cvReleaseMat(@ByPtrPtr
                                opencv_core.CvMat mat)

cvDecRefData
```
public static void cvDecRefData(opencv_core.CvArr arr)
```
\brief Decrements an array data reference counter.
The function decrements the data reference counter in a CvMat or CvMatND if the reference counter
pointer is not NULL. If the counter reaches zero, the data is deallocated. In the current implementation the reference counter is not NULL only if the data was allocated using the cvCreateData function. The counter will be NULL in other cases such as: external data was assigned to the header using cvSetData, header is part of a larger matrix or image, or the header was converted from an image or n-dimensional matrix header.

Parameters:

arr - Pointer to an array header

cvIncRefData
```
public static int cvIncRefData(opencv_core.CvArr arr)
```
\brief Increments array data reference counter.
The function increments CvMat or CvMatND data reference counter and returns the new counter value if the reference counter pointer is not NULL, otherwise it returns zero.

Parameters:

arr - Array header

cvCloneMat

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

Creates an exact copy of the input matrix (except, may be, step value)

cvGetSubRect
```
public static opencv_core.CvMat cvGetSubRect(@Const
                                             opencv_core.CvArr arr,
                                             opencv_core.CvMat submat,
                                             @ByVal
                                             opencv_core.CvRect rect)
```
\brief Returns matrix header corresponding to the rectangular sub-array of input image or matrix.
The function returns header, corresponding to a specified rectangle of the input array. In other
words, it allows the user to treat a rectangular part of input array as a stand-alone array. ROI is taken into account by the function so the sub-array of ROI is actually extracted.

Parameters:

arr - Input array

submat - Pointer to the resultant sub-array header

rect - Zero-based coordinates of the rectangle of interest

cvGetSubArr

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

cvGetRows
```
public static opencv_core.CvMat cvGetRows(@Const
                                          opencv_core.CvArr arr,
                                          opencv_core.CvMat submat,
                                          int start_row,
                                          int end_row,
                                          int delta_row)
```
\brief Returns array row or row span.
The function returns the header, corresponding to a specified row/row span of the input array. cvGetRow(arr, submat, row) is a shortcut for cvGetRows(arr, submat, row, row+1).

Parameters:

arr - Input array

submat - Pointer to the resulting sub-array header

start_row - Zero-based index of the starting row (inclusive) of the span

end_row - Zero-based index of the ending row (exclusive) of the span

delta_row - Index step in the row span. That is, the function extracts every delta_row -th row from start_row and up to (but not including) end_row .

cvGetRows

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

cvGetRow

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

\overload

Parameters:: arr - Input array; submat - Pointer to the resulting sub-array header; row - Zero-based index of the selected row

cvGetCols
```
public static opencv_core.CvMat cvGetCols(@Const
                                          opencv_core.CvArr arr,
                                          opencv_core.CvMat submat,
                                          int start_col,
                                          int end_col)
```
\brief Returns one of more array columns.
The function returns the header, corresponding to a specified column span of the input array. That
is, no data is copied. Therefore, any modifications of the submatrix will affect the original array. If you need to copy the columns, use cvCloneMat. cvGetCol(arr, submat, col) is a shortcut for cvGetCols(arr, submat, col, col+1).

Parameters:

arr - Input array

submat - Pointer to the resulting sub-array header

start_col - Zero-based index of the starting column (inclusive) of the span

end_col - Zero-based index of the ending column (exclusive) of the span

cvGetCol

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

\overload

Parameters:: arr - Input array; submat - Pointer to the resulting sub-array header; col - Zero-based index of the selected column

cvGetDiag
```
public static opencv_core.CvMat cvGetDiag(@Const
                                          opencv_core.CvArr arr,
                                          opencv_core.CvMat submat,
                                          int diag)
```
\brief Returns one of array diagonals.
The function returns the header, corresponding to a specified diagonal of the input array.

Parameters:

arr - Input array

submat - Pointer to the resulting sub-array header

diag - Index of the array diagonal. Zero value corresponds to the main diagonal, -1 corresponds to the diagonal above the main, 1 corresponds to the diagonal below the main, and so forth.

cvGetDiag

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

cvScalarToRawData

public static void cvScalarToRawData(@Const
                                     opencv_core.CvScalar scalar,
                                     org.bytedeco.javacpp.Pointer data,
                                     int type,
                                     int extend_to_12)

low-level scalar <-> raw data conversion functions

cvScalarToRawData

public static void cvScalarToRawData(@Const
                                     opencv_core.CvScalar scalar,
                                     org.bytedeco.javacpp.Pointer data,
                                     int type)

cvRawDataToScalar

public static void cvRawDataToScalar(@Const
                                     org.bytedeco.javacpp.Pointer data,
                                     int type,
                                     opencv_core.CvScalar scalar)

cvCreateMatNDHeader
```
public static opencv_core.CvMatND cvCreateMatNDHeader(int dims,
                                                      @Const
                                                      org.bytedeco.javacpp.IntPointer sizes,
                                                      int type)
```
\brief Creates a new matrix header but does not allocate the matrix data.
The function allocates a header for a multi-dimensional dense array. The array data can further be allocated using cvCreateData or set explicitly to user-allocated data via cvSetData.

Parameters:

dims - Number of array dimensions

sizes - Array of dimension sizes

type - Type of array elements, see cvCreateMat

cvCreateMatNDHeader

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

cvCreateMatNDHeader

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

cvCreateMatND
```
public static opencv_core.CvMatND cvCreateMatND(int dims,
                                                @Const
                                                org.bytedeco.javacpp.IntPointer sizes,
                                                int type)
```
\brief Creates the header and allocates the data for a multi-dimensional dense array.
This function call is equivalent to the following code:
```
    CvMatND* mat = cvCreateMatNDHeader(dims, sizes, type);
    cvCreateData(mat);
```
Parameters:

dims - Number of array dimensions. This must not exceed CV_MAX_DIM (32 by default, but can be changed at build time).

sizes - Array of dimension sizes.

type - Type of array elements, see cvCreateMat .

cvCreateMatND

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

cvCreateMatND

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

cvInitMatNDHeader

public static opencv_core.CvMatND cvInitMatNDHeader(opencv_core.CvMatND mat,
                                                    int dims,
                                                    @Const
                                                    org.bytedeco.javacpp.IntPointer sizes,
                                                    int type,
                                                    org.bytedeco.javacpp.Pointer data)

\brief Initializes a pre-allocated multi-dimensional array header.

Parameters:: mat - A pointer to the array header to be initialized; dims - The number of array dimensions; sizes - An array of dimension sizes; type - Type of array elements, see cvCreateMat; data - Optional data pointer assigned to the matrix header

cvInitMatNDHeader

public static opencv_core.CvMatND cvInitMatNDHeader(opencv_core.CvMatND mat,
                                                    int dims,
                                                    @Const
                                                    org.bytedeco.javacpp.IntPointer sizes,
                                                    int type)

cvInitMatNDHeader

public static opencv_core.CvMatND cvInitMatNDHeader(opencv_core.CvMatND mat,
                                                    int dims,
                                                    @Const
                                                    IntBuffer sizes,
                                                    int type,
                                                    org.bytedeco.javacpp.Pointer data)

cvInitMatNDHeader

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

cvInitMatNDHeader

public static opencv_core.CvMatND cvInitMatNDHeader(opencv_core.CvMatND mat,
                                                    int dims,
                                                    @Const
                                                    int[] sizes,
                                                    int type,
                                                    org.bytedeco.javacpp.Pointer data)

cvInitMatNDHeader

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

cvReleaseMatND
```
public static void cvReleaseMatND(@Cast(value="CvMatND**")
                                  org.bytedeco.javacpp.PointerPointer mat)
```
\brief Deallocates a multi-dimensional array.
The function decrements the array data reference counter and releases the array header. If the reference counter reaches 0, it also deallocates the data. :
```
    if(*mat )
        cvDecRefData(*mat);
    cvFree((void**)mat);
```
Parameters:

mat - Double pointer to the array

cvReleaseMatND

public static void cvReleaseMatND(@ByPtrPtr
                                  opencv_core.CvMatND mat)

cvCloneMatND

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

Creates a copy of CvMatND (except, may be, steps)

cvCreateSparseMat
```
public static opencv_core.CvSparseMat cvCreateSparseMat(int dims,
                                                        @Const
                                                        org.bytedeco.javacpp.IntPointer sizes,
                                                        int type)
```
\brief Creates sparse array.
The function allocates a multi-dimensional sparse array. Initially the array contain no elements, that is PtrND and other related functions will return 0 for every index.

Parameters:

dims - Number of array dimensions. In contrast to the dense matrix, the number of dimensions is practically unlimited (up to \f$2^{16}\f$ ).

sizes - Array of dimension sizes

type - Type of array elements. The same as for CvMat

cvCreateSparseMat

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

cvCreateSparseMat

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

cvReleaseSparseMat
```
public static void cvReleaseSparseMat(@Cast(value="CvSparseMat**")
                                      org.bytedeco.javacpp.PointerPointer mat)
```
\brief Deallocates sparse array.
The function releases the sparse array and clears the array pointer upon exit.

Parameters:

mat - Double pointer to the array

cvReleaseSparseMat

public static void cvReleaseSparseMat(@ByPtrPtr
                                      opencv_core.CvSparseMat mat)

cvCloneSparseMat

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

Creates a copy of CvSparseMat (except, may be, zero items)

cvInitSparseMatIterator

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

\brief Initializes sparse array elements iterator.

The function initializes iterator of sparse array elements and returns pointer to the first element, or NULL if the array is empty.

Parameters:: mat - Input array; mat_iterator - Initialized iterator

cvGetNextSparseNode

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

\brief Returns the next sparse matrix element

The function moves iterator to the next sparse matrix element and returns pointer to it. In the current version there is no any particular order of the elements, because they are stored in the hash table. The sample below demonstrates how to iterate through the sparse matrix:


    // print all the non-zero sparse matrix elements and compute their sum
    double sum = 0;
    int i, dims = cvGetDims(sparsemat);
    CvSparseMatIterator it;
    CvSparseNode* node = cvInitSparseMatIterator(sparsemat, &it);

    for(; node != 0; node = cvGetNextSparseNode(&it))
    {
        int* idx = CV_NODE_IDX(array, node);
        float val = *(float*)CV_NODE_VAL(array, node);
        printf("M");
        for(i = 0; i < dims; i++ )
            printf("[%d]", idx[i]);
        printf("=%g\n", val);

        sum += val;
    }

    printf("nTotal sum = %g\n", sum);

Parameters:: mat_iterator - Sparse array iterator

cvInitNArrayIterator

public static int cvInitNArrayIterator(int count,
                                       @Cast(value="CvArr**")
                                       org.bytedeco.javacpp.PointerPointer arrs,
                                       @Const
                                       opencv_core.CvArr mask,
                                       opencv_core.CvMatND stubs,
                                       opencv_core.CvNArrayIterator array_iterator,
                                       int flags)

initializes iterator that traverses through several arrays simulteneously (the function together with cvNextArraySlice is used for N-ari element-wise operations)

cvInitNArrayIterator

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

cvInitNArrayIterator

public static int cvInitNArrayIterator(int count,
                                       @ByPtrPtr
                                       opencv_core.CvArr arrs,
                                       @Const
                                       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)
```
returns zero value if iteration is finished, non-zero (slice length) otherwise

cvGetElemType
```
public static int cvGetElemType(@Const
                                opencv_core.CvArr arr)
```
\brief Returns type of array elements.
The function returns type of the array elements. In the case of IplImage the type is converted to CvMat-like representation. For example, if the image has been created as:
```
    IplImage* img = cvCreateImage(cvSize(640, 480), IPL_DEPTH_8U, 3);
```
The code cvGetElemType(img) will return CV_8UC3.
Parameters:

arr - Input array

cvGetDims
```
public static int cvGetDims(@Const
                            opencv_core.CvArr arr,
                            org.bytedeco.javacpp.IntPointer sizes)
```
\brief Return number of array dimensions
The function returns the array dimensionality and the array of dimension sizes. In the case of IplImage or CvMat it always returns 2 regardless of number of image/matrix rows. For example, the following code calculates total number of array elements:
```
    int sizes[CV_MAX_DIM];
    int i, total = 1;
    int dims = cvGetDims(arr, size);
    for(i = 0; i < dims; i++ )
        total *= sizes[i];
```
Parameters:

arr - Input array

sizes - Optional output vector of the array dimension sizes. For 2d arrays the number of rows (height) goes first, number of columns (width) next.

cvGetDims

public static int cvGetDims(@Const
                            opencv_core.CvArr arr)

cvGetDims

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

cvGetDims

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

cvGetDimSize
```
public static int cvGetDimSize(@Const
                               opencv_core.CvArr arr,
                               int index)
```
\brief Returns array size along the specified dimension.

Parameters:

arr - Input array

index - Zero-based dimension index (for matrices 0 means number of rows, 1 means number of columns; for images 0 means height, 1 means width)

cvPtr1D
```
@Cast(value="uchar*")
public static org.bytedeco.javacpp.BytePointer cvPtr1D(@Const
                                                                             opencv_core.CvArr arr,
                                                                             int idx0,
                                                                             org.bytedeco.javacpp.IntPointer type)
```
\brief Return pointer to a particular array element.
The functions return a pointer to a specific array element. Number of array dimension should match to the number of indices passed to the function except for cvPtr1D function that can be used for sequential access to 1D, 2D or nD dense arrays.
The functions can be used for sparse arrays as well - if the requested node does not exist they create it and set it to zero.
All these as well as other functions accessing array elements ( cvGetND , cvGetRealND , cvSet , cvSetND , cvSetRealND ) raise an error in case if the element index is out of range.

Parameters:

arr - Input array

idx0 - The first zero-based component of the element index

type - Optional output parameter: type of matrix elements

cvPtr1D

@Cast(value="uchar*")
public static org.bytedeco.javacpp.BytePointer cvPtr1D(@Const
                                                                             opencv_core.CvArr arr,
                                                                             int idx0)

cvPtr1D

@Cast(value="uchar*")
public static ByteBuffer cvPtr1D(@Const
                                                       opencv_core.CvArr arr,
                                                       int idx0,
                                                       IntBuffer type)

cvPtr1D

@Cast(value="uchar*")
public static byte[] cvPtr1D(@Const
                                                   opencv_core.CvArr arr,
                                                   int idx0,
                                                   int[] type)

cvPtr2D

@Cast(value="uchar*")
public static org.bytedeco.javacpp.BytePointer cvPtr2D(@Const
                                                                             opencv_core.CvArr arr,
                                                                             int idx0,
                                                                             int idx1,
                                                                             org.bytedeco.javacpp.IntPointer type)

\overload

cvPtr2D

@Cast(value="uchar*")
public static org.bytedeco.javacpp.BytePointer cvPtr2D(@Const
                                                                             opencv_core.CvArr arr,
                                                                             int idx0,
                                                                             int idx1)

cvPtr2D

@Cast(value="uchar*")
public static ByteBuffer cvPtr2D(@Const
                                                       opencv_core.CvArr arr,
                                                       int idx0,
                                                       int idx1,
                                                       IntBuffer type)

cvPtr2D

@Cast(value="uchar*")
public static byte[] cvPtr2D(@Const
                                                   opencv_core.CvArr arr,
                                                   int idx0,
                                                   int idx1,
                                                   int[] type)

cvPtr3D

@Cast(value="uchar*")
public static org.bytedeco.javacpp.BytePointer cvPtr3D(@Const
                                                                             opencv_core.CvArr arr,
                                                                             int idx0,
                                                                             int idx1,
                                                                             int idx2,
                                                                             org.bytedeco.javacpp.IntPointer type)

\overload

cvPtr3D

@Cast(value="uchar*")
public static org.bytedeco.javacpp.BytePointer cvPtr3D(@Const
                                                                             opencv_core.CvArr arr,
                                                                             int idx0,
                                                                             int idx1,
                                                                             int idx2)

cvPtr3D

@Cast(value="uchar*")
public static ByteBuffer cvPtr3D(@Const
                                                       opencv_core.CvArr arr,
                                                       int idx0,
                                                       int idx1,
                                                       int idx2,
                                                       IntBuffer type)

cvPtr3D

@Cast(value="uchar*")
public static byte[] cvPtr3D(@Const
                                                   opencv_core.CvArr arr,
                                                   int idx0,
                                                   int idx1,
                                                   int idx2,
                                                   int[] type)

cvPtrND

@Cast(value="uchar*")
public static org.bytedeco.javacpp.BytePointer cvPtrND(@Const
                                                                             opencv_core.CvArr arr,
                                                                             @Const
                                                                             org.bytedeco.javacpp.IntPointer idx,
                                                                             org.bytedeco.javacpp.IntPointer type,
                                                                             int create_node,
                                                                             @Cast(value="unsigned*")
                                                                             org.bytedeco.javacpp.IntPointer precalc_hashval)

\overload

Parameters:: arr - Input array; idx - Array of the element indices; type - Optional output parameter: type of matrix elements; create_node - Optional input parameter for sparse matrices. Non-zero value of the parameter means that the requested element is created if it does not exist already.; precalc_hashval - Optional input parameter for sparse matrices. If the pointer is not NULL, the function does not recalculate the node hash value, but takes it from the specified location. It is useful for speeding up pair-wise operations (TODO: provide an example)

cvPtrND

@Cast(value="uchar*")
public static org.bytedeco.javacpp.BytePointer cvPtrND(@Const
                                                                             opencv_core.CvArr arr,
                                                                             @Const
                                                                             org.bytedeco.javacpp.IntPointer idx)

cvPtrND

@Cast(value="uchar*")
public static ByteBuffer cvPtrND(@Const
                                                       opencv_core.CvArr arr,
                                                       @Const
                                                       IntBuffer idx,
                                                       IntBuffer type,
                                                       int create_node,
                                                       @Cast(value="unsigned*")
                                                       IntBuffer precalc_hashval)

cvPtrND

@Cast(value="uchar*")
public static ByteBuffer cvPtrND(@Const
                                                       opencv_core.CvArr arr,
                                                       @Const
                                                       IntBuffer idx)

cvPtrND

@Cast(value="uchar*")
public static byte[] cvPtrND(@Const
                                                   opencv_core.CvArr arr,
                                                   @Const
                                                   int[] idx,
                                                   int[] type,
                                                   int create_node,
                                                   @Cast(value="unsigned*")
                                                   int[] precalc_hashval)

cvPtrND

@Cast(value="uchar*")
public static byte[] cvPtrND(@Const
                                                   opencv_core.CvArr arr,
                                                   @Const
                                                   int[] idx)

cvGet1D
```
@ByVal
public static opencv_core.CvScalar cvGet1D(@Const
                                                  opencv_core.CvArr arr,
                                                  int idx0)
```
\brief Return a specific array element.
The functions return a specific array element. In the case of a sparse array the functions return 0 if the requested node does not exist (no new node is created by the functions).

Parameters:

arr - Input array

idx0 - The first zero-based component of the element index

cvGet2D

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

\overload

cvGet3D

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

\overload

cvGetND

@ByVal
public static opencv_core.CvScalar cvGetND(@Const
                                                  opencv_core.CvArr arr,
                                                  @Const
                                                  org.bytedeco.javacpp.IntPointer idx)

\overload

Parameters:: arr - Input array; idx - Array of the element indices

cvGetND

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

cvGetND

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

cvGetReal1D
```
public static double cvGetReal1D(@Const
                                 opencv_core.CvArr arr,
                                 int idx0)
```
\brief Return a specific element of single-channel 1D, 2D, 3D or nD array.
Returns a specific element of a single-channel array. If the array has multiple channels, a runtime error is raised. Note that Get?D functions can be used safely for both single-channel and multiple-channel arrays though they are a bit slower.
In the case of a sparse array the functions return 0 if the requested node does not exist (no new node is created by the functions).

Parameters:

arr - Input array. Must have a single channel.

idx0 - The first zero-based component of the element index

cvGetReal2D

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

\overload

cvGetReal3D

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

\overload

cvGetRealND

public static double cvGetRealND(@Const
                                 opencv_core.CvArr arr,
                                 @Const
                                 org.bytedeco.javacpp.IntPointer idx)

\overload

Parameters:: arr - Input array. Must have a single channel.; idx - Array of the element indices

cvGetRealND

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

cvGetRealND

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

cvSet1D
```
public static void cvSet1D(opencv_core.CvArr arr,
                           int idx0,
                           @ByVal
                           opencv_core.CvScalar value)
```
\brief Change the particular array element.
The functions assign the new value to a particular array element. In the case of a sparse array the functions create the node if it does not exist yet.

Parameters:

arr - Input array

idx0 - The first zero-based component of the element index

value - The assigned value

cvSet2D

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

\overload

cvSet3D

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

\overload

cvSetND

public static void cvSetND(opencv_core.CvArr arr,
                           @Const
                           org.bytedeco.javacpp.IntPointer idx,
                           @ByVal
                           opencv_core.CvScalar value)

\overload

Parameters:: arr - Input array; idx - Array of the element indices; value - The assigned value

cvSetND

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

cvSetND

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

cvSetReal1D
```
public static void cvSetReal1D(opencv_core.CvArr arr,
                               int idx0,
                               double value)
```
\brief Change a specific array element.
The functions assign a new value to a specific element of a single-channel array. If the array has multiple channels, a runtime error is raised. Note that the Set\*D function can be used safely for both single-channel and multiple-channel arrays, though they are a bit slower.
In the case of a sparse array the functions create the node if it does not yet exist.

Parameters:

arr - Input array

idx0 - The first zero-based component of the element index

value - The assigned value

cvSetReal2D

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

\overload

cvSetReal3D

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

\overload

cvSetRealND

public static void cvSetRealND(opencv_core.CvArr arr,
                               @Const
                               org.bytedeco.javacpp.IntPointer idx,
                               double value)

\overload

Parameters:: arr - Input array; idx - Array of the element indices; value - The assigned value

cvSetRealND

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

cvSetRealND

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

cvClearND

public static void cvClearND(opencv_core.CvArr arr,
                             @Const
                             org.bytedeco.javacpp.IntPointer idx)

clears element of ND dense array, in case of sparse arrays it deletes the specified node

cvClearND

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

cvClearND

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

cvGetMat
```
public static opencv_core.CvMat cvGetMat(@Const
                                         opencv_core.CvArr arr,
                                         opencv_core.CvMat header,
                                         org.bytedeco.javacpp.IntPointer coi,
                                         int allowND)
```
\brief Returns matrix header for arbitrary array.
The function returns a matrix header for the input array that can be a matrix - CvMat, an image - IplImage, or a multi-dimensional dense array - CvMatND (the third option is allowed only if allowND != 0) . In the case of matrix the function simply returns the input pointer. In the case of IplImage\* or CvMatND it initializes the header structure with parameters of the current image ROI and returns &header. Because COI is not supported by CvMat, it is returned separately.
The function provides an easy way to handle both types of arrays - IplImage and CvMat using the same code. Input array must have non-zero data pointer, otherwise the function will report an error.
\note If the input array is IplImage with planar data layout and COI set, the function returns the pointer to the selected plane and COI == 0. This feature allows user to process IplImage structures with planar data layout, even though OpenCV does not support such images.

Parameters:

arr - Input array

header - Pointer to CvMat structure used as a temporary buffer

coi - Optional output parameter for storing COI

allowND - If non-zero, the function accepts multi-dimensional dense arrays (CvMatND\*) and returns 2D matrix (if CvMatND has two dimensions) or 1D matrix (when CvMatND has 1 dimension or more than 2 dimensions). The CvMatND array must be continuous. \sa cvGetImage, cvarrToMat.

cvGetMat

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

cvGetMat

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

cvGetMat

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

cvGetImage
```
public static opencv_core.IplImage cvGetImage(@Const
                                              opencv_core.CvArr arr,
                                              opencv_core.IplImage image_header)
```
\brief Returns image header for arbitrary array.
The function returns the image header for the input array that can be a matrix (CvMat) or image (IplImage). In the case of an image the function simply returns the input pointer. In the case of CvMat it initializes an image_header structure with the parameters of the input matrix. Note that if we transform IplImage to CvMat using cvGetMat and then transform CvMat back to IplImage using this function, we will get different headers if the ROI is set in the original image.

Parameters:

arr - Input array

image_header - Pointer to IplImage structure used as a temporary buffer

cvReshapeMatND

public static opencv_core.CvArr cvReshapeMatND(@Const
                                               opencv_core.CvArr arr,
                                               int sizeof_header,
                                               opencv_core.CvArr header,
                                               int new_cn,
                                               int new_dims,
                                               org.bytedeco.javacpp.IntPointer new_sizes)

\brief Changes the shape of a multi-dimensional array without copying the data.

The function is an advanced version of cvReshape that can work with multi-dimensional arrays as well (though it can work with ordinary images and matrices) and change the number of dimensions.

Below are the two samples from the cvReshape description rewritten using cvReshapeMatND:


    IplImage* color_img = cvCreateImage(cvSize(320,240), IPL_DEPTH_8U, 3);
    IplImage gray_img_hdr, *gray_img;
    gray_img = (IplImage*)cvReshapeMatND(color_img, sizeof(gray_img_hdr), &gray_img_hdr, 1, 0, 0);
    ...
    int size[] = { 2, 2, 2 };
    CvMatND* mat = cvCreateMatND(3, size, CV_32F);
    CvMat row_header, *row;
    row = (CvMat*)cvReshapeMatND(mat, sizeof(row_header), &row_header, 0, 1, 0);

In C, the header file for this function includes a convenient macro cvReshapeND that does away with the sizeof_header parameter. So, the lines containing the call to cvReshapeMatND in the examples may be replaced as follow:


    gray_img = (IplImage*)cvReshapeND(color_img, &gray_img_hdr, 1, 0, 0);
    ...
    row = (CvMat*)cvReshapeND(mat, &row_header, 0, 1, 0);

Parameters:: arr - Input array; sizeof_header - Size of output header to distinguish between IplImage, CvMat and CvMatND output headers; header - Output header to be filled; new_cn - New number of channels. new_cn = 0 means that the number of channels remains unchanged.; new_dims - New number of dimensions. new_dims = 0 means that the number of dimensions remains the same.; new_sizes - Array of new dimension sizes. Only new_dims-1 values are used, because the total number of elements must remain the same. Thus, if new_dims = 1, new_sizes array is not used.

cvReshapeMatND

public static opencv_core.CvArr cvReshapeMatND(@Const
                                               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(@Const
                                               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(@Const
                                          opencv_core.CvArr arr,
                                          opencv_core.CvMat header,
                                          int new_cn,
                                          int new_rows)
```
\brief Changes shape of matrix/image without copying data.
The function initializes the CvMat header so that it points to the same data as the original array but has a different shape - different number of channels, different number of rows, or both.
The following example code creates one image buffer and two image headers, the first is for a 320x240x3 image and the second is for a 960x240x1 image:
```
    IplImage* color_img = cvCreateImage(cvSize(320,240), IPL_DEPTH_8U, 3);
    CvMat gray_mat_hdr;
    IplImage gray_img_hdr, *gray_img;
    cvReshape(color_img, &gray_mat_hdr, 1);
    gray_img = cvGetImage(&gray_mat_hdr, &gray_img_hdr);
```
And the next example converts a 3x3 matrix to a single 1x9 vector:
```
    CvMat* mat = cvCreateMat(3, 3, CV_32F);
    CvMat row_header, *row;
    row = cvReshape(mat, &row_header, 0, 1);
```
Parameters:

arr - Input array

header - Output header to be filled

new_cn - New number of channels. 'new_cn = 0' means that the number of channels remains unchanged.

new_rows - New number of rows. 'new_rows = 0' means that the number of rows remains unchanged unless it needs to be changed according to new_cn value.

cvReshape

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

cvRepeat

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

Repeats source 2d array several times in both horizontal and vertical direction to fill destination array

cvCreateData
```
public static void cvCreateData(opencv_core.CvArr arr)
```
\brief Allocates array data
The function allocates image, matrix or multi-dimensional dense array data. Note that in the case of matrix types OpenCV allocation functions are used. In the case of IplImage they are used unless CV_TURN_ON_IPL_COMPATIBILITY() has been called before. In the latter case IPL functions are used to allocate the data.

Parameters:

arr - Array header

cvReleaseData
```
public static void cvReleaseData(opencv_core.CvArr arr)
```
\brief Releases array data.
The function releases the array data. In the case of CvMat or CvMatND it simply calls cvDecRefData(), that is the function can not deallocate external data. See also the note to cvCreateData .

Parameters:

arr - Array header

cvSetData
```
public static void cvSetData(opencv_core.CvArr arr,
                             org.bytedeco.javacpp.Pointer data,
                             int step)
```
\brief Assigns user data to the array header.
The function assigns user data to the array header. Header should be initialized before using cvCreateMatHeader, cvCreateImageHeader, cvCreateMatNDHeader, cvInitMatHeader, cvInitImageHeader or cvInitMatNDHeader.

Parameters:

arr - Array header

data - User data

step - Full row length in bytes

cvGetRawData

public static void cvGetRawData(@Const
                                opencv_core.CvArr arr,
                                @Cast(value="uchar**")
                                org.bytedeco.javacpp.PointerPointer data,
                                org.bytedeco.javacpp.IntPointer step,
                                opencv_core.CvSize roi_size)

\brief Retrieves low-level information about the array.

The function fills output variables with low-level information about the array data. All output

parameters are optional, so some of the pointers may be set to NULL. If the array is IplImage with ROI set, the parameters of ROI are returned.

The following example shows how to get access to array elements. It computes absolute values of the array elements :


    float* data;
    int step;
    CvSize size;

    cvGetRawData(array, (uchar**)&data, &step, &size);
    step /= sizeof(data[0]);

    for(int y = 0; y < size.height; y++, data += step )
        for(int x = 0; x < size.width; x++ )
            data[x] = (float)fabs(data[x]);

Parameters:: arr - Array header; data - Output pointer to the whole image origin or ROI origin if ROI is set; step - Output full row length in bytes; roi_size - Output ROI size

cvGetRawData

public static void cvGetRawData(@Const
                                opencv_core.CvArr arr,
                                @Cast(value="uchar**") @ByPtrPtr
                                org.bytedeco.javacpp.BytePointer data)

cvGetRawData

public static void cvGetRawData(@Const
                                opencv_core.CvArr arr,
                                @Cast(value="uchar**") @ByPtrPtr
                                org.bytedeco.javacpp.BytePointer data,
                                org.bytedeco.javacpp.IntPointer step,
                                opencv_core.CvSize roi_size)

cvGetRawData

public static void cvGetRawData(@Const
                                opencv_core.CvArr arr,
                                @Cast(value="uchar**") @ByPtrPtr
                                ByteBuffer data,
                                IntBuffer step,
                                opencv_core.CvSize roi_size)

cvGetRawData

public static void cvGetRawData(@Const
                                opencv_core.CvArr arr,
                                @Cast(value="uchar**") @ByPtrPtr
                                ByteBuffer data)

cvGetRawData

public static void cvGetRawData(@Const
                                opencv_core.CvArr arr,
                                @Cast(value="uchar**") @ByPtrPtr
                                byte[] data,
                                int[] step,
                                opencv_core.CvSize roi_size)

cvGetRawData

public static void cvGetRawData(@Const
                                opencv_core.CvArr arr,
                                @Cast(value="uchar**") @ByPtrPtr
                                byte[] data)

cvGetSize
```
@ByVal
public static opencv_core.CvSize cvGetSize(@Const
                                                  opencv_core.CvArr arr)
```
\brief Returns size of matrix or image ROI.
The function returns number of rows (CvSize::height) and number of columns (CvSize::width) of the input matrix or image. In the case of image the size of ROI is returned.

Parameters:

arr - array header

cvCopy
```
public static void cvCopy(@Const
                          opencv_core.CvArr src,
                          opencv_core.CvArr dst,
                          @Const
                          opencv_core.CvArr mask)
```
\brief Copies one array to another.
The function copies selected elements from an input array to an output array:
\f[\texttt{dst} (I)= \texttt{src} (I) \quad \text{if} \quad \texttt{mask} (I) \ne 0.\f]
If any of the passed arrays is of IplImage type, then its ROI and COI fields are used. Both arrays must have the same type, the same number of dimensions, and the same size. The function can also copy sparse arrays (mask is not supported in this case).

Parameters:

src - The source array

dst - The destination array

mask - Operation mask, 8-bit single channel array; specifies elements of the destination array to be changed

cvCopy

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

cvSet
```
public static void cvSet(opencv_core.CvArr arr,
                         @ByVal
                         opencv_core.CvScalar value,
                         @Const
                         opencv_core.CvArr mask)
```
\brief Sets every element of an array to a given value.
The function copies the scalar value to every selected element of the destination array: \f[\texttt{arr} (I)= \texttt{value} \quad \text{if} \quad \texttt{mask} (I) \ne 0\f] If array arr is of IplImage type, then is ROI used, but COI must not be set.

Parameters:

arr - The destination array

value - Fill value

mask - Operation mask, 8-bit single channel array; specifies elements of the destination array to be changed

cvSet

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

cvSetZero
```
public static void cvSetZero(opencv_core.CvArr arr)
```
\brief Clears the array.
The function clears the array. In the case of dense arrays (CvMat, CvMatND or IplImage), cvZero(array) is equivalent to cvSet(array,cvScalarAll(0),0). In the case of sparse arrays all the elements are removed.

Parameters:

arr - Array to be cleared

cvZero

public static void cvZero(opencv_core.CvArr arg1)

cvSplit

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

Splits a multi-channel array into the set of single-channel arrays or extracts particular [color] plane

cvMerge

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

Merges a set of single-channel arrays into the single multi-channel array or inserts one particular [color] plane to the array

cvMixChannels

public static void cvMixChannels(@Cast(value="const CvArr**")
                                 org.bytedeco.javacpp.PointerPointer src,
                                 int src_count,
                                 @Cast(value="CvArr**")
                                 org.bytedeco.javacpp.PointerPointer dst,
                                 int dst_count,
                                 @Const
                                 org.bytedeco.javacpp.IntPointer from_to,
                                 int pair_count)

Copies several channels from input arrays to certain channels of output arrays

cvMixChannels

public static void cvMixChannels(@Const @ByPtrPtr
                                 opencv_core.CvArr src,
                                 int src_count,
                                 @ByPtrPtr
                                 opencv_core.CvArr dst,
                                 int dst_count,
                                 @Const
                                 org.bytedeco.javacpp.IntPointer from_to,
                                 int pair_count)

cvMixChannels

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

cvMixChannels

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

cvConvertScale
```
public static void cvConvertScale(@Const
                                  opencv_core.CvArr src,
                                  opencv_core.CvArr dst,
                                  double scale,
                                  double shift)
```
\brief Converts one array to another with optional linear transformation.
The function has several different purposes, and thus has several different names. It copies one array to another with optional scaling, which is performed first, and/or optional type conversion, performed after:
\f[\texttt{dst} (I) = \texttt{scale} \texttt{src} (I) + ( \texttt{shift} _0, \texttt{shift} _1,...)\f]
All the channels of multi-channel arrays are processed independently.
The type of conversion is done with rounding and saturation, that is if the result of scaling + conversion can not be represented exactly by a value of the destination array element type, it is set to the nearest representable value on the real axis.

Parameters:

src - Source array

dst - Destination array

scale - Scale factor

shift - Value added to the scaled source array elements

cvConvertScale

public static void cvConvertScale(@Const
                                  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(@Const
                                     opencv_core.CvArr src,
                                     opencv_core.CvArr dst,
                                     double scale,
                                     double shift)

Performs linear transformation on every source array element, stores absolute value of the result: dst(x,y,c) = abs(scale*src(x,y,c)+shift). destination array must have 8u type. In other cases one may use cvConvertScale + cvAbsDiffS

cvConvertScaleAbs

public static void cvConvertScaleAbs(@Const
                                     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

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

checks termination criteria validity and sets eps to default_eps (if it is not set), max_iter to default_max_iters (if it is not set)

cvAdd

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

dst(mask) = src1(mask) + src2(mask)

cvAdd

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

cvAddS

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

dst(mask) = src(mask) + value

cvAddS

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

cvSub

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

dst(mask) = src1(mask) - src2(mask)

cvSub

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

cvSubS

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

dst(mask) = src(mask) - value = src(mask) + (-value)

cvSubS

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

cvSubRS

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

dst(mask) = value - src(mask)

cvSubRS

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

cvMul

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

dst(idx) = src1(idx) * src2(idx) * scale (scaled element-wise multiplication of 2 arrays)

cvMul

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

cvDiv

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

element-wise division/inversion with scaling: dst(idx) = src1(idx) * scale / src2(idx) or dst(idx) = scale / src2(idx) if src1 == 0

cvDiv

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

cvScaleAdd

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

dst = src1 * scale + src2

cvAddWeighted

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

dst = src1 * alpha + src2 * beta + gamma

cvDotProduct
```
public static double cvDotProduct(@Const
                                  opencv_core.CvArr src1,
                                  @Const
                                  opencv_core.CvArr src2)
```
\brief Calculates the dot product of two arrays in Euclidean metrics.
The function calculates and returns the Euclidean dot product of two arrays.
\f[src1 \bullet src2 = \sum _I ( \texttt{src1} (I) \texttt{src2} (I))\f]
In the case of multiple channel arrays, the results for all channels are accumulated. In particular, cvDotProduct(a,a) where a is a complex vector, will return \f$||\texttt{a}||^2\f$. The function can process multi-dimensional arrays, row by row, layer by layer, and so on.

Parameters:

src1 - The first source array

src2 - The second source array

cvAnd

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

dst(idx) = src1(idx) & src2(idx)

cvAnd

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

cvAndS

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

dst(idx) = src(idx) & value

cvAndS

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

cvOr

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

dst(idx) = src1(idx) | src2(idx)

cvOr

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

cvOrS

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

dst(idx) = src(idx) | value

cvOrS

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

cvXor

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

dst(idx) = src1(idx) ^ src2(idx)

cvXor

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

cvXorS

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

dst(idx) = src(idx) ^ value

cvXorS

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

cvNot

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

dst(idx) = ~src(idx)

cvInRange

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

dst(idx) = lower(idx) <= src(idx) < upper(idx)

cvInRangeS

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

dst(idx) = lower <= src(idx) < upper

cvCmp

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

dst(idx) = src1(idx) _cmp_op_ src2(idx)

cvCmpS

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

dst(idx) = src1(idx) _cmp_op_ value

cvMin

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

dst(idx) = min(src1(idx),src2(idx))

cvMax

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

dst(idx) = max(src1(idx),src2(idx))

cvMinS

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

dst(idx) = min(src(idx),value)

cvMaxS

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

dst(idx) = max(src(idx),value)

cvAbsDiff

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

dst(x,y,c) = abs(src1(x,y,c) - src2(x,y,c))

cvAbsDiffS

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

dst(x,y,c) = abs(src(x,y,c) - value(c))

cvCartToPolar

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

Does cartesian->polar coordinates conversion. Either of output components (magnitude or angle) is optional

cvCartToPolar

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

cvPolarToCart

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

Does polar->cartesian coordinates conversion. Either of output components (magnitude or angle) is optional. If magnitude is missing it is assumed to be all 1's

cvPolarToCart

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

cvPow

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

Does powering: dst(idx) = src(idx)^power

cvExp

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

Does exponention: dst(idx) = exp(src(idx)). Overflow is not handled yet. Underflow is handled. Maximal relative error is ~7e-6 for single-precision input

cvLog

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

Calculates natural logarithms: dst(idx) = log(abs(src(idx))). Logarithm of 0 gives large negative number(~-700) Maximal relative error is ~3e-7 for single-precision output

cvFastArctan

public static float cvFastArctan(float y,
                                 float x)

Fast arctangent calculation

cvCbrt

public static float cvCbrt(float value)

Fast cubic root calculation

cvCheckArr

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

Checks array values for NaNs, Infs or simply for too large numbers (if CV_CHECK_RANGE is set). If CV_CHECK_QUIET is set, no runtime errors is raised (function returns zero value in case of "bad" values). Otherwise cvError is called

cvCheckArr

public static int cvCheckArr(@Const
                             opencv_core.CvArr arr)

cvCheckArray

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

cvRandArr
```
public static void cvRandArr(@Cast(value="CvRNG*")
                             org.bytedeco.javacpp.LongPointer rng,
                             opencv_core.CvArr arr,
                             int dist_type,
                             @ByVal
                             opencv_core.CvScalar param1,
                             @ByVal
                             opencv_core.CvScalar param2)
```
\brief Fills an array with random numbers and updates the RNG state.
The function fills the destination array with uniformly or normally distributed random numbers.

Parameters:

rng - CvRNG state initialized by cvRNG

arr - The destination array

dist_type - Distribution type > - **CV_RAND_UNI** uniform distribution > - **CV_RAND_NORMAL** normal or Gaussian distribution

param1 - The first parameter of the distribution. In the case of a uniform distribution it is the inclusive lower boundary of the random numbers range. In the case of a normal distribution it is the mean value of the random numbers.

param2 - The second parameter of the distribution. In the case of a uniform distribution it is the exclusive upper boundary of the random numbers range. In the case of a normal distribution it is the standard deviation of the random numbers. \sa randu, randn, RNG::fill.

cvRandArr

public static void cvRandArr(@Cast(value="CvRNG*")
                             LongBuffer rng,
                             opencv_core.CvArr arr,
                             int dist_type,
                             @ByVal
                             opencv_core.CvScalar param1,
                             @ByVal
                             opencv_core.CvScalar param2)

cvRandArr

public static void cvRandArr(@Cast(value="CvRNG*")
                             long[] rng,
                             opencv_core.CvArr arr,
                             int dist_type,
                             @ByVal
                             opencv_core.CvScalar param1,
                             @ByVal
                             opencv_core.CvScalar param2)

cvRandShuffle

public static void cvRandShuffle(opencv_core.CvArr mat,
                                 @Cast(value="CvRNG*")
                                 org.bytedeco.javacpp.LongPointer rng,
                                 double iter_factor)

cvRandShuffle

public static void cvRandShuffle(opencv_core.CvArr mat,
                                 @Cast(value="CvRNG*")
                                 org.bytedeco.javacpp.LongPointer rng)

cvRandShuffle

public static void cvRandShuffle(opencv_core.CvArr mat,
                                 @Cast(value="CvRNG*")
                                 LongBuffer rng,
                                 double iter_factor)

cvRandShuffle

public static void cvRandShuffle(opencv_core.CvArr mat,
                                 @Cast(value="CvRNG*")
                                 LongBuffer rng)

cvRandShuffle

public static void cvRandShuffle(opencv_core.CvArr mat,
                                 @Cast(value="CvRNG*")
                                 long[] rng,
                                 double iter_factor)

cvRandShuffle

public static void cvRandShuffle(opencv_core.CvArr mat,
                                 @Cast(value="CvRNG*")
                                 long[] rng)

cvSort

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

cvSort

public static void cvSort(@Const
                          opencv_core.CvArr src)

cvSolveCubic

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

Finds real roots of a cubic equation

cvSolvePoly

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

Finds all real and complex roots of a polynomial equation

cvSolvePoly

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

cvCrossProduct
```
public static void cvCrossProduct(@Const
                                  opencv_core.CvArr src1,
                                  @Const
                                  opencv_core.CvArr src2,
                                  opencv_core.CvArr dst)
```
\brief Calculates the cross product of two 3D vectors.
The function calculates the cross product of two 3D vectors: \f[\texttt{dst} = \texttt{src1} \times \texttt{src2}\f] or: \f[\begin{array}{l} \texttt{dst} _1 = \texttt{src1} _2 \texttt{src2} _3 - \texttt{src1} _3 \texttt{src2} _2 \\ \texttt{dst} _2 = \texttt{src1} _3 \texttt{src2} _1 - \texttt{src1} _1 \texttt{src2} _3 \\ \texttt{dst} _3 = \texttt{src1} _1 \texttt{src2} _2 - \texttt{src1} _2 \texttt{src2} _1 \end{array}\f]

Parameters:

src1 - The first source vector

src2 - The second source vector

dst - The destination vector

cvMatMulAdd

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

Matrix transform: dst = A*B + C, C is optional

cvMatMul

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

cvGEMM

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

Extended matrix transform: dst = alpha*op(A)*op(B) + beta*op(C), where op(X) is X or X^T

cvGEMM

public static void cvGEMM(@Const
                          opencv_core.CvArr src1,
                          @Const
                          opencv_core.CvArr src2,
                          double alpha,
                          @Const
                          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(@Const
                               opencv_core.CvArr src,
                               opencv_core.CvArr dst,
                               @Const
                               opencv_core.CvMat transmat,
                               @Const
                               opencv_core.CvMat shiftvec)

Transforms each element of source array and stores resultant vectors in destination array

cvTransform

public static void cvTransform(@Const
                               opencv_core.CvArr src,
                               opencv_core.CvArr dst,
                               @Const
                               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(@Const
                                          opencv_core.CvArr src,
                                          opencv_core.CvArr dst,
                                          @Const
                                          opencv_core.CvMat mat)

Does perspective transform on every element of input array

cvMulTransposed

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

Calculates (A-delta)*(A-delta)^T (order=0) or (A-delta)^T*(A-delta) (order=1)

cvMulTransposed

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

cvTranspose

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

Tranposes matrix. Square matrices can be transposed in-place

cvT

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

cvCompleteSymm

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

Completes the symmetric matrix from the lower (LtoR=0) or from the upper (LtoR!=0) part

cvCompleteSymm

public static void cvCompleteSymm(opencv_core.CvMat matrix)

cvFlip

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

Mirror array data around horizontal (flip=0), vertical (flip=1) or both(flip=-1) axises: cvFlip(src) flips images vertically and sequences horizontally (inplace)

cvFlip

public static void cvFlip(@Const
                          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)

Performs Singular Value Decomposition of a matrix

cvSVD

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

cvSVBkSb

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

Performs Singular Value Back Substitution (solves A*X = B): flags must be the same as in cvSVD

cvInvert

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

Inverts matrix

cvInvert

public static double cvInvert(@Const
                              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(@Const
                          opencv_core.CvArr src1,
                          @Const
                          opencv_core.CvArr src2,
                          opencv_core.CvArr dst,
                          int method)

Solves linear system (src1)*(dst) = (src2) (returns 0 if src1 is a singular and CV_LU method is used)

cvSolve

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

cvDet

public static double cvDet(@Const
                           opencv_core.CvArr mat)

Calculates determinant of input matrix

cvTrace

@ByVal
public static opencv_core.CvScalar cvTrace(@Const
                                                  opencv_core.CvArr mat)

Calculates trace of the matrix (sum of elements on the main diagonal)

cvEigenVV

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

Finds eigen values and vectors of a symmetric matrix

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,
                                 @ByVal(nullValue="CvScalar(cvRealScalar(1))")
                                 opencv_core.CvScalar value)

Makes an identity matrix (mat_ij = i == j)

cvSetIdentity

public static void cvSetIdentity(opencv_core.CvArr mat)

cvRange

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

Fills matrix with given range of numbers

cvCalcCovarMatrix

public static void cvCalcCovarMatrix(@Cast(value="const CvArr**")
                                     org.bytedeco.javacpp.PointerPointer vects,
                                     int count,
                                     opencv_core.CvArr cov_mat,
                                     opencv_core.CvArr avg,
                                     int flags)

Calculates covariation matrix for a set of vectors

See Also:: core_c_CovarFlags "flags"

cvCalcCovarMatrix

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

cvCalcPCA

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

cvProjectPCA

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

cvBackProjectPCA

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

cvMahalanobis

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

Calculates Mahalanobis(weighted) distance

cvMahalonobis

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

cvSum

@ByVal
public static opencv_core.CvScalar cvSum(@Const
                                                opencv_core.CvArr arr)

Finds sum of array elements

cvCountNonZero

public static int cvCountNonZero(@Const
                                 opencv_core.CvArr arr)

Calculates number of non-zero pixels

cvAvg

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

Calculates mean value of array elements

cvAvg

@ByVal
public static opencv_core.CvScalar cvAvg(@Const
                                                opencv_core.CvArr arr)

cvAvgSdv

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

Calculates mean and standard deviation of pixel values

cvAvgSdv

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

cvMinMaxLoc

public static void cvMinMaxLoc(@Const
                               opencv_core.CvArr arr,
                               org.bytedeco.javacpp.DoublePointer min_val,
                               org.bytedeco.javacpp.DoublePointer max_val,
                               opencv_core.CvPoint min_loc,
                               opencv_core.CvPoint max_loc,
                               @Const
                               opencv_core.CvArr mask)

Finds global minimum, maximum and their positions

cvMinMaxLoc

public static void cvMinMaxLoc(@Const
                               opencv_core.CvArr arr,
                               org.bytedeco.javacpp.DoublePointer min_val,
                               org.bytedeco.javacpp.DoublePointer max_val)

cvMinMaxLoc

public static void cvMinMaxLoc(@Const
                               opencv_core.CvArr arr,
                               DoubleBuffer min_val,
                               DoubleBuffer max_val,
                               @Cast(value="CvPoint*")
                               IntBuffer min_loc,
                               @Cast(value="CvPoint*")
                               IntBuffer max_loc,
                               @Const
                               opencv_core.CvArr mask)

cvMinMaxLoc

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

cvMinMaxLoc

public static void cvMinMaxLoc(@Const
                               opencv_core.CvArr arr,
                               double[] min_val,
                               double[] max_val,
                               @Cast(value="CvPoint*")
                               int[] min_loc,
                               @Cast(value="CvPoint*")
                               int[] max_loc,
                               @Const
                               opencv_core.CvArr mask)

cvMinMaxLoc

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

cvNorm

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

Finds norm, difference norm or relative difference norm for an array (or two arrays)

See Also:: core_c_NormFlags "flags"

cvNorm

public static double cvNorm(@Const
                            opencv_core.CvArr arr1)

cvNormalize

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

See Also:: core_c_NormFlags "flags"

cvNormalize

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

cvReduce

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

See Also:: core_c_ReduceFlags "flags"

cvReduce

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

cvDFT

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

Discrete Fourier Transform: complex->complex, real->ccs (forward), ccs->real (inverse)

See Also:: "flags"

cvDFT

public static void cvDFT(@Const
                         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(@Const
                                  opencv_core.CvArr src1,
                                  @Const
                                  opencv_core.CvArr src2,
                                  opencv_core.CvArr dst,
                                  int flags)

Multiply results of DFTs: DFT(X)*DFT(Y) or DFT(X)*conj(DFT(Y))

See Also:: "flags"

cvGetOptimalDFTSize
```
public static int cvGetOptimalDFTSize(int size0)
```
Finds optimal DFT vector size >= size0

cvDCT

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

Discrete Cosine Transform

See Also:: "flags"

cvSliceLength

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

Calculates length of sequence slice (with support of negative indices).

cvCreateMemStorage
```
public static opencv_core.CvMemStorage cvCreateMemStorage(int block_size)
```
Creates new memory storage. block_size == 0 means that default, somewhat optimal size, is used (currently, it is 64K)

cvCreateMemStorage

public static opencv_core.CvMemStorage cvCreateMemStorage()

cvCreateChildMemStorage

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

Creates a memory storage that will borrow memory blocks from parent storage

cvReleaseMemStorage
```
public static void cvReleaseMemStorage(@Cast(value="CvMemStorage**")
                                       org.bytedeco.javacpp.PointerPointer storage)
```
Releases memory storage. All the children of a parent must be released before the parent. A child storage returns all the blocks to parent when it is released

cvReleaseMemStorage

public static void cvReleaseMemStorage(@ByPtrPtr
                                       opencv_core.CvMemStorage storage)

cvClearMemStorage
```
public static void cvClearMemStorage(opencv_core.CvMemStorage storage)
```
Clears memory storage. This is the only way(!!!) (besides cvRestoreMemStoragePos) to reuse memory allocated for the storage - cvClearSeq,cvClearSet ... do not free any memory. A child storage returns all the blocks to the parent when it is cleared

cvSaveMemStoragePos

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

Remember a storage "free memory" position

cvRestoreMemStoragePos

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

Restore a storage "free memory" position

cvMemStorageAlloc

public static org.bytedeco.javacpp.Pointer cvMemStorageAlloc(opencv_core.CvMemStorage storage,
                                                             @Cast(value="size_t")
                                                             long size)

Allocates continuous buffer of the specified size in the storage

cvMemStorageAllocString

@ByVal
public static opencv_core.CvString cvMemStorageAllocString(opencv_core.CvMemStorage storage,
                                                                  @Cast(value="const char*")
                                                                  org.bytedeco.javacpp.BytePointer ptr,
                                                                  int len)

Allocates string in memory storage

cvMemStorageAllocString

@ByVal
public static opencv_core.CvString cvMemStorageAllocString(opencv_core.CvMemStorage storage,
                                                                  @Cast(value="const char*")
                                                                  org.bytedeco.javacpp.BytePointer ptr)

cvMemStorageAllocString

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

cvMemStorageAllocString

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

cvCreateSeq

public static opencv_core.CvSeq cvCreateSeq(int seq_flags,
                                            @Cast(value="size_t")
                                            long header_size,
                                            @Cast(value="size_t")
                                            long elem_size,
                                            opencv_core.CvMemStorage storage)

Creates new empty sequence that will reside in the specified storage

cvSetSeqBlockSize

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

Changes default size (granularity) of sequence blocks. The default size is ~1Kbyte

cvSeqPush

@Cast(value="schar*")
public static org.bytedeco.javacpp.BytePointer cvSeqPush(opencv_core.CvSeq seq,
                                                                               @Const
                                                                               org.bytedeco.javacpp.Pointer element)

Adds new element to the end of sequence. Returns pointer to the element

cvSeqPush

@Cast(value="schar*")
public static org.bytedeco.javacpp.BytePointer cvSeqPush(opencv_core.CvSeq seq)

cvSeqPushFront

@Cast(value="schar*")
public static org.bytedeco.javacpp.BytePointer cvSeqPushFront(opencv_core.CvSeq seq,
                                                                                    @Const
                                                                                    org.bytedeco.javacpp.Pointer element)

Adds new element to the beginning of sequence. Returns pointer to it

cvSeqPushFront

@Cast(value="schar*")
public static org.bytedeco.javacpp.BytePointer cvSeqPushFront(opencv_core.CvSeq seq)

cvSeqPop

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

Removes the last element from sequence and optionally saves it

cvSeqPop

public static void cvSeqPop(opencv_core.CvSeq seq)

cvSeqPopFront

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

Removes the first element from sequence and optioanally saves it

cvSeqPopFront

public static void cvSeqPopFront(opencv_core.CvSeq seq)

cvSeqPushMulti

public static void cvSeqPushMulti(opencv_core.CvSeq seq,
                                  @Const
                                  org.bytedeco.javacpp.Pointer elements,
                                  int count,
                                  int in_front)

Adds several new elements to the end of sequence

cvSeqPushMulti

public static void cvSeqPushMulti(opencv_core.CvSeq seq,
                                  @Const
                                  org.bytedeco.javacpp.Pointer elements,
                                  int count)

cvSeqPopMulti

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

Removes several elements from the end of sequence and optionally saves them

cvSeqPopMulti

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

cvSeqInsert

@Cast(value="schar*")
public static org.bytedeco.javacpp.BytePointer cvSeqInsert(opencv_core.CvSeq seq,
                                                                                 int before_index,
                                                                                 @Const
                                                                                 org.bytedeco.javacpp.Pointer element)

Inserts a new element in the middle of sequence. cvSeqInsert(seq,0,elem) == cvSeqPushFront(seq,elem)

cvSeqInsert

@Cast(value="schar*")
public static org.bytedeco.javacpp.BytePointer cvSeqInsert(opencv_core.CvSeq seq,
                                                                                 int before_index)

cvSeqRemove

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

Removes specified sequence element

cvClearSeq
```
public static void cvClearSeq(opencv_core.CvSeq seq)
```
Removes all the elements from the sequence. The freed memory can be reused later only by the same sequence unless cvClearMemStorage or cvRestoreMemStoragePos is called

cvGetSeqElem

@Cast(value="schar*")
public static org.bytedeco.javacpp.BytePointer cvGetSeqElem(@Const
                                                                                  opencv_core.CvSeq seq,
                                                                                  int index)

Retrieves pointer to specified sequence element. Negative indices are supported and mean counting from the end (e.g -1 means the last sequence element)

cvSeqElemIdx

public static int cvSeqElemIdx(@Const
                               opencv_core.CvSeq seq,
                               @Const
                               org.bytedeco.javacpp.Pointer element,
                               @Cast(value="CvSeqBlock**")
                               org.bytedeco.javacpp.PointerPointer block)

Calculates index of the specified sequence element. Returns -1 if element does not belong to the sequence

cvSeqElemIdx

public static int cvSeqElemIdx(@Const
                               opencv_core.CvSeq seq,
                               @Const
                               org.bytedeco.javacpp.Pointer element)

cvSeqElemIdx

public static int cvSeqElemIdx(@Const
                               opencv_core.CvSeq seq,
                               @Const
                               org.bytedeco.javacpp.Pointer element,
                               @ByPtrPtr
                               opencv_core.CvSeqBlock block)

cvStartAppendToSeq

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

Initializes sequence writer. The new elements will be added to the end of sequence

cvStartWriteSeq

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

Combination of cvCreateSeq and cvStartAppendToSeq

cvEndWriteSeq
```
public static opencv_core.CvSeq cvEndWriteSeq(opencv_core.CvSeqWriter writer)
```
Closes sequence writer, updates sequence header and returns pointer to the resultant sequence (which may be useful if the sequence was created using cvStartWriteSeq))

cvFlushSeqWriter
```
public static void cvFlushSeqWriter(opencv_core.CvSeqWriter writer)
```
Updates sequence header. May be useful to get access to some of previously written elements via cvGetSeqElem or sequence reader

cvStartReadSeq

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

Initializes sequence reader. The sequence can be read in forward or backward direction

cvStartReadSeq

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

cvGetSeqReaderPos
```
public static int cvGetSeqReaderPos(opencv_core.CvSeqReader reader)
```
Returns current sequence reader position (currently observed sequence element)

cvSetSeqReaderPos

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

Changes sequence reader position. It may seek to an absolute or to relative to the current position

cvSetSeqReaderPos

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

cvCvtSeqToArray

public static org.bytedeco.javacpp.Pointer cvCvtSeqToArray(@Const
                                                           opencv_core.CvSeq seq,
                                                           org.bytedeco.javacpp.Pointer elements,
                                                           @ByVal(nullValue="CvSlice(CV_WHOLE_SEQ)")
                                                           opencv_core.CvSlice slice)

Copies sequence content to a continuous piece of memory

cvCvtSeqToArray

public static org.bytedeco.javacpp.Pointer cvCvtSeqToArray(@Const
                                                           opencv_core.CvSeq seq,
                                                           org.bytedeco.javacpp.Pointer elements)

cvMakeSeqHeaderForArray

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

Creates sequence header for array. After that all the operations on sequences that do not alter the content can be applied to the resultant sequence

cvSeqSlice

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

Extracts sequence slice (with or without copying sequence elements)

cvSeqSlice

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

cvCloneSeq

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

cvCloneSeq

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

cvSeqRemoveSlice

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

Removes sequence slice

cvSeqInsertSlice

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

Inserts a sequence or array into another sequence

cvSeqSort

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

Sorts sequence in-place given element comparison function

cvSeqSort

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

cvSeqSearch

@Cast(value="schar*")
public static org.bytedeco.javacpp.BytePointer cvSeqSearch(opencv_core.CvSeq seq,
                                                                                 @Const
                                                                                 org.bytedeco.javacpp.Pointer elem,
                                                                                 opencv_core.CvCmpFunc func,
                                                                                 int is_sorted,
                                                                                 org.bytedeco.javacpp.IntPointer elem_idx,
                                                                                 org.bytedeco.javacpp.Pointer userdata)

Finds element in a [sorted] sequence

cvSeqSearch

@Cast(value="schar*")
public static org.bytedeco.javacpp.BytePointer cvSeqSearch(opencv_core.CvSeq seq,
                                                                                 @Const
                                                                                 org.bytedeco.javacpp.Pointer elem,
                                                                                 opencv_core.CvCmpFunc func,
                                                                                 int is_sorted,
                                                                                 org.bytedeco.javacpp.IntPointer elem_idx)

cvSeqSearch

@Cast(value="schar*")
public static ByteBuffer cvSeqSearch(opencv_core.CvSeq seq,
                                                           @Const
                                                           org.bytedeco.javacpp.Pointer elem,
                                                           opencv_core.CvCmpFunc func,
                                                           int is_sorted,
                                                           IntBuffer elem_idx,
                                                           org.bytedeco.javacpp.Pointer userdata)

cvSeqSearch

@Cast(value="schar*")
public static ByteBuffer cvSeqSearch(opencv_core.CvSeq seq,
                                                           @Const
                                                           org.bytedeco.javacpp.Pointer elem,
                                                           opencv_core.CvCmpFunc func,
                                                           int is_sorted,
                                                           IntBuffer elem_idx)

cvSeqSearch

@Cast(value="schar*")
public static byte[] cvSeqSearch(opencv_core.CvSeq seq,
                                                       @Const
                                                       org.bytedeco.javacpp.Pointer elem,
                                                       opencv_core.CvCmpFunc func,
                                                       int is_sorted,
                                                       int[] elem_idx,
                                                       org.bytedeco.javacpp.Pointer userdata)

cvSeqSearch

@Cast(value="schar*")
public static byte[] cvSeqSearch(opencv_core.CvSeq seq,
                                                       @Const
                                                       org.bytedeco.javacpp.Pointer elem,
                                                       opencv_core.CvCmpFunc func,
                                                       int is_sorted,
                                                       int[] elem_idx)

cvSeqInvert

public static void cvSeqInvert(opencv_core.CvSeq seq)

Reverses order of sequence elements in-place

cvSeqPartition

public static int cvSeqPartition(@Const
                                 opencv_core.CvSeq seq,
                                 opencv_core.CvMemStorage storage,
                                 @Cast(value="CvSeq**")
                                 org.bytedeco.javacpp.PointerPointer labels,
                                 opencv_core.CvCmpFunc is_equal,
                                 org.bytedeco.javacpp.Pointer userdata)

Splits sequence into one or more equivalence classes using the specified criteria

cvSeqPartition

public static int cvSeqPartition(@Const
                                 opencv_core.CvSeq seq,
                                 opencv_core.CvMemStorage storage,
                                 @ByPtrPtr
                                 opencv_core.CvSeq labels,
                                 opencv_core.CvCmpFunc is_equal,
                                 org.bytedeco.javacpp.Pointer userdata)

cvChangeSeqBlock

public static void cvChangeSeqBlock(org.bytedeco.javacpp.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)

Creates a new set

cvSetAdd

public static int cvSetAdd(opencv_core.CvSet set_header,
                           opencv_core.CvSetElem elem,
                           @Cast(value="CvSetElem**")
                           org.bytedeco.javacpp.PointerPointer inserted_elem)

Adds new element to the set and returns pointer to it

cvSetAdd

public static int cvSetAdd(opencv_core.CvSet set_header)

cvSetAdd

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

cvSetNew

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

Fast variant of cvSetAdd

cvSetRemoveByPtr

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

Removes set element given its pointer

cvSetRemove

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

Removes element from the set by its index

cvGetSetElem

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

Returns a set element by index. If the element doesn't belong to the set, NULL is returned

cvClearSet

public static void cvClearSet(opencv_core.CvSet set_header)

Removes all the elements from the set

cvCreateGraph

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

Creates new graph

cvGraphAddVtx

public static int cvGraphAddVtx(opencv_core.CvGraph graph,
                                @Const
                                opencv_core.CvGraphVtx vtx,
                                @Cast(value="CvGraphVtx**")
                                org.bytedeco.javacpp.PointerPointer inserted_vtx)

Adds new vertex to the graph

cvGraphAddVtx

public static int cvGraphAddVtx(opencv_core.CvGraph graph)

cvGraphAddVtx

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

cvGraphRemoveVtx

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

Removes vertex from the graph together with all incident edges

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,
                                 @Const
                                 opencv_core.CvGraphEdge edge,
                                 @Cast(value="CvGraphEdge**")
                                 org.bytedeco.javacpp.PointerPointer inserted_edge)

Link two vertices specified by indices or pointers if they are not connected or return pointer to already existing edge connecting the vertices. Functions return 1 if a new edge was created, 0 otherwise

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,
                                 @Const
                                 opencv_core.CvGraphEdge edge,
                                 @ByPtrPtr
                                 opencv_core.CvGraphEdge inserted_edge)

cvGraphAddEdgeByPtr

public static int cvGraphAddEdgeByPtr(opencv_core.CvGraph graph,
                                      opencv_core.CvGraphVtx start_vtx,
                                      opencv_core.CvGraphVtx end_vtx,
                                      @Const
                                      opencv_core.CvGraphEdge edge,
                                      @Cast(value="CvGraphEdge**")
                                      org.bytedeco.javacpp.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,
                                      @Const
                                      opencv_core.CvGraphEdge edge,
                                      @ByPtrPtr
                                      opencv_core.CvGraphEdge inserted_edge)

cvGraphRemoveEdge

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

Remove edge connecting two vertices

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(@Const
                                                      opencv_core.CvGraph graph,
                                                      int start_idx,
                                                      int end_idx)

Find edge connecting two vertices

cvFindGraphEdgeByPtr

public static opencv_core.CvGraphEdge cvFindGraphEdgeByPtr(@Const
                                                           opencv_core.CvGraph graph,
                                                           @Const
                                                           opencv_core.CvGraphVtx start_vtx,
                                                           @Const
                                                           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)

Remove all vertices and edges from the graph

cvGraphVtxDegree

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

Count number of edges incident to the vertex

cvGraphVtxDegreeByPtr

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

cvCreateGraphScanner

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

Creates new graph scanner.

cvCreateGraphScanner

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

cvReleaseGraphScanner

public static void cvReleaseGraphScanner(@Cast(value="CvGraphScanner**")
                                         org.bytedeco.javacpp.PointerPointer scanner)

Releases graph scanner.

cvReleaseGraphScanner

public static void cvReleaseGraphScanner(@ByPtrPtr
                                         opencv_core.CvGraphScanner scanner)

cvNextGraphItem

public static int cvNextGraphItem(opencv_core.CvGraphScanner scanner)

Get next graph element

cvCloneGraph

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

Creates a copy of graph

cvLUT

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

Does look-up transformation. Elements of the source array (that should be 8uC1 or 8sC1) are used as indexes in lutarr 256-element table

cvInitTreeNodeIterator

public static void cvInitTreeNodeIterator(opencv_core.CvTreeNodeIterator tree_iterator,
                                          @Const
                                          org.bytedeco.javacpp.Pointer first,
                                          int max_level)

cvNextTreeNode

public static org.bytedeco.javacpp.Pointer cvNextTreeNode(opencv_core.CvTreeNodeIterator tree_iterator)

cvPrevTreeNode

public static org.bytedeco.javacpp.Pointer cvPrevTreeNode(opencv_core.CvTreeNodeIterator tree_iterator)

cvInsertNodeIntoTree

public static void cvInsertNodeIntoTree(org.bytedeco.javacpp.Pointer node,
                                        org.bytedeco.javacpp.Pointer parent,
                                        org.bytedeco.javacpp.Pointer frame)

Inserts sequence into tree with specified "parent" sequence. If parent is equal to frame (e.g. the most external contour), then added contour will have null pointer to parent.

cvRemoveNodeFromTree

public static void cvRemoveNodeFromTree(org.bytedeco.javacpp.Pointer node,
                                        org.bytedeco.javacpp.Pointer frame)

Removes contour from tree (together with the contour children).

cvTreeToNodeSeq

public static opencv_core.CvSeq cvTreeToNodeSeq(@Const
                                                org.bytedeco.javacpp.Pointer first,
                                                int header_size,
                                                opencv_core.CvMemStorage storage)

Gathers pointers to all the sequences, accessible from the first, to the single sequence

cvKMeans2

public static int cvKMeans2(@Const
                            opencv_core.CvArr samples,
                            int cluster_count,
                            opencv_core.CvArr labels,
                            @ByVal
                            opencv_core.CvTermCriteria termcrit,
                            int attempts,
                            @Cast(value="CvRNG*")
                            org.bytedeco.javacpp.LongPointer rng,
                            int flags,
                            opencv_core.CvArr _centers,
                            org.bytedeco.javacpp.DoublePointer compactness)

cvKMeans2

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

cvKMeans2

public static int cvKMeans2(@Const
                            opencv_core.CvArr samples,
                            int cluster_count,
                            opencv_core.CvArr labels,
                            @ByVal
                            opencv_core.CvTermCriteria termcrit,
                            int attempts,
                            @Cast(value="CvRNG*")
                            LongBuffer rng,
                            int flags,
                            opencv_core.CvArr _centers,
                            DoubleBuffer compactness)

cvKMeans2

public static int cvKMeans2(@Const
                            opencv_core.CvArr samples,
                            int cluster_count,
                            opencv_core.CvArr labels,
                            @ByVal
                            opencv_core.CvTermCriteria termcrit,
                            int attempts,
                            @Cast(value="CvRNG*")
                            long[] rng,
                            int flags,
                            opencv_core.CvArr _centers,
                            double[] compactness)

cvUseOptimized
```
public static int cvUseOptimized(int on_off)
```
Loads optimized functions from IPP, MKL etc. or switches back to pure C code

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)

\brief Makes OpenCV use IPL functions for allocating IplImage and IplROI structures.

Normally, the function is not called directly. Instead, a simple macro CV_TURN_ON_IPL_COMPATIBILITY() is used that calls cvSetIPLAllocators and passes there pointers to IPL allocation functions. :


    ...
    CV_TURN_ON_IPL_COMPATIBILITY()
    ...

Parameters:: create_header - pointer to a function, creating IPL image header.; allocate_data - pointer to a function, allocating IPL image data.; deallocate - pointer to a function, deallocating IPL image.; create_roi - pointer to a function, creating IPL image ROI (i.e. Region of Interest).; clone_image - pointer to a function, cloning an IPL image.

cvOpenFileStorage
```
public static opencv_core.CvFileStorage cvOpenFileStorage(@Cast(value="const char*")
                                                          org.bytedeco.javacpp.BytePointer filename,
                                                          opencv_core.CvMemStorage memstorage,
                                                          int flags,
                                                          @Cast(value="const char*")
                                                          org.bytedeco.javacpp.BytePointer encoding)
```
\brief Opens file storage for reading or writing data.
The function opens file storage for reading or writing data. In the latter case, a new file is created or an existing file is rewritten. The type of the read or written file is determined by the filename extension: .xml for XML, .yml or .yaml for YAML and .json for JSON.
At the same time, it also supports adding parameters like "example.xml?base64".
The function returns a pointer to the CvFileStorage structure. If the file cannot be opened then the function returns NULL.

Parameters:

filename - Name of the file associated with the storage

memstorage - Memory storage used for temporary data and for : storing dynamic structures, such as CvSeq or CvGraph . If it is NULL, a temporary memory storage is created and used.

flags - Can be one of the following: > - **CV_STORAGE_READ** the storage is open for reading > - **CV_STORAGE_WRITE** the storage is open for writing (use **CV_STORAGE_WRITE | CV_STORAGE_WRITE_BASE64** to write rawdata in Base64)

encoding -

cvOpenFileStorage

public static opencv_core.CvFileStorage cvOpenFileStorage(@Cast(value="const char*")
                                                          org.bytedeco.javacpp.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(@Cast(value="CvFileStorage**")
                                        org.bytedeco.javacpp.PointerPointer fs)
```
\brief Releases file storage.
The function closes the file associated with the storage and releases all the temporary structures. It must be called after all I/O operations with the storage are finished.

Parameters:

fs - Double pointer to the released file storage

cvReleaseFileStorage

public static void cvReleaseFileStorage(@ByPtrPtr
                                        opencv_core.CvFileStorage fs)

cvAttrValue

@Cast(value="const char*")
public static org.bytedeco.javacpp.BytePointer cvAttrValue(@Const
                                                                                      opencv_core.CvAttrList attr,
                                                                                      @Cast(value="const char*")
                                                                                      org.bytedeco.javacpp.BytePointer attr_name)

returns attribute value or 0 (NULL) if there is no such attribute

cvAttrValue

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

cvStartWriteStruct
```
public static void cvStartWriteStruct(opencv_core.CvFileStorage fs,
                                      @Cast(value="const char*")
                                      org.bytedeco.javacpp.BytePointer name,
                                      int struct_flags,
                                      @Cast(value="const char*")
                                      org.bytedeco.javacpp.BytePointer type_name,
                                      @ByVal(nullValue="CvAttrList(cvAttrList())")
                                      opencv_core.CvAttrList attributes)
```
\brief Starts writing a new structure.
The function starts writing a compound structure (collection) that can be a sequence or a map. After all the structure fields, which can be scalars or structures, are written, cvEndWriteStruct should be called. The function can be used to group some objects or to implement the write function for a some user object (see CvTypeInfo).

Parameters:

fs - File storage

name - Name of the written structure. The structure can be accessed by this name when the storage is read.

struct_flags - A combination one of the following values: - **CV_NODE_SEQ** the written structure is a sequence (see discussion of CvFileStorage ), that is, its elements do not have a name. - **CV_NODE_MAP** the written structure is a map (see discussion of CvFileStorage ), that is, all its elements have names. One and only one of the two above flags must be specified - **CV_NODE_FLOW** the optional flag that makes sense only for YAML streams. It means that the structure is written as a flow (not as a block), which is more compact. It is recommended to use this flag for structures or arrays whose elements are all scalars.

type_name - Optional parameter - the object type name. In case of XML it is written as a type_id attribute of the structure opening tag. In the case of YAML it is written after a colon following the structure name (see the example in CvFileStorage description). In case of JSON it is written as a name/value pair. Mainly it is used with user objects. When the storage is read, the encoded type name is used to determine the object type (see CvTypeInfo and cvFindType ).

attributes - This parameter is not used in the current implementation

cvStartWriteStruct

public static void cvStartWriteStruct(opencv_core.CvFileStorage fs,
                                      @Cast(value="const char*")
                                      org.bytedeco.javacpp.BytePointer name,
                                      int struct_flags)

cvStartWriteStruct

public static void cvStartWriteStruct(opencv_core.CvFileStorage fs,
                                      String name,
                                      int struct_flags,
                                      String type_name,
                                      @ByVal(nullValue="CvAttrList(cvAttrList())")
                                      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)
```
\brief Finishes writing to a file node collection.

Parameters:

fs - File storage \sa cvStartWriteStruct.

cvWriteInt
```
public static void cvWriteInt(opencv_core.CvFileStorage fs,
                              @Cast(value="const char*")
                              org.bytedeco.javacpp.BytePointer name,
                              int value)
```
\brief Writes an integer value.
The function writes a single integer value (with or without a name) to the file storage.

Parameters:

fs - File storage

name - Name of the written value. Should be NULL if and only if the parent structure is a sequence.

value - The written value

cvWriteInt

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

cvWriteReal

public static void cvWriteReal(opencv_core.CvFileStorage fs,
                               @Cast(value="const char*")
                               org.bytedeco.javacpp.BytePointer name,
                               double value)

\brief Writes a floating-point value.

The function writes a single floating-point value (with or without a name) to file storage. Special values are encoded as follows: NaN (Not A Number) as .NaN, infinity as +.Inf or -.Inf.

The following example shows how to use the low-level writing functions to store custom structures, such as termination criteria, without registering a new type. :


    void write_termcriteria( CvFileStorage* fs, const char* struct_name,
                             CvTermCriteria* termcrit )
    {
        cvStartWriteStruct( fs, struct_name, CV_NODE_MAP, NULL, cvAttrList(0,0));
        cvWriteComment( fs, "termination criteria", 1 ); // just a description
        if( termcrit->type & CV_TERMCRIT_ITER )
            cvWriteInteger( fs, "max_iterations", termcrit->max_iter );
        if( termcrit->type & CV_TERMCRIT_EPS )
            cvWriteReal( fs, "accuracy", termcrit->epsilon );
        cvEndWriteStruct( fs );
    }

Parameters:: fs - File storage; name - Name of the written value. Should be NULL if and only if the parent structure is a sequence.; value - The written value

cvWriteReal

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

cvWriteString
```
public static void cvWriteString(opencv_core.CvFileStorage fs,
                                 @Cast(value="const char*")
                                 org.bytedeco.javacpp.BytePointer name,
                                 @Cast(value="const char*")
                                 org.bytedeco.javacpp.BytePointer str,
                                 int quote)
```
\brief Writes a text string.
The function writes a text string to file storage.

Parameters:

fs - File storage

name - Name of the written string . Should be NULL if and only if the parent structure is a sequence.

str - The written text string

quote - If non-zero, the written string is put in quotes, regardless of whether they are required. Otherwise, if the flag is zero, quotes are used only when they are required (e.g. when the string starts with a digit or contains spaces).

cvWriteString

public static void cvWriteString(opencv_core.CvFileStorage fs,
                                 @Cast(value="const char*")
                                 org.bytedeco.javacpp.BytePointer name,
                                 @Cast(value="const char*")
                                 org.bytedeco.javacpp.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,
                                  @Cast(value="const char*")
                                  org.bytedeco.javacpp.BytePointer comment,
                                  int eol_comment)
```
\brief Writes a comment.
The function writes a comment into file storage. The comments are skipped when the storage is read.

Parameters:

fs - File storage

comment - The written comment, single-line or multi-line

eol_comment - If non-zero, the function tries to put the comment at the end of current line. If the flag is zero, if the comment is multi-line, or if it does not fit at the end of the current line, the comment starts a new line.

cvWriteComment

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

cvWrite
```
public static void cvWrite(opencv_core.CvFileStorage fs,
                           @Cast(value="const char*")
                           org.bytedeco.javacpp.BytePointer name,
                           @Const
                           org.bytedeco.javacpp.Pointer ptr,
                           @ByVal(nullValue="CvAttrList(cvAttrList())")
                           opencv_core.CvAttrList attributes)
```
\brief Writes an object to file storage.
The function writes an object to file storage. First, the appropriate type info is found using cvTypeOf. Then, the write method associated with the type info is called.
Attributes are used to customize the writing procedure. The standard types support the following attributes (all the dt attributes have the same format as in cvWriteRawData):
-# CvSeq - **header_dt** description of user fields of the sequence header that follow CvSeq, or CvChain (if the sequence is a Freeman chain) or CvContour (if the sequence is a contour or point sequence) - **dt** description of the sequence elements. - **recursive** if the attribute is present and is not equal to "0" or "false", the whole tree of sequences (contours) is stored. -# CvGraph - **header_dt** description of user fields of the graph header that follows CvGraph; - **vertex_dt** description of user fields of graph vertices - **edge_dt** description of user fields of graph edges (note that the edge weight is always written, so there is no need to specify it explicitly)
Below is the code that creates the YAML file shown in the CvFileStorage description:
```
    #include "cxcore.h"

    int main( int argc, char** argv )
    {
        CvMat* mat = cvCreateMat( 3, 3, CV_32F );
        CvFileStorage* fs = cvOpenFileStorage( "example.yml", 0, CV_STORAGE_WRITE );

        cvSetIdentity( mat );
        cvWrite( fs, "A", mat, cvAttrList(0,0) );

        cvReleaseFileStorage( &fs );
        cvReleaseMat( &mat );
        return 0;
    }
```
Parameters:

fs - File storage

name - Name of the written object. Should be NULL if and only if the parent structure is a sequence.

ptr - Pointer to the object

attributes - The attributes of the object. They are specific for each particular type (see the discussion below).

cvWrite

public static void cvWrite(opencv_core.CvFileStorage fs,
                           @Cast(value="const char*")
                           org.bytedeco.javacpp.BytePointer name,
                           @Const
                           org.bytedeco.javacpp.Pointer ptr)

cvWrite

public static void cvWrite(opencv_core.CvFileStorage fs,
                           String name,
                           @Const
                           org.bytedeco.javacpp.Pointer ptr,
                           @ByVal(nullValue="CvAttrList(cvAttrList())")
                           opencv_core.CvAttrList attributes)

cvWrite

public static void cvWrite(opencv_core.CvFileStorage fs,
                           String name,
                           @Const
                           org.bytedeco.javacpp.Pointer ptr)

cvStartNextStream
```
public static void cvStartNextStream(opencv_core.CvFileStorage fs)
```
\brief Starts the next stream.
The function finishes the currently written stream and starts the next stream. In the case of XML the file with multiple streams looks like this:
```
 {.xml}
    <opencv_storage>
    
    </opencv_storage>
    <opencv_storage>
    
    </opencv_storage>
    ...
```
The YAML file will look like this:
```
 {.yaml}
    %YAML 1.0
    # stream #1 data
    ...
    ---
    # stream #2 data
```
This is useful for concatenating files or for resuming the writing process.
Parameters:

fs - File storage

cvWriteRawData
```
public static void cvWriteRawData(opencv_core.CvFileStorage fs,
                                  @Const
                                  org.bytedeco.javacpp.Pointer src,
                                  int len,
                                  @Cast(value="const char*")
                                  org.bytedeco.javacpp.BytePointer dt)
```
\brief Writes multiple numbers.
The function writes an array, whose elements consist of single or multiple numbers. The function call can be replaced with a loop containing a few cvWriteInt and cvWriteReal calls, but a single call is more efficient. Note that because none of the elements have a name, they should be written to a sequence rather than a map.

Parameters:

fs - File storage

src - Pointer to the written array

len - Number of the array elements to write

dt - Specification of each array element, see \ref format_spec "format specification"

cvWriteRawData

public static void cvWriteRawData(opencv_core.CvFileStorage fs,
                                  @Const
                                  org.bytedeco.javacpp.Pointer src,
                                  int len,
                                  String dt)

cvWriteRawDataBase64
```
public static void cvWriteRawDataBase64(opencv_core.CvFileStorage fs,
                                        @Const
                                        org.bytedeco.javacpp.Pointer src,
                                        int len,
                                        @Cast(value="const char*")
                                        org.bytedeco.javacpp.BytePointer dt)
```
\brief Writes multiple numbers in Base64.
If either CV_STORAGE_WRITE_BASE64 or cv::FileStorage::WRITE_BASE64 is used, this function will be the same as cvWriteRawData. If neither, the main difference is that it outputs a sequence in Base64 encoding rather than in plain text.
This function can only be used to write a sequence with a type "binary".

Parameters:

fs - File storage

src - Pointer to the written array

len - Number of the array elements to write

dt - Specification of each array element, see \ref format_spec "format specification"

cvWriteRawDataBase64

public static void cvWriteRawDataBase64(opencv_core.CvFileStorage fs,
                                        @Const
                                        org.bytedeco.javacpp.Pointer src,
                                        int len,
                                        String dt)

cvGetHashedKey

public static opencv_core.CvStringHashNode cvGetHashedKey(opencv_core.CvFileStorage fs,
                                                          @Cast(value="const char*")
                                                          org.bytedeco.javacpp.BytePointer name,
                                                          int len,
                                                          int create_missing)

\brief Returns a unique pointer for a given name.

The function returns a unique pointer for each particular file node name. This pointer can be then passed to the cvGetFileNode function that is faster than cvGetFileNodeByName because it compares text strings by comparing pointers rather than the strings' content.

Consider the following example where an array of points is encoded as a sequence of 2-entry maps:


    points:
      - { x: 10, y: 10 }
      - { x: 20, y: 20 }
      - { x: 30, y: 30 }
      # ...

Then, it is possible to get hashed "x" and "y" pointers to speed up decoding of the points. :


    #include "cxcore.h"

    int main( int argc, char** argv )
    {
        CvFileStorage* fs = cvOpenFileStorage( "points.yml", 0, CV_STORAGE_READ );
        CvStringHashNode* x_key = cvGetHashedNode( fs, "x", -1, 1 );
        CvStringHashNode* y_key = cvGetHashedNode( fs, "y", -1, 1 );
        CvFileNode* points = cvGetFileNodeByName( fs, 0, "points" );

        if( CV_NODE_IS_SEQ(points->tag) )
        {
            CvSeq* seq = points->data.seq;
            int i, total = seq->total;
            CvSeqReader reader;
            cvStartReadSeq( seq, &reader, 0 );
            for( i = 0; i < total; i++ )
            {
                CvFileNode* pt = (CvFileNode*)reader.ptr;
    #if 1 // faster variant
                CvFileNode* xnode = cvGetFileNode( fs, pt, x_key, 0 );
                CvFileNode* ynode = cvGetFileNode( fs, pt, y_key, 0 );
                assert( xnode && CV_NODE_IS_INT(xnode->tag) &&
                        ynode && CV_NODE_IS_INT(ynode->tag));
                int x = xnode->data.i; // or x = cvReadInt( xnode, 0 );
                int y = ynode->data.i; // or y = cvReadInt( ynode, 0 );
    #elif 1 // slower variant; does not use x_key & y_key
                CvFileNode* xnode = cvGetFileNodeByName( fs, pt, "x" );
                CvFileNode* ynode = cvGetFileNodeByName( fs, pt, "y" );
                assert( xnode && CV_NODE_IS_INT(xnode->tag) &&
                        ynode && CV_NODE_IS_INT(ynode->tag));
                int x = xnode->data.i; // or x = cvReadInt( xnode, 0 );
                int y = ynode->data.i; // or y = cvReadInt( ynode, 0 );
    #else // the slowest yet the easiest to use variant
                int x = cvReadIntByName( fs, pt, "x", 0 );
                int y = cvReadIntByName( fs, pt, "y", 0 );
    #endif
                CV_NEXT_SEQ_ELEM( seq->elem_size, reader );
                printf("
            }
        }
        cvReleaseFileStorage( &fs );
        return 0;
    }

Please note that whatever method of accessing a map you are using, it is still much slower than using plain sequences; for example, in the above example, it is more efficient to encode the points as pairs of integers in a single numeric sequence.

Parameters:: fs - File storage; name - Literal node name; len - Length of the name (if it is known apriori), or -1 if it needs to be calculated; create_missing - Flag that specifies, whether an absent key should be added into the hash table

cvGetHashedKey

public static opencv_core.CvStringHashNode cvGetHashedKey(opencv_core.CvFileStorage fs,
                                                          @Cast(value="const char*")
                                                          org.bytedeco.javacpp.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(@Const
                                                       opencv_core.CvFileStorage fs,
                                                       int stream_index)
```
\brief Retrieves one of the top-level nodes of the file storage.
The function returns one of the top-level file nodes. The top-level nodes do not have a name, they correspond to the streams that are stored one after another in the file storage. If the index is out of range, the function returns a NULL pointer, so all the top-level nodes can be iterated by subsequent calls to the function with stream_index=0,1,..., until the NULL pointer is returned. This function can be used as a base for recursive traversal of the file storage.

Parameters:

fs - File storage

stream_index - Zero-based index of the stream. See cvStartNextStream . In most cases, there is only one stream in the file; however, there can be several.

cvGetRootFileNode

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

cvGetFileNode
```
public static opencv_core.CvFileNode cvGetFileNode(opencv_core.CvFileStorage fs,
                                                   opencv_core.CvFileNode map,
                                                   @Const
                                                   opencv_core.CvStringHashNode key,
                                                   int create_missing)
```
\brief Finds a node in a map or file storage.
The function finds a file node. It is a faster version of cvGetFileNodeByName (see cvGetHashedKey discussion). Also, the function can insert a new node, if it is not in the map yet.

Parameters:

fs - File storage

map - The parent map. If it is NULL, the function searches a top-level node. If both map and key are NULLs, the function returns the root file node - a map that contains top-level nodes.

key - Unique pointer to the node name, retrieved with cvGetHashedKey

create_missing - Flag that specifies whether an absent node should be added to the map

cvGetFileNode

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

cvGetFileNodeByName
```
public static opencv_core.CvFileNode cvGetFileNodeByName(@Const
                                                         opencv_core.CvFileStorage fs,
                                                         @Const
                                                         opencv_core.CvFileNode map,
                                                         @Cast(value="const char*")
                                                         org.bytedeco.javacpp.BytePointer name)
```
\brief Finds a node in a map or file storage.
The function finds a file node by name. The node is searched either in map or, if the pointer is NULL, among the top-level file storage nodes. Using this function for maps and cvGetSeqElem (or sequence reader) for sequences, it is possible to navigate through the file storage. To speed up multiple queries for a certain key (e.g., in the case of an array of structures) one may use a combination of cvGetHashedKey and cvGetFileNode.

Parameters:

fs - File storage

map - The parent map. If it is NULL, the function searches in all the top-level nodes (streams), starting with the first one.

name - The file node name

cvGetFileNodeByName

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

cvReadInt
```
public static int cvReadInt(@Const
                            opencv_core.CvFileNode node,
                            int default_value)
```
\brief Retrieves an integer value from a file node.
The function returns an integer that is represented by the file node. If the file node is NULL, the default_value is returned (thus, it is convenient to call the function right after cvGetFileNode without checking for a NULL pointer). If the file node has type CV_NODE_INT, then node-\>data.i is returned. If the file node has type CV_NODE_REAL, then node-\>data.f is converted to an integer and returned. Otherwise the error is reported.

Parameters:

node - File node

default_value - The value that is returned if node is NULL

cvReadInt

public static int cvReadInt(@Const
                            opencv_core.CvFileNode node)

cvReadIntByName

public static int cvReadIntByName(@Const
                                  opencv_core.CvFileStorage fs,
                                  @Const
                                  opencv_core.CvFileNode map,
                                  @Cast(value="const char*")
                                  org.bytedeco.javacpp.BytePointer name,
                                  int default_value)

\brief Finds a file node and returns its value.

The function is a simple superposition of cvGetFileNodeByName and cvReadInt.

Parameters:: fs - File storage; map - The parent map. If it is NULL, the function searches a top-level node.; name - The node name; default_value - The value that is returned if the file node is not found

cvReadIntByName

public static int cvReadIntByName(@Const
                                  opencv_core.CvFileStorage fs,
                                  @Const
                                  opencv_core.CvFileNode map,
                                  @Cast(value="const char*")
                                  org.bytedeco.javacpp.BytePointer name)

cvReadIntByName

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

cvReadIntByName

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

cvReadReal
```
public static double cvReadReal(@Const
                                opencv_core.CvFileNode node,
                                double default_value)
```
\brief Retrieves a floating-point value from a file node.
The function returns a floating-point value that is represented by the file node. If the file node is NULL, the default_value is returned (thus, it is convenient to call the function right after cvGetFileNode without checking for a NULL pointer). If the file node has type CV_NODE_REAL , then node-\>data.f is returned. If the file node has type CV_NODE_INT , then node-:math:\>data.f is converted to floating-point and returned. Otherwise the result is not determined.

Parameters:

node - File node

default_value - The value that is returned if node is NULL

cvReadReal

public static double cvReadReal(@Const
                                opencv_core.CvFileNode node)

cvReadRealByName

public static double cvReadRealByName(@Const
                                      opencv_core.CvFileStorage fs,
                                      @Const
                                      opencv_core.CvFileNode map,
                                      @Cast(value="const char*")
                                      org.bytedeco.javacpp.BytePointer name,
                                      double default_value)

\brief Finds a file node and returns its value.

The function is a simple superposition of cvGetFileNodeByName and cvReadReal .

Parameters:: fs - File storage; map - The parent map. If it is NULL, the function searches a top-level node.; name - The node name; default_value - The value that is returned if the file node is not found

cvReadRealByName

public static double cvReadRealByName(@Const
                                      opencv_core.CvFileStorage fs,
                                      @Const
                                      opencv_core.CvFileNode map,
                                      @Cast(value="const char*")
                                      org.bytedeco.javacpp.BytePointer name)

cvReadRealByName

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

cvReadRealByName

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

cvReadString

@Cast(value="const char*")
public static org.bytedeco.javacpp.BytePointer cvReadString(@Const
                                                                                       opencv_core.CvFileNode node,
                                                                                       @Cast(value="const char*")
                                                                                       org.bytedeco.javacpp.BytePointer default_value)

\brief Retrieves a text string from a file node.

The function returns a text string that is represented by the file node. If the file node is NULL, the default_value is returned (thus, it is convenient to call the function right after cvGetFileNode without checking for a NULL pointer). If the file node has type CV_NODE_STR , then node-:math:\>data.str.ptr is returned. Otherwise the result is not determined.

Parameters:: node - File node; default_value - The value that is returned if node is NULL

cvReadString

@Cast(value="const char*")
public static org.bytedeco.javacpp.BytePointer cvReadString(@Const
                                                                                       opencv_core.CvFileNode node)

cvReadString

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

cvReadStringByName

@Cast(value="const char*")
public static org.bytedeco.javacpp.BytePointer cvReadStringByName(@Const
                                                                                             opencv_core.CvFileStorage fs,
                                                                                             @Const
                                                                                             opencv_core.CvFileNode map,
                                                                                             @Cast(value="const char*")
                                                                                             org.bytedeco.javacpp.BytePointer name,
                                                                                             @Cast(value="const char*")
                                                                                             org.bytedeco.javacpp.BytePointer default_value)

\brief Finds a file node by its name and returns its value.

The function is a simple superposition of cvGetFileNodeByName and cvReadString .

Parameters:: fs - File storage; map - The parent map. If it is NULL, the function searches a top-level node.; name - The node name; default_value - The value that is returned if the file node is not found

cvReadStringByName

@Cast(value="const char*")
public static org.bytedeco.javacpp.BytePointer cvReadStringByName(@Const
                                                                                             opencv_core.CvFileStorage fs,
                                                                                             @Const
                                                                                             opencv_core.CvFileNode map,
                                                                                             @Cast(value="const char*")
                                                                                             org.bytedeco.javacpp.BytePointer name)

cvReadStringByName

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

cvReadStringByName

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

cvRead
```
public static org.bytedeco.javacpp.Pointer cvRead(opencv_core.CvFileStorage fs,
                                                  opencv_core.CvFileNode node,
                                                  opencv_core.CvAttrList attributes)
```
\brief Decodes an object and returns a pointer to it.
The function decodes a user object (creates an object in a native representation from the file storage subtree) and returns it. The object to be decoded must be an instance of a registered type that supports the read method (see CvTypeInfo). The type of the object is determined by the type name that is encoded in the file. If the object is a dynamic structure, it is created either in memory storage and passed to cvOpenFileStorage or, if a NULL pointer was passed, in temporary memory storage, which is released when cvReleaseFileStorage is called. Otherwise, if the object is not a dynamic structure, it is created in a heap and should be released with a specialized function or by using the generic cvRelease.

Parameters:

fs - File storage

node - The root object node

attributes - Unused parameter

cvRead

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

cvReadByName

public static org.bytedeco.javacpp.Pointer cvReadByName(opencv_core.CvFileStorage fs,
                                                        @Const
                                                        opencv_core.CvFileNode map,
                                                        @Cast(value="const char*")
                                                        org.bytedeco.javacpp.BytePointer name,
                                                        opencv_core.CvAttrList attributes)

\brief Finds an object by name and decodes it.

The function is a simple superposition of cvGetFileNodeByName and cvRead.

Parameters:: fs - File storage; map - The parent map. If it is NULL, the function searches a top-level node.; name - The node name; attributes - Unused parameter

cvReadByName

public static org.bytedeco.javacpp.Pointer cvReadByName(opencv_core.CvFileStorage fs,
                                                        @Const
                                                        opencv_core.CvFileNode map,
                                                        @Cast(value="const char*")
                                                        org.bytedeco.javacpp.BytePointer name)

cvReadByName

public static org.bytedeco.javacpp.Pointer cvReadByName(opencv_core.CvFileStorage fs,
                                                        @Const
                                                        opencv_core.CvFileNode map,
                                                        String name,
                                                        opencv_core.CvAttrList attributes)

cvReadByName

public static org.bytedeco.javacpp.Pointer cvReadByName(opencv_core.CvFileStorage fs,
                                                        @Const
                                                        opencv_core.CvFileNode map,
                                                        String name)

cvStartReadRawData

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

\brief Initializes the file node sequence reader.

The function initializes the sequence reader to read data from a file node. The initialized reader can be then passed to cvReadRawDataSlice.

Parameters:: fs - File storage; src - The file node (a sequence) to read numbers from; reader - Pointer to the sequence reader

cvReadRawDataSlice
```
public static void cvReadRawDataSlice(@Const
                                      opencv_core.CvFileStorage fs,
                                      opencv_core.CvSeqReader reader,
                                      int count,
                                      org.bytedeco.javacpp.Pointer dst,
                                      @Cast(value="const char*")
                                      org.bytedeco.javacpp.BytePointer dt)
```
\brief Initializes file node sequence reader.
The function reads one or more elements from the file node, representing a sequence, to a user-specified array. The total number of read sequence elements is a product of total and the number of components in each array element. For example, if dt=2if, the function will read total\*3 sequence elements. As with any sequence, some parts of the file node sequence can be skipped or read repeatedly by repositioning the reader using cvSetSeqReaderPos.

Parameters:

fs - File storage

reader - The sequence reader. Initialize it with cvStartReadRawData .

count - The number of elements to read

dst - Pointer to the destination array

dt - Specification of each array element. It has the same format as in cvWriteRawData .

cvReadRawDataSlice

public static void cvReadRawDataSlice(@Const
                                      opencv_core.CvFileStorage fs,
                                      opencv_core.CvSeqReader reader,
                                      int count,
                                      org.bytedeco.javacpp.Pointer dst,
                                      String dt)

cvReadRawData

public static void cvReadRawData(@Const
                                 opencv_core.CvFileStorage fs,
                                 @Const
                                 opencv_core.CvFileNode src,
                                 org.bytedeco.javacpp.Pointer dst,
                                 @Cast(value="const char*")
                                 org.bytedeco.javacpp.BytePointer dt)

\brief Reads multiple numbers.

The function reads elements from a file node that represents a sequence of scalars.

Parameters:: fs - File storage; src - The file node (a sequence) to read numbers from; dst - Pointer to the destination array; dt - Specification of each array element. It has the same format as in cvWriteRawData .

cvReadRawData

public static void cvReadRawData(@Const
                                 opencv_core.CvFileStorage fs,
                                 @Const
                                 opencv_core.CvFileNode src,
                                 org.bytedeco.javacpp.Pointer dst,
                                 String dt)

cvWriteFileNode
```
public static void cvWriteFileNode(opencv_core.CvFileStorage fs,
                                   @Cast(value="const char*")
                                   org.bytedeco.javacpp.BytePointer new_node_name,
                                   @Const
                                   opencv_core.CvFileNode node,
                                   int embed)
```
\brief Writes a file node to another file storage.
The function writes a copy of a file node to file storage. Possible applications of the function are merging several file storages into one and conversion between XML, YAML and JSON formats.

Parameters:

fs - Destination file storage

new_node_name - New name of the file node in the destination file storage. To keep the existing name, use cvcvGetFileNodeName

node - The written node

embed - If the written node is a collection and this parameter is not zero, no extra level of hierarchy is created. Instead, all the elements of node are written into the currently written structure. Of course, map elements can only be embedded into another map, and sequence elements can only be embedded into another sequence.

cvWriteFileNode

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

cvGetFileNodeName

@Cast(value="const char*")
public static org.bytedeco.javacpp.BytePointer cvGetFileNodeName(@Const
                                                                                            opencv_core.CvFileNode node)

\brief Returns the name of a file node.

The function returns the name of a file node or NULL, if the file node does not have a name or if node is NULL.

Parameters:: node - File node

cvRegisterType
```
public static void cvRegisterType(@Const
                                  opencv_core.CvTypeInfo info)
```
\brief Registers a new type.
The function registers a new type, which is described by info . The function creates a copy of the structure, so the user should delete it after calling the function.

Parameters:

info - Type info structure

cvUnregisterType
```
public static void cvUnregisterType(@Cast(value="const char*")
                                    org.bytedeco.javacpp.BytePointer type_name)
```
\brief Unregisters the type.
The function unregisters a type with a specified name. If the name is unknown, it is possible to locate the type info by an instance of the type using cvTypeOf or by iterating the type list, starting from cvFirstType, and then calling cvUnregisterType(info-\>typeName).

Parameters:

type_name - Name of an unregistered type

cvUnregisterType

public static void cvUnregisterType(String type_name)

cvFirstType
```
public static opencv_core.CvTypeInfo cvFirstType()
```
\brief Returns the beginning of a type list.
The function returns the first type in the list of registered types. Navigation through the list can be done via the prev and next fields of the CvTypeInfo structure.

cvFindType
```
public static opencv_core.CvTypeInfo cvFindType(@Cast(value="const char*")
                                                org.bytedeco.javacpp.BytePointer type_name)
```
\brief Finds a type by its name.
The function finds a registered type by its name. It returns NULL if there is no type with the specified name.

Parameters:

type_name - Type name

cvFindType

public static opencv_core.CvTypeInfo cvFindType(String type_name)

cvTypeOf
```
public static opencv_core.CvTypeInfo cvTypeOf(@Const
                                              org.bytedeco.javacpp.Pointer struct_ptr)
```
\brief Returns the type of an object.
The function finds the type of a given object. It iterates through the list of registered types and calls the is_instance function/method for every type info structure with that object until one of them returns non-zero or until the whole list has been traversed. In the latter case, the function returns NULL.

Parameters:

struct_ptr - The object pointer

cvRelease
```
public static void cvRelease(@Cast(value="void**")
                             org.bytedeco.javacpp.PointerPointer struct_ptr)
```
\brief Releases an object.
The function finds the type of a given object and calls release with the double pointer.

Parameters:

struct_ptr - Double pointer to the object

cvRelease

public static void cvRelease(@Cast(value="void**") @ByPtrPtr
                             org.bytedeco.javacpp.Pointer struct_ptr)

cvClone
```
public static org.bytedeco.javacpp.Pointer cvClone(@Const
                                                   org.bytedeco.javacpp.Pointer struct_ptr)
```
\brief Makes a clone of an object.
The function finds the type of a given object and calls clone with the passed object. Of course, if you know the object type, for example, struct_ptr is CvMat\*, it is faster to call the specific function, like cvCloneMat.

Parameters:

struct_ptr - The object to clone

cvSave

public static void cvSave(@Cast(value="const char*")
                          org.bytedeco.javacpp.BytePointer filename,
                          @Const
                          org.bytedeco.javacpp.Pointer struct_ptr,
                          @Cast(value="const char*")
                          org.bytedeco.javacpp.BytePointer name,
                          @Cast(value="const char*")
                          org.bytedeco.javacpp.BytePointer comment,
                          @ByVal(nullValue="CvAttrList(cvAttrList())")
                          opencv_core.CvAttrList attributes)

\brief Saves an object to a file.

The function saves an object to a file. It provides a simple interface to cvWrite .

Parameters:: filename - File name; struct_ptr - Object to save; name - Optional object name. If it is NULL, the name will be formed from filename .; comment - Optional comment to put in the beginning of the file; attributes - Optional attributes passed to cvWrite

cvSave

public static void cvSave(@Cast(value="const char*")
                          org.bytedeco.javacpp.BytePointer filename,
                          @Const
                          org.bytedeco.javacpp.Pointer struct_ptr)

cvSave

public static void cvSave(String filename,
                          @Const
                          org.bytedeco.javacpp.Pointer struct_ptr,
                          String name,
                          String comment,
                          @ByVal(nullValue="CvAttrList(cvAttrList())")
                          opencv_core.CvAttrList attributes)

cvSave

public static void cvSave(String filename,
                          @Const
                          org.bytedeco.javacpp.Pointer struct_ptr)

cvLoad
```
public static org.bytedeco.javacpp.Pointer cvLoad(@Cast(value="const char*")
                                                  org.bytedeco.javacpp.BytePointer filename,
                                                  opencv_core.CvMemStorage memstorage,
                                                  @Cast(value="const char*")
                                                  org.bytedeco.javacpp.BytePointer name,
                                                  @Cast(value="const char**")
                                                  org.bytedeco.javacpp.PointerPointer real_name)
```
\brief Loads an object from a file.
The function loads an object from a file. It basically reads the specified file, find the first top-level node and calls cvRead for that node. If the file node does not have type information or the type information can not be found by the type name, the function returns NULL. After the object is loaded, the file storage is closed and all the temporary buffers are deleted. Thus, to load a dynamic structure, such as a sequence, contour, or graph, one should pass a valid memory storage destination to the function.

Parameters:

filename - File name

memstorage - Memory storage for dynamic structures, such as CvSeq or CvGraph . It is not used for matrices or images.

name - Optional object name. If it is NULL, the first top-level object in the storage will be loaded.

real_name - Optional output parameter that will contain the name of the loaded object (useful if name=NULL )

cvLoad

public static org.bytedeco.javacpp.Pointer cvLoad(@Cast(value="const char*")
                                                  org.bytedeco.javacpp.BytePointer filename)

cvLoad

public static org.bytedeco.javacpp.Pointer cvLoad(@Cast(value="const char*")
                                                  org.bytedeco.javacpp.BytePointer filename,
                                                  opencv_core.CvMemStorage memstorage,
                                                  @Cast(value="const char*")
                                                  org.bytedeco.javacpp.BytePointer name,
                                                  @Cast(value="const char**") @ByPtrPtr
                                                  org.bytedeco.javacpp.BytePointer real_name)

cvLoad

public static org.bytedeco.javacpp.Pointer cvLoad(String filename,
                                                  opencv_core.CvMemStorage memstorage,
                                                  String name,
                                                  @Cast(value="const char**") @ByPtrPtr
                                                  ByteBuffer real_name)

cvLoad

public static org.bytedeco.javacpp.Pointer cvLoad(String filename)

cvLoad

public static org.bytedeco.javacpp.Pointer cvLoad(@Cast(value="const char*")
                                                  org.bytedeco.javacpp.BytePointer filename,
                                                  opencv_core.CvMemStorage memstorage,
                                                  @Cast(value="const char*")
                                                  org.bytedeco.javacpp.BytePointer name,
                                                  @Cast(value="const char**") @ByPtrPtr
                                                  byte[] real_name)

cvLoad

public static org.bytedeco.javacpp.Pointer cvLoad(String filename,
                                                  opencv_core.CvMemStorage memstorage,
                                                  String name,
                                                  @Cast(value="const char**") @ByPtrPtr
                                                  org.bytedeco.javacpp.BytePointer real_name)

cvLoad

public static org.bytedeco.javacpp.Pointer cvLoad(@Cast(value="const char*")
                                                  org.bytedeco.javacpp.BytePointer filename,
                                                  opencv_core.CvMemStorage memstorage,
                                                  @Cast(value="const char*")
                                                  org.bytedeco.javacpp.BytePointer name,
                                                  @Cast(value="const char**") @ByPtrPtr
                                                  ByteBuffer real_name)

cvLoad

public static org.bytedeco.javacpp.Pointer cvLoad(String filename,
                                                  opencv_core.CvMemStorage memstorage,
                                                  String name,
                                                  @Cast(value="const char**") @ByPtrPtr
                                                  byte[] real_name)

cvGetTickCount
```
@Cast(value="int64")
public static long cvGetTickCount()
```
helper functions for RNG initialization and accurate time measurement: uses internal clock counter on x86

cvGetTickFrequency

public static double cvGetTickFrequency()

cvCheckHardwareSupport

public static int cvCheckHardwareSupport(int feature)

CPU capabilities

cvGetNumThreads
```
public static int cvGetNumThreads()
```
retrieve/set the number of threads used in OpenMP implementations

cvSetNumThreads

public static void cvSetNumThreads(int threads)

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

cvGetThreadNum
```
public static int cvGetThreadNum()
```
get index of the thread being executed

cvGetErrStatus
```
public static int cvGetErrStatus()
```
Get current OpenCV error status

cvSetErrStatus

public static void cvSetErrStatus(int status)

Sets error status silently

cvGetErrMode
```
public static int cvGetErrMode()
```
Retrieves current error processing mode

cvSetErrMode
```
public static int cvSetErrMode(int mode)
```
Sets error processing mode, returns previously used mode

cvError

public static void cvError(int status,
                           @Cast(value="const char*")
                           org.bytedeco.javacpp.BytePointer func_name,
                           @Cast(value="const char*")
                           org.bytedeco.javacpp.BytePointer err_msg,
                           @Cast(value="const char*")
                           org.bytedeco.javacpp.BytePointer file_name,
                           int line)

Sets error status and performs some additional actions (displaying message box, writing message to stderr, terminating application etc.) depending on the current error mode

cvError

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

cvErrorStr

@Cast(value="const char*")
public static org.bytedeco.javacpp.BytePointer cvErrorStr(int status)

Retrieves textual description of the error given its code

cvGetErrInfo

public static int cvGetErrInfo(@Cast(value="const char**")
                               org.bytedeco.javacpp.PointerPointer errcode_desc,
                               @Cast(value="const char**")
                               org.bytedeco.javacpp.PointerPointer description,
                               @Cast(value="const char**")
                               org.bytedeco.javacpp.PointerPointer filename,
                               org.bytedeco.javacpp.IntPointer line)

Retrieves detailed information about the last error occurred

cvGetErrInfo

public static int cvGetErrInfo(@Cast(value="const char**") @ByPtrPtr
                               org.bytedeco.javacpp.BytePointer errcode_desc,
                               @Cast(value="const char**") @ByPtrPtr
                               org.bytedeco.javacpp.BytePointer description,
                               @Cast(value="const char**") @ByPtrPtr
                               org.bytedeco.javacpp.BytePointer filename,
                               org.bytedeco.javacpp.IntPointer line)

cvGetErrInfo

public static int cvGetErrInfo(@Cast(value="const char**") @ByPtrPtr
                               ByteBuffer errcode_desc,
                               @Cast(value="const char**") @ByPtrPtr
                               ByteBuffer description,
                               @Cast(value="const char**") @ByPtrPtr
                               ByteBuffer filename,
                               IntBuffer line)

cvGetErrInfo

public static int cvGetErrInfo(@Cast(value="const char**") @ByPtrPtr
                               byte[] errcode_desc,
                               @Cast(value="const char**") @ByPtrPtr
                               byte[] description,
                               @Cast(value="const char**") @ByPtrPtr
                               byte[] filename,
                               int[] line)

cvErrorFromIppStatus
```
public static int cvErrorFromIppStatus(int ipp_status)
```
Maps IPP error codes to the counterparts from OpenCV

cvRedirectError

public static opencv_core.CvErrorCallback cvRedirectError(opencv_core.CvErrorCallback error_handler,
                                                          org.bytedeco.javacpp.Pointer userdata,
                                                          @Cast(value="void**")
                                                          org.bytedeco.javacpp.PointerPointer prev_userdata)

Assigns a new error-handling function

cvRedirectError

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

cvRedirectError

public static opencv_core.CvErrorCallback cvRedirectError(opencv_core.CvErrorCallback error_handler,
                                                          org.bytedeco.javacpp.Pointer userdata,
                                                          @Cast(value="void**") @ByPtrPtr
                                                          org.bytedeco.javacpp.Pointer prev_userdata)

cvNulDevReport

public static int cvNulDevReport(int status,
                                 @Cast(value="const char*")
                                 org.bytedeco.javacpp.BytePointer func_name,
                                 @Cast(value="const char*")
                                 org.bytedeco.javacpp.BytePointer err_msg,
                                 @Cast(value="const char*")
                                 org.bytedeco.javacpp.BytePointer file_name,
                                 int line,
                                 org.bytedeco.javacpp.Pointer userdata)

Output nothing

cvNulDevReport

public static int cvNulDevReport(int status,
                                 String func_name,
                                 String err_msg,
                                 String file_name,
                                 int line,
                                 org.bytedeco.javacpp.Pointer userdata)

cvStdErrReport

public static int cvStdErrReport(int status,
                                 @Cast(value="const char*")
                                 org.bytedeco.javacpp.BytePointer func_name,
                                 @Cast(value="const char*")
                                 org.bytedeco.javacpp.BytePointer err_msg,
                                 @Cast(value="const char*")
                                 org.bytedeco.javacpp.BytePointer file_name,
                                 int line,
                                 org.bytedeco.javacpp.Pointer userdata)

Output to console(fprintf(stderr,...))

cvStdErrReport

public static int cvStdErrReport(int status,
                                 String func_name,
                                 String err_msg,
                                 String file_name,
                                 int line,
                                 org.bytedeco.javacpp.Pointer userdata)

cvGuiBoxReport

public static int cvGuiBoxReport(int status,
                                 @Cast(value="const char*")
                                 org.bytedeco.javacpp.BytePointer func_name,
                                 @Cast(value="const char*")
                                 org.bytedeco.javacpp.BytePointer err_msg,
                                 @Cast(value="const char*")
                                 org.bytedeco.javacpp.BytePointer file_name,
                                 int line,
                                 org.bytedeco.javacpp.Pointer userdata)

Output to MessageBox(WIN32)

cvGuiBoxReport

public static int cvGuiBoxReport(int status,
                                 String func_name,
                                 String err_msg,
                                 String file_name,
                                 int line,
                                 org.bytedeco.javacpp.Pointer userdata)

cvarrToMat

@Namespace(value="cv")
 @ByVal
public static opencv_core.Mat cvarrToMat(@Const
                                                                        opencv_core.CvArr arr,
                                                                        @Cast(value="bool")
                                                                        boolean copyData,
                                                                        @Cast(value="bool")
                                                                        boolean allowND,
                                                                        int coiMode,
                                                                        @Cast(value="cv::AutoBuffer<double>*")
                                                                        org.bytedeco.javacpp.Pointer buf)

\addtogroup core_c_glue \{

/////////////////////////////////////////// glue ///////////////////////////////////////////

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

cvarrToMat

@Namespace(value="cv")
 @ByVal
public static opencv_core.Mat cvarrToMat(@Const
                                                                        opencv_core.CvArr arr)

cvarrToMatND

@Namespace(value="cv")
 @ByVal
public static opencv_core.Mat cvarrToMatND(@Const
                                                                          opencv_core.CvArr arr,
                                                                          @Cast(value="bool")
                                                                          boolean copyData,
                                                                          int coiMode)

cvarrToMatND

@Namespace(value="cv")
 @ByVal
public static opencv_core.Mat cvarrToMatND(@Const
                                                                          opencv_core.CvArr arr)

extractImageCOI

@Namespace(value="cv")
public static void extractImageCOI(@Const
                                                          opencv_core.CvArr arr,
                                                          @ByVal
                                                          opencv_core.Mat coiimg,
                                                          int coi)

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

extractImageCOI

@Namespace(value="cv")
public static void extractImageCOI(@Const
                                                          opencv_core.CvArr arr,
                                                          @ByVal
                                                          opencv_core.Mat coiimg)

extractImageCOI

@Namespace(value="cv")
public static void extractImageCOI(@Const
                                                          opencv_core.CvArr arr,
                                                          @ByVal
                                                          opencv_core.UMat coiimg,
                                                          int coi)

extractImageCOI

@Namespace(value="cv")
public static void extractImageCOI(@Const
                                                          opencv_core.CvArr arr,
                                                          @ByVal
                                                          opencv_core.UMat coiimg)

extractImageCOI

@Namespace(value="cv")
public static void extractImageCOI(@Const
                                                          opencv_core.CvArr arr,
                                                          @ByVal
                                                          opencv_core.GpuMat coiimg,
                                                          int coi)

extractImageCOI

@Namespace(value="cv")
public static void extractImageCOI(@Const
                                                          opencv_core.CvArr arr,
                                                          @ByVal
                                                          opencv_core.GpuMat coiimg)

insertImageCOI

@Namespace(value="cv")
public static void insertImageCOI(@ByVal
                                                         opencv_core.Mat coiimg,
                                                         opencv_core.CvArr arr,
                                                         int coi)

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

insertImageCOI

@Namespace(value="cv")
public static void insertImageCOI(@ByVal
                                                         opencv_core.Mat coiimg,
                                                         opencv_core.CvArr arr)

insertImageCOI

@Namespace(value="cv")
public static void insertImageCOI(@ByVal
                                                         opencv_core.UMat coiimg,
                                                         opencv_core.CvArr arr,
                                                         int coi)

insertImageCOI

@Namespace(value="cv")
public static void insertImageCOI(@ByVal
                                                         opencv_core.UMat coiimg,
                                                         opencv_core.CvArr arr)

insertImageCOI

@Namespace(value="cv")
public static void insertImageCOI(@ByVal
                                                         opencv_core.GpuMat coiimg,
                                                         opencv_core.CvArr arr,
                                                         int coi)

insertImageCOI

@Namespace(value="cv")
public static void insertImageCOI(@ByVal
                                                         opencv_core.GpuMat coiimg,
                                                         opencv_core.CvArr arr)

seqPush

@Namespace(value="cv")
 @Cast(value="schar*")
public static org.bytedeco.javacpp.BytePointer seqPush(opencv_core.CvSeq seq,
                                                                                                     @Const
                                                                                                     org.bytedeco.javacpp.Pointer element)

STL-style Sequence Iterator inherited from the CvSeqReader structure

seqPush

@Namespace(value="cv")
 @Cast(value="schar*")
public static org.bytedeco.javacpp.BytePointer seqPush(opencv_core.CvSeq seq)

seqPushFront

@Namespace(value="cv")
 @Cast(value="schar*")
public static org.bytedeco.javacpp.BytePointer seqPushFront(opencv_core.CvSeq seq,
                                                                                                          @Const
                                                                                                          org.bytedeco.javacpp.Pointer element)

seqPushFront

@Namespace(value="cv")
 @Cast(value="schar*")
public static org.bytedeco.javacpp.BytePointer seqPushFront(opencv_core.CvSeq seq)

seqPop

@Namespace(value="cv")
public static void seqPop(opencv_core.CvSeq seq,
                                                 org.bytedeco.javacpp.Pointer element)

seqPop

@Namespace(value="cv")
public static void seqPop(opencv_core.CvSeq seq)

seqPopFront

@Namespace(value="cv")
public static void seqPopFront(opencv_core.CvSeq seq,
                                                      org.bytedeco.javacpp.Pointer element)

seqPopFront

@Namespace(value="cv")
public static void seqPopFront(opencv_core.CvSeq seq)

seqRemove

@Namespace(value="cv")
public static void seqRemove(opencv_core.CvSeq seq,
                                                    int index)

clearSeq

@Namespace(value="cv")
public static void clearSeq(opencv_core.CvSeq seq)

getSeqElem

@Namespace(value="cv")
 @Cast(value="schar*")
public static org.bytedeco.javacpp.BytePointer getSeqElem(@Const
                                                                                                        opencv_core.CvSeq seq,
                                                                                                        int index)

seqRemoveSlice

@Namespace(value="cv")
public static void seqRemoveSlice(opencv_core.CvSeq seq,
                                                         @ByVal
                                                         opencv_core.CvSlice slice)

seqInsertSlice

@Namespace(value="cv")
public static void seqInsertSlice(opencv_core.CvSeq seq,
                                                         int before_index,
                                                         @Const
                                                         opencv_core.CvArr from_arr)

equals

@Namespace(value="cv")
 @Cast(value="bool")
 @Name(value="operator ==")
public static boolean equals(@Const @ByRef
                                                                                                     opencv_core.Range r1,
                                                                                                     @Const @ByRef
                                                                                                     opencv_core.Range r2)

\brief measure dissimilarity between two sample sets computes the complement of the Jaccard Index as described in . For rectangles this reduces to computing the intersection over the union.

notEquals

@Namespace(value="cv")
 @Cast(value="bool")
 @Name(value="operator !=")
public static boolean notEquals(@Const @ByRef
                                                                                                        opencv_core.Range r1,
                                                                                                        @Const @ByRef
                                                                                                        opencv_core.Range r2)

not

@Namespace(value="cv")
 @Cast(value="bool")
 @Name(value="operator !")
public static boolean not(@Const @ByRef
                                                                                                 opencv_core.Range r)

and

@Namespace(value="cv")
 @ByVal
 @Name(value="operator &")
public static opencv_core.Range and(@Const @ByRef
                                                                                              opencv_core.Range r1,
                                                                                              @Const @ByRef
                                                                                              opencv_core.Range r2)

andPut

@Namespace(value="cv")
 @ByRef
 @Name(value="operator &=")
public static opencv_core.Range andPut(@ByRef
                                                                                                  opencv_core.Range r1,
                                                                                                  @Const @ByRef
                                                                                                  opencv_core.Range r2)

add

@Namespace(value="cv")
 @ByVal
 @Name(value="operator +")
public static opencv_core.Range add(@Const @ByRef
                                                                                              opencv_core.Range r1,
                                                                                              int delta)

add

@Namespace(value="cv")
 @ByVal
 @Name(value="operator +")
public static opencv_core.Range add(int delta,
                                                                                              @Const @ByRef
                                                                                              opencv_core.Range r1)

subtract

@Namespace(value="cv")
 @ByVal
 @Name(value="operator -")
public static opencv_core.Range subtract(@Const @ByRef
                                                                                                   opencv_core.Range r1,
                                                                                                   int delta)

swap

@Namespace(value="cv")
public static void swap(@ByRef
                                               opencv_core.Mat a,
                                               @ByRef
                                               opencv_core.Mat b)

\brief Swaps two matrices

swap

@Namespace(value="cv")
public static void swap(@ByRef
                                               opencv_core.UMat a,
                                               @ByRef
                                               opencv_core.UMat b)

\overload

borderInterpolate
```
@Namespace(value="cv")
public static int borderInterpolate(int p,
                                                           int len,
                                                           int borderType)
```
\} core
\addtogroup core_array \{
/** \brief Computes the source location of an extrapolated pixel.
The function computes and returns the coordinate of a donor pixel corresponding to the specified extrapolated pixel when using the specified extrapolation border mode. For example, if you use cv::BORDER_WRAP mode in the horizontal direction, cv::BORDER_REFLECT_101 in the vertical direction and want to compute value of the "virtual" pixel Point(-5, 100) in a floating-point image img , it looks like:
```
 {.cpp}
    float val = img.at<float>(borderInterpolate(100, img.rows, cv::BORDER_REFLECT_101),
                              borderInterpolate(-5, img.cols, cv::BORDER_WRAP));
```
Normally, the function is not called directly. It is used inside filtering functions and also in copyMakeBorder.
Parameters:

p - 0-based coordinate of the extrapolated pixel along one of the axes, likely \<0 or \>= len

len - Length of the array along the corresponding axis.

borderType - Border type, one of the #BorderTypes, except for #BORDER_TRANSPARENT and #BORDER_ISOLATED . When borderType==#BORDER_CONSTANT , the function always returns -1, regardless of p and len.
\sa copyMakeBorder

copyMakeBorder

@Namespace(value="cv")
public static void copyMakeBorder(@ByVal
                                                         opencv_core.Mat src,
                                                         @ByVal
                                                         opencv_core.Mat dst,
                                                         int top,
                                                         int bottom,
                                                         int left,
                                                         int right,
                                                         int borderType,
                                                         @Const @ByRef(nullValue="cv::Scalar()")
                                                         opencv_core.Scalar value)

\brief Forms a border around an image.

The function copies the source image into the middle of the destination image. The areas to the left, to the right, above and below the copied source image will be filled with extrapolated pixels. This is not what filtering functions based on it do (they extrapolate pixels on-fly), but what other more complex functions, including your own, may do to simplify image boundary handling.

The function supports the mode when src is already in the middle of dst . In this case, the function does not copy src itself but simply constructs the border, for example:

 {.cpp}
    // let border be the same in all directions
    int border=2;
    // constructs a larger image to fit both the image and the border
    Mat gray_buf(rgb.rows + border*2, rgb.cols + border*2, rgb.depth());
    // select the middle part of it w/o copying data
    Mat gray(gray_canvas, Rect(border, border, rgb.cols, rgb.rows));
    // convert image from RGB to grayscale
    cvtColor(rgb, gray, COLOR_RGB2GRAY);
    // form a border in-place
    copyMakeBorder(gray, gray_buf, border, border,
                   border, border, BORDER_REPLICATE);
    // now do some custom filtering ...
    ...

\note When the source image is a part (ROI) of a bigger image, the function will try to use the pixels outside of the ROI to form a border. To disable this feature and always do extrapolation, as if src was not a ROI, use borderType | #BORDER_ISOLATED.

Parameters:: src - Source image.; dst - Destination image of the same type as src and the size Size(src.cols+left+right, src.rows+top+bottom) .; top -; bottom -; left -; right - Parameter specifying how many pixels in each direction from the source image rectangle to extrapolate. For example, top=1, bottom=1, left=1, right=1 mean that 1 pixel-wide border needs to be built.; borderType - Border type. See borderInterpolate for details.; value - Border value if borderType==BORDER_CONSTANT .
\sa borderInterpolate

copyMakeBorder

@Namespace(value="cv")
public static void copyMakeBorder(@ByVal
                                                         opencv_core.Mat src,
                                                         @ByVal
                                                         opencv_core.Mat dst,
                                                         int top,
                                                         int bottom,
                                                         int left,
                                                         int right,
                                                         int borderType)

copyMakeBorder

@Namespace(value="cv")
public static void copyMakeBorder(@ByVal
                                                         opencv_core.UMat src,
                                                         @ByVal
                                                         opencv_core.UMat dst,
                                                         int top,
                                                         int bottom,
                                                         int left,
                                                         int right,
                                                         int borderType,
                                                         @Const @ByRef(nullValue="cv::Scalar()")
                                                         opencv_core.Scalar value)

copyMakeBorder

@Namespace(value="cv")
public static void copyMakeBorder(@ByVal
                                                         opencv_core.UMat src,
                                                         @ByVal
                                                         opencv_core.UMat dst,
                                                         int top,
                                                         int bottom,
                                                         int left,
                                                         int right,
                                                         int borderType)

copyMakeBorder

@Namespace(value="cv")
public static void copyMakeBorder(@ByVal
                                                         opencv_core.GpuMat src,
                                                         @ByVal
                                                         opencv_core.GpuMat dst,
                                                         int top,
                                                         int bottom,
                                                         int left,
                                                         int right,
                                                         int borderType,
                                                         @Const @ByRef(nullValue="cv::Scalar()")
                                                         opencv_core.Scalar value)

copyMakeBorder

@Namespace(value="cv")
public static void copyMakeBorder(@ByVal
                                                         opencv_core.GpuMat src,
                                                         @ByVal
                                                         opencv_core.GpuMat dst,
                                                         int top,
                                                         int bottom,
                                                         int left,
                                                         int right,
                                                         int borderType)

add
```
@Namespace(value="cv")
public static void add(@ByVal
                                              opencv_core.Mat src1,
                                              @ByVal
                                              opencv_core.Mat src2,
                                              @ByVal
                                              opencv_core.Mat dst,
                                              @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                              opencv_core.Mat mask,
                                              int dtype)
```
\brief Calculates the per-element sum of two arrays or an array and a scalar.
The function add calculates: - Sum of two arrays when both input arrays have the same size and the same number of channels: \f[\texttt{dst}(I) = \texttt{saturate} ( \texttt{src1}(I) + \texttt{src2}(I)) \quad \texttt{if mask}(I) \ne0\f] - Sum of an array and a scalar when src2 is constructed from Scalar or has the same number of elements as src1.channels(): \f[\texttt{dst}(I) = \texttt{saturate} ( \texttt{src1}(I) + \texttt{src2} ) \quad \texttt{if mask}(I) \ne0\f] - Sum of a scalar and an array when src1 is constructed from Scalar or has the same number of elements as src2.channels(): \f[\texttt{dst}(I) = \texttt{saturate} ( \texttt{src1} + \texttt{src2}(I) ) \quad \texttt{if mask}(I) \ne0\f] where I is a multi-dimensional index of array elements. In case of multi-channel arrays, each channel is processed independently.
The first function in the list above can be replaced with matrix expressions:
```
 {.cpp}
    dst = src1 + src2;
    dst += src1; // equivalent to add(dst, src1, dst);
```
The input arrays and the output array can all have the same or different depths. For example, you can add a 16-bit unsigned array to a 8-bit signed array and store the sum as a 32-bit floating-point array. Depth of the output array is determined by the dtype parameter. In the second and third cases above, as well as in the first case, when src1.depth() == src2.depth(), dtype can be set to the default -1. In this case, the output array will have the same depth as the input array, be it src1, src2 or both. \note Saturation is not applied when the output array has the depth CV_32S. You may even get result of an incorrect sign in the case of overflow.
Parameters:

src1 - first input array or a scalar.

src2 - second input array or a scalar.

dst - output array that has the same size and number of channels as the input array(s); the depth is defined by dtype or src1/src2.

mask - optional operation mask - 8-bit single channel array, that specifies elements of the output array to be changed.

dtype - optional depth of the output array (see the discussion below). \sa subtract, addWeighted, scaleAdd, Mat::convertTo

add

@Namespace(value="cv")
public static void add(@ByVal
                                              opencv_core.Mat src1,
                                              @ByVal
                                              opencv_core.Mat src2,
                                              @ByVal
                                              opencv_core.Mat dst)

add

@Namespace(value="cv")
public static void add(@ByVal
                                              opencv_core.UMat src1,
                                              @ByVal
                                              opencv_core.UMat src2,
                                              @ByVal
                                              opencv_core.UMat dst,
                                              @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                              opencv_core.UMat mask,
                                              int dtype)

add

@Namespace(value="cv")
public static void add(@ByVal
                                              opencv_core.UMat src1,
                                              @ByVal
                                              opencv_core.UMat src2,
                                              @ByVal
                                              opencv_core.UMat dst)

add

@Namespace(value="cv")
public static void add(@ByVal
                                              opencv_core.GpuMat src1,
                                              @ByVal
                                              opencv_core.GpuMat src2,
                                              @ByVal
                                              opencv_core.GpuMat dst,
                                              @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                              opencv_core.GpuMat mask,
                                              int dtype)

add

@Namespace(value="cv")
public static void add(@ByVal
                                              opencv_core.GpuMat src1,
                                              @ByVal
                                              opencv_core.GpuMat src2,
                                              @ByVal
                                              opencv_core.GpuMat dst)

subtract
```
@Namespace(value="cv")
public static void subtract(@ByVal
                                                   opencv_core.Mat src1,
                                                   @ByVal
                                                   opencv_core.Mat src2,
                                                   @ByVal
                                                   opencv_core.Mat dst,
                                                   @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                   opencv_core.Mat mask,
                                                   int dtype)
```
\brief Calculates the per-element difference between two arrays or array and a scalar.
The function subtract calculates: - Difference between two arrays, when both input arrays have the same size and the same number of channels: \f[\texttt{dst}(I) = \texttt{saturate} ( \texttt{src1}(I) - \texttt{src2}(I)) \quad \texttt{if mask}(I) \ne0\f] - Difference between an array and a scalar, when src2 is constructed from Scalar or has the same number of elements as src1.channels(): \f[\texttt{dst}(I) = \texttt{saturate} ( \texttt{src1}(I) - \texttt{src2} ) \quad \texttt{if mask}(I) \ne0\f] - Difference between a scalar and an array, when src1 is constructed from Scalar or has the same number of elements as src2.channels(): \f[\texttt{dst}(I) = \texttt{saturate} ( \texttt{src1} - \texttt{src2}(I) ) \quad \texttt{if mask}(I) \ne0\f] - The reverse difference between a scalar and an array in the case of SubRS: \f[\texttt{dst}(I) = \texttt{saturate} ( \texttt{src2} - \texttt{src1}(I) ) \quad \texttt{if mask}(I) \ne0\f] where I is a multi-dimensional index of array elements. In case of multi-channel arrays, each channel is processed independently.
The first function in the list above can be replaced with matrix expressions:
```
 {.cpp}
    dst = src1 - src2;
    dst -= src1; // equivalent to subtract(dst, src1, dst);
```
The input arrays and the output array can all have the same or different depths. For example, you can subtract to 8-bit unsigned arrays and store the difference in a 16-bit signed array. Depth of the output array is determined by dtype parameter. In the second and third cases above, as well as in the first case, when src1.depth() == src2.depth(), dtype can be set to the default -1. In this case the output array will have the same depth as the input array, be it src1, src2 or both. \note Saturation is not applied when the output array has the depth CV_32S. You may even get result of an incorrect sign in the case of overflow.
Parameters:

src1 - first input array or a scalar.

src2 - second input array or a scalar.

dst - output array of the same size and the same number of channels as the input array.

mask - optional operation mask; this is an 8-bit single channel array that specifies elements of the output array to be changed.

dtype - optional depth of the output array \sa add, addWeighted, scaleAdd, Mat::convertTo

subtract

@Namespace(value="cv")
public static void subtract(@ByVal
                                                   opencv_core.Mat src1,
                                                   @ByVal
                                                   opencv_core.Mat src2,
                                                   @ByVal
                                                   opencv_core.Mat dst)

subtract

@Namespace(value="cv")
public static void subtract(@ByVal
                                                   opencv_core.UMat src1,
                                                   @ByVal
                                                   opencv_core.UMat src2,
                                                   @ByVal
                                                   opencv_core.UMat dst,
                                                   @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                   opencv_core.UMat mask,
                                                   int dtype)

subtract

@Namespace(value="cv")
public static void subtract(@ByVal
                                                   opencv_core.UMat src1,
                                                   @ByVal
                                                   opencv_core.UMat src2,
                                                   @ByVal
                                                   opencv_core.UMat dst)

subtract

@Namespace(value="cv")
public static void subtract(@ByVal
                                                   opencv_core.GpuMat src1,
                                                   @ByVal
                                                   opencv_core.GpuMat src2,
                                                   @ByVal
                                                   opencv_core.GpuMat dst,
                                                   @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                   opencv_core.GpuMat mask,
                                                   int dtype)

subtract

@Namespace(value="cv")
public static void subtract(@ByVal
                                                   opencv_core.GpuMat src1,
                                                   @ByVal
                                                   opencv_core.GpuMat src2,
                                                   @ByVal
                                                   opencv_core.GpuMat dst)

multiply
```
@Namespace(value="cv")
public static void multiply(@ByVal
                                                   opencv_core.Mat src1,
                                                   @ByVal
                                                   opencv_core.Mat src2,
                                                   @ByVal
                                                   opencv_core.Mat dst,
                                                   double scale,
                                                   int dtype)
```
\brief Calculates the per-element scaled product of two arrays.
The function multiply calculates the per-element product of two arrays:
\f[\texttt{dst} (I)= \texttt{saturate} ( \texttt{scale} \cdot \texttt{src1} (I) \cdot \texttt{src2} (I))\f]
There is also a \ref MatrixExpressions -friendly variant of the first function. See Mat::mul .
For a not-per-element matrix product, see gemm .
\note Saturation is not applied when the output array has the depth CV_32S. You may even get result of an incorrect sign in the case of overflow.

Parameters:

src1 - first input array.

src2 - second input array of the same size and the same type as src1.

dst - output array of the same size and type as src1.

scale - optional scale factor.

dtype - optional depth of the output array \sa add, subtract, divide, scaleAdd, addWeighted, accumulate, accumulateProduct, accumulateSquare, Mat::convertTo

multiply

@Namespace(value="cv")
public static void multiply(@ByVal
                                                   opencv_core.Mat src1,
                                                   @ByVal
                                                   opencv_core.Mat src2,
                                                   @ByVal
                                                   opencv_core.Mat dst)

multiply

@Namespace(value="cv")
public static void multiply(@ByVal
                                                   opencv_core.UMat src1,
                                                   @ByVal
                                                   opencv_core.UMat src2,
                                                   @ByVal
                                                   opencv_core.UMat dst,
                                                   double scale,
                                                   int dtype)

multiply

@Namespace(value="cv")
public static void multiply(@ByVal
                                                   opencv_core.UMat src1,
                                                   @ByVal
                                                   opencv_core.UMat src2,
                                                   @ByVal
                                                   opencv_core.UMat dst)

multiply

@Namespace(value="cv")
public static void multiply(@ByVal
                                                   opencv_core.GpuMat src1,
                                                   @ByVal
                                                   opencv_core.GpuMat src2,
                                                   @ByVal
                                                   opencv_core.GpuMat dst,
                                                   double scale,
                                                   int dtype)

multiply

@Namespace(value="cv")
public static void multiply(@ByVal
                                                   opencv_core.GpuMat src1,
                                                   @ByVal
                                                   opencv_core.GpuMat src2,
                                                   @ByVal
                                                   opencv_core.GpuMat dst)

divide
```
@Namespace(value="cv")
public static void divide(@ByVal
                                                 opencv_core.Mat src1,
                                                 @ByVal
                                                 opencv_core.Mat src2,
                                                 @ByVal
                                                 opencv_core.Mat dst,
                                                 double scale,
                                                 int dtype)
```
\brief Performs per-element division of two arrays or a scalar by an array.
The function cv::divide divides one array by another: \f[\texttt{dst(I) = saturate(src1(I)*scale/src2(I))}\f] or a scalar by an array when there is no src1 : \f[\texttt{dst(I) = saturate(scale/src2(I))}\f]
When src2(I) is zero, dst(I) will also be zero. Different channels of multi-channel arrays are processed independently.
\note Saturation is not applied when the output array has the depth CV_32S. You may even get result of an incorrect sign in the case of overflow.

Parameters:

src1 - first input array.

src2 - second input array of the same size and type as src1.

scale - scalar factor.

dst - output array of the same size and type as src2.

dtype - optional depth of the output array; if -1, dst will have depth src2.depth(), but in case of an array-by-array division, you can only pass -1 when src1.depth()==src2.depth(). \sa multiply, add, subtract

divide

@Namespace(value="cv")
public static void divide(@ByVal
                                                 opencv_core.Mat src1,
                                                 @ByVal
                                                 opencv_core.Mat src2,
                                                 @ByVal
                                                 opencv_core.Mat dst)

divide

@Namespace(value="cv")
public static void divide(@ByVal
                                                 opencv_core.UMat src1,
                                                 @ByVal
                                                 opencv_core.UMat src2,
                                                 @ByVal
                                                 opencv_core.UMat dst,
                                                 double scale,
                                                 int dtype)

divide

@Namespace(value="cv")
public static void divide(@ByVal
                                                 opencv_core.UMat src1,
                                                 @ByVal
                                                 opencv_core.UMat src2,
                                                 @ByVal
                                                 opencv_core.UMat dst)

divide

@Namespace(value="cv")
public static void divide(@ByVal
                                                 opencv_core.GpuMat src1,
                                                 @ByVal
                                                 opencv_core.GpuMat src2,
                                                 @ByVal
                                                 opencv_core.GpuMat dst,
                                                 double scale,
                                                 int dtype)

divide

@Namespace(value="cv")
public static void divide(@ByVal
                                                 opencv_core.GpuMat src1,
                                                 @ByVal
                                                 opencv_core.GpuMat src2,
                                                 @ByVal
                                                 opencv_core.GpuMat dst)

divide

@Namespace(value="cv")
public static void divide(double scale,
                                                 @ByVal
                                                 opencv_core.Mat src2,
                                                 @ByVal
                                                 opencv_core.Mat dst,
                                                 int dtype)

\overload

divide

@Namespace(value="cv")
public static void divide(double scale,
                                                 @ByVal
                                                 opencv_core.Mat src2,
                                                 @ByVal
                                                 opencv_core.Mat dst)

divide

@Namespace(value="cv")
public static void divide(double scale,
                                                 @ByVal
                                                 opencv_core.UMat src2,
                                                 @ByVal
                                                 opencv_core.UMat dst,
                                                 int dtype)

divide

@Namespace(value="cv")
public static void divide(double scale,
                                                 @ByVal
                                                 opencv_core.UMat src2,
                                                 @ByVal
                                                 opencv_core.UMat dst)

divide

@Namespace(value="cv")
public static void divide(double scale,
                                                 @ByVal
                                                 opencv_core.GpuMat src2,
                                                 @ByVal
                                                 opencv_core.GpuMat dst,
                                                 int dtype)

divide

@Namespace(value="cv")
public static void divide(double scale,
                                                 @ByVal
                                                 opencv_core.GpuMat src2,
                                                 @ByVal
                                                 opencv_core.GpuMat dst)

scaleAdd
```
@Namespace(value="cv")
public static void scaleAdd(@ByVal
                                                   opencv_core.Mat src1,
                                                   double alpha,
                                                   @ByVal
                                                   opencv_core.Mat src2,
                                                   @ByVal
                                                   opencv_core.Mat dst)
```
\brief Calculates the sum of a scaled array and another array.
The function scaleAdd is one of the classical primitive linear algebra operations, known as DAXPY or SAXPY in [BLAS](http://en.wikipedia.org/wiki/Basic_Linear_Algebra_Subprograms). It calculates the sum of a scaled array and another array: \f[\texttt{dst} (I)= \texttt{scale} \cdot \texttt{src1} (I) + \texttt{src2} (I)\f] The function can also be emulated with a matrix expression, for example:
```
 {.cpp}
    Mat A(3, 3, CV_64F);
    ...
    A.row(0) = A.row(1)*2 + A.row(2);
```
Parameters:

src1 - first input array.

alpha - scale factor for the first array.

src2 - second input array of the same size and type as src1.

dst - output array of the same size and type as src1. \sa add, addWeighted, subtract, Mat::dot, Mat::convertTo

scaleAdd

@Namespace(value="cv")
public static void scaleAdd(@ByVal
                                                   opencv_core.UMat src1,
                                                   double alpha,
                                                   @ByVal
                                                   opencv_core.UMat src2,
                                                   @ByVal
                                                   opencv_core.UMat dst)

scaleAdd

@Namespace(value="cv")
public static void scaleAdd(@ByVal
                                                   opencv_core.GpuMat src1,
                                                   double alpha,
                                                   @ByVal
                                                   opencv_core.GpuMat src2,
                                                   @ByVal
                                                   opencv_core.GpuMat dst)

addWeighted
```
@Namespace(value="cv")
public static void addWeighted(@ByVal
                                                      opencv_core.Mat src1,
                                                      double alpha,
                                                      @ByVal
                                                      opencv_core.Mat src2,
                                                      double beta,
                                                      double gamma,
                                                      @ByVal
                                                      opencv_core.Mat dst,
                                                      int dtype)
```
\brief Calculates the weighted sum of two arrays.
The function addWeighted calculates the weighted sum of two arrays as follows: \f[\texttt{dst} (I)= \texttt{saturate} ( \texttt{src1} (I)* \texttt{alpha} + \texttt{src2} (I)* \texttt{beta} + \texttt{gamma} )\f] where I is a multi-dimensional index of array elements. In case of multi-channel arrays, each channel is processed independently. The function can be replaced with a matrix expression:
```
 {.cpp}
    dst = src1*alpha + src2*beta + gamma;
```
\note Saturation is not applied when the output array has the depth CV_32S. You may even get result of an incorrect sign in the case of overflow.
Parameters:

src1 - first input array.

alpha - weight of the first array elements.

src2 - second input array of the same size and channel number as src1.

beta - weight of the second array elements.

gamma - scalar added to each sum.

dst - output array that has the same size and number of channels as the input arrays.

dtype - optional depth of the output array; when both input arrays have the same depth, dtype can be set to -1, which will be equivalent to src1.depth(). \sa add, subtract, scaleAdd, Mat::convertTo

addWeighted

@Namespace(value="cv")
public static void addWeighted(@ByVal
                                                      opencv_core.Mat src1,
                                                      double alpha,
                                                      @ByVal
                                                      opencv_core.Mat src2,
                                                      double beta,
                                                      double gamma,
                                                      @ByVal
                                                      opencv_core.Mat dst)

addWeighted

@Namespace(value="cv")
public static void addWeighted(@ByVal
                                                      opencv_core.UMat src1,
                                                      double alpha,
                                                      @ByVal
                                                      opencv_core.UMat src2,
                                                      double beta,
                                                      double gamma,
                                                      @ByVal
                                                      opencv_core.UMat dst,
                                                      int dtype)

addWeighted

@Namespace(value="cv")
public static void addWeighted(@ByVal
                                                      opencv_core.UMat src1,
                                                      double alpha,
                                                      @ByVal
                                                      opencv_core.UMat src2,
                                                      double beta,
                                                      double gamma,
                                                      @ByVal
                                                      opencv_core.UMat dst)

addWeighted

@Namespace(value="cv")
public static void addWeighted(@ByVal
                                                      opencv_core.GpuMat src1,
                                                      double alpha,
                                                      @ByVal
                                                      opencv_core.GpuMat src2,
                                                      double beta,
                                                      double gamma,
                                                      @ByVal
                                                      opencv_core.GpuMat dst,
                                                      int dtype)

addWeighted

@Namespace(value="cv")
public static void addWeighted(@ByVal
                                                      opencv_core.GpuMat src1,
                                                      double alpha,
                                                      @ByVal
                                                      opencv_core.GpuMat src2,
                                                      double beta,
                                                      double gamma,
                                                      @ByVal
                                                      opencv_core.GpuMat dst)

convertScaleAbs
```
@Namespace(value="cv")
public static void convertScaleAbs(@ByVal
                                                          opencv_core.Mat src,
                                                          @ByVal
                                                          opencv_core.Mat dst,
                                                          double alpha,
                                                          double beta)
```
\brief Scales, calculates absolute values, and converts the result to 8-bit.
On each element of the input array, the function convertScaleAbs performs three operations sequentially: scaling, taking an absolute value, conversion to an unsigned 8-bit type: \f[\texttt{dst} (I)= \texttt{saturate\_cast} (| \texttt{src} (I)* \texttt{alpha} + \texttt{beta} |)\f] In case of multi-channel arrays, the function processes each channel independently. When the output is not 8-bit, the operation can be emulated by calling the Mat::convertTo method (or by using matrix expressions) and then by calculating an absolute value of the result. For example:
```
 {.cpp}
    Mat_<float> A(30,30);
    randu(A, Scalar(-100), Scalar(100));
    Mat_<float> B = A*5 + 3;
    B = abs(B);
    // Mat_<float> B = abs(A*5+3) will also do the job,
    // but it will allocate a temporary matrix
```
Parameters:

src - input array.

dst - output array.

alpha - optional scale factor.

beta - optional delta added to the scaled values. \sa Mat::convertTo, cv::abs(const Mat&)

convertScaleAbs

@Namespace(value="cv")
public static void convertScaleAbs(@ByVal
                                                          opencv_core.Mat src,
                                                          @ByVal
                                                          opencv_core.Mat dst)

convertScaleAbs

@Namespace(value="cv")
public static void convertScaleAbs(@ByVal
                                                          opencv_core.UMat src,
                                                          @ByVal
                                                          opencv_core.UMat dst,
                                                          double alpha,
                                                          double beta)

convertScaleAbs

@Namespace(value="cv")
public static void convertScaleAbs(@ByVal
                                                          opencv_core.UMat src,
                                                          @ByVal
                                                          opencv_core.UMat dst)

convertScaleAbs

@Namespace(value="cv")
public static void convertScaleAbs(@ByVal
                                                          opencv_core.GpuMat src,
                                                          @ByVal
                                                          opencv_core.GpuMat dst,
                                                          double alpha,
                                                          double beta)

convertScaleAbs

@Namespace(value="cv")
public static void convertScaleAbs(@ByVal
                                                          opencv_core.GpuMat src,
                                                          @ByVal
                                                          opencv_core.GpuMat dst)

convertFp16
```
@Namespace(value="cv")
public static void convertFp16(@ByVal
                                                      opencv_core.Mat src,
                                                      @ByVal
                                                      opencv_core.Mat dst)
```
\brief Converts an array to half precision floating number.
This function converts FP32 (single precision floating point) from/to FP16 (half precision floating point). CV_16S format is used to represent FP16 data. There are two use modes (src -> dst): CV_32F -> CV_16S and CV_16S -> CV_32F. The input array has to have type of CV_32F or CV_16S to represent the bit depth. If the input array is neither of them, the function will raise an error. The format of half precision floating point is defined in IEEE 754-2008.

Parameters:

src - input array.

dst - output array.

convertFp16

@Namespace(value="cv")
public static void convertFp16(@ByVal
                                                      opencv_core.UMat src,
                                                      @ByVal
                                                      opencv_core.UMat dst)

convertFp16

@Namespace(value="cv")
public static void convertFp16(@ByVal
                                                      opencv_core.GpuMat src,
                                                      @ByVal
                                                      opencv_core.GpuMat dst)

LUT
```
@Namespace(value="cv")
public static void LUT(@ByVal
                                              opencv_core.Mat src,
                                              @ByVal
                                              opencv_core.Mat lut,
                                              @ByVal
                                              opencv_core.Mat dst)
```
\brief Performs a look-up table transform of an array.
The function LUT fills the output array with values from the look-up table. Indices of the entries are taken from the input array. That is, the function processes each element of src as follows: \f[\texttt{dst} (I) \leftarrow \texttt{lut(src(I) + d)}\f] where \f[d = \fork{0}{if $\texttt{src}$ has depth $\texttt{CV_8U}$}{128}{if $\texttt{src}$ has depth $\texttt{CV_8S}$}\f]

Parameters:

src - input array of 8-bit elements.

lut - look-up table of 256 elements; in case of multi-channel input array, the table should either have a single channel (in this case the same table is used for all channels) or the same number of channels as in the input array.

dst - output array of the same size and number of channels as src, and the same depth as lut. \sa convertScaleAbs, Mat::convertTo

LUT

@Namespace(value="cv")
public static void LUT(@ByVal
                                              opencv_core.UMat src,
                                              @ByVal
                                              opencv_core.UMat lut,
                                              @ByVal
                                              opencv_core.UMat dst)

LUT

@Namespace(value="cv")
public static void LUT(@ByVal
                                              opencv_core.GpuMat src,
                                              @ByVal
                                              opencv_core.GpuMat lut,
                                              @ByVal
                                              opencv_core.GpuMat dst)

sumElems

@Namespace(value="cv")
 @ByVal
 @Name(value="sum")
public static opencv_core.Scalar sumElems(@ByVal
                                                                                             opencv_core.Mat src)

\brief Calculates the sum of array elements.

The function cv::sum calculates and returns the sum of array elements, independently for each channel.

Parameters:: src - input array that must have from 1 to 4 channels. \sa countNonZero, mean, meanStdDev, norm, minMaxLoc, reduce

sumElems

@Namespace(value="cv")
 @ByVal
 @Name(value="sum")
public static opencv_core.Scalar sumElems(@ByVal
                                                                                             opencv_core.UMat src)

sumElems

@Namespace(value="cv")
 @ByVal
 @Name(value="sum")
public static opencv_core.Scalar sumElems(@ByVal
                                                                                             opencv_core.GpuMat src)

countNonZero
```
@Namespace(value="cv")
public static int countNonZero(@ByVal
                                                      opencv_core.Mat src)
```
\brief Counts non-zero array elements.
The function returns the number of non-zero elements in src : \f[\sum _{I: \; \texttt{src} (I) \ne0 } 1\f]

Parameters:

src - single-channel array. \sa mean, meanStdDev, norm, minMaxLoc, calcCovarMatrix

countNonZero

@Namespace(value="cv")
public static int countNonZero(@ByVal
                                                      opencv_core.UMat src)

countNonZero

@Namespace(value="cv")
public static int countNonZero(@ByVal
                                                      opencv_core.GpuMat src)

findNonZero

@Namespace(value="cv")
public static void findNonZero(@ByVal
                                                      opencv_core.Mat src,
                                                      @ByVal
                                                      opencv_core.Mat idx)

\brief Returns the list of locations of non-zero pixels

Given a binary matrix (likely returned from an operation such as threshold(), compare(), >, ==, etc, return all of the non-zero indices as a cv::Mat or std::vector (x,y) For example:

 {.cpp}
    cv::Mat binaryImage; // input, binary image
    cv::Mat locations;   // output, locations of non-zero pixels
    cv::findNonZero(binaryImage, locations);

    // access pixel coordinates
    Point pnt = locations.at<Point>(i);

 {.cpp}
    cv::Mat binaryImage; // input, binary image
    vector<Point> locations;   // output, locations of non-zero pixels
    cv::findNonZero(binaryImage, locations);

    // access pixel coordinates
    Point pnt = locations[i];

Parameters:: src - single-channel array (type CV_8UC1); idx - the output array, type of cv::Mat or std::vector, corresponding to non-zero indices in the input

findNonZero

@Namespace(value="cv")
public static void findNonZero(@ByVal
                                                      opencv_core.UMat src,
                                                      @ByVal
                                                      opencv_core.UMat idx)

findNonZero

@Namespace(value="cv")
public static void findNonZero(@ByVal
                                                      opencv_core.GpuMat src,
                                                      @ByVal
                                                      opencv_core.GpuMat idx)

mean
```
@Namespace(value="cv")
 @ByVal
public static opencv_core.Scalar mean(@ByVal
                                                                     opencv_core.Mat src,
                                                                     @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                                     opencv_core.Mat mask)
```
\brief Calculates an average (mean) of array elements.
The function cv::mean calculates the mean value M of array elements, independently for each channel, and return it: \f[\begin{array}{l} N = \sum _{I: \; \texttt{mask} (I) \ne 0} 1 \\ M_c = \left ( \sum _{I: \; \texttt{mask} (I) \ne 0}{ \texttt{mtx} (I)_c} \right )/N \end{array}\f] When all the mask elements are 0's, the function returns Scalar::all(0)

Parameters:

src - input array that should have from 1 to 4 channels so that the result can be stored in Scalar_ .

mask - optional operation mask. \sa countNonZero, meanStdDev, norm, minMaxLoc

mean

@Namespace(value="cv")
 @ByVal
public static opencv_core.Scalar mean(@ByVal
                                                                     opencv_core.Mat src)

mean

@Namespace(value="cv")
 @ByVal
public static opencv_core.Scalar mean(@ByVal
                                                                     opencv_core.UMat src,
                                                                     @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                                     opencv_core.UMat mask)

mean

@Namespace(value="cv")
 @ByVal
public static opencv_core.Scalar mean(@ByVal
                                                                     opencv_core.UMat src)

mean

@Namespace(value="cv")
 @ByVal
public static opencv_core.Scalar mean(@ByVal
                                                                     opencv_core.GpuMat src,
                                                                     @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                                     opencv_core.GpuMat mask)

mean

@Namespace(value="cv")
 @ByVal
public static opencv_core.Scalar mean(@ByVal
                                                                     opencv_core.GpuMat src)

meanStdDev
```
@Namespace(value="cv")
public static void meanStdDev(@ByVal
                                                     opencv_core.Mat src,
                                                     @ByVal
                                                     opencv_core.Mat mean,
                                                     @ByVal
                                                     opencv_core.Mat stddev,
                                                     @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                     opencv_core.Mat mask)
```
Calculates a mean and standard deviation of array elements.
The function cv::meanStdDev calculates the mean and the standard deviation M of array elements independently for each channel and returns it via the output parameters: \f[\begin{array}{l} N = \sum _{I, \texttt{mask} (I) \ne 0} 1 \\ \texttt{mean} _c = \frac{\sum_{ I: \; \texttt{mask}(I) \ne 0} \texttt{src} (I)_c}{N} \\ \texttt{stddev} _c = \sqrt{\frac{\sum_{ I: \; \texttt{mask}(I) \ne 0} \left ( \texttt{src} (I)_c - \texttt{mean} _c \right )^2}{N}} \end{array}\f] When all the mask elements are 0's, the function returns mean=stddev=Scalar::all(0). \note The calculated standard deviation is only the diagonal of the complete normalized covariance matrix. If the full matrix is needed, you can reshape the multi-channel array M x N to the single-channel array M\*N x mtx.channels() (only possible when the matrix is continuous) and then pass the matrix to calcCovarMatrix .

Parameters:

src - input array that should have from 1 to 4 channels so that the results can be stored in Scalar_ 's.

mean - output parameter: calculated mean value.

stddev - output parameter: calculated standard deviation.

mask - optional operation mask. \sa countNonZero, mean, norm, minMaxLoc, calcCovarMatrix

meanStdDev

@Namespace(value="cv")
public static void meanStdDev(@ByVal
                                                     opencv_core.Mat src,
                                                     @ByVal
                                                     opencv_core.Mat mean,
                                                     @ByVal
                                                     opencv_core.Mat stddev)

meanStdDev

@Namespace(value="cv")
public static void meanStdDev(@ByVal
                                                     opencv_core.UMat src,
                                                     @ByVal
                                                     opencv_core.UMat mean,
                                                     @ByVal
                                                     opencv_core.UMat stddev,
                                                     @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                     opencv_core.UMat mask)

meanStdDev

@Namespace(value="cv")
public static void meanStdDev(@ByVal
                                                     opencv_core.UMat src,
                                                     @ByVal
                                                     opencv_core.UMat mean,
                                                     @ByVal
                                                     opencv_core.UMat stddev)

meanStdDev

@Namespace(value="cv")
public static void meanStdDev(@ByVal
                                                     opencv_core.GpuMat src,
                                                     @ByVal
                                                     opencv_core.GpuMat mean,
                                                     @ByVal
                                                     opencv_core.GpuMat stddev,
                                                     @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                     opencv_core.GpuMat mask)

meanStdDev

@Namespace(value="cv")
public static void meanStdDev(@ByVal
                                                     opencv_core.GpuMat src,
                                                     @ByVal
                                                     opencv_core.GpuMat mean,
                                                     @ByVal
                                                     opencv_core.GpuMat stddev)

norm
```
@Namespace(value="cv")
public static double norm(@ByVal
                                                 opencv_core.Mat src1,
                                                 int normType,
                                                 @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                 opencv_core.Mat mask)
```
\brief Calculates the absolute norm of an array.
This version of #norm calculates the absolute norm of src1. The type of norm to calculate is specified using #NormTypes.
As example for one array consider the function \f$r(x)= \begin{pmatrix} x \\ 1-x \end{pmatrix}, x \in [-1;1]\f$. The \f$ L_{1}, L_{2} \f$ and \f$ L_{\infty} \f$ norm for the sample value \f$r(-1) = \begin{pmatrix} -1 \\ 2 \end{pmatrix}\f$ is calculated as follows \f{align*} \| r(-1) \|_{L_1} &= |-1| + |2| = 3 \\ \| r(-1) \|_{L_2} &= \sqrt{(-1)^{2} + (2)^{2}} = \sqrt{5} \\ \| r(-1) \|_{L_\infty} &= \max(|-1|,|2|) = 2 \f} and for \f$r(0.5) = \begin{pmatrix} 0.5 \\ 0.5 \end{pmatrix}\f$ the calculation is \f{align*} \| r(0.5) \|_{L_1} &= |0.5| + |0.5| = 1 \\ \| r(0.5) \|_{L_2} &= \sqrt{(0.5)^{2} + (0.5)^{2}} = \sqrt{0.5} \\ \| r(0.5) \|_{L_\infty} &= \max(|0.5|,|0.5|) = 0.5. \f} The following graphic shows all values for the three norm functions \f$\| r(x) \|_{L_1}, \| r(x) \|_{L_2}\f$ and \f$\| r(x) \|_{L_\infty}\f$. It is notable that the \f$ L_{1} \f$ norm forms the upper and the \f$ L_{\infty} \f$ norm forms the lower border for the example function \f$ r(x) \f$. ![Graphs for the different norm functions from the above example](pics/NormTypes_OneArray_1-2-INF.png)
When the mask parameter is specified and it is not empty, the norm is
If normType is not specified, #NORM_L2 is used. calculated only over the region specified by the mask.
Multi-channel input arrays are treated as single-channel arrays, that is, the results for all channels are combined.
Hamming norms can only be calculated with CV_8U depth arrays.

Parameters:

src1 - first input array.

normType - type of the norm (see #NormTypes).

mask - optional operation mask; it must have the same size as src1 and CV_8UC1 type.

norm

@Namespace(value="cv")
public static double norm(@ByVal
                                                 opencv_core.Mat src1)

norm

@Namespace(value="cv")
public static double norm(@ByVal
                                                 opencv_core.UMat src1,
                                                 int normType,
                                                 @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                 opencv_core.UMat mask)

norm

@Namespace(value="cv")
public static double norm(@ByVal
                                                 opencv_core.UMat src1)

norm

@Namespace(value="cv")
public static double norm(@ByVal
                                                 opencv_core.GpuMat src1,
                                                 int normType,
                                                 @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                 opencv_core.GpuMat mask)

norm

@Namespace(value="cv")
public static double norm(@ByVal
                                                 opencv_core.GpuMat src1)

norm

@Namespace(value="cv")
public static double norm(@ByVal
                                                 opencv_core.Mat src1,
                                                 @ByVal
                                                 opencv_core.Mat src2,
                                                 int normType,
                                                 @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                 opencv_core.Mat mask)

\brief Calculates an absolute difference norm or a relative difference norm.

This version of cv::norm calculates the absolute difference norm or the relative difference norm of arrays src1 and src2. The type of norm to calculate is specified using #NormTypes.

Parameters:: src1 - first input array.; src2 - second input array of the same size and the same type as src1.; normType - type of the norm (see #NormTypes).; mask - optional operation mask; it must have the same size as src1 and CV_8UC1 type.

norm

@Namespace(value="cv")
public static double norm(@ByVal
                                                 opencv_core.Mat src1,
                                                 @ByVal
                                                 opencv_core.Mat src2)

norm

@Namespace(value="cv")
public static double norm(@ByVal
                                                 opencv_core.UMat src1,
                                                 @ByVal
                                                 opencv_core.UMat src2,
                                                 int normType,
                                                 @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                 opencv_core.UMat mask)

norm

@Namespace(value="cv")
public static double norm(@ByVal
                                                 opencv_core.UMat src1,
                                                 @ByVal
                                                 opencv_core.UMat src2)

norm

@Namespace(value="cv")
public static double norm(@ByVal
                                                 opencv_core.GpuMat src1,
                                                 @ByVal
                                                 opencv_core.GpuMat src2,
                                                 int normType,
                                                 @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                 opencv_core.GpuMat mask)

norm

@Namespace(value="cv")
public static double norm(@ByVal
                                                 opencv_core.GpuMat src1,
                                                 @ByVal
                                                 opencv_core.GpuMat src2)

norm

@Namespace(value="cv")
public static double norm(@Const @ByRef
                                                 opencv_core.SparseMat src,
                                                 int normType)

\overload

Parameters:: src - first input array.; normType - type of the norm (see #NormTypes).

PSNR
```
@Namespace(value="cv")
public static double PSNR(@ByVal
                                                 opencv_core.Mat src1,
                                                 @ByVal
                                                 opencv_core.Mat src2)
```
\brief Computes the Peak Signal-to-Noise Ratio (PSNR) image quality metric.
This function calculates the Peak Signal-to-Noise Ratio (PSNR) image quality metric in decibels (dB), between two input arrays src1 and src2. Arrays must have depth CV_8U.
The PSNR is calculated as follows:
\f[ \texttt{PSNR} = 10 \cdot \log_{10}{\left( \frac{R^2}{MSE} \right) } \f]
where R is the maximum integer value of depth CV_8U (255) and MSE is the mean squared error between the two arrays.

Parameters:

src1 - first input array.

src2 - second input array of the same size as src1.

PSNR

@Namespace(value="cv")
public static double PSNR(@ByVal
                                                 opencv_core.UMat src1,
                                                 @ByVal
                                                 opencv_core.UMat src2)

PSNR

@Namespace(value="cv")
public static double PSNR(@ByVal
                                                 opencv_core.GpuMat src1,
                                                 @ByVal
                                                 opencv_core.GpuMat src2)

batchDistance

@Namespace(value="cv")
public static void batchDistance(@ByVal
                                                        opencv_core.Mat src1,
                                                        @ByVal
                                                        opencv_core.Mat src2,
                                                        @ByVal
                                                        opencv_core.Mat dist,
                                                        int dtype,
                                                        @ByVal
                                                        opencv_core.Mat nidx,
                                                        int normType,
                                                        int K,
                                                        @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                        opencv_core.Mat mask,
                                                        int update,
                                                        @Cast(value="bool")
                                                        boolean crosscheck)

\brief naive nearest neighbor finder

see http://en.wikipedia.org/wiki/Nearest_neighbor_search \todo document

batchDistance

@Namespace(value="cv")
public static void batchDistance(@ByVal
                                                        opencv_core.Mat src1,
                                                        @ByVal
                                                        opencv_core.Mat src2,
                                                        @ByVal
                                                        opencv_core.Mat dist,
                                                        int dtype,
                                                        @ByVal
                                                        opencv_core.Mat nidx)

batchDistance

@Namespace(value="cv")
public static void batchDistance(@ByVal
                                                        opencv_core.UMat src1,
                                                        @ByVal
                                                        opencv_core.UMat src2,
                                                        @ByVal
                                                        opencv_core.UMat dist,
                                                        int dtype,
                                                        @ByVal
                                                        opencv_core.UMat nidx,
                                                        int normType,
                                                        int K,
                                                        @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                        opencv_core.UMat mask,
                                                        int update,
                                                        @Cast(value="bool")
                                                        boolean crosscheck)

batchDistance

@Namespace(value="cv")
public static void batchDistance(@ByVal
                                                        opencv_core.UMat src1,
                                                        @ByVal
                                                        opencv_core.UMat src2,
                                                        @ByVal
                                                        opencv_core.UMat dist,
                                                        int dtype,
                                                        @ByVal
                                                        opencv_core.UMat nidx)

batchDistance

@Namespace(value="cv")
public static void batchDistance(@ByVal
                                                        opencv_core.GpuMat src1,
                                                        @ByVal
                                                        opencv_core.GpuMat src2,
                                                        @ByVal
                                                        opencv_core.GpuMat dist,
                                                        int dtype,
                                                        @ByVal
                                                        opencv_core.GpuMat nidx,
                                                        int normType,
                                                        int K,
                                                        @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                        opencv_core.GpuMat mask,
                                                        int update,
                                                        @Cast(value="bool")
                                                        boolean crosscheck)

batchDistance

@Namespace(value="cv")
public static void batchDistance(@ByVal
                                                        opencv_core.GpuMat src1,
                                                        @ByVal
                                                        opencv_core.GpuMat src2,
                                                        @ByVal
                                                        opencv_core.GpuMat dist,
                                                        int dtype,
                                                        @ByVal
                                                        opencv_core.GpuMat nidx)

normalize

@Namespace(value="cv")
public static void normalize(@ByVal
                                                    opencv_core.Mat src,
                                                    @ByVal
                                                    opencv_core.Mat dst,
                                                    double alpha,
                                                    double beta,
                                                    int norm_type,
                                                    int dtype,
                                                    @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                    opencv_core.Mat mask)

\brief Normalizes the norm or value range of an array.

The function cv::normalize normalizes scale and shift the input array elements so that \f[\| \texttt{dst} \| _{L_p}= \texttt{alpha}\f] (where p=Inf, 1 or 2) when normType=NORM_INF, NORM_L1, or NORM_L2, respectively; or so that \f[\min _I \texttt{dst} (I)= \texttt{alpha} , \, \, \max _I \texttt{dst} (I)= \texttt{beta}\f]

when normType=NORM_MINMAX (for dense arrays only). The optional mask specifies a sub-array to be normalized. This means that the norm or min-n-max are calculated over the sub-array, and then this sub-array is modified to be normalized. If you want to only use the mask to calculate the norm or min-max but modify the whole array, you can use norm and Mat::convertTo.

In case of sparse matrices, only the non-zero values are analyzed and transformed. Because of this, the range transformation for sparse matrices is not allowed since it can shift the zero level.

Possible usage with some positive example data:

 {.cpp}
    vector<double> positiveData = { 2.0, 8.0, 10.0 };
    vector<double> normalizedData_l1, normalizedData_l2, normalizedData_inf, normalizedData_minmax;

    // Norm to probability (total count)
    // sum(numbers) = 20.0
    // 2.0      0.1     (2.0/20.0)
    // 8.0      0.4     (8.0/20.0)
    // 10.0     0.5     (10.0/20.0)
    normalize(positiveData, normalizedData_l1, 1.0, 0.0, NORM_L1);

    // Norm to unit vector: ||positiveData|| = 1.0
    // 2.0      0.15
    // 8.0      0.62
    // 10.0     0.77
    normalize(positiveData, normalizedData_l2, 1.0, 0.0, NORM_L2);

    // Norm to max element
    // 2.0      0.2     (2.0/10.0)
    // 8.0      0.8     (8.0/10.0)
    // 10.0     1.0     (10.0/10.0)
    normalize(positiveData, normalizedData_inf, 1.0, 0.0, NORM_INF);

    // Norm to range [0.0;1.0]
    // 2.0      0.0     (shift to left border)
    // 8.0      0.75    (6.0/8.0)
    // 10.0     1.0     (shift to right border)
    normalize(positiveData, normalizedData_minmax, 1.0, 0.0, NORM_MINMAX);

Parameters:: src - input array.; dst - output array of the same size as src .; alpha - norm value to normalize to or the lower range boundary in case of the range normalization.; beta - upper range boundary in case of the range normalization; it is not used for the norm normalization.; norm_type - normalization type (see cv::NormTypes).; dtype - when negative, the output array has the same type as src; otherwise, it has the same number of channels as src and the depth =CV_MAT_DEPTH(dtype).; mask - optional operation mask. \sa norm, Mat::convertTo, SparseMat::convertTo

normalize

@Namespace(value="cv")
public static void normalize(@ByVal
                                                    opencv_core.Mat src,
                                                    @ByVal
                                                    opencv_core.Mat dst)

normalize

@Namespace(value="cv")
public static void normalize(@ByVal
                                                    opencv_core.UMat src,
                                                    @ByVal
                                                    opencv_core.UMat dst,
                                                    double alpha,
                                                    double beta,
                                                    int norm_type,
                                                    int dtype,
                                                    @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                    opencv_core.UMat mask)

normalize

@Namespace(value="cv")
public static void normalize(@ByVal
                                                    opencv_core.UMat src,
                                                    @ByVal
                                                    opencv_core.UMat dst)

normalize

@Namespace(value="cv")
public static void normalize(@ByVal
                                                    opencv_core.GpuMat src,
                                                    @ByVal
                                                    opencv_core.GpuMat dst,
                                                    double alpha,
                                                    double beta,
                                                    int norm_type,
                                                    int dtype,
                                                    @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                    opencv_core.GpuMat mask)

normalize

@Namespace(value="cv")
public static void normalize(@ByVal
                                                    opencv_core.GpuMat src,
                                                    @ByVal
                                                    opencv_core.GpuMat dst)

normalize

@Namespace(value="cv")
public static void normalize(@Const @ByRef
                                                    opencv_core.SparseMat src,
                                                    @ByRef
                                                    opencv_core.SparseMat dst,
                                                    double alpha,
                                                    int normType)

\overload

Parameters:: src - input array.; dst - output array of the same size as src .; alpha - norm value to normalize to or the lower range boundary in case of the range normalization.; normType - normalization type (see cv::NormTypes).

minMaxLoc
```
@Namespace(value="cv")
public static void minMaxLoc(@ByVal
                                                    opencv_core.Mat src,
                                                    org.bytedeco.javacpp.DoublePointer minVal,
                                                    org.bytedeco.javacpp.DoublePointer maxVal,
                                                    opencv_core.Point minLoc,
                                                    opencv_core.Point maxLoc,
                                                    @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                    opencv_core.Mat mask)
```
\brief Finds the global minimum and maximum in an array.
The function cv::minMaxLoc finds the minimum and maximum element values and their positions. The extremums are searched across the whole array or, if mask is not an empty array, in the specified array region.
The function do not work with multi-channel arrays. If you need to find minimum or maximum elements across all the channels, use Mat::reshape first to reinterpret the array as single-channel. Or you may extract the particular channel using either extractImageCOI , or mixChannels , or split .

Parameters:

src - input single-channel array.

minVal - pointer to the returned minimum value; NULL is used if not required.

maxVal - pointer to the returned maximum value; NULL is used if not required.

minLoc - pointer to the returned minimum location (in 2D case); NULL is used if not required.

maxLoc - pointer to the returned maximum location (in 2D case); NULL is used if not required.

mask - optional mask used to select a sub-array. \sa max, min, compare, inRange, extractImageCOI, mixChannels, split, Mat::reshape

minMaxLoc

@Namespace(value="cv")
public static void minMaxLoc(@ByVal
                                                    opencv_core.Mat src,
                                                    org.bytedeco.javacpp.DoublePointer minVal)

minMaxLoc

@Namespace(value="cv")
public static void minMaxLoc(@ByVal
                                                    opencv_core.Mat src,
                                                    DoubleBuffer minVal,
                                                    DoubleBuffer maxVal,
                                                    opencv_core.Point minLoc,
                                                    opencv_core.Point maxLoc,
                                                    @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                    opencv_core.Mat mask)

minMaxLoc

@Namespace(value="cv")
public static void minMaxLoc(@ByVal
                                                    opencv_core.Mat src,
                                                    DoubleBuffer minVal)

minMaxLoc

@Namespace(value="cv")
public static void minMaxLoc(@ByVal
                                                    opencv_core.Mat src,
                                                    double[] minVal,
                                                    double[] maxVal,
                                                    opencv_core.Point minLoc,
                                                    opencv_core.Point maxLoc,
                                                    @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                    opencv_core.Mat mask)

minMaxLoc

@Namespace(value="cv")
public static void minMaxLoc(@ByVal
                                                    opencv_core.Mat src,
                                                    double[] minVal)

minMaxLoc

@Namespace(value="cv")
public static void minMaxLoc(@ByVal
                                                    opencv_core.UMat src,
                                                    org.bytedeco.javacpp.DoublePointer minVal,
                                                    org.bytedeco.javacpp.DoublePointer maxVal,
                                                    opencv_core.Point minLoc,
                                                    opencv_core.Point maxLoc,
                                                    @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                    opencv_core.UMat mask)

minMaxLoc

@Namespace(value="cv")
public static void minMaxLoc(@ByVal
                                                    opencv_core.UMat src,
                                                    org.bytedeco.javacpp.DoublePointer minVal)

minMaxLoc

@Namespace(value="cv")
public static void minMaxLoc(@ByVal
                                                    opencv_core.UMat src,
                                                    DoubleBuffer minVal,
                                                    DoubleBuffer maxVal,
                                                    opencv_core.Point minLoc,
                                                    opencv_core.Point maxLoc,
                                                    @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                    opencv_core.UMat mask)

minMaxLoc

@Namespace(value="cv")
public static void minMaxLoc(@ByVal
                                                    opencv_core.UMat src,
                                                    DoubleBuffer minVal)

minMaxLoc

@Namespace(value="cv")
public static void minMaxLoc(@ByVal
                                                    opencv_core.UMat src,
                                                    double[] minVal,
                                                    double[] maxVal,
                                                    opencv_core.Point minLoc,
                                                    opencv_core.Point maxLoc,
                                                    @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                    opencv_core.UMat mask)

minMaxLoc

@Namespace(value="cv")
public static void minMaxLoc(@ByVal
                                                    opencv_core.UMat src,
                                                    double[] minVal)

minMaxLoc

@Namespace(value="cv")
public static void minMaxLoc(@ByVal
                                                    opencv_core.GpuMat src,
                                                    org.bytedeco.javacpp.DoublePointer minVal,
                                                    org.bytedeco.javacpp.DoublePointer maxVal,
                                                    opencv_core.Point minLoc,
                                                    opencv_core.Point maxLoc,
                                                    @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                    opencv_core.GpuMat mask)

minMaxLoc

@Namespace(value="cv")
public static void minMaxLoc(@ByVal
                                                    opencv_core.GpuMat src,
                                                    org.bytedeco.javacpp.DoublePointer minVal)

minMaxLoc

@Namespace(value="cv")
public static void minMaxLoc(@ByVal
                                                    opencv_core.GpuMat src,
                                                    DoubleBuffer minVal,
                                                    DoubleBuffer maxVal,
                                                    opencv_core.Point minLoc,
                                                    opencv_core.Point maxLoc,
                                                    @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                    opencv_core.GpuMat mask)

minMaxLoc

@Namespace(value="cv")
public static void minMaxLoc(@ByVal
                                                    opencv_core.GpuMat src,
                                                    DoubleBuffer minVal)

minMaxLoc

@Namespace(value="cv")
public static void minMaxLoc(@ByVal
                                                    opencv_core.GpuMat src,
                                                    double[] minVal,
                                                    double[] maxVal,
                                                    opencv_core.Point minLoc,
                                                    opencv_core.Point maxLoc,
                                                    @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                    opencv_core.GpuMat mask)

minMaxLoc

@Namespace(value="cv")
public static void minMaxLoc(@ByVal
                                                    opencv_core.GpuMat src,
                                                    double[] minVal)

minMaxIdx
```
@Namespace(value="cv")
public static void minMaxIdx(@ByVal
                                                    opencv_core.Mat src,
                                                    org.bytedeco.javacpp.DoublePointer minVal,
                                                    org.bytedeco.javacpp.DoublePointer maxVal,
                                                    org.bytedeco.javacpp.IntPointer minIdx,
                                                    org.bytedeco.javacpp.IntPointer maxIdx,
                                                    @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                    opencv_core.Mat mask)
```
\brief Finds the global minimum and maximum in an array
The function cv::minMaxIdx finds the minimum and maximum element values and their positions. The extremums are searched across the whole array or, if mask is not an empty array, in the specified array region. The function does not work with multi-channel arrays. If you need to find minimum or maximum elements across all the channels, use Mat::reshape first to reinterpret the array as single-channel. Or you may extract the particular channel using either extractImageCOI , or mixChannels , or split . In case of a sparse matrix, the minimum is found among non-zero elements only. \note When minIdx is not NULL, it must have at least 2 elements (as well as maxIdx), even if src is a single-row or single-column matrix. In OpenCV (following MATLAB) each array has at least 2 dimensions, i.e. single-column matrix is Mx1 matrix (and therefore minIdx/maxIdx will be (i1,0)/(i2,0)) and single-row matrix is 1xN matrix (and therefore minIdx/maxIdx will be (0,j1)/(0,j2)).

Parameters:

src - input single-channel array.

minVal - pointer to the returned minimum value; NULL is used if not required.

maxVal - pointer to the returned maximum value; NULL is used if not required.

minIdx - pointer to the returned minimum location (in nD case); NULL is used if not required; Otherwise, it must point to an array of src.dims elements, the coordinates of the minimum element in each dimension are stored there sequentially.

maxIdx - pointer to the returned maximum location (in nD case). NULL is used if not required.

mask - specified array region

minMaxIdx

@Namespace(value="cv")
public static void minMaxIdx(@ByVal
                                                    opencv_core.Mat src,
                                                    org.bytedeco.javacpp.DoublePointer minVal)

minMaxIdx

@Namespace(value="cv")
public static void minMaxIdx(@ByVal
                                                    opencv_core.Mat src,
                                                    DoubleBuffer minVal,
                                                    DoubleBuffer maxVal,
                                                    IntBuffer minIdx,
                                                    IntBuffer maxIdx,
                                                    @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                    opencv_core.Mat mask)

minMaxIdx

@Namespace(value="cv")
public static void minMaxIdx(@ByVal
                                                    opencv_core.Mat src,
                                                    DoubleBuffer minVal)

minMaxIdx

@Namespace(value="cv")
public static void minMaxIdx(@ByVal
                                                    opencv_core.Mat src,
                                                    double[] minVal,
                                                    double[] maxVal,
                                                    int[] minIdx,
                                                    int[] maxIdx,
                                                    @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                    opencv_core.Mat mask)

minMaxIdx

@Namespace(value="cv")
public static void minMaxIdx(@ByVal
                                                    opencv_core.Mat src,
                                                    double[] minVal)

minMaxIdx

@Namespace(value="cv")
public static void minMaxIdx(@ByVal
                                                    opencv_core.UMat src,
                                                    org.bytedeco.javacpp.DoublePointer minVal,
                                                    org.bytedeco.javacpp.DoublePointer maxVal,
                                                    org.bytedeco.javacpp.IntPointer minIdx,
                                                    org.bytedeco.javacpp.IntPointer maxIdx,
                                                    @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                    opencv_core.UMat mask)

minMaxIdx

@Namespace(value="cv")
public static void minMaxIdx(@ByVal
                                                    opencv_core.UMat src,
                                                    org.bytedeco.javacpp.DoublePointer minVal)

minMaxIdx

@Namespace(value="cv")
public static void minMaxIdx(@ByVal
                                                    opencv_core.UMat src,
                                                    DoubleBuffer minVal,
                                                    DoubleBuffer maxVal,
                                                    IntBuffer minIdx,
                                                    IntBuffer maxIdx,
                                                    @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                    opencv_core.UMat mask)

minMaxIdx

@Namespace(value="cv")
public static void minMaxIdx(@ByVal
                                                    opencv_core.UMat src,
                                                    DoubleBuffer minVal)

minMaxIdx

@Namespace(value="cv")
public static void minMaxIdx(@ByVal
                                                    opencv_core.UMat src,
                                                    double[] minVal,
                                                    double[] maxVal,
                                                    int[] minIdx,
                                                    int[] maxIdx,
                                                    @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                    opencv_core.UMat mask)

minMaxIdx

@Namespace(value="cv")
public static void minMaxIdx(@ByVal
                                                    opencv_core.UMat src,
                                                    double[] minVal)

minMaxIdx

@Namespace(value="cv")
public static void minMaxIdx(@ByVal
                                                    opencv_core.GpuMat src,
                                                    org.bytedeco.javacpp.DoublePointer minVal,
                                                    org.bytedeco.javacpp.DoublePointer maxVal,
                                                    org.bytedeco.javacpp.IntPointer minIdx,
                                                    org.bytedeco.javacpp.IntPointer maxIdx,
                                                    @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                    opencv_core.GpuMat mask)

minMaxIdx

@Namespace(value="cv")
public static void minMaxIdx(@ByVal
                                                    opencv_core.GpuMat src,
                                                    org.bytedeco.javacpp.DoublePointer minVal)

minMaxIdx

@Namespace(value="cv")
public static void minMaxIdx(@ByVal
                                                    opencv_core.GpuMat src,
                                                    DoubleBuffer minVal,
                                                    DoubleBuffer maxVal,
                                                    IntBuffer minIdx,
                                                    IntBuffer maxIdx,
                                                    @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                    opencv_core.GpuMat mask)

minMaxIdx

@Namespace(value="cv")
public static void minMaxIdx(@ByVal
                                                    opencv_core.GpuMat src,
                                                    DoubleBuffer minVal)

minMaxIdx

@Namespace(value="cv")
public static void minMaxIdx(@ByVal
                                                    opencv_core.GpuMat src,
                                                    double[] minVal,
                                                    double[] maxVal,
                                                    int[] minIdx,
                                                    int[] maxIdx,
                                                    @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                    opencv_core.GpuMat mask)

minMaxIdx

@Namespace(value="cv")
public static void minMaxIdx(@ByVal
                                                    opencv_core.GpuMat src,
                                                    double[] minVal)

minMaxLoc

@Namespace(value="cv")
public static void minMaxLoc(@Const @ByRef
                                                    opencv_core.SparseMat a,
                                                    org.bytedeco.javacpp.DoublePointer minVal,
                                                    org.bytedeco.javacpp.DoublePointer maxVal,
                                                    org.bytedeco.javacpp.IntPointer minIdx,
                                                    org.bytedeco.javacpp.IntPointer maxIdx)

\overload

Parameters:: a - input single-channel array.; minVal - pointer to the returned minimum value; NULL is used if not required.; maxVal - pointer to the returned maximum value; NULL is used if not required.; minIdx - pointer to the returned minimum location (in nD case); NULL is used if not required; Otherwise, it must point to an array of src.dims elements, the coordinates of the minimum element in each dimension are stored there sequentially.; maxIdx - pointer to the returned maximum location (in nD case). NULL is used if not required.

minMaxLoc

@Namespace(value="cv")
public static void minMaxLoc(@Const @ByRef
                                                    opencv_core.SparseMat a,
                                                    org.bytedeco.javacpp.DoublePointer minVal,
                                                    org.bytedeco.javacpp.DoublePointer maxVal)

minMaxLoc

@Namespace(value="cv")
public static void minMaxLoc(@Const @ByRef
                                                    opencv_core.SparseMat a,
                                                    DoubleBuffer minVal,
                                                    DoubleBuffer maxVal,
                                                    IntBuffer minIdx,
                                                    IntBuffer maxIdx)

minMaxLoc

@Namespace(value="cv")
public static void minMaxLoc(@Const @ByRef
                                                    opencv_core.SparseMat a,
                                                    DoubleBuffer minVal,
                                                    DoubleBuffer maxVal)

minMaxLoc

@Namespace(value="cv")
public static void minMaxLoc(@Const @ByRef
                                                    opencv_core.SparseMat a,
                                                    double[] minVal,
                                                    double[] maxVal,
                                                    int[] minIdx,
                                                    int[] maxIdx)

minMaxLoc

@Namespace(value="cv")
public static void minMaxLoc(@Const @ByRef
                                                    opencv_core.SparseMat a,
                                                    double[] minVal,
                                                    double[] maxVal)

reduce
```
@Namespace(value="cv")
public static void reduce(@ByVal
                                                 opencv_core.Mat src,
                                                 @ByVal
                                                 opencv_core.Mat dst,
                                                 int dim,
                                                 int rtype,
                                                 int dtype)
```
\brief Reduces a matrix to a vector.
The function #reduce reduces the matrix to a vector by treating the matrix rows/columns as a set of 1D vectors and performing the specified operation on the vectors until a single row/column is obtained. For example, the function can be used to compute horizontal and vertical projections of a raster image. In case of #REDUCE_MAX and #REDUCE_MIN , the output image should have the same type as the source one. In case of #REDUCE_SUM and #REDUCE_AVG , the output may have a larger element bit-depth to preserve accuracy. And multi-channel arrays are also supported in these two reduction modes.
The following code demonstrates its usage for a single channel matrix. \snippet snippets/core_reduce.cpp example
And the following code demonstrates its usage for a two-channel matrix. \snippet snippets/core_reduce.cpp example2

Parameters:

src - input 2D matrix.

dst - output vector. Its size and type is defined by dim and dtype parameters.

dim - dimension index along which the matrix is reduced. 0 means that the matrix is reduced to a single row. 1 means that the matrix is reduced to a single column.

rtype - reduction operation that could be one of #ReduceTypes

dtype - when negative, the output vector will have the same type as the input matrix, otherwise, its type will be CV_MAKE_TYPE(CV_MAT_DEPTH(dtype), src.channels()). \sa repeat

reduce

@Namespace(value="cv")
public static void reduce(@ByVal
                                                 opencv_core.Mat src,
                                                 @ByVal
                                                 opencv_core.Mat dst,
                                                 int dim,
                                                 int rtype)

reduce

@Namespace(value="cv")
public static void reduce(@ByVal
                                                 opencv_core.UMat src,
                                                 @ByVal
                                                 opencv_core.UMat dst,
                                                 int dim,
                                                 int rtype,
                                                 int dtype)

reduce

@Namespace(value="cv")
public static void reduce(@ByVal
                                                 opencv_core.UMat src,
                                                 @ByVal
                                                 opencv_core.UMat dst,
                                                 int dim,
                                                 int rtype)

reduce

@Namespace(value="cv")
public static void reduce(@ByVal
                                                 opencv_core.GpuMat src,
                                                 @ByVal
                                                 opencv_core.GpuMat dst,
                                                 int dim,
                                                 int rtype,
                                                 int dtype)

reduce

@Namespace(value="cv")
public static void reduce(@ByVal
                                                 opencv_core.GpuMat src,
                                                 @ByVal
                                                 opencv_core.GpuMat dst,
                                                 int dim,
                                                 int rtype)

merge
```
@Namespace(value="cv")
public static void merge(@Const
                                                opencv_core.Mat mv,
                                                @Cast(value="size_t")
                                                long count,
                                                @ByVal
                                                opencv_core.Mat dst)
```
\brief Creates one multi-channel array out of several single-channel ones.
The function cv::merge merges several arrays to make a single multi-channel array. That is, each element of the output array will be a concatenation of the elements of the input arrays, where elements of i-th input array are treated as mv[i].channels()-element vectors.
The function cv::split does the reverse operation. If you need to shuffle channels in some other advanced way, use cv::mixChannels.
The following example shows how to merge 3 single channel matrices into a single 3-channel matrix. \snippet snippets/core_merge.cpp example

Parameters:

mv - input array of matrices to be merged; all the matrices in mv must have the same size and the same depth.

count - number of input matrices when mv is a plain C array; it must be greater than zero.

dst - output array of the same size and the same depth as mv[0]; The number of channels will be equal to the parameter count. \sa mixChannels, split, Mat::reshape

merge

@Namespace(value="cv")
public static void merge(@Const
                                                opencv_core.Mat mv,
                                                @Cast(value="size_t")
                                                long count,
                                                @ByVal
                                                opencv_core.UMat dst)

merge

@Namespace(value="cv")
public static void merge(@Const
                                                opencv_core.Mat mv,
                                                @Cast(value="size_t")
                                                long count,
                                                @ByVal
                                                opencv_core.GpuMat dst)

merge

@Namespace(value="cv")
public static void merge(@ByVal
                                                opencv_core.MatVector mv,
                                                @ByVal
                                                opencv_core.Mat dst)

\overload

Parameters:: mv - input vector of matrices to be merged; all the matrices in mv must have the same size and the same depth.; dst - output array of the same size and the same depth as mv[0]; The number of channels will be the total number of channels in the matrix array.

merge

@Namespace(value="cv")
public static void merge(@ByVal
                                                opencv_core.UMatVector mv,
                                                @ByVal
                                                opencv_core.Mat dst)

merge

@Namespace(value="cv")
public static void merge(@ByVal
                                                opencv_core.GpuMatVector mv,
                                                @ByVal
                                                opencv_core.Mat dst)

merge

@Namespace(value="cv")
public static void merge(@ByVal
                                                opencv_core.MatVector mv,
                                                @ByVal
                                                opencv_core.UMat dst)

merge

@Namespace(value="cv")
public static void merge(@ByVal
                                                opencv_core.UMatVector mv,
                                                @ByVal
                                                opencv_core.UMat dst)

merge

@Namespace(value="cv")
public static void merge(@ByVal
                                                opencv_core.GpuMatVector mv,
                                                @ByVal
                                                opencv_core.UMat dst)

merge

@Namespace(value="cv")
public static void merge(@ByVal
                                                opencv_core.MatVector mv,
                                                @ByVal
                                                opencv_core.GpuMat dst)

merge

@Namespace(value="cv")
public static void merge(@ByVal
                                                opencv_core.UMatVector mv,
                                                @ByVal
                                                opencv_core.GpuMat dst)

merge

@Namespace(value="cv")
public static void merge(@ByVal
                                                opencv_core.GpuMatVector mv,
                                                @ByVal
                                                opencv_core.GpuMat dst)

split
```
@Namespace(value="cv")
public static void split(@Const @ByRef
                                                opencv_core.Mat src,
                                                opencv_core.Mat mvbegin)
```
\brief Divides a multi-channel array into several single-channel arrays.
The function cv::split splits a multi-channel array into separate single-channel arrays: \f[\texttt{mv} [c](I) = \texttt{src} (I)_c\f] If you need to extract a single channel or do some other sophisticated channel permutation, use mixChannels .
The following example demonstrates how to split a 3-channel matrix into 3 single channel matrices. \snippet snippets/core_split.cpp example

Parameters:

src - input multi-channel array.

mvbegin - output array; the number of arrays must match src.channels(); the arrays themselves are reallocated, if needed. \sa merge, mixChannels, cvtColor

split

@Namespace(value="cv")
public static void split(@ByVal
                                                opencv_core.Mat m,
                                                @ByVal
                                                opencv_core.MatVector mv)

\overload

Parameters:: m - input multi-channel array.; mv - output vector of arrays; the arrays themselves are reallocated, if needed.

split

@Namespace(value="cv")
public static void split(@ByVal
                                                opencv_core.Mat m,
                                                @ByVal
                                                opencv_core.UMatVector mv)

split

@Namespace(value="cv")
public static void split(@ByVal
                                                opencv_core.Mat m,
                                                @ByVal
                                                opencv_core.GpuMatVector mv)

split

@Namespace(value="cv")
public static void split(@ByVal
                                                opencv_core.UMat m,
                                                @ByVal
                                                opencv_core.MatVector mv)

split

@Namespace(value="cv")
public static void split(@ByVal
                                                opencv_core.UMat m,
                                                @ByVal
                                                opencv_core.UMatVector mv)

split

@Namespace(value="cv")
public static void split(@ByVal
                                                opencv_core.UMat m,
                                                @ByVal
                                                opencv_core.GpuMatVector mv)

split

@Namespace(value="cv")
public static void split(@ByVal
                                                opencv_core.GpuMat m,
                                                @ByVal
                                                opencv_core.MatVector mv)

split

@Namespace(value="cv")
public static void split(@ByVal
                                                opencv_core.GpuMat m,
                                                @ByVal
                                                opencv_core.UMatVector mv)

split

@Namespace(value="cv")
public static void split(@ByVal
                                                opencv_core.GpuMat m,
                                                @ByVal
                                                opencv_core.GpuMatVector mv)

mixChannels
```
@Namespace(value="cv")
public static void mixChannels(@Const
                                                      opencv_core.Mat src,
                                                      @Cast(value="size_t")
                                                      long nsrcs,
                                                      opencv_core.Mat dst,
                                                      @Cast(value="size_t")
                                                      long ndsts,
                                                      @Const
                                                      org.bytedeco.javacpp.IntPointer fromTo,
                                                      @Cast(value="size_t")
                                                      long npairs)
```
\brief Copies specified channels from input arrays to the specified channels of output arrays.
The function cv::mixChannels provides an advanced mechanism for shuffling image channels.
cv::split,cv::merge,cv::extractChannel,cv::insertChannel and some forms of cv::cvtColor are partial cases of cv::mixChannels.
In the example below, the code splits a 4-channel BGRA image into a 3-channel BGR (with B and R channels swapped) and a separate alpha-channel image:
```
 {.cpp}
    Mat bgra( 100, 100, CV_8UC4, Scalar(255,0,0,255) );
    Mat bgr( bgra.rows, bgra.cols, CV_8UC3 );
    Mat alpha( bgra.rows, bgra.cols, CV_8UC1 );

    // forming an array of matrices is a quite efficient operation,
    // because the matrix data is not copied, only the headers
    Mat out[] = { bgr, alpha };
    // bgra[0] -> bgr[2], bgra[1] -> bgr[1],
    // bgra[2] -> bgr[0], bgra[3] -> alpha[0]
    int from_to[] = { 0,2, 1,1, 2,0, 3,3 };
    mixChannels( &bgra, 1, out, 2, from_to, 4 );
```
\note Unlike many other new-style C++ functions in OpenCV (see the introduction section and Mat::create ), cv::mixChannels requires the output arrays to be pre-allocated before calling the function.
Parameters:

src - input array or vector of matrices; all of the matrices must have the same size and the same depth.

nsrcs - number of matrices in src.

dst - output array or vector of matrices; all the matrices **must be allocated**; their size and depth must be the same as in src[0].

ndsts - number of matrices in dst.

fromTo - array of index pairs specifying which channels are copied and where; fromTo[k\*2] is a 0-based index of the input channel in src, fromTo[k\*2+1] is an index of the output channel in dst; the continuous channel numbering is used: the first input image channels are indexed from 0 to src[0].channels()-1, the second input image channels are indexed from src[0].channels() to src[0].channels() + src[1].channels()-1, and so on, the same scheme is used for the output image channels; as a special case, when fromTo[k\*2] is negative, the corresponding output channel is filled with zero .

npairs - number of index pairs in fromTo. \sa split, merge, extractChannel, insertChannel, cvtColor

mixChannels

@Namespace(value="cv")
public static void mixChannels(@Const
                                                      opencv_core.Mat src,
                                                      @Cast(value="size_t")
                                                      long nsrcs,
                                                      opencv_core.Mat dst,
                                                      @Cast(value="size_t")
                                                      long ndsts,
                                                      @Const
                                                      IntBuffer fromTo,
                                                      @Cast(value="size_t")
                                                      long npairs)

mixChannels

@Namespace(value="cv")
public static void mixChannels(@Const
                                                      opencv_core.Mat src,
                                                      @Cast(value="size_t")
                                                      long nsrcs,
                                                      opencv_core.Mat dst,
                                                      @Cast(value="size_t")
                                                      long ndsts,
                                                      @Const
                                                      int[] fromTo,
                                                      @Cast(value="size_t")
                                                      long npairs)

mixChannels
```
@Namespace(value="cv")
public static void mixChannels(@ByVal
                                                      opencv_core.MatVector src,
                                                      @ByVal
                                                      opencv_core.MatVector dst,
                                                      @Const
                                                      org.bytedeco.javacpp.IntPointer fromTo,
                                                      @Cast(value="size_t")
                                                      long npairs)
```
\overload

Parameters:

src - input array or vector of matrices; all of the matrices must have the same size and the same depth.

dst - output array or vector of matrices; all the matrices **must be allocated**; their size and depth must be the same as in src[0].

fromTo - array of index pairs specifying which channels are copied and where; fromTo[k\*2] is a 0-based index of the input channel in src, fromTo[k\*2+1] is an index of the output channel in dst; the continuous channel numbering is used: the first input image channels are indexed from 0 to src[0].channels()-1, the second input image channels are indexed from src[0].channels() to src[0].channels() + src[1].channels()-1, and so on, the same scheme is used for the output image channels; as a special case, when fromTo[k\*2] is negative, the corresponding output channel is filled with zero .

npairs - number of index pairs in fromTo.

mixChannels

@Namespace(value="cv")
public static void mixChannels(@ByVal
                                                      opencv_core.UMatVector src,
                                                      @ByVal
                                                      opencv_core.UMatVector dst,
                                                      @Const
                                                      IntBuffer fromTo,
                                                      @Cast(value="size_t")
                                                      long npairs)

mixChannels

@Namespace(value="cv")
public static void mixChannels(@ByVal
                                                      opencv_core.GpuMatVector src,
                                                      @ByVal
                                                      opencv_core.GpuMatVector dst,
                                                      @Const
                                                      int[] fromTo,
                                                      @Cast(value="size_t")
                                                      long npairs)

mixChannels
```
@Namespace(value="cv")
public static void mixChannels(@ByVal
                                                      opencv_core.MatVector src,
                                                      @ByVal
                                                      opencv_core.MatVector dst,
                                                      @StdVector
                                                      org.bytedeco.javacpp.IntPointer fromTo)
```
\overload

Parameters:

src - input array or vector of matrices; all of the matrices must have the same size and the same depth.

dst - output array or vector of matrices; all the matrices **must be allocated**; their size and depth must be the same as in src[0].

fromTo - array of index pairs specifying which channels are copied and where; fromTo[k\*2] is a 0-based index of the input channel in src, fromTo[k\*2+1] is an index of the output channel in dst; the continuous channel numbering is used: the first input image channels are indexed from 0 to src[0].channels()-1, the second input image channels are indexed from src[0].channels() to src[0].channels() + src[1].channels()-1, and so on, the same scheme is used for the output image channels; as a special case, when fromTo[k\*2] is negative, the corresponding output channel is filled with zero .

mixChannels

@Namespace(value="cv")
public static void mixChannels(@ByVal
                                                      opencv_core.UMatVector src,
                                                      @ByVal
                                                      opencv_core.UMatVector dst,
                                                      @StdVector
                                                      IntBuffer fromTo)

mixChannels

@Namespace(value="cv")
public static void mixChannels(@ByVal
                                                      opencv_core.GpuMatVector src,
                                                      @ByVal
                                                      opencv_core.GpuMatVector dst,
                                                      @StdVector
                                                      int[] fromTo)

extractChannel

@Namespace(value="cv")
public static void extractChannel(@ByVal
                                                         opencv_core.Mat src,
                                                         @ByVal
                                                         opencv_core.Mat dst,
                                                         int coi)

\brief Extracts a single channel from src (coi is 0-based index)

Parameters:: src - input array; dst - output array; coi - index of channel to extract \sa mixChannels, split

extractChannel

@Namespace(value="cv")
public static void extractChannel(@ByVal
                                                         opencv_core.UMat src,
                                                         @ByVal
                                                         opencv_core.UMat dst,
                                                         int coi)

extractChannel

@Namespace(value="cv")
public static void extractChannel(@ByVal
                                                         opencv_core.GpuMat src,
                                                         @ByVal
                                                         opencv_core.GpuMat dst,
                                                         int coi)

insertChannel

@Namespace(value="cv")
public static void insertChannel(@ByVal
                                                        opencv_core.Mat src,
                                                        @ByVal
                                                        opencv_core.Mat dst,
                                                        int coi)

\brief Inserts a single channel to dst (coi is 0-based index)

Parameters:: src - input array; dst - output array; coi - index of channel for insertion \sa mixChannels, merge

insertChannel

@Namespace(value="cv")
public static void insertChannel(@ByVal
                                                        opencv_core.UMat src,
                                                        @ByVal
                                                        opencv_core.UMat dst,
                                                        int coi)

insertChannel

@Namespace(value="cv")
public static void insertChannel(@ByVal
                                                        opencv_core.GpuMat src,
                                                        @ByVal
                                                        opencv_core.GpuMat dst,
                                                        int coi)

flip
```
@Namespace(value="cv")
public static void flip(@ByVal
                                               opencv_core.Mat src,
                                               @ByVal
                                               opencv_core.Mat dst,
                                               int flipCode)
```
\brief Flips a 2D array around vertical, horizontal, or both axes.
The function cv::flip flips the array in one of three different ways (row and column indices are 0-based): \f[\texttt{dst} _{ij} = \left\{ \begin{array}{l l} \texttt{src} _{\texttt{src.rows}-i-1,j} & if\; \texttt{flipCode} = 0 \\ \texttt{src} _{i, \texttt{src.cols} -j-1} & if\; \texttt{flipCode} > 0 \\ \texttt{src} _{ \texttt{src.rows} -i-1, \texttt{src.cols} -j-1} & if\; \texttt{flipCode} < 0 \\ \end{array} \right.\f] The example scenarios of using the function are the following: Vertical flipping of the image (flipCode == 0) to switch between top-left and bottom-left image origin. This is a typical operation in video processing on Microsoft Windows\* OS. Horizontal flipping of the image with the subsequent horizontal shift and absolute difference calculation to check for a vertical-axis symmetry (flipCode \> 0). Simultaneous horizontal and vertical flipping of the image with the subsequent shift and absolute difference calculation to check for a central symmetry (flipCode \< 0). Reversing the order of point arrays (flipCode \> 0 or flipCode == 0).

Parameters:

src - input array.

dst - output array of the same size and type as src.

flipCode - a flag to specify how to flip the array; 0 means flipping around the x-axis and positive value (for example, 1) means flipping around y-axis. Negative value (for example, -1) means flipping around both axes. \sa transpose , repeat , completeSymm

flip

@Namespace(value="cv")
public static void flip(@ByVal
                                               opencv_core.UMat src,
                                               @ByVal
                                               opencv_core.UMat dst,
                                               int flipCode)

flip

@Namespace(value="cv")
public static void flip(@ByVal
                                               opencv_core.GpuMat src,
                                               @ByVal
                                               opencv_core.GpuMat dst,
                                               int flipCode)

rotate
```
@Namespace(value="cv")
public static void rotate(@ByVal
                                                 opencv_core.Mat src,
                                                 @ByVal
                                                 opencv_core.Mat dst,
                                                 int rotateCode)
```
\brief Rotates a 2D array in multiples of 90 degrees. The function cv::rotate rotates the array in one of three different ways: Rotate by 90 degrees clockwise (rotateCode = ROTATE_90_CLOCKWISE). Rotate by 180 degrees clockwise (rotateCode = ROTATE_180). Rotate by 270 degrees clockwise (rotateCode = ROTATE_90_COUNTERCLOCKWISE).

Parameters:

src - input array.

dst - output array of the same type as src. The size is the same with ROTATE_180, and the rows and cols are switched for ROTATE_90_CLOCKWISE and ROTATE_90_COUNTERCLOCKWISE.

rotateCode - an enum to specify how to rotate the array; see the enum #RotateFlags \sa transpose , repeat , completeSymm, flip, RotateFlags

rotate

@Namespace(value="cv")
public static void rotate(@ByVal
                                                 opencv_core.UMat src,
                                                 @ByVal
                                                 opencv_core.UMat dst,
                                                 int rotateCode)

rotate

@Namespace(value="cv")
public static void rotate(@ByVal
                                                 opencv_core.GpuMat src,
                                                 @ByVal
                                                 opencv_core.GpuMat dst,
                                                 int rotateCode)

repeat
```
@Namespace(value="cv")
public static void repeat(@ByVal
                                                 opencv_core.Mat src,
                                                 int ny,
                                                 int nx,
                                                 @ByVal
                                                 opencv_core.Mat dst)
```
\brief Fills the output array with repeated copies of the input array.
The function cv::repeat duplicates the input array one or more times along each of the two axes: \f[\texttt{dst} _{ij}= \texttt{src} _{i\mod src.rows, \; j\mod src.cols }\f] The second variant of the function is more convenient to use with \ref MatrixExpressions.

Parameters:

src - input array to replicate.

ny - Flag to specify how many times the src is repeated along the vertical axis.

nx - Flag to specify how many times the src is repeated along the horizontal axis.

dst - output array of the same type as src. \sa cv::reduce

repeat

@Namespace(value="cv")
public static void repeat(@ByVal
                                                 opencv_core.UMat src,
                                                 int ny,
                                                 int nx,
                                                 @ByVal
                                                 opencv_core.UMat dst)

repeat

@Namespace(value="cv")
public static void repeat(@ByVal
                                                 opencv_core.GpuMat src,
                                                 int ny,
                                                 int nx,
                                                 @ByVal
                                                 opencv_core.GpuMat dst)

repeat

@Namespace(value="cv")
 @ByVal
public static opencv_core.Mat repeat(@Const @ByRef
                                                                    opencv_core.Mat src,
                                                                    int ny,
                                                                    int nx)

\overload

Parameters:: src - input array to replicate.; ny - Flag to specify how many times the src is repeated along the vertical axis.; nx - Flag to specify how many times the src is repeated along the horizontal axis.

hconcat

@Namespace(value="cv")
public static void hconcat(@Const
                                                  opencv_core.Mat src,
                                                  @Cast(value="size_t")
                                                  long nsrc,
                                                  @ByVal
                                                  opencv_core.Mat dst)

\brief Applies horizontal concatenation to given matrices.

The function horizontally concatenates two or more cv::Mat matrices (with the same number of rows).

 {.cpp}
    cv::Mat matArray[] = { cv::Mat(4, 1, CV_8UC1, cv::Scalar(1)),
                           cv::Mat(4, 1, CV_8UC1, cv::Scalar(2)),
                           cv::Mat(4, 1, CV_8UC1, cv::Scalar(3)),};

    cv::Mat out;
    cv::hconcat( matArray, 3, out );
    //out:
    //[1, 2, 3;
    // 1, 2, 3;
    // 1, 2, 3;
    // 1, 2, 3]

Parameters:: src - input array or vector of matrices. all of the matrices must have the same number of rows and the same depth.; nsrc - number of matrices in src.; dst - output array. It has the same number of rows and depth as the src, and the sum of cols of the src. \sa cv::vconcat(const Mat*, size_t, OutputArray), \sa cv::vconcat(InputArrayOfArrays, OutputArray) and \sa cv::vconcat(InputArray, InputArray, OutputArray)

hconcat

@Namespace(value="cv")
public static void hconcat(@Const
                                                  opencv_core.Mat src,
                                                  @Cast(value="size_t")
                                                  long nsrc,
                                                  @ByVal
                                                  opencv_core.UMat dst)

hconcat

@Namespace(value="cv")
public static void hconcat(@Const
                                                  opencv_core.Mat src,
                                                  @Cast(value="size_t")
                                                  long nsrc,
                                                  @ByVal
                                                  opencv_core.GpuMat dst)

hconcat

@Namespace(value="cv")
public static void hconcat(@ByVal
                                                  opencv_core.Mat src1,
                                                  @ByVal
                                                  opencv_core.Mat src2,
                                                  @ByVal
                                                  opencv_core.Mat dst)

\overload

 {.cpp}
    cv::Mat_<float> A = (cv::Mat_<float>(3, 2) << 1, 4,
                                                  2, 5,
                                                  3, 6);
    cv::Mat_<float> B = (cv::Mat_<float>(3, 2) << 7, 10,
                                                  8, 11,
                                                  9, 12);

    cv::Mat C;
    cv::hconcat(A, B, C);
    //C:
    //[1, 4, 7, 10;
    // 2, 5, 8, 11;
    // 3, 6, 9, 12]

Parameters:: src1 - first input array to be considered for horizontal concatenation.; src2 - second input array to be considered for horizontal concatenation.; dst - output array. It has the same number of rows and depth as the src1 and src2, and the sum of cols of the src1 and src2.

hconcat

@Namespace(value="cv")
public static void hconcat(@ByVal
                                                  opencv_core.UMat src1,
                                                  @ByVal
                                                  opencv_core.UMat src2,
                                                  @ByVal
                                                  opencv_core.UMat dst)

hconcat

@Namespace(value="cv")
public static void hconcat(@ByVal
                                                  opencv_core.GpuMat src1,
                                                  @ByVal
                                                  opencv_core.GpuMat src2,
                                                  @ByVal
                                                  opencv_core.GpuMat dst)

hconcat

@Namespace(value="cv")
public static void hconcat(@ByVal
                                                  opencv_core.MatVector src,
                                                  @ByVal
                                                  opencv_core.Mat dst)

\overload

 {.cpp}
    std::vector<cv::Mat> matrices = { cv::Mat(4, 1, CV_8UC1, cv::Scalar(1)),
                                      cv::Mat(4, 1, CV_8UC1, cv::Scalar(2)),
                                      cv::Mat(4, 1, CV_8UC1, cv::Scalar(3)),};

    cv::Mat out;
    cv::hconcat( matrices, out );
    //out:
    //[1, 2, 3;
    // 1, 2, 3;
    // 1, 2, 3;
    // 1, 2, 3]

Parameters:: src - input array or vector of matrices. all of the matrices must have the same number of rows and the same depth.; dst - output array. It has the same number of rows and depth as the src, and the sum of cols of the src. same depth.

hconcat

@Namespace(value="cv")
public static void hconcat(@ByVal
                                                  opencv_core.UMatVector src,
                                                  @ByVal
                                                  opencv_core.Mat dst)

hconcat

@Namespace(value="cv")
public static void hconcat(@ByVal
                                                  opencv_core.GpuMatVector src,
                                                  @ByVal
                                                  opencv_core.Mat dst)

hconcat

@Namespace(value="cv")
public static void hconcat(@ByVal
                                                  opencv_core.MatVector src,
                                                  @ByVal
                                                  opencv_core.UMat dst)

hconcat

@Namespace(value="cv")
public static void hconcat(@ByVal
                                                  opencv_core.UMatVector src,
                                                  @ByVal
                                                  opencv_core.UMat dst)

hconcat

@Namespace(value="cv")
public static void hconcat(@ByVal
                                                  opencv_core.GpuMatVector src,
                                                  @ByVal
                                                  opencv_core.UMat dst)

hconcat

@Namespace(value="cv")
public static void hconcat(@ByVal
                                                  opencv_core.MatVector src,
                                                  @ByVal
                                                  opencv_core.GpuMat dst)

hconcat

@Namespace(value="cv")
public static void hconcat(@ByVal
                                                  opencv_core.UMatVector src,
                                                  @ByVal
                                                  opencv_core.GpuMat dst)

hconcat

@Namespace(value="cv")
public static void hconcat(@ByVal
                                                  opencv_core.GpuMatVector src,
                                                  @ByVal
                                                  opencv_core.GpuMat dst)

vconcat

@Namespace(value="cv")
public static void vconcat(@Const
                                                  opencv_core.Mat src,
                                                  @Cast(value="size_t")
                                                  long nsrc,
                                                  @ByVal
                                                  opencv_core.Mat dst)

\brief Applies vertical concatenation to given matrices.

The function vertically concatenates two or more cv::Mat matrices (with the same number of cols).

 {.cpp}
    cv::Mat matArray[] = { cv::Mat(1, 4, CV_8UC1, cv::Scalar(1)),
                           cv::Mat(1, 4, CV_8UC1, cv::Scalar(2)),
                           cv::Mat(1, 4, CV_8UC1, cv::Scalar(3)),};

    cv::Mat out;
    cv::vconcat( matArray, 3, out );
    //out:
    //[1,   1,   1,   1;
    // 2,   2,   2,   2;
    // 3,   3,   3,   3]

Parameters:: src - input array or vector of matrices. all of the matrices must have the same number of cols and the same depth.; nsrc - number of matrices in src.; dst - output array. It has the same number of cols and depth as the src, and the sum of rows of the src. \sa cv::hconcat(const Mat*, size_t, OutputArray), \sa cv::hconcat(InputArrayOfArrays, OutputArray) and \sa cv::hconcat(InputArray, InputArray, OutputArray)

vconcat

@Namespace(value="cv")
public static void vconcat(@Const
                                                  opencv_core.Mat src,
                                                  @Cast(value="size_t")
                                                  long nsrc,
                                                  @ByVal
                                                  opencv_core.UMat dst)

vconcat

@Namespace(value="cv")
public static void vconcat(@Const
                                                  opencv_core.Mat src,
                                                  @Cast(value="size_t")
                                                  long nsrc,
                                                  @ByVal
                                                  opencv_core.GpuMat dst)

vconcat

@Namespace(value="cv")
public static void vconcat(@ByVal
                                                  opencv_core.Mat src1,
                                                  @ByVal
                                                  opencv_core.Mat src2,
                                                  @ByVal
                                                  opencv_core.Mat dst)

\overload

 {.cpp}
    cv::Mat_<float> A = (cv::Mat_<float>(3, 2) << 1, 7,
                                                  2, 8,
                                                  3, 9);
    cv::Mat_<float> B = (cv::Mat_<float>(3, 2) << 4, 10,
                                                  5, 11,
                                                  6, 12);

    cv::Mat C;
    cv::vconcat(A, B, C);
    //C:
    //[1, 7;
    // 2, 8;
    // 3, 9;
    // 4, 10;
    // 5, 11;
    // 6, 12]

Parameters:: src1 - first input array to be considered for vertical concatenation.; src2 - second input array to be considered for vertical concatenation.; dst - output array. It has the same number of cols and depth as the src1 and src2, and the sum of rows of the src1 and src2.

vconcat

@Namespace(value="cv")
public static void vconcat(@ByVal
                                                  opencv_core.UMat src1,
                                                  @ByVal
                                                  opencv_core.UMat src2,
                                                  @ByVal
                                                  opencv_core.UMat dst)

vconcat

@Namespace(value="cv")
public static void vconcat(@ByVal
                                                  opencv_core.GpuMat src1,
                                                  @ByVal
                                                  opencv_core.GpuMat src2,
                                                  @ByVal
                                                  opencv_core.GpuMat dst)

vconcat

@Namespace(value="cv")
public static void vconcat(@ByVal
                                                  opencv_core.MatVector src,
                                                  @ByVal
                                                  opencv_core.Mat dst)

\overload

 {.cpp}
    std::vector<cv::Mat> matrices = { cv::Mat(1, 4, CV_8UC1, cv::Scalar(1)),
                                      cv::Mat(1, 4, CV_8UC1, cv::Scalar(2)),
                                      cv::Mat(1, 4, CV_8UC1, cv::Scalar(3)),};

    cv::Mat out;
    cv::vconcat( matrices, out );
    //out:
    //[1,   1,   1,   1;
    // 2,   2,   2,   2;
    // 3,   3,   3,   3]

Parameters:: src - input array or vector of matrices. all of the matrices must have the same number of cols and the same depth; dst - output array. It has the same number of cols and depth as the src, and the sum of rows of the src. same depth.

vconcat

@Namespace(value="cv")
public static void vconcat(@ByVal
                                                  opencv_core.UMatVector src,
                                                  @ByVal
                                                  opencv_core.Mat dst)

vconcat

@Namespace(value="cv")
public static void vconcat(@ByVal
                                                  opencv_core.GpuMatVector src,
                                                  @ByVal
                                                  opencv_core.Mat dst)

vconcat

@Namespace(value="cv")
public static void vconcat(@ByVal
                                                  opencv_core.MatVector src,
                                                  @ByVal
                                                  opencv_core.UMat dst)

vconcat

@Namespace(value="cv")
public static void vconcat(@ByVal
                                                  opencv_core.UMatVector src,
                                                  @ByVal
                                                  opencv_core.UMat dst)

vconcat

@Namespace(value="cv")
public static void vconcat(@ByVal
                                                  opencv_core.GpuMatVector src,
                                                  @ByVal
                                                  opencv_core.UMat dst)

vconcat

@Namespace(value="cv")
public static void vconcat(@ByVal
                                                  opencv_core.MatVector src,
                                                  @ByVal
                                                  opencv_core.GpuMat dst)

vconcat

@Namespace(value="cv")
public static void vconcat(@ByVal
                                                  opencv_core.UMatVector src,
                                                  @ByVal
                                                  opencv_core.GpuMat dst)

vconcat

@Namespace(value="cv")
public static void vconcat(@ByVal
                                                  opencv_core.GpuMatVector src,
                                                  @ByVal
                                                  opencv_core.GpuMat dst)

bitwise_and
```
@Namespace(value="cv")
public static void bitwise_and(@ByVal
                                                      opencv_core.Mat src1,
                                                      @ByVal
                                                      opencv_core.Mat src2,
                                                      @ByVal
                                                      opencv_core.Mat dst,
                                                      @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                      opencv_core.Mat mask)
```
\brief computes bitwise conjunction of the two arrays (dst = src1 & src2) Calculates the per-element bit-wise conjunction of two arrays or an array and a scalar.
The function cv::bitwise_and calculates the per-element bit-wise logical conjunction for: Two arrays when src1 and src2 have the same size: \f[\texttt{dst} (I) = \texttt{src1} (I) \wedge \texttt{src2} (I) \quad \texttt{if mask} (I) \ne0\f] An array and a scalar when src2 is constructed from Scalar or has the same number of elements as src1.channels(): \f[\texttt{dst} (I) = \texttt{src1} (I) \wedge \texttt{src2} \quad \texttt{if mask} (I) \ne0\f] A scalar and an array when src1 is constructed from Scalar or has the same number of elements as src2.channels(): \f[\texttt{dst} (I) = \texttt{src1} \wedge \texttt{src2} (I) \quad \texttt{if mask} (I) \ne0\f] In case of floating-point arrays, their machine-specific bit representations (usually IEEE754-compliant) are used for the operation. In case of multi-channel arrays, each channel is processed independently. In the second and third cases above, the scalar is first converted to the array type.

Parameters:

src1 - first input array or a scalar.

src2 - second input array or a scalar.

dst - output array that has the same size and type as the input arrays.

mask - optional operation mask, 8-bit single channel array, that specifies elements of the output array to be changed.

bitwise_and

@Namespace(value="cv")
public static void bitwise_and(@ByVal
                                                      opencv_core.Mat src1,
                                                      @ByVal
                                                      opencv_core.Mat src2,
                                                      @ByVal
                                                      opencv_core.Mat dst)

bitwise_and

@Namespace(value="cv")
public static void bitwise_and(@ByVal
                                                      opencv_core.UMat src1,
                                                      @ByVal
                                                      opencv_core.UMat src2,
                                                      @ByVal
                                                      opencv_core.UMat dst,
                                                      @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                      opencv_core.UMat mask)

bitwise_and

@Namespace(value="cv")
public static void bitwise_and(@ByVal
                                                      opencv_core.UMat src1,
                                                      @ByVal
                                                      opencv_core.UMat src2,
                                                      @ByVal
                                                      opencv_core.UMat dst)

bitwise_and

@Namespace(value="cv")
public static void bitwise_and(@ByVal
                                                      opencv_core.GpuMat src1,
                                                      @ByVal
                                                      opencv_core.GpuMat src2,
                                                      @ByVal
                                                      opencv_core.GpuMat dst,
                                                      @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                      opencv_core.GpuMat mask)

bitwise_and

@Namespace(value="cv")
public static void bitwise_and(@ByVal
                                                      opencv_core.GpuMat src1,
                                                      @ByVal
                                                      opencv_core.GpuMat src2,
                                                      @ByVal
                                                      opencv_core.GpuMat dst)

bitwise_or
```
@Namespace(value="cv")
public static void bitwise_or(@ByVal
                                                     opencv_core.Mat src1,
                                                     @ByVal
                                                     opencv_core.Mat src2,
                                                     @ByVal
                                                     opencv_core.Mat dst,
                                                     @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                     opencv_core.Mat mask)
```
\brief Calculates the per-element bit-wise disjunction of two arrays or an array and a scalar.
The function cv::bitwise_or calculates the per-element bit-wise logical disjunction for: Two arrays when src1 and src2 have the same size: \f[\texttt{dst} (I) = \texttt{src1} (I) \vee \texttt{src2} (I) \quad \texttt{if mask} (I) \ne0\f] An array and a scalar when src2 is constructed from Scalar or has the same number of elements as src1.channels(): \f[\texttt{dst} (I) = \texttt{src1} (I) \vee \texttt{src2} \quad \texttt{if mask} (I) \ne0\f] A scalar and an array when src1 is constructed from Scalar or has the same number of elements as src2.channels(): \f[\texttt{dst} (I) = \texttt{src1} \vee \texttt{src2} (I) \quad \texttt{if mask} (I) \ne0\f] In case of floating-point arrays, their machine-specific bit representations (usually IEEE754-compliant) are used for the operation. In case of multi-channel arrays, each channel is processed independently. In the second and third cases above, the scalar is first converted to the array type.

Parameters:

src1 - first input array or a scalar.

src2 - second input array or a scalar.

dst - output array that has the same size and type as the input arrays.

mask - optional operation mask, 8-bit single channel array, that specifies elements of the output array to be changed.

bitwise_or

@Namespace(value="cv")
public static void bitwise_or(@ByVal
                                                     opencv_core.Mat src1,
                                                     @ByVal
                                                     opencv_core.Mat src2,
                                                     @ByVal
                                                     opencv_core.Mat dst)

bitwise_or

@Namespace(value="cv")
public static void bitwise_or(@ByVal
                                                     opencv_core.UMat src1,
                                                     @ByVal
                                                     opencv_core.UMat src2,
                                                     @ByVal
                                                     opencv_core.UMat dst,
                                                     @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                     opencv_core.UMat mask)

bitwise_or

@Namespace(value="cv")
public static void bitwise_or(@ByVal
                                                     opencv_core.UMat src1,
                                                     @ByVal
                                                     opencv_core.UMat src2,
                                                     @ByVal
                                                     opencv_core.UMat dst)

bitwise_or

@Namespace(value="cv")
public static void bitwise_or(@ByVal
                                                     opencv_core.GpuMat src1,
                                                     @ByVal
                                                     opencv_core.GpuMat src2,
                                                     @ByVal
                                                     opencv_core.GpuMat dst,
                                                     @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                     opencv_core.GpuMat mask)

bitwise_or

@Namespace(value="cv")
public static void bitwise_or(@ByVal
                                                     opencv_core.GpuMat src1,
                                                     @ByVal
                                                     opencv_core.GpuMat src2,
                                                     @ByVal
                                                     opencv_core.GpuMat dst)

bitwise_xor
```
@Namespace(value="cv")
public static void bitwise_xor(@ByVal
                                                      opencv_core.Mat src1,
                                                      @ByVal
                                                      opencv_core.Mat src2,
                                                      @ByVal
                                                      opencv_core.Mat dst,
                                                      @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                      opencv_core.Mat mask)
```
\brief Calculates the per-element bit-wise "exclusive or" operation on two arrays or an array and a scalar.
The function cv::bitwise_xor calculates the per-element bit-wise logical "exclusive-or" operation for: Two arrays when src1 and src2 have the same size: \f[\texttt{dst} (I) = \texttt{src1} (I) \oplus \texttt{src2} (I) \quad \texttt{if mask} (I) \ne0\f] An array and a scalar when src2 is constructed from Scalar or has the same number of elements as src1.channels(): \f[\texttt{dst} (I) = \texttt{src1} (I) \oplus \texttt{src2} \quad \texttt{if mask} (I) \ne0\f] A scalar and an array when src1 is constructed from Scalar or has the same number of elements as src2.channels(): \f[\texttt{dst} (I) = \texttt{src1} \oplus \texttt{src2} (I) \quad \texttt{if mask} (I) \ne0\f] In case of floating-point arrays, their machine-specific bit representations (usually IEEE754-compliant) are used for the operation. In case of multi-channel arrays, each channel is processed independently. In the 2nd and 3rd cases above, the scalar is first converted to the array type.

Parameters:

src1 - first input array or a scalar.

src2 - second input array or a scalar.

dst - output array that has the same size and type as the input arrays.

mask - optional operation mask, 8-bit single channel array, that specifies elements of the output array to be changed.

bitwise_xor

@Namespace(value="cv")
public static void bitwise_xor(@ByVal
                                                      opencv_core.Mat src1,
                                                      @ByVal
                                                      opencv_core.Mat src2,
                                                      @ByVal
                                                      opencv_core.Mat dst)

bitwise_xor

@Namespace(value="cv")
public static void bitwise_xor(@ByVal
                                                      opencv_core.UMat src1,
                                                      @ByVal
                                                      opencv_core.UMat src2,
                                                      @ByVal
                                                      opencv_core.UMat dst,
                                                      @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                      opencv_core.UMat mask)

bitwise_xor

@Namespace(value="cv")
public static void bitwise_xor(@ByVal
                                                      opencv_core.UMat src1,
                                                      @ByVal
                                                      opencv_core.UMat src2,
                                                      @ByVal
                                                      opencv_core.UMat dst)

bitwise_xor

@Namespace(value="cv")
public static void bitwise_xor(@ByVal
                                                      opencv_core.GpuMat src1,
                                                      @ByVal
                                                      opencv_core.GpuMat src2,
                                                      @ByVal
                                                      opencv_core.GpuMat dst,
                                                      @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                      opencv_core.GpuMat mask)

bitwise_xor

@Namespace(value="cv")
public static void bitwise_xor(@ByVal
                                                      opencv_core.GpuMat src1,
                                                      @ByVal
                                                      opencv_core.GpuMat src2,
                                                      @ByVal
                                                      opencv_core.GpuMat dst)

bitwise_not

@Namespace(value="cv")
public static void bitwise_not(@ByVal
                                                      opencv_core.Mat src,
                                                      @ByVal
                                                      opencv_core.Mat dst,
                                                      @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                      opencv_core.Mat mask)

\brief Inverts every bit of an array.

The function cv::bitwise_not calculates per-element bit-wise inversion of the input array: \f[\texttt{dst} (I) = \neg \texttt{src} (I)\f] In case of a floating-point input array, its machine-specific bit representation (usually IEEE754-compliant) is used for the operation. In case of multi-channel arrays, each channel is processed independently.

Parameters:: src - input array.; dst - output array that has the same size and type as the input array.; mask - optional operation mask, 8-bit single channel array, that specifies elements of the output array to be changed.

bitwise_not

@Namespace(value="cv")
public static void bitwise_not(@ByVal
                                                      opencv_core.Mat src,
                                                      @ByVal
                                                      opencv_core.Mat dst)

bitwise_not

@Namespace(value="cv")
public static void bitwise_not(@ByVal
                                                      opencv_core.UMat src,
                                                      @ByVal
                                                      opencv_core.UMat dst,
                                                      @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                      opencv_core.UMat mask)

bitwise_not

@Namespace(value="cv")
public static void bitwise_not(@ByVal
                                                      opencv_core.UMat src,
                                                      @ByVal
                                                      opencv_core.UMat dst)

bitwise_not

@Namespace(value="cv")
public static void bitwise_not(@ByVal
                                                      opencv_core.GpuMat src,
                                                      @ByVal
                                                      opencv_core.GpuMat dst,
                                                      @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                      opencv_core.GpuMat mask)

bitwise_not

@Namespace(value="cv")
public static void bitwise_not(@ByVal
                                                      opencv_core.GpuMat src,
                                                      @ByVal
                                                      opencv_core.GpuMat dst)

absdiff
```
@Namespace(value="cv")
public static void absdiff(@ByVal
                                                  opencv_core.Mat src1,
                                                  @ByVal
                                                  opencv_core.Mat src2,
                                                  @ByVal
                                                  opencv_core.Mat dst)
```
\brief Calculates the per-element absolute difference between two arrays or between an array and a scalar.
The function cv::absdiff calculates: Absolute difference between two arrays when they have the same size and type: \f[\texttt{dst}(I) = \texttt{saturate} (| \texttt{src1}(I) - \texttt{src2}(I)|)\f] Absolute difference between an array and a scalar when the second array is constructed from Scalar or has as many elements as the number of channels in src1: \f[\texttt{dst}(I) = \texttt{saturate} (| \texttt{src1}(I) - \texttt{src2} |)\f] Absolute difference between a scalar and an array when the first array is constructed from Scalar or has as many elements as the number of channels in src2: \f[\texttt{dst}(I) = \texttt{saturate} (| \texttt{src1} - \texttt{src2}(I) |)\f] where I is a multi-dimensional index of array elements. In case of multi-channel arrays, each channel is processed independently. \note Saturation is not applied when the arrays have the depth CV_32S. You may even get a negative value in the case of overflow.

Parameters:

src1 - first input array or a scalar.

src2 - second input array or a scalar.

dst - output array that has the same size and type as input arrays. \sa cv::abs(const Mat&)

absdiff

@Namespace(value="cv")
public static void absdiff(@ByVal
                                                  opencv_core.UMat src1,
                                                  @ByVal
                                                  opencv_core.UMat src2,
                                                  @ByVal
                                                  opencv_core.UMat dst)

absdiff

@Namespace(value="cv")
public static void absdiff(@ByVal
                                                  opencv_core.GpuMat src1,
                                                  @ByVal
                                                  opencv_core.GpuMat src2,
                                                  @ByVal
                                                  opencv_core.GpuMat dst)

inRange
```
@Namespace(value="cv")
public static void inRange(@ByVal
                                                  opencv_core.Mat src,
                                                  @ByVal
                                                  opencv_core.Mat lowerb,
                                                  @ByVal
                                                  opencv_core.Mat upperb,
                                                  @ByVal
                                                  opencv_core.Mat dst)
```
\brief Checks if array elements lie between the elements of two other arrays.
The function checks the range as follows: - For every element of a single-channel input array: \f[\texttt{dst} (I)= \texttt{lowerb} (I)_0 \leq \texttt{src} (I)_0 \leq \texttt{upperb} (I)_0\f] - For two-channel arrays: \f[\texttt{dst} (I)= \texttt{lowerb} (I)_0 \leq \texttt{src} (I)_0 \leq \texttt{upperb} (I)_0 \land \texttt{lowerb} (I)_1 \leq \texttt{src} (I)_1 \leq \texttt{upperb} (I)_1\f] - and so forth.
That is, dst (I) is set to 255 (all 1 -bits) if src (I) is within the specified 1D, 2D, 3D, ... box and 0 otherwise.
When the lower and/or upper boundary parameters are scalars, the indexes (I) at lowerb and upperb in the above formulas should be omitted.

Parameters:

src - first input array.

lowerb - inclusive lower boundary array or a scalar.

upperb - inclusive upper boundary array or a scalar.

dst - output array of the same size as src and CV_8U type.

inRange

@Namespace(value="cv")
public static void inRange(@ByVal
                                                  opencv_core.UMat src,
                                                  @ByVal
                                                  opencv_core.UMat lowerb,
                                                  @ByVal
                                                  opencv_core.UMat upperb,
                                                  @ByVal
                                                  opencv_core.UMat dst)

inRange

@Namespace(value="cv")
public static void inRange(@ByVal
                                                  opencv_core.GpuMat src,
                                                  @ByVal
                                                  opencv_core.GpuMat lowerb,
                                                  @ByVal
                                                  opencv_core.GpuMat upperb,
                                                  @ByVal
                                                  opencv_core.GpuMat dst)

compare
```
@Namespace(value="cv")
public static void compare(@ByVal
                                                  opencv_core.Mat src1,
                                                  @ByVal
                                                  opencv_core.Mat src2,
                                                  @ByVal
                                                  opencv_core.Mat dst,
                                                  int cmpop)
```
\brief Performs the per-element comparison of two arrays or an array and scalar value.
The function compares: Elements of two arrays when src1 and src2 have the same size: \f[\texttt{dst} (I) = \texttt{src1} (I) \,\texttt{cmpop}\, \texttt{src2} (I)\f] Elements of src1 with a scalar src2 when src2 is constructed from Scalar or has a single element: \f[\texttt{dst} (I) = \texttt{src1}(I) \,\texttt{cmpop}\, \texttt{src2}\f] src1 with elements of src2 when src1 is constructed from Scalar or has a single element: \f[\texttt{dst} (I) = \texttt{src1} \,\texttt{cmpop}\, \texttt{src2} (I)\f] When the comparison result is true, the corresponding element of output array is set to 255. The comparison operations can be replaced with the equivalent matrix expressions:
```
 {.cpp}
    Mat dst1 = src1 >= src2;
    Mat dst2 = src1 < 8;
    ...
```
Parameters:

src1 - first input array or a scalar; when it is an array, it must have a single channel.

src2 - second input array or a scalar; when it is an array, it must have a single channel.

dst - output array of type ref CV_8U that has the same size and the same number of channels as the input arrays.

cmpop - a flag, that specifies correspondence between the arrays (cv::CmpTypes) \sa checkRange, min, max, threshold

compare

@Namespace(value="cv")
public static void compare(@ByVal
                                                  opencv_core.UMat src1,
                                                  @ByVal
                                                  opencv_core.UMat src2,
                                                  @ByVal
                                                  opencv_core.UMat dst,
                                                  int cmpop)

compare

@Namespace(value="cv")
public static void compare(@ByVal
                                                  opencv_core.GpuMat src1,
                                                  @ByVal
                                                  opencv_core.GpuMat src2,
                                                  @ByVal
                                                  opencv_core.GpuMat dst,
                                                  int cmpop)

min

@Namespace(value="cv")
public static void min(@Const @ByRef
                                              opencv_core.Mat src1,
                                              @Const @ByRef
                                              opencv_core.Mat src2,
                                              @ByRef
                                              opencv_core.Mat dst)

\overload needed to avoid conflicts with const _Tp& std::min(const _Tp&, const _Tp&, _Compare)

min

@Namespace(value="cv")
public static void min(@Const @ByRef
                                              opencv_core.UMat src1,
                                              @Const @ByRef
                                              opencv_core.UMat src2,
                                              @ByRef
                                              opencv_core.UMat dst)

\overload needed to avoid conflicts with const _Tp& std::min(const _Tp&, const _Tp&, _Compare)

max

@Namespace(value="cv")
public static void max(@Const @ByRef
                                              opencv_core.Mat src1,
                                              @Const @ByRef
                                              opencv_core.Mat src2,
                                              @ByRef
                                              opencv_core.Mat dst)

\overload needed to avoid conflicts with const _Tp& std::min(const _Tp&, const _Tp&, _Compare)

max

@Namespace(value="cv")
public static void max(@Const @ByRef
                                              opencv_core.UMat src1,
                                              @Const @ByRef
                                              opencv_core.UMat src2,
                                              @ByRef
                                              opencv_core.UMat dst)

\overload needed to avoid conflicts with const _Tp& std::min(const _Tp&, const _Tp&, _Compare)

sqrt
```
@Namespace(value="cv")
public static void sqrt(@ByVal
                                               opencv_core.Mat src,
                                               @ByVal
                                               opencv_core.Mat dst)
```
\brief Calculates a square root of array elements.
The function cv::sqrt calculates a square root of each input array element. In case of multi-channel arrays, each channel is processed independently. The accuracy is approximately the same as of the built-in std::sqrt .

Parameters:

src - input floating-point array.

dst - output array of the same size and type as src.

sqrt

@Namespace(value="cv")
public static void sqrt(@ByVal
                                               opencv_core.UMat src,
                                               @ByVal
                                               opencv_core.UMat dst)

sqrt

@Namespace(value="cv")
public static void sqrt(@ByVal
                                               opencv_core.GpuMat src,
                                               @ByVal
                                               opencv_core.GpuMat dst)

pow
```
@Namespace(value="cv")
public static void pow(@ByVal
                                              opencv_core.Mat src,
                                              double power,
                                              @ByVal
                                              opencv_core.Mat dst)
```
\brief Raises every array element to a power.
The function cv::pow raises every element of the input array to power : \f[\texttt{dst} (I) = \fork{\texttt{src}(I)^{power}}{if $\texttt{power}$ is integer}{|\texttt{src}(I)|^{power}}{otherwise}\f]
So, for a non-integer power exponent, the absolute values of input array elements are used. However, it is possible to get true values for negative values using some extra operations. In the example below, computing the 5th root of array src shows:
```
 {.cpp}
    Mat mask = src < 0;
    pow(src, 1./5, dst);
    subtract(Scalar::all(0), dst, dst, mask);
```
For some values of power, such as integer values, 0.5 and -0.5, specialized faster algorithms are used.
Special values (NaN, Inf) are not handled.
Parameters:

src - input array.

power - exponent of power.

dst - output array of the same size and type as src. \sa sqrt, exp, log, cartToPolar, polarToCart

pow

@Namespace(value="cv")
public static void pow(@ByVal
                                              opencv_core.UMat src,
                                              double power,
                                              @ByVal
                                              opencv_core.UMat dst)

pow

@Namespace(value="cv")
public static void pow(@ByVal
                                              opencv_core.GpuMat src,
                                              double power,
                                              @ByVal
                                              opencv_core.GpuMat dst)

exp
```
@Namespace(value="cv")
public static void exp(@ByVal
                                              opencv_core.Mat src,
                                              @ByVal
                                              opencv_core.Mat dst)
```
\brief Calculates the exponent of every array element.
The function cv::exp calculates the exponent of every element of the input array: \f[\texttt{dst} [I] = e^{ src(I) }\f]
The maximum relative error is about 7e-6 for single-precision input and less than 1e-10 for double-precision input. Currently, the function converts denormalized values to zeros on output. Special values (NaN, Inf) are not handled.

Parameters:

src - input array.

dst - output array of the same size and type as src. \sa log , cartToPolar , polarToCart , phase , pow , sqrt , magnitude

exp

@Namespace(value="cv")
public static void exp(@ByVal
                                              opencv_core.UMat src,
                                              @ByVal
                                              opencv_core.UMat dst)

exp

@Namespace(value="cv")
public static void exp(@ByVal
                                              opencv_core.GpuMat src,
                                              @ByVal
                                              opencv_core.GpuMat dst)

log
```
@Namespace(value="cv")
public static void log(@ByVal
                                              opencv_core.Mat src,
                                              @ByVal
                                              opencv_core.Mat dst)
```
\brief Calculates the natural logarithm of every array element.
The function cv::log calculates the natural logarithm of every element of the input array: \f[\texttt{dst} (I) = \log (\texttt{src}(I)) \f]
Output on zero, negative and special (NaN, Inf) values is undefined.

Parameters:

src - input array.

dst - output array of the same size and type as src . \sa exp, cartToPolar, polarToCart, phase, pow, sqrt, magnitude

log

@Namespace(value="cv")
public static void log(@ByVal
                                              opencv_core.UMat src,
                                              @ByVal
                                              opencv_core.UMat dst)

log

@Namespace(value="cv")
public static void log(@ByVal
                                              opencv_core.GpuMat src,
                                              @ByVal
                                              opencv_core.GpuMat dst)

polarToCart
```
@Namespace(value="cv")
public static void polarToCart(@ByVal
                                                      opencv_core.Mat magnitude,
                                                      @ByVal
                                                      opencv_core.Mat angle,
                                                      @ByVal
                                                      opencv_core.Mat x,
                                                      @ByVal
                                                      opencv_core.Mat y,
                                                      @Cast(value="bool")
                                                      boolean angleInDegrees)
```
\brief Calculates x and y coordinates of 2D vectors from their magnitude and angle.
The function cv::polarToCart calculates the Cartesian coordinates of each 2D vector represented by the corresponding elements of magnitude and angle: \f[\begin{array}{l} \texttt{x} (I) = \texttt{magnitude} (I) \cos ( \texttt{angle} (I)) \\ \texttt{y} (I) = \texttt{magnitude} (I) \sin ( \texttt{angle} (I)) \\ \end{array}\f]
The relative accuracy of the estimated coordinates is about 1e-6.

Parameters:

magnitude - input floating-point array of magnitudes of 2D vectors; it can be an empty matrix (=Mat()), in this case, the function assumes that all the magnitudes are =1; if it is not empty, it must have the same size and type as angle.

angle - input floating-point array of angles of 2D vectors.

x - output array of x-coordinates of 2D vectors; it has the same size and type as angle.

y - output array of y-coordinates of 2D vectors; it has the same size and type as angle.

angleInDegrees - when true, the input angles are measured in degrees, otherwise, they are measured in radians. \sa cartToPolar, magnitude, phase, exp, log, pow, sqrt

polarToCart

@Namespace(value="cv")
public static void polarToCart(@ByVal
                                                      opencv_core.Mat magnitude,
                                                      @ByVal
                                                      opencv_core.Mat angle,
                                                      @ByVal
                                                      opencv_core.Mat x,
                                                      @ByVal
                                                      opencv_core.Mat y)

polarToCart

@Namespace(value="cv")
public static void polarToCart(@ByVal
                                                      opencv_core.UMat magnitude,
                                                      @ByVal
                                                      opencv_core.UMat angle,
                                                      @ByVal
                                                      opencv_core.UMat x,
                                                      @ByVal
                                                      opencv_core.UMat y,
                                                      @Cast(value="bool")
                                                      boolean angleInDegrees)

polarToCart

@Namespace(value="cv")
public static void polarToCart(@ByVal
                                                      opencv_core.UMat magnitude,
                                                      @ByVal
                                                      opencv_core.UMat angle,
                                                      @ByVal
                                                      opencv_core.UMat x,
                                                      @ByVal
                                                      opencv_core.UMat y)

polarToCart

@Namespace(value="cv")
public static void polarToCart(@ByVal
                                                      opencv_core.GpuMat magnitude,
                                                      @ByVal
                                                      opencv_core.GpuMat angle,
                                                      @ByVal
                                                      opencv_core.GpuMat x,
                                                      @ByVal
                                                      opencv_core.GpuMat y,
                                                      @Cast(value="bool")
                                                      boolean angleInDegrees)

polarToCart

@Namespace(value="cv")
public static void polarToCart(@ByVal
                                                      opencv_core.GpuMat magnitude,
                                                      @ByVal
                                                      opencv_core.GpuMat angle,
                                                      @ByVal
                                                      opencv_core.GpuMat x,
                                                      @ByVal
                                                      opencv_core.GpuMat y)

cartToPolar
```
@Namespace(value="cv")
public static void cartToPolar(@ByVal
                                                      opencv_core.Mat x,
                                                      @ByVal
                                                      opencv_core.Mat y,
                                                      @ByVal
                                                      opencv_core.Mat magnitude,
                                                      @ByVal
                                                      opencv_core.Mat angle,
                                                      @Cast(value="bool")
                                                      boolean angleInDegrees)
```
\brief Calculates the magnitude and angle of 2D vectors.
The function cv::cartToPolar calculates either the magnitude, angle, or both for every 2D vector (x(I),y(I)): \f[\begin{array}{l} \texttt{magnitude} (I)= \sqrt{\texttt{x}(I)^2+\texttt{y}(I)^2} , \\ \texttt{angle} (I)= \texttt{atan2} ( \texttt{y} (I), \texttt{x} (I))[ \cdot180 / \pi ] \end{array}\f]
The angles are calculated with accuracy about 0.3 degrees. For the point (0,0), the angle is set to 0.

Parameters:

x - array of x-coordinates; this must be a single-precision or double-precision floating-point array.

y - array of y-coordinates, that must have the same size and same type as x.

magnitude - output array of magnitudes of the same size and type as x.

angle - output array of angles that has the same size and type as x; the angles are measured in radians (from 0 to 2\*Pi) or in degrees (0 to 360 degrees).

angleInDegrees - a flag, indicating whether the angles are measured in radians (which is by default), or in degrees. \sa Sobel, Scharr

cartToPolar

@Namespace(value="cv")
public static void cartToPolar(@ByVal
                                                      opencv_core.Mat x,
                                                      @ByVal
                                                      opencv_core.Mat y,
                                                      @ByVal
                                                      opencv_core.Mat magnitude,
                                                      @ByVal
                                                      opencv_core.Mat angle)

cartToPolar

@Namespace(value="cv")
public static void cartToPolar(@ByVal
                                                      opencv_core.UMat x,
                                                      @ByVal
                                                      opencv_core.UMat y,
                                                      @ByVal
                                                      opencv_core.UMat magnitude,
                                                      @ByVal
                                                      opencv_core.UMat angle,
                                                      @Cast(value="bool")
                                                      boolean angleInDegrees)

cartToPolar

@Namespace(value="cv")
public static void cartToPolar(@ByVal
                                                      opencv_core.UMat x,
                                                      @ByVal
                                                      opencv_core.UMat y,
                                                      @ByVal
                                                      opencv_core.UMat magnitude,
                                                      @ByVal
                                                      opencv_core.UMat angle)

cartToPolar

@Namespace(value="cv")
public static void cartToPolar(@ByVal
                                                      opencv_core.GpuMat x,
                                                      @ByVal
                                                      opencv_core.GpuMat y,
                                                      @ByVal
                                                      opencv_core.GpuMat magnitude,
                                                      @ByVal
                                                      opencv_core.GpuMat angle,
                                                      @Cast(value="bool")
                                                      boolean angleInDegrees)

cartToPolar

@Namespace(value="cv")
public static void cartToPolar(@ByVal
                                                      opencv_core.GpuMat x,
                                                      @ByVal
                                                      opencv_core.GpuMat y,
                                                      @ByVal
                                                      opencv_core.GpuMat magnitude,
                                                      @ByVal
                                                      opencv_core.GpuMat angle)

phase
```
@Namespace(value="cv")
public static void phase(@ByVal
                                                opencv_core.Mat x,
                                                @ByVal
                                                opencv_core.Mat y,
                                                @ByVal
                                                opencv_core.Mat angle,
                                                @Cast(value="bool")
                                                boolean angleInDegrees)
```
\brief Calculates the rotation angle of 2D vectors.
The function cv::phase calculates the rotation angle of each 2D vector that is formed from the corresponding elements of x and y : \f[\texttt{angle} (I) = \texttt{atan2} ( \texttt{y} (I), \texttt{x} (I))\f]
The angle estimation accuracy is about 0.3 degrees. When x(I)=y(I)=0 , the corresponding angle(I) is set to 0.

Parameters:

x - input floating-point array of x-coordinates of 2D vectors.

y - input array of y-coordinates of 2D vectors; it must have the same size and the same type as x.

angle - output array of vector angles; it has the same size and same type as x .

angleInDegrees - when true, the function calculates the angle in degrees, otherwise, they are measured in radians.

phase

@Namespace(value="cv")
public static void phase(@ByVal
                                                opencv_core.Mat x,
                                                @ByVal
                                                opencv_core.Mat y,
                                                @ByVal
                                                opencv_core.Mat angle)

phase

@Namespace(value="cv")
public static void phase(@ByVal
                                                opencv_core.UMat x,
                                                @ByVal
                                                opencv_core.UMat y,
                                                @ByVal
                                                opencv_core.UMat angle,
                                                @Cast(value="bool")
                                                boolean angleInDegrees)

phase

@Namespace(value="cv")
public static void phase(@ByVal
                                                opencv_core.UMat x,
                                                @ByVal
                                                opencv_core.UMat y,
                                                @ByVal
                                                opencv_core.UMat angle)

phase

@Namespace(value="cv")
public static void phase(@ByVal
                                                opencv_core.GpuMat x,
                                                @ByVal
                                                opencv_core.GpuMat y,
                                                @ByVal
                                                opencv_core.GpuMat angle,
                                                @Cast(value="bool")
                                                boolean angleInDegrees)

phase

@Namespace(value="cv")
public static void phase(@ByVal
                                                opencv_core.GpuMat x,
                                                @ByVal
                                                opencv_core.GpuMat y,
                                                @ByVal
                                                opencv_core.GpuMat angle)

magnitude

@Namespace(value="cv")
public static void magnitude(@ByVal
                                                    opencv_core.Mat x,
                                                    @ByVal
                                                    opencv_core.Mat y,
                                                    @ByVal
                                                    opencv_core.Mat magnitude)

\brief Calculates the magnitude of 2D vectors.

The function cv::magnitude calculates the magnitude of 2D vectors formed from the corresponding elements of x and y arrays: \f[\texttt{dst} (I) = \sqrt{\texttt{x}(I)^2 + \texttt{y}(I)^2}\f]

Parameters:: x - floating-point array of x-coordinates of the vectors.; y - floating-point array of y-coordinates of the vectors; it must have the same size as x.; magnitude - output array of the same size and type as x. \sa cartToPolar, polarToCart, phase, sqrt

magnitude

@Namespace(value="cv")
public static void magnitude(@ByVal
                                                    opencv_core.UMat x,
                                                    @ByVal
                                                    opencv_core.UMat y,
                                                    @ByVal
                                                    opencv_core.UMat magnitude)

magnitude

@Namespace(value="cv")
public static void magnitude(@ByVal
                                                    opencv_core.GpuMat x,
                                                    @ByVal
                                                    opencv_core.GpuMat y,
                                                    @ByVal
                                                    opencv_core.GpuMat magnitude)

checkRange
```
@Namespace(value="cv")
 @Cast(value="bool")
public static boolean checkRange(@ByVal
                                                                             opencv_core.Mat a,
                                                                             @Cast(value="bool")
                                                                             boolean quiet,
                                                                             opencv_core.Point pos,
                                                                             double minVal,
                                                                             double maxVal)
```
\brief Checks every element of an input array for invalid values.
The function cv::checkRange checks that every array element is neither NaN nor infinite. When minVal \> -DBL_MAX and maxVal \< DBL_MAX, the function also checks that each value is between minVal and maxVal. In case of multi-channel arrays, each channel is processed independently. If some values are out of range, position of the first outlier is stored in pos (when pos != NULL). Then, the function either returns false (when quiet=true) or throws an exception.

Parameters:

a - input array.

quiet - a flag, indicating whether the functions quietly return false when the array elements are out of range or they throw an exception.

pos - optional output parameter, when not NULL, must be a pointer to array of src.dims elements.

minVal - inclusive lower boundary of valid values range.

maxVal - exclusive upper boundary of valid values range.

checkRange

@Namespace(value="cv")
 @Cast(value="bool")
public static boolean checkRange(@ByVal
                                                                             opencv_core.Mat a)

checkRange

@Namespace(value="cv")
 @Cast(value="bool")
public static boolean checkRange(@ByVal
                                                                             opencv_core.UMat a,
                                                                             @Cast(value="bool")
                                                                             boolean quiet,
                                                                             opencv_core.Point pos,
                                                                             double minVal,
                                                                             double maxVal)

checkRange

@Namespace(value="cv")
 @Cast(value="bool")
public static boolean checkRange(@ByVal
                                                                             opencv_core.UMat a)

checkRange

@Namespace(value="cv")
 @Cast(value="bool")
public static boolean checkRange(@ByVal
                                                                             opencv_core.GpuMat a,
                                                                             @Cast(value="bool")
                                                                             boolean quiet,
                                                                             opencv_core.Point pos,
                                                                             double minVal,
                                                                             double maxVal)

checkRange

@Namespace(value="cv")
 @Cast(value="bool")
public static boolean checkRange(@ByVal
                                                                             opencv_core.GpuMat a)

patchNaNs

@Namespace(value="cv")
public static void patchNaNs(@ByVal
                                                    opencv_core.Mat a,
                                                    double val)

\brief converts NaN's to the given number

patchNaNs

@Namespace(value="cv")
public static void patchNaNs(@ByVal
                                                    opencv_core.Mat a)

patchNaNs

@Namespace(value="cv")
public static void patchNaNs(@ByVal
                                                    opencv_core.UMat a,
                                                    double val)

patchNaNs

@Namespace(value="cv")
public static void patchNaNs(@ByVal
                                                    opencv_core.UMat a)

patchNaNs

@Namespace(value="cv")
public static void patchNaNs(@ByVal
                                                    opencv_core.GpuMat a,
                                                    double val)

patchNaNs

@Namespace(value="cv")
public static void patchNaNs(@ByVal
                                                    opencv_core.GpuMat a)

gemm
```
@Namespace(value="cv")
public static void gemm(@ByVal
                                               opencv_core.Mat src1,
                                               @ByVal
                                               opencv_core.Mat src2,
                                               double alpha,
                                               @ByVal
                                               opencv_core.Mat src3,
                                               double beta,
                                               @ByVal
                                               opencv_core.Mat dst,
                                               int flags)
```
\brief Performs generalized matrix multiplication.
The function cv::gemm performs generalized matrix multiplication similar to the gemm functions in BLAS level 3. For example, gemm(src1, src2, alpha, src3, beta, dst, GEMM_1_T + GEMM_3_T) corresponds to \f[\texttt{dst} = \texttt{alpha} \cdot \texttt{src1} ^T \cdot \texttt{src2} + \texttt{beta} \cdot \texttt{src3} ^T\f]
In case of complex (two-channel) data, performed a complex matrix multiplication.
The function can be replaced with a matrix expression. For example, the above call can be replaced with:
```
 {.cpp}
    dst = alpha*src1.t()*src2 + beta*src3.t();
```
Parameters:

src1 - first multiplied input matrix that could be real(CV_32FC1, CV_64FC1) or complex(CV_32FC2, CV_64FC2).

src2 - second multiplied input matrix of the same type as src1.

alpha - weight of the matrix product.

src3 - third optional delta matrix added to the matrix product; it should have the same type as src1 and src2.

beta - weight of src3.

dst - output matrix; it has the proper size and the same type as input matrices.

flags - operation flags (cv::GemmFlags) \sa mulTransposed , transform

gemm

@Namespace(value="cv")
public static void gemm(@ByVal
                                               opencv_core.Mat src1,
                                               @ByVal
                                               opencv_core.Mat src2,
                                               double alpha,
                                               @ByVal
                                               opencv_core.Mat src3,
                                               double beta,
                                               @ByVal
                                               opencv_core.Mat dst)

gemm

@Namespace(value="cv")
public static void gemm(@ByVal
                                               opencv_core.UMat src1,
                                               @ByVal
                                               opencv_core.UMat src2,
                                               double alpha,
                                               @ByVal
                                               opencv_core.UMat src3,
                                               double beta,
                                               @ByVal
                                               opencv_core.UMat dst,
                                               int flags)

gemm

@Namespace(value="cv")
public static void gemm(@ByVal
                                               opencv_core.UMat src1,
                                               @ByVal
                                               opencv_core.UMat src2,
                                               double alpha,
                                               @ByVal
                                               opencv_core.UMat src3,
                                               double beta,
                                               @ByVal
                                               opencv_core.UMat dst)

gemm

@Namespace(value="cv")
public static void gemm(@ByVal
                                               opencv_core.GpuMat src1,
                                               @ByVal
                                               opencv_core.GpuMat src2,
                                               double alpha,
                                               @ByVal
                                               opencv_core.GpuMat src3,
                                               double beta,
                                               @ByVal
                                               opencv_core.GpuMat dst,
                                               int flags)

gemm

@Namespace(value="cv")
public static void gemm(@ByVal
                                               opencv_core.GpuMat src1,
                                               @ByVal
                                               opencv_core.GpuMat src2,
                                               double alpha,
                                               @ByVal
                                               opencv_core.GpuMat src3,
                                               double beta,
                                               @ByVal
                                               opencv_core.GpuMat dst)

mulTransposed
```
@Namespace(value="cv")
public static void mulTransposed(@ByVal
                                                        opencv_core.Mat src,
                                                        @ByVal
                                                        opencv_core.Mat dst,
                                                        @Cast(value="bool")
                                                        boolean aTa,
                                                        @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                        opencv_core.Mat delta,
                                                        double scale,
                                                        int dtype)
```
\brief Calculates the product of a matrix and its transposition.
The function cv::mulTransposed calculates the product of src and its transposition: \f[\texttt{dst} = \texttt{scale} ( \texttt{src} - \texttt{delta} )^T ( \texttt{src} - \texttt{delta} )\f] if aTa=true , and \f[\texttt{dst} = \texttt{scale} ( \texttt{src} - \texttt{delta} ) ( \texttt{src} - \texttt{delta} )^T\f] otherwise. The function is used to calculate the covariance matrix. With zero delta, it can be used as a faster substitute for general matrix product A\*B when B=A'

Parameters:

src - input single-channel matrix. Note that unlike gemm, the function can multiply not only floating-point matrices.

dst - output square matrix.

aTa - Flag specifying the multiplication ordering. See the description below.

delta - Optional delta matrix subtracted from src before the multiplication. When the matrix is empty ( delta=noArray() ), it is assumed to be zero, that is, nothing is subtracted. If it has the same size as src , it is simply subtracted. Otherwise, it is "repeated" (see repeat ) to cover the full src and then subtracted. Type of the delta matrix, when it is not empty, must be the same as the type of created output matrix. See the dtype parameter description below.

scale - Optional scale factor for the matrix product.

dtype - Optional type of the output matrix. When it is negative, the output matrix will have the same type as src . Otherwise, it will be type=CV_MAT_DEPTH(dtype) that should be either CV_32F or CV_64F . \sa calcCovarMatrix, gemm, repeat, reduce

mulTransposed

@Namespace(value="cv")
public static void mulTransposed(@ByVal
                                                        opencv_core.Mat src,
                                                        @ByVal
                                                        opencv_core.Mat dst,
                                                        @Cast(value="bool")
                                                        boolean aTa)

mulTransposed

@Namespace(value="cv")
public static void mulTransposed(@ByVal
                                                        opencv_core.UMat src,
                                                        @ByVal
                                                        opencv_core.UMat dst,
                                                        @Cast(value="bool")
                                                        boolean aTa,
                                                        @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                        opencv_core.UMat delta,
                                                        double scale,
                                                        int dtype)

mulTransposed

@Namespace(value="cv")
public static void mulTransposed(@ByVal
                                                        opencv_core.UMat src,
                                                        @ByVal
                                                        opencv_core.UMat dst,
                                                        @Cast(value="bool")
                                                        boolean aTa)

mulTransposed

@Namespace(value="cv")
public static void mulTransposed(@ByVal
                                                        opencv_core.GpuMat src,
                                                        @ByVal
                                                        opencv_core.GpuMat dst,
                                                        @Cast(value="bool")
                                                        boolean aTa,
                                                        @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                        opencv_core.GpuMat delta,
                                                        double scale,
                                                        int dtype)

mulTransposed

@Namespace(value="cv")
public static void mulTransposed(@ByVal
                                                        opencv_core.GpuMat src,
                                                        @ByVal
                                                        opencv_core.GpuMat dst,
                                                        @Cast(value="bool")
                                                        boolean aTa)

transpose

@Namespace(value="cv")
public static void transpose(@ByVal
                                                    opencv_core.Mat src,
                                                    @ByVal
                                                    opencv_core.Mat dst)

\brief Transposes a matrix.

The function cv::transpose transposes the matrix src : \f[\texttt{dst} (i,j) = \texttt{src} (j,i)\f] \note No complex conjugation is done in case of a complex matrix. It should be done separately if needed.

Parameters:: src - input array.; dst - output array of the same type as src.

transpose

@Namespace(value="cv")
public static void transpose(@ByVal
                                                    opencv_core.UMat src,
                                                    @ByVal
                                                    opencv_core.UMat dst)

transpose

@Namespace(value="cv")
public static void transpose(@ByVal
                                                    opencv_core.GpuMat src,
                                                    @ByVal
                                                    opencv_core.GpuMat dst)

transform
```
@Namespace(value="cv")
public static void transform(@ByVal
                                                    opencv_core.Mat src,
                                                    @ByVal
                                                    opencv_core.Mat dst,
                                                    @ByVal
                                                    opencv_core.Mat m)
```
\brief Performs the matrix transformation of every array element.
The function cv::transform performs the matrix transformation of every element of the array src and stores the results in dst : \f[\texttt{dst} (I) = \texttt{m} \cdot \texttt{src} (I)\f] (when m.cols=src.channels() ), or \f[\texttt{dst} (I) = \texttt{m} \cdot [ \texttt{src} (I); 1]\f] (when m.cols=src.channels()+1 )
Every element of the N -channel array src is interpreted as N -element vector that is transformed using the M x N or M x (N+1) matrix m to M-element vector - the corresponding element of the output array dst .
The function may be used for geometrical transformation of N -dimensional points, arbitrary linear color space transformation (such as various kinds of RGB to YUV transforms), shuffling the image channels, and so forth.

Parameters:

src - input array that must have as many channels (1 to 4) as m.cols or m.cols-1.

dst - output array of the same size and depth as src; it has as many channels as m.rows.

m - transformation 2x2 or 2x3 floating-point matrix. \sa perspectiveTransform, getAffineTransform, estimateAffine2D, warpAffine, warpPerspective

transform

@Namespace(value="cv")
public static void transform(@ByVal
                                                    opencv_core.UMat src,
                                                    @ByVal
                                                    opencv_core.UMat dst,
                                                    @ByVal
                                                    opencv_core.UMat m)

transform

@Namespace(value="cv")
public static void transform(@ByVal
                                                    opencv_core.GpuMat src,
                                                    @ByVal
                                                    opencv_core.GpuMat dst,
                                                    @ByVal
                                                    opencv_core.GpuMat m)

perspectiveTransform
```
@Namespace(value="cv")
public static void perspectiveTransform(@ByVal
                                                               opencv_core.Mat src,
                                                               @ByVal
                                                               opencv_core.Mat dst,
                                                               @ByVal
                                                               opencv_core.Mat m)
```
\brief Performs the perspective matrix transformation of vectors.
The function cv::perspectiveTransform transforms every element of src by treating it as a 2D or 3D vector, in the following way: \f[(x, y, z) \rightarrow (x'/w, y'/w, z'/w)\f] where \f[(x', y', z', w') = \texttt{mat} \cdot \begin{bmatrix} x & y & z & 1 \end{bmatrix}\f] and \f[w = \fork{w'}{if $w' \ne 0$}{\infty}{otherwise}\f]
Here a 3D vector transformation is shown. In case of a 2D vector transformation, the z component is omitted.
\note The function transforms a sparse set of 2D or 3D vectors. If you want to transform an image using perspective transformation, use warpPerspective . If you have an inverse problem, that is, you want to compute the most probable perspective transformation out of several pairs of corresponding points, you can use getPerspectiveTransform or findHomography .

Parameters:

src - input two-channel or three-channel floating-point array; each element is a 2D/3D vector to be transformed.

dst - output array of the same size and type as src.

m - 3x3 or 4x4 floating-point transformation matrix. \sa transform, warpPerspective, getPerspectiveTransform, findHomography

perspectiveTransform

@Namespace(value="cv")
public static void perspectiveTransform(@ByVal
                                                               opencv_core.UMat src,
                                                               @ByVal
                                                               opencv_core.UMat dst,
                                                               @ByVal
                                                               opencv_core.UMat m)

perspectiveTransform

@Namespace(value="cv")
public static void perspectiveTransform(@ByVal
                                                               opencv_core.GpuMat src,
                                                               @ByVal
                                                               opencv_core.GpuMat dst,
                                                               @ByVal
                                                               opencv_core.GpuMat m)

completeSymm
```
@Namespace(value="cv")
public static void completeSymm(@ByVal
                                                       opencv_core.Mat m,
                                                       @Cast(value="bool")
                                                       boolean lowerToUpper)
```
\brief Copies the lower or the upper half of a square matrix to its another half.
The function cv::completeSymm copies the lower or the upper half of a square matrix to its another half. The matrix diagonal remains unchanged: - \f$\texttt{m}_{ij}=\texttt{m}_{ji}\f$ for \f$i > j\f$ if lowerToUpper=false - \f$\texttt{m}_{ij}=\texttt{m}_{ji}\f$ for \f$i < j\f$ if lowerToUpper=true

Parameters:

m - input-output floating-point square matrix.

lowerToUpper - operation flag; if true, the lower half is copied to the upper half. Otherwise, the upper half is copied to the lower half. \sa flip, transpose

completeSymm

@Namespace(value="cv")
public static void completeSymm(@ByVal
                                                       opencv_core.Mat m)

completeSymm

@Namespace(value="cv")
public static void completeSymm(@ByVal
                                                       opencv_core.UMat m,
                                                       @Cast(value="bool")
                                                       boolean lowerToUpper)

completeSymm

@Namespace(value="cv")
public static void completeSymm(@ByVal
                                                       opencv_core.UMat m)

completeSymm

@Namespace(value="cv")
public static void completeSymm(@ByVal
                                                       opencv_core.GpuMat m,
                                                       @Cast(value="bool")
                                                       boolean lowerToUpper)

completeSymm

@Namespace(value="cv")
public static void completeSymm(@ByVal
                                                       opencv_core.GpuMat m)

setIdentity

@Namespace(value="cv")
public static void setIdentity(@ByVal
                                                      opencv_core.Mat mtx,
                                                      @Const @ByRef(nullValue="cv::Scalar(1)")
                                                      opencv_core.Scalar s)

\brief Initializes a scaled identity matrix.

The function cv::setIdentity initializes a scaled identity matrix: \f[\texttt{mtx} (i,j)= \fork{\texttt{value}}{ if $i=j$}{0}{otherwise}\f]

The function can also be emulated using the matrix initializers and the matrix expressions:


    Mat A = Mat::eye(4, 3, CV_32F)*5;
    // A will be set to [[5, 0, 0], [0, 5, 0], [0, 0, 5], [0, 0, 0]]

Parameters:: mtx - matrix to initialize (not necessarily square).; s - value to assign to diagonal elements. \sa Mat::zeros, Mat::ones, Mat::setTo, Mat::operator=

setIdentity

@Namespace(value="cv")
public static void setIdentity(@ByVal
                                                      opencv_core.Mat mtx)

setIdentity

@Namespace(value="cv")
public static void setIdentity(@ByVal
                                                      opencv_core.UMat mtx,
                                                      @Const @ByRef(nullValue="cv::Scalar(1)")
                                                      opencv_core.Scalar s)

setIdentity

@Namespace(value="cv")
public static void setIdentity(@ByVal
                                                      opencv_core.UMat mtx)

setIdentity

@Namespace(value="cv")
public static void setIdentity(@ByVal
                                                      opencv_core.GpuMat mtx,
                                                      @Const @ByRef(nullValue="cv::Scalar(1)")
                                                      opencv_core.Scalar s)

setIdentity

@Namespace(value="cv")
public static void setIdentity(@ByVal
                                                      opencv_core.GpuMat mtx)

determinant
```
@Namespace(value="cv")
public static double determinant(@ByVal
                                                        opencv_core.Mat mtx)
```
\brief Returns the determinant of a square floating-point matrix.
The function cv::determinant calculates and returns the determinant of the specified matrix. For small matrices ( mtx.cols=mtx.rows\<=3 ), the direct method is used. For larger matrices, the function uses LU factorization with partial pivoting.
For symmetric positively-determined matrices, it is also possible to use eigen decomposition to calculate the determinant.

Parameters:

mtx - input matrix that must have CV_32FC1 or CV_64FC1 type and square size. \sa trace, invert, solve, eigen, \ref MatrixExpressions

determinant

@Namespace(value="cv")
public static double determinant(@ByVal
                                                        opencv_core.UMat mtx)

determinant

@Namespace(value="cv")
public static double determinant(@ByVal
                                                        opencv_core.GpuMat mtx)

trace

@Namespace(value="cv")
 @ByVal
public static opencv_core.Scalar trace(@ByVal
                                                                      opencv_core.Mat mtx)

\brief Returns the trace of a matrix.

The function cv::trace returns the sum of the diagonal elements of the matrix mtx . \f[\mathrm{tr} ( \texttt{mtx} ) = \sum _i \texttt{mtx} (i,i)\f]

Parameters:: mtx - input matrix.

trace

@Namespace(value="cv")
 @ByVal
public static opencv_core.Scalar trace(@ByVal
                                                                      opencv_core.UMat mtx)

trace

@Namespace(value="cv")
 @ByVal
public static opencv_core.Scalar trace(@ByVal
                                                                      opencv_core.GpuMat mtx)

invert
```
@Namespace(value="cv")
public static double invert(@ByVal
                                                   opencv_core.Mat src,
                                                   @ByVal
                                                   opencv_core.Mat dst,
                                                   int flags)
```
\brief Finds the inverse or pseudo-inverse of a matrix.
The function cv::invert inverts the matrix src and stores the result in dst . When the matrix src is singular or non-square, the function calculates the pseudo-inverse matrix (the dst matrix) so that norm(src\*dst - I) is minimal, where I is an identity matrix.
In case of the #DECOMP_LU method, the function returns non-zero value if the inverse has been successfully calculated and 0 if src is singular.
In case of the #DECOMP_SVD method, the function returns the inverse condition number of src (the ratio of the smallest singular value to the largest singular value) and 0 if src is singular. The SVD method calculates a pseudo-inverse matrix if src is singular.
Similarly to #DECOMP_LU, the method #DECOMP_CHOLESKY works only with non-singular square matrices that should also be symmetrical and positively defined. In this case, the function stores the inverted matrix in dst and returns non-zero. Otherwise, it returns 0.

Parameters:

src - input floating-point M x N matrix.

dst - output matrix of N x M size and the same type as src.

flags - inversion method (cv::DecompTypes) \sa solve, SVD

invert

@Namespace(value="cv")
public static double invert(@ByVal
                                                   opencv_core.Mat src,
                                                   @ByVal
                                                   opencv_core.Mat dst)

invert

@Namespace(value="cv")
public static double invert(@ByVal
                                                   opencv_core.UMat src,
                                                   @ByVal
                                                   opencv_core.UMat dst,
                                                   int flags)

invert

@Namespace(value="cv")
public static double invert(@ByVal
                                                   opencv_core.UMat src,
                                                   @ByVal
                                                   opencv_core.UMat dst)

invert

@Namespace(value="cv")
public static double invert(@ByVal
                                                   opencv_core.GpuMat src,
                                                   @ByVal
                                                   opencv_core.GpuMat dst,
                                                   int flags)

invert

@Namespace(value="cv")
public static double invert(@ByVal
                                                   opencv_core.GpuMat src,
                                                   @ByVal
                                                   opencv_core.GpuMat dst)

solve
```
@Namespace(value="cv")
 @Cast(value="bool")
public static boolean solve(@ByVal
                                                                        opencv_core.Mat src1,
                                                                        @ByVal
                                                                        opencv_core.Mat src2,
                                                                        @ByVal
                                                                        opencv_core.Mat dst,
                                                                        int flags)
```
\brief Solves one or more linear systems or least-squares problems.
The function cv::solve solves a linear system or least-squares problem (the latter is possible with SVD or QR methods, or by specifying the flag #DECOMP_NORMAL ): \f[\texttt{dst} = \arg \min _X \| \texttt{src1} \cdot \texttt{X} - \texttt{src2} \|\f]
If #DECOMP_LU or #DECOMP_CHOLESKY method is used, the function returns 1 if src1 (or \f$\texttt{src1}^T\texttt{src1}\f$ ) is non-singular. Otherwise, it returns 0. In the latter case, dst is not valid. Other methods find a pseudo-solution in case of a singular left-hand side part.
\note If you want to find a unity-norm solution of an under-defined singular system \f$\texttt{src1}\cdot\texttt{dst}=0\f$ , the function solve will not do the work. Use SVD::solveZ instead.

Parameters:

src1 - input matrix on the left-hand side of the system.

src2 - input matrix on the right-hand side of the system.

dst - output solution.

flags - solution (matrix inversion) method (#DecompTypes) \sa invert, SVD, eigen

solve

@Namespace(value="cv")
 @Cast(value="bool")
public static boolean solve(@ByVal
                                                                        opencv_core.Mat src1,
                                                                        @ByVal
                                                                        opencv_core.Mat src2,
                                                                        @ByVal
                                                                        opencv_core.Mat dst)

solve

@Namespace(value="cv")
 @Cast(value="bool")
public static boolean solve(@ByVal
                                                                        opencv_core.UMat src1,
                                                                        @ByVal
                                                                        opencv_core.UMat src2,
                                                                        @ByVal
                                                                        opencv_core.UMat dst,
                                                                        int flags)

solve

@Namespace(value="cv")
 @Cast(value="bool")
public static boolean solve(@ByVal
                                                                        opencv_core.UMat src1,
                                                                        @ByVal
                                                                        opencv_core.UMat src2,
                                                                        @ByVal
                                                                        opencv_core.UMat dst)

solve

@Namespace(value="cv")
 @Cast(value="bool")
public static boolean solve(@ByVal
                                                                        opencv_core.GpuMat src1,
                                                                        @ByVal
                                                                        opencv_core.GpuMat src2,
                                                                        @ByVal
                                                                        opencv_core.GpuMat dst,
                                                                        int flags)

solve

@Namespace(value="cv")
 @Cast(value="bool")
public static boolean solve(@ByVal
                                                                        opencv_core.GpuMat src1,
                                                                        @ByVal
                                                                        opencv_core.GpuMat src2,
                                                                        @ByVal
                                                                        opencv_core.GpuMat dst)

sort
```
@Namespace(value="cv")
public static void sort(@ByVal
                                               opencv_core.Mat src,
                                               @ByVal
                                               opencv_core.Mat dst,
                                               int flags)
```
\brief Sorts each row or each column of a matrix.
The function cv::sort sorts each matrix row or each matrix column in ascending or descending order. So you should pass two operation flags to get desired behaviour. If you want to sort matrix rows or columns lexicographically, you can use STL std::sort generic function with the proper comparison predicate.

Parameters:

src - input single-channel array.

dst - output array of the same size and type as src.

flags - operation flags, a combination of #SortFlags \sa sortIdx, randShuffle

sort

@Namespace(value="cv")
public static void sort(@ByVal
                                               opencv_core.UMat src,
                                               @ByVal
                                               opencv_core.UMat dst,
                                               int flags)

sort

@Namespace(value="cv")
public static void sort(@ByVal
                                               opencv_core.GpuMat src,
                                               @ByVal
                                               opencv_core.GpuMat dst,
                                               int flags)

sortIdx

@Namespace(value="cv")
public static void sortIdx(@ByVal
                                                  opencv_core.Mat src,
                                                  @ByVal
                                                  opencv_core.Mat dst,
                                                  int flags)

\brief Sorts each row or each column of a matrix.

The function cv::sortIdx sorts each matrix row or each matrix column in the ascending or descending order. So you should pass two operation flags to get desired behaviour. Instead of reordering the elements themselves, it stores the indices of sorted elements in the output array. For example:


    Mat A = Mat::eye(3,3,CV_32F), B;
    sortIdx(A, B, SORT_EVERY_ROW + SORT_ASCENDING);
    // B will probably contain
    // (because of equal elements in A some permutations are possible):
    // [[1, 2, 0], [0, 2, 1], [0, 1, 2]]

Parameters:: src - input single-channel array.; dst - output integer array of the same size as src.; flags - operation flags that could be a combination of cv::SortFlags \sa sort, randShuffle

sortIdx

@Namespace(value="cv")
public static void sortIdx(@ByVal
                                                  opencv_core.UMat src,
                                                  @ByVal
                                                  opencv_core.UMat dst,
                                                  int flags)

sortIdx

@Namespace(value="cv")
public static void sortIdx(@ByVal
                                                  opencv_core.GpuMat src,
                                                  @ByVal
                                                  opencv_core.GpuMat dst,
                                                  int flags)

solveCubic
```
@Namespace(value="cv")
public static int solveCubic(@ByVal
                                                    opencv_core.Mat coeffs,
                                                    @ByVal
                                                    opencv_core.Mat roots)
```
\brief Finds the real roots of a cubic equation.
The function solveCubic finds the real roots of a cubic equation: - if coeffs is a 4-element vector: \f[\texttt{coeffs} [0] x^3 + \texttt{coeffs} [1] x^2 + \texttt{coeffs} [2] x + \texttt{coeffs} [3] = 0\f] - if coeffs is a 3-element vector: \f[x^3 + \texttt{coeffs} [0] x^2 + \texttt{coeffs} [1] x + \texttt{coeffs} [2] = 0\f]
The roots are stored in the roots array.

Parameters:

coeffs - equation coefficients, an array of 3 or 4 elements.

roots - output array of real roots that has 1 or 3 elements.

Returns:

number of real roots. It can be 0, 1 or 2.

solveCubic

@Namespace(value="cv")
public static int solveCubic(@ByVal
                                                    opencv_core.UMat coeffs,
                                                    @ByVal
                                                    opencv_core.UMat roots)

solveCubic

@Namespace(value="cv")
public static int solveCubic(@ByVal
                                                    opencv_core.GpuMat coeffs,
                                                    @ByVal
                                                    opencv_core.GpuMat roots)

solvePoly

@Namespace(value="cv")
public static double solvePoly(@ByVal
                                                      opencv_core.Mat coeffs,
                                                      @ByVal
                                                      opencv_core.Mat roots,
                                                      int maxIters)

\brief Finds the real or complex roots of a polynomial equation.

The function cv::solvePoly finds real and complex roots of a polynomial equation: \f[\texttt{coeffs} [n] x^{n} + \texttt{coeffs} [n-1] x^{n-1} + ... + \texttt{coeffs} [1] x + \texttt{coeffs} [0] = 0\f]

Parameters:: coeffs - array of polynomial coefficients.; roots - output (complex) array of roots.; maxIters - maximum number of iterations the algorithm does.

solvePoly

@Namespace(value="cv")
public static double solvePoly(@ByVal
                                                      opencv_core.Mat coeffs,
                                                      @ByVal
                                                      opencv_core.Mat roots)

solvePoly

@Namespace(value="cv")
public static double solvePoly(@ByVal
                                                      opencv_core.UMat coeffs,
                                                      @ByVal
                                                      opencv_core.UMat roots,
                                                      int maxIters)

solvePoly

@Namespace(value="cv")
public static double solvePoly(@ByVal
                                                      opencv_core.UMat coeffs,
                                                      @ByVal
                                                      opencv_core.UMat roots)

solvePoly

@Namespace(value="cv")
public static double solvePoly(@ByVal
                                                      opencv_core.GpuMat coeffs,
                                                      @ByVal
                                                      opencv_core.GpuMat roots,
                                                      int maxIters)

solvePoly

@Namespace(value="cv")
public static double solvePoly(@ByVal
                                                      opencv_core.GpuMat coeffs,
                                                      @ByVal
                                                      opencv_core.GpuMat roots)

eigen

@Namespace(value="cv")
 @Cast(value="bool")
public static boolean eigen(@ByVal
                                                                        opencv_core.Mat src,
                                                                        @ByVal
                                                                        opencv_core.Mat eigenvalues,
                                                                        @ByVal(nullValue="cv::OutputArray(cv::noArray())")
                                                                        opencv_core.Mat eigenvectors)

\brief Calculates eigenvalues and eigenvectors of a symmetric matrix.

The function cv::eigen calculates just eigenvalues, or eigenvalues and eigenvectors of the symmetric matrix src:


    src*eigenvectors.row(i).t() = eigenvalues.at<srcType>(i)*eigenvectors.row(i).t()

\note Use cv::eigenNonSymmetric for calculation of real eigenvalues and eigenvectors of non-symmetric matrix.

Parameters:: src - input matrix that must have CV_32FC1 or CV_64FC1 type, square size and be symmetrical (src ^T^ == src).; eigenvalues - output vector of eigenvalues of the same type as src; the eigenvalues are stored in the descending order.; eigenvectors - output matrix of eigenvectors; it has the same size and type as src; the eigenvectors are stored as subsequent matrix rows, in the same order as the corresponding eigenvalues. \sa eigenNonSymmetric, completeSymm , PCA

eigen

@Namespace(value="cv")
 @Cast(value="bool")
public static boolean eigen(@ByVal
                                                                        opencv_core.Mat src,
                                                                        @ByVal
                                                                        opencv_core.Mat eigenvalues)

eigen

@Namespace(value="cv")
 @Cast(value="bool")
public static boolean eigen(@ByVal
                                                                        opencv_core.UMat src,
                                                                        @ByVal
                                                                        opencv_core.UMat eigenvalues,
                                                                        @ByVal(nullValue="cv::OutputArray(cv::noArray())")
                                                                        opencv_core.UMat eigenvectors)

eigen

@Namespace(value="cv")
 @Cast(value="bool")
public static boolean eigen(@ByVal
                                                                        opencv_core.UMat src,
                                                                        @ByVal
                                                                        opencv_core.UMat eigenvalues)

eigen

@Namespace(value="cv")
 @Cast(value="bool")
public static boolean eigen(@ByVal
                                                                        opencv_core.GpuMat src,
                                                                        @ByVal
                                                                        opencv_core.GpuMat eigenvalues,
                                                                        @ByVal(nullValue="cv::OutputArray(cv::noArray())")
                                                                        opencv_core.GpuMat eigenvectors)

eigen

@Namespace(value="cv")
 @Cast(value="bool")
public static boolean eigen(@ByVal
                                                                        opencv_core.GpuMat src,
                                                                        @ByVal
                                                                        opencv_core.GpuMat eigenvalues)

eigenNonSymmetric

@Namespace(value="cv")
public static void eigenNonSymmetric(@ByVal
                                                            opencv_core.Mat src,
                                                            @ByVal
                                                            opencv_core.Mat eigenvalues,
                                                            @ByVal
                                                            opencv_core.Mat eigenvectors)

\brief Calculates eigenvalues and eigenvectors of a non-symmetric matrix (real eigenvalues only).

\note Assumes real eigenvalues.

The function calculates eigenvalues and eigenvectors (optional) of the square matrix src:


    src*eigenvectors.row(i).t() = eigenvalues.at<srcType>(i)*eigenvectors.row(i).t()

Parameters:: src - input matrix (CV_32FC1 or CV_64FC1 type).; eigenvalues - output vector of eigenvalues (type is the same type as src).; eigenvectors - output matrix of eigenvectors (type is the same type as src). The eigenvectors are stored as subsequent matrix rows, in the same order as the corresponding eigenvalues. \sa eigen

eigenNonSymmetric

@Namespace(value="cv")
public static void eigenNonSymmetric(@ByVal
                                                            opencv_core.UMat src,
                                                            @ByVal
                                                            opencv_core.UMat eigenvalues,
                                                            @ByVal
                                                            opencv_core.UMat eigenvectors)

eigenNonSymmetric

@Namespace(value="cv")
public static void eigenNonSymmetric(@ByVal
                                                            opencv_core.GpuMat src,
                                                            @ByVal
                                                            opencv_core.GpuMat eigenvalues,
                                                            @ByVal
                                                            opencv_core.GpuMat eigenvectors)

calcCovarMatrix

@Namespace(value="cv")
public static void calcCovarMatrix(@Const
                                                          opencv_core.Mat samples,
                                                          int nsamples,
                                                          @ByRef
                                                          opencv_core.Mat covar,
                                                          @ByRef
                                                          opencv_core.Mat mean,
                                                          int flags,
                                                          int ctype)

\brief Calculates the covariance matrix of a set of vectors.

The function cv::calcCovarMatrix calculates the covariance matrix and, optionally, the mean vector of the set of input vectors.

Parameters:: samples - samples stored as separate matrices; nsamples - number of samples; covar - output covariance matrix of the type ctype and square size.; mean - input or output (depending on the flags) array as the average value of the input vectors.; flags - operation flags as a combination of #CovarFlags; ctype - type of the matrixl; it equals 'CV_64F' by default. \sa PCA, mulTransposed, Mahalanobis \todo InputArrayOfArrays

calcCovarMatrix

@Namespace(value="cv")
public static void calcCovarMatrix(@Const
                                                          opencv_core.Mat samples,
                                                          int nsamples,
                                                          @ByRef
                                                          opencv_core.Mat covar,
                                                          @ByRef
                                                          opencv_core.Mat mean,
                                                          int flags)

calcCovarMatrix

@Namespace(value="cv")
public static void calcCovarMatrix(@ByVal
                                                          opencv_core.Mat samples,
                                                          @ByVal
                                                          opencv_core.Mat covar,
                                                          @ByVal
                                                          opencv_core.Mat mean,
                                                          int flags,
                                                          int ctype)

\overload \note use #COVAR_ROWS or #COVAR_COLS flag

Parameters:: samples - samples stored as rows/columns of a single matrix.; covar - output covariance matrix of the type ctype and square size.; mean - input or output (depending on the flags) array as the average value of the input vectors.; flags - operation flags as a combination of #CovarFlags; ctype - type of the matrixl; it equals 'CV_64F' by default.

calcCovarMatrix

@Namespace(value="cv")
public static void calcCovarMatrix(@ByVal
                                                          opencv_core.Mat samples,
                                                          @ByVal
                                                          opencv_core.Mat covar,
                                                          @ByVal
                                                          opencv_core.Mat mean,
                                                          int flags)

calcCovarMatrix

@Namespace(value="cv")
public static void calcCovarMatrix(@ByVal
                                                          opencv_core.UMat samples,
                                                          @ByVal
                                                          opencv_core.UMat covar,
                                                          @ByVal
                                                          opencv_core.UMat mean,
                                                          int flags,
                                                          int ctype)

calcCovarMatrix

@Namespace(value="cv")
public static void calcCovarMatrix(@ByVal
                                                          opencv_core.UMat samples,
                                                          @ByVal
                                                          opencv_core.UMat covar,
                                                          @ByVal
                                                          opencv_core.UMat mean,
                                                          int flags)

calcCovarMatrix

@Namespace(value="cv")
public static void calcCovarMatrix(@ByVal
                                                          opencv_core.GpuMat samples,
                                                          @ByVal
                                                          opencv_core.GpuMat covar,
                                                          @ByVal
                                                          opencv_core.GpuMat mean,
                                                          int flags,
                                                          int ctype)

calcCovarMatrix

@Namespace(value="cv")
public static void calcCovarMatrix(@ByVal
                                                          opencv_core.GpuMat samples,
                                                          @ByVal
                                                          opencv_core.GpuMat covar,
                                                          @ByVal
                                                          opencv_core.GpuMat mean,
                                                          int flags)

PCACompute

@Namespace(value="cv")
public static void PCACompute(@ByVal
                                                     opencv_core.Mat data,
                                                     @ByVal
                                                     opencv_core.Mat mean,
                                                     @ByVal
                                                     opencv_core.Mat eigenvectors,
                                                     int maxComponents)

wrap PCA::operator()

PCACompute

@Namespace(value="cv")
public static void PCACompute(@ByVal
                                                     opencv_core.Mat data,
                                                     @ByVal
                                                     opencv_core.Mat mean,
                                                     @ByVal
                                                     opencv_core.Mat eigenvectors)

PCACompute

@Namespace(value="cv")
public static void PCACompute(@ByVal
                                                     opencv_core.UMat data,
                                                     @ByVal
                                                     opencv_core.UMat mean,
                                                     @ByVal
                                                     opencv_core.UMat eigenvectors,
                                                     int maxComponents)

PCACompute

@Namespace(value="cv")
public static void PCACompute(@ByVal
                                                     opencv_core.UMat data,
                                                     @ByVal
                                                     opencv_core.UMat mean,
                                                     @ByVal
                                                     opencv_core.UMat eigenvectors)

PCACompute

@Namespace(value="cv")
public static void PCACompute(@ByVal
                                                     opencv_core.GpuMat data,
                                                     @ByVal
                                                     opencv_core.GpuMat mean,
                                                     @ByVal
                                                     opencv_core.GpuMat eigenvectors,
                                                     int maxComponents)

PCACompute

@Namespace(value="cv")
public static void PCACompute(@ByVal
                                                     opencv_core.GpuMat data,
                                                     @ByVal
                                                     opencv_core.GpuMat mean,
                                                     @ByVal
                                                     opencv_core.GpuMat eigenvectors)

PCACompute2

@Namespace(value="cv")
 @Name(value="PCACompute")
public static void PCACompute2(@ByVal
                                                                                 opencv_core.Mat data,
                                                                                 @ByVal
                                                                                 opencv_core.Mat mean,
                                                                                 @ByVal
                                                                                 opencv_core.Mat eigenvectors,
                                                                                 @ByVal
                                                                                 opencv_core.Mat eigenvalues,
                                                                                 int maxComponents)

wrap PCA::operator() and add eigenvalues output parameter

PCACompute2

@Namespace(value="cv")
 @Name(value="PCACompute")
public static void PCACompute2(@ByVal
                                                                                 opencv_core.Mat data,
                                                                                 @ByVal
                                                                                 opencv_core.Mat mean,
                                                                                 @ByVal
                                                                                 opencv_core.Mat eigenvectors,
                                                                                 @ByVal
                                                                                 opencv_core.Mat eigenvalues)

PCACompute2

@Namespace(value="cv")
 @Name(value="PCACompute")
public static void PCACompute2(@ByVal
                                                                                 opencv_core.UMat data,
                                                                                 @ByVal
                                                                                 opencv_core.UMat mean,
                                                                                 @ByVal
                                                                                 opencv_core.UMat eigenvectors,
                                                                                 @ByVal
                                                                                 opencv_core.UMat eigenvalues,
                                                                                 int maxComponents)

PCACompute2

@Namespace(value="cv")
 @Name(value="PCACompute")
public static void PCACompute2(@ByVal
                                                                                 opencv_core.UMat data,
                                                                                 @ByVal
                                                                                 opencv_core.UMat mean,
                                                                                 @ByVal
                                                                                 opencv_core.UMat eigenvectors,
                                                                                 @ByVal
                                                                                 opencv_core.UMat eigenvalues)

PCACompute2

@Namespace(value="cv")
 @Name(value="PCACompute")
public static void PCACompute2(@ByVal
                                                                                 opencv_core.GpuMat data,
                                                                                 @ByVal
                                                                                 opencv_core.GpuMat mean,
                                                                                 @ByVal
                                                                                 opencv_core.GpuMat eigenvectors,
                                                                                 @ByVal
                                                                                 opencv_core.GpuMat eigenvalues,
                                                                                 int maxComponents)

PCACompute2

@Namespace(value="cv")
 @Name(value="PCACompute")
public static void PCACompute2(@ByVal
                                                                                 opencv_core.GpuMat data,
                                                                                 @ByVal
                                                                                 opencv_core.GpuMat mean,
                                                                                 @ByVal
                                                                                 opencv_core.GpuMat eigenvectors,
                                                                                 @ByVal
                                                                                 opencv_core.GpuMat eigenvalues)

PCACompute

@Namespace(value="cv")
public static void PCACompute(@ByVal
                                                     opencv_core.Mat data,
                                                     @ByVal
                                                     opencv_core.Mat mean,
                                                     @ByVal
                                                     opencv_core.Mat eigenvectors,
                                                     double retainedVariance)

wrap PCA::operator()

PCACompute

@Namespace(value="cv")
public static void PCACompute(@ByVal
                                                     opencv_core.UMat data,
                                                     @ByVal
                                                     opencv_core.UMat mean,
                                                     @ByVal
                                                     opencv_core.UMat eigenvectors,
                                                     double retainedVariance)

PCACompute

@Namespace(value="cv")
public static void PCACompute(@ByVal
                                                     opencv_core.GpuMat data,
                                                     @ByVal
                                                     opencv_core.GpuMat mean,
                                                     @ByVal
                                                     opencv_core.GpuMat eigenvectors,
                                                     double retainedVariance)

PCACompute2

@Namespace(value="cv")
 @Name(value="PCACompute")
public static void PCACompute2(@ByVal
                                                                                 opencv_core.Mat data,
                                                                                 @ByVal
                                                                                 opencv_core.Mat mean,
                                                                                 @ByVal
                                                                                 opencv_core.Mat eigenvectors,
                                                                                 @ByVal
                                                                                 opencv_core.Mat eigenvalues,
                                                                                 double retainedVariance)

wrap PCA::operator() and add eigenvalues output parameter

PCACompute2

@Namespace(value="cv")
 @Name(value="PCACompute")
public static void PCACompute2(@ByVal
                                                                                 opencv_core.UMat data,
                                                                                 @ByVal
                                                                                 opencv_core.UMat mean,
                                                                                 @ByVal
                                                                                 opencv_core.UMat eigenvectors,
                                                                                 @ByVal
                                                                                 opencv_core.UMat eigenvalues,
                                                                                 double retainedVariance)

PCACompute2

@Namespace(value="cv")
 @Name(value="PCACompute")
public static void PCACompute2(@ByVal
                                                                                 opencv_core.GpuMat data,
                                                                                 @ByVal
                                                                                 opencv_core.GpuMat mean,
                                                                                 @ByVal
                                                                                 opencv_core.GpuMat eigenvectors,
                                                                                 @ByVal
                                                                                 opencv_core.GpuMat eigenvalues,
                                                                                 double retainedVariance)

PCAProject

@Namespace(value="cv")
public static void PCAProject(@ByVal
                                                     opencv_core.Mat data,
                                                     @ByVal
                                                     opencv_core.Mat mean,
                                                     @ByVal
                                                     opencv_core.Mat eigenvectors,
                                                     @ByVal
                                                     opencv_core.Mat result)

wrap PCA::project

PCAProject

@Namespace(value="cv")
public static void PCAProject(@ByVal
                                                     opencv_core.UMat data,
                                                     @ByVal
                                                     opencv_core.UMat mean,
                                                     @ByVal
                                                     opencv_core.UMat eigenvectors,
                                                     @ByVal
                                                     opencv_core.UMat result)

PCAProject

@Namespace(value="cv")
public static void PCAProject(@ByVal
                                                     opencv_core.GpuMat data,
                                                     @ByVal
                                                     opencv_core.GpuMat mean,
                                                     @ByVal
                                                     opencv_core.GpuMat eigenvectors,
                                                     @ByVal
                                                     opencv_core.GpuMat result)

PCABackProject

@Namespace(value="cv")
public static void PCABackProject(@ByVal
                                                         opencv_core.Mat data,
                                                         @ByVal
                                                         opencv_core.Mat mean,
                                                         @ByVal
                                                         opencv_core.Mat eigenvectors,
                                                         @ByVal
                                                         opencv_core.Mat result)

wrap PCA::backProject

PCABackProject

@Namespace(value="cv")
public static void PCABackProject(@ByVal
                                                         opencv_core.UMat data,
                                                         @ByVal
                                                         opencv_core.UMat mean,
                                                         @ByVal
                                                         opencv_core.UMat eigenvectors,
                                                         @ByVal
                                                         opencv_core.UMat result)

PCABackProject

@Namespace(value="cv")
public static void PCABackProject(@ByVal
                                                         opencv_core.GpuMat data,
                                                         @ByVal
                                                         opencv_core.GpuMat mean,
                                                         @ByVal
                                                         opencv_core.GpuMat eigenvectors,
                                                         @ByVal
                                                         opencv_core.GpuMat result)

SVDecomp

@Namespace(value="cv")
public static void SVDecomp(@ByVal
                                                   opencv_core.Mat src,
                                                   @ByVal
                                                   opencv_core.Mat w,
                                                   @ByVal
                                                   opencv_core.Mat u,
                                                   @ByVal
                                                   opencv_core.Mat vt,
                                                   int flags)

wrap SVD::compute

SVDecomp

@Namespace(value="cv")
public static void SVDecomp(@ByVal
                                                   opencv_core.Mat src,
                                                   @ByVal
                                                   opencv_core.Mat w,
                                                   @ByVal
                                                   opencv_core.Mat u,
                                                   @ByVal
                                                   opencv_core.Mat vt)

SVDecomp

@Namespace(value="cv")
public static void SVDecomp(@ByVal
                                                   opencv_core.UMat src,
                                                   @ByVal
                                                   opencv_core.UMat w,
                                                   @ByVal
                                                   opencv_core.UMat u,
                                                   @ByVal
                                                   opencv_core.UMat vt,
                                                   int flags)

SVDecomp

@Namespace(value="cv")
public static void SVDecomp(@ByVal
                                                   opencv_core.UMat src,
                                                   @ByVal
                                                   opencv_core.UMat w,
                                                   @ByVal
                                                   opencv_core.UMat u,
                                                   @ByVal
                                                   opencv_core.UMat vt)

SVDecomp

@Namespace(value="cv")
public static void SVDecomp(@ByVal
                                                   opencv_core.GpuMat src,
                                                   @ByVal
                                                   opencv_core.GpuMat w,
                                                   @ByVal
                                                   opencv_core.GpuMat u,
                                                   @ByVal
                                                   opencv_core.GpuMat vt,
                                                   int flags)

SVDecomp

@Namespace(value="cv")
public static void SVDecomp(@ByVal
                                                   opencv_core.GpuMat src,
                                                   @ByVal
                                                   opencv_core.GpuMat w,
                                                   @ByVal
                                                   opencv_core.GpuMat u,
                                                   @ByVal
                                                   opencv_core.GpuMat vt)

SVBackSubst

@Namespace(value="cv")
public static void SVBackSubst(@ByVal
                                                      opencv_core.Mat w,
                                                      @ByVal
                                                      opencv_core.Mat u,
                                                      @ByVal
                                                      opencv_core.Mat vt,
                                                      @ByVal
                                                      opencv_core.Mat rhs,
                                                      @ByVal
                                                      opencv_core.Mat dst)

wrap SVD::backSubst

SVBackSubst

@Namespace(value="cv")
public static void SVBackSubst(@ByVal
                                                      opencv_core.UMat w,
                                                      @ByVal
                                                      opencv_core.UMat u,
                                                      @ByVal
                                                      opencv_core.UMat vt,
                                                      @ByVal
                                                      opencv_core.UMat rhs,
                                                      @ByVal
                                                      opencv_core.UMat dst)

SVBackSubst

@Namespace(value="cv")
public static void SVBackSubst(@ByVal
                                                      opencv_core.GpuMat w,
                                                      @ByVal
                                                      opencv_core.GpuMat u,
                                                      @ByVal
                                                      opencv_core.GpuMat vt,
                                                      @ByVal
                                                      opencv_core.GpuMat rhs,
                                                      @ByVal
                                                      opencv_core.GpuMat dst)

Mahalanobis
```
@Namespace(value="cv")
public static double Mahalanobis(@ByVal
                                                        opencv_core.Mat v1,
                                                        @ByVal
                                                        opencv_core.Mat v2,
                                                        @ByVal
                                                        opencv_core.Mat icovar)
```
\brief Calculates the Mahalanobis distance between two vectors.
The function cv::Mahalanobis calculates and returns the weighted distance between two vectors: \f[d( \texttt{vec1} , \texttt{vec2} )= \sqrt{\sum_{i,j}{\texttt{icovar(i,j)}\cdot(\texttt{vec1}(I)-\texttt{vec2}(I))\cdot(\texttt{vec1(j)}-\texttt{vec2(j)})} }\f] The covariance matrix may be calculated using the #calcCovarMatrix function and then inverted using the invert function (preferably using the #DECOMP_SVD method, as the most accurate).

Parameters:

v1 - first 1D input vector.

v2 - second 1D input vector.

icovar - inverse covariance matrix.

Mahalanobis

@Namespace(value="cv")
public static double Mahalanobis(@ByVal
                                                        opencv_core.UMat v1,
                                                        @ByVal
                                                        opencv_core.UMat v2,
                                                        @ByVal
                                                        opencv_core.UMat icovar)

Mahalanobis

@Namespace(value="cv")
public static double Mahalanobis(@ByVal
                                                        opencv_core.GpuMat v1,
                                                        @ByVal
                                                        opencv_core.GpuMat v2,
                                                        @ByVal
                                                        opencv_core.GpuMat icovar)

dft
```
@Namespace(value="cv")
public static void dft(@ByVal
                                              opencv_core.Mat src,
                                              @ByVal
                                              opencv_core.Mat dst,
                                              int flags,
                                              int nonzeroRows)
```
\brief Performs a forward or inverse Discrete Fourier transform of a 1D or 2D floating-point array.
The function cv::dft performs one of the following: - Forward the Fourier transform of a 1D vector of N elements: \f[Y = F^{(N)} \cdot X,\f] where \f$F^{(N)}_{jk}=\exp(-2\pi i j k/N)\f$ and \f$i=\sqrt{-1}\f$ - Inverse the Fourier transform of a 1D vector of N elements: \f[\begin{array}{l} X'= \left (F^{(N)} \right )^{-1} \cdot Y = \left (F^{(N)} \right )^* \cdot y \\ X = (1/N) \cdot X, \end{array}\f] where \f$F^*=\left(\textrm{Re}(F^{(N)})-\textrm{Im}(F^{(N)})\right)^T\f$ - Forward the 2D Fourier transform of a M x N matrix: \f[Y = F^{(M)} \cdot X \cdot F^{(N)}\f] - Inverse the 2D Fourier transform of a M x N matrix: \f[\begin{array}{l} X'= \left (F^{(M)} \right )^* \cdot Y \cdot \left (F^{(N)} \right )^* \\ X = \frac{1}{M \cdot N} \cdot X' \end{array}\f]
In case of real (single-channel) data, the output spectrum of the forward Fourier transform or input spectrum of the inverse Fourier transform can be represented in a packed format called *CCS* (complex-conjugate-symmetrical). It was borrowed from IPL (Intel\* Image Processing Library). Here is how 2D *CCS* spectrum looks: \f[\begin{bmatrix} Re Y_{0,0} & Re Y_{0,1} & Im Y_{0,1} & Re Y_{0,2} & Im Y_{0,2} & \cdots & Re Y_{0,N/2-1} & Im Y_{0,N/2-1} & Re Y_{0,N/2} \\ Re Y_{1,0} & Re Y_{1,1} & Im Y_{1,1} & Re Y_{1,2} & Im Y_{1,2} & \cdots & Re Y_{1,N/2-1} & Im Y_{1,N/2-1} & Re Y_{1,N/2} \\ Im Y_{1,0} & Re Y_{2,1} & Im Y_{2,1} & Re Y_{2,2} & Im Y_{2,2} & \cdots & Re Y_{2,N/2-1} & Im Y_{2,N/2-1} & Im Y_{1,N/2} \\ \hdotsfor{9} \\ Re Y_{M/2-1,0} & Re Y_{M-3,1} & Im Y_{M-3,1} & \hdotsfor{3} & Re Y_{M-3,N/2-1} & Im Y_{M-3,N/2-1}& Re Y_{M/2-1,N/2} \\ Im Y_{M/2-1,0} & Re Y_{M-2,1} & Im Y_{M-2,1} & \hdotsfor{3} & Re Y_{M-2,N/2-1} & Im Y_{M-2,N/2-1}& Im Y_{M/2-1,N/2} \\ Re Y_{M/2,0} & Re Y_{M-1,1} & Im Y_{M-1,1} & \hdotsfor{3} & Re Y_{M-1,N/2-1} & Im Y_{M-1,N/2-1}& Re Y_{M/2,N/2} \end{bmatrix}\f]
In case of 1D transform of a real vector, the output looks like the first row of the matrix above.
So, the function chooses an operation mode depending on the flags and size of the input array: - If #DFT_ROWS is set or the input array has a single row or single column, the function performs a 1D forward or inverse transform of each row of a matrix when #DFT_ROWS is set. Otherwise, it performs a 2D transform. - If the input array is real and #DFT_INVERSE is not set, the function performs a forward 1D or 2D transform: - When #DFT_COMPLEX_OUTPUT is set, the output is a complex matrix of the same size as input. - When #DFT_COMPLEX_OUTPUT is not set, the output is a real matrix of the same size as input. In case of 2D transform, it uses the packed format as shown above. In case of a single 1D transform, it looks like the first row of the matrix above. In case of multiple 1D transforms (when using the #DFT_ROWS flag), each row of the output matrix looks like the first row of the matrix above. - If the input array is complex and either #DFT_INVERSE or #DFT_REAL_OUTPUT are not set, the output is a complex array of the same size as input. The function performs a forward or inverse 1D or 2D transform of the whole input array or each row of the input array independently, depending on the flags DFT_INVERSE and DFT_ROWS. - When #DFT_INVERSE is set and the input array is real, or it is complex but #DFT_REAL_OUTPUT is set, the output is a real array of the same size as input. The function performs a 1D or 2D inverse transformation of the whole input array or each individual row, depending on the flags #DFT_INVERSE and #DFT_ROWS.
If #DFT_SCALE is set, the scaling is done after the transformation.
Unlike dct , the function supports arrays of arbitrary size. But only those arrays are processed efficiently, whose sizes can be factorized in a product of small prime numbers (2, 3, and 5 in the current implementation). Such an efficient DFT size can be calculated using the getOptimalDFTSize method.
The sample below illustrates how to calculate a DFT-based convolution of two 2D real arrays:
```
    void convolveDFT(InputArray A, InputArray B, OutputArray C)
    {
        // reallocate the output array if needed
        C.create(abs(A.rows - B.rows)+1, abs(A.cols - B.cols)+1, A.type());
        Size dftSize;
        // calculate the size of DFT transform
        dftSize.width = getOptimalDFTSize(A.cols + B.cols - 1);
        dftSize.height = getOptimalDFTSize(A.rows + B.rows - 1);

        // allocate temporary buffers and initialize them with 0's
        Mat tempA(dftSize, A.type(), Scalar::all(0));
        Mat tempB(dftSize, B.type(), Scalar::all(0));

        // copy A and B to the top-left corners of tempA and tempB, respectively
        Mat roiA(tempA, Rect(0,0,A.cols,A.rows));
        A.copyTo(roiA);
        Mat roiB(tempB, Rect(0,0,B.cols,B.rows));
        B.copyTo(roiB);

        // now transform the padded A & B in-place;
        // use "nonzeroRows" hint for faster processing
        dft(tempA, tempA, 0, A.rows);
        dft(tempB, tempB, 0, B.rows);

        // multiply the spectrums;
        // the function handles packed spectrum representations well
        mulSpectrums(tempA, tempB, tempA);

        // transform the product back from the frequency domain.
        // Even though all the result rows will be non-zero,
        // you need only the first C.rows of them, and thus you
        // pass nonzeroRows == C.rows
        dft(tempA, tempA, DFT_INVERSE + DFT_SCALE, C.rows);

        // now copy the result back to C.
        tempA(Rect(0, 0, C.cols, C.rows)).copyTo(C);

        // all the temporary buffers will be deallocated automatically
    }
```
To optimize this sample, consider the following approaches: - Since nonzeroRows != 0 is passed to the forward transform calls and since A and B are copied to the top-left corners of tempA and tempB, respectively, it is not necessary to clear the whole tempA and tempB. It is only necessary to clear the tempA.cols - A.cols ( tempB.cols - B.cols) rightmost columns of the matrices. - This DFT-based convolution does not have to be applied to the whole big arrays, especially if B is significantly smaller than A or vice versa. Instead, you can calculate convolution by parts. To do this, you need to split the output array C into multiple tiles. For each tile, estimate which parts of A and B are required to calculate convolution in this tile. If the tiles in C are too small, the speed will decrease a lot because of repeated work. In the ultimate case, when each tile in C is a single pixel, the algorithm becomes equivalent to the naive convolution algorithm. If the tiles are too big, the temporary arrays tempA and tempB become too big and there is also a slowdown because of bad cache locality. So, there is an optimal tile size somewhere in the middle. - If different tiles in C can be calculated in parallel and, thus, the convolution is done by parts, the loop can be threaded.
All of the above improvements have been implemented in #matchTemplate and #filter2D . Therefore, by using them, you can get the performance even better than with the above theoretically optimal implementation. Though, those two functions actually calculate cross-correlation, not convolution, so you need to "flip" the second convolution operand B vertically and horizontally using flip . \note - An example using the discrete fourier transform can be found at opencv_source_code/samples/cpp/dft.cpp - (Python) An example using the dft functionality to perform Wiener deconvolution can be found at opencv_source/samples/python/deconvolution.py - (Python) An example rearranging the quadrants of a Fourier image can be found at opencv_source/samples/python/dft.py
Parameters:

src - input array that could be real or complex.

dst - output array whose size and type depends on the flags .

flags - transformation flags, representing a combination of the #DftFlags

nonzeroRows - when the parameter is not zero, the function assumes that only the first nonzeroRows rows of the input array (#DFT_INVERSE is not set) or only the first nonzeroRows of the output array (#DFT_INVERSE is set) contain non-zeros, thus, the function can handle the rest of the rows more efficiently and save some time; this technique is very useful for calculating array cross-correlation or convolution using DFT. \sa dct , getOptimalDFTSize , mulSpectrums, filter2D , matchTemplate , flip , cartToPolar , magnitude , phase

dft

@Namespace(value="cv")
public static void dft(@ByVal
                                              opencv_core.Mat src,
                                              @ByVal
                                              opencv_core.Mat dst)

dft

@Namespace(value="cv")
public static void dft(@ByVal
                                              opencv_core.UMat src,
                                              @ByVal
                                              opencv_core.UMat dst,
                                              int flags,
                                              int nonzeroRows)

dft

@Namespace(value="cv")
public static void dft(@ByVal
                                              opencv_core.UMat src,
                                              @ByVal
                                              opencv_core.UMat dst)

dft

@Namespace(value="cv")
public static void dft(@ByVal
                                              opencv_core.GpuMat src,
                                              @ByVal
                                              opencv_core.GpuMat dst,
                                              int flags,
                                              int nonzeroRows)

dft

@Namespace(value="cv")
public static void dft(@ByVal
                                              opencv_core.GpuMat src,
                                              @ByVal
                                              opencv_core.GpuMat dst)

idft
```
@Namespace(value="cv")
public static void idft(@ByVal
                                               opencv_core.Mat src,
                                               @ByVal
                                               opencv_core.Mat dst,
                                               int flags,
                                               int nonzeroRows)
```
\brief Calculates the inverse Discrete Fourier Transform of a 1D or 2D array.
idft(src, dst, flags) is equivalent to dft(src, dst, flags | #DFT_INVERSE) . \note None of dft and idft scales the result by default. So, you should pass #DFT_SCALE to one of dft or idft explicitly to make these transforms mutually inverse. \sa dft, dct, idct, mulSpectrums, getOptimalDFTSize

Parameters:

src - input floating-point real or complex array.

dst - output array whose size and type depend on the flags.

flags - operation flags (see dft and #DftFlags).

nonzeroRows - number of dst rows to process; the rest of the rows have undefined content (see the convolution sample in dft description.

idft

@Namespace(value="cv")
public static void idft(@ByVal
                                               opencv_core.Mat src,
                                               @ByVal
                                               opencv_core.Mat dst)

idft

@Namespace(value="cv")
public static void idft(@ByVal
                                               opencv_core.UMat src,
                                               @ByVal
                                               opencv_core.UMat dst,
                                               int flags,
                                               int nonzeroRows)

idft

@Namespace(value="cv")
public static void idft(@ByVal
                                               opencv_core.UMat src,
                                               @ByVal
                                               opencv_core.UMat dst)

idft

@Namespace(value="cv")
public static void idft(@ByVal
                                               opencv_core.GpuMat src,
                                               @ByVal
                                               opencv_core.GpuMat dst,
                                               int flags,
                                               int nonzeroRows)

idft

@Namespace(value="cv")
public static void idft(@ByVal
                                               opencv_core.GpuMat src,
                                               @ByVal
                                               opencv_core.GpuMat dst)

dct
```
@Namespace(value="cv")
public static void dct(@ByVal
                                              opencv_core.Mat src,
                                              @ByVal
                                              opencv_core.Mat dst,
                                              int flags)
```
\brief Performs a forward or inverse discrete Cosine transform of 1D or 2D array.
The function cv::dct performs a forward or inverse discrete Cosine transform (DCT) of a 1D or 2D floating-point array: - Forward Cosine transform of a 1D vector of N elements: \f[Y = C^{(N)} \cdot X\f] where \f[C^{(N)}_{jk}= \sqrt{\alpha_j/N} \cos \left ( \frac{\pi(2k+1)j}{2N} \right )\f] and \f$\alpha_0=1\f$, \f$\alpha_j=2\f$ for *j \> 0*. - Inverse Cosine transform of a 1D vector of N elements: \f[X = \left (C^{(N)} \right )^{-1} \cdot Y = \left (C^{(N)} \right )^T \cdot Y\f] (since \f$C^{(N)}\f$ is an orthogonal matrix, \f$C^{(N)} \cdot \left(C^{(N)}\right)^T = I\f$ ) - Forward 2D Cosine transform of M x N matrix: \f[Y = C^{(N)} \cdot X \cdot \left (C^{(N)} \right )^T\f] - Inverse 2D Cosine transform of M x N matrix: \f[X = \left (C^{(N)} \right )^T \cdot X \cdot C^{(N)}\f]
The function chooses the mode of operation by looking at the flags and size of the input array: - If (flags & #DCT_INVERSE) == 0 , the function does a forward 1D or 2D transform. Otherwise, it is an inverse 1D or 2D transform. - If (flags & #DCT_ROWS) != 0 , the function performs a 1D transform of each row. - If the array is a single column or a single row, the function performs a 1D transform. - If none of the above is true, the function performs a 2D transform.
\note Currently dct supports even-size arrays (2, 4, 6 ...). For data analysis and approximation, you can pad the array when necessary. Also, the function performance depends very much, and not monotonically, on the array size (see getOptimalDFTSize ). In the current implementation DCT of a vector of size N is calculated via DFT of a vector of size N/2 . Thus, the optimal DCT size N1 \>= N can be calculated as:
```
    size_t getOptimalDCTSize(size_t N) { return 2*getOptimalDFTSize((N+1)/2); }
    N1 = getOptimalDCTSize(N);
```
Parameters:

src - input floating-point array.

dst - output array of the same size and type as src .

flags - transformation flags as a combination of cv::DftFlags (DCT_*) \sa dft , getOptimalDFTSize , idct

dct

@Namespace(value="cv")
public static void dct(@ByVal
                                              opencv_core.Mat src,
                                              @ByVal
                                              opencv_core.Mat dst)

dct

@Namespace(value="cv")
public static void dct(@ByVal
                                              opencv_core.UMat src,
                                              @ByVal
                                              opencv_core.UMat dst,
                                              int flags)

dct

@Namespace(value="cv")
public static void dct(@ByVal
                                              opencv_core.UMat src,
                                              @ByVal
                                              opencv_core.UMat dst)

dct

@Namespace(value="cv")
public static void dct(@ByVal
                                              opencv_core.GpuMat src,
                                              @ByVal
                                              opencv_core.GpuMat dst,
                                              int flags)

dct

@Namespace(value="cv")
public static void dct(@ByVal
                                              opencv_core.GpuMat src,
                                              @ByVal
                                              opencv_core.GpuMat dst)

idct

@Namespace(value="cv")
public static void idct(@ByVal
                                               opencv_core.Mat src,
                                               @ByVal
                                               opencv_core.Mat dst,
                                               int flags)

\brief Calculates the inverse Discrete Cosine Transform of a 1D or 2D array.

idct(src, dst, flags) is equivalent to dct(src, dst, flags | DCT_INVERSE).

Parameters:: src - input floating-point single-channel array.; dst - output array of the same size and type as src.; flags - operation flags. \sa dct, dft, idft, getOptimalDFTSize

idct

@Namespace(value="cv")
public static void idct(@ByVal
                                               opencv_core.Mat src,
                                               @ByVal
                                               opencv_core.Mat dst)

idct

@Namespace(value="cv")
public static void idct(@ByVal
                                               opencv_core.UMat src,
                                               @ByVal
                                               opencv_core.UMat dst,
                                               int flags)

idct

@Namespace(value="cv")
public static void idct(@ByVal
                                               opencv_core.UMat src,
                                               @ByVal
                                               opencv_core.UMat dst)

idct

@Namespace(value="cv")
public static void idct(@ByVal
                                               opencv_core.GpuMat src,
                                               @ByVal
                                               opencv_core.GpuMat dst,
                                               int flags)

idct

@Namespace(value="cv")
public static void idct(@ByVal
                                               opencv_core.GpuMat src,
                                               @ByVal
                                               opencv_core.GpuMat dst)

mulSpectrums
```
@Namespace(value="cv")
public static void mulSpectrums(@ByVal
                                                       opencv_core.Mat a,
                                                       @ByVal
                                                       opencv_core.Mat b,
                                                       @ByVal
                                                       opencv_core.Mat c,
                                                       int flags,
                                                       @Cast(value="bool")
                                                       boolean conjB)
```
\brief Performs the per-element multiplication of two Fourier spectrums.
The function cv::mulSpectrums performs the per-element multiplication of the two CCS-packed or complex matrices that are results of a real or complex Fourier transform.
The function, together with dft and idft , may be used to calculate convolution (pass conjB=false ) or correlation (pass conjB=true ) of two arrays rapidly. When the arrays are complex, they are simply multiplied (per element) with an optional conjugation of the second-array elements. When the arrays are real, they are assumed to be CCS-packed (see dft for details).

Parameters:

a - first input array.

b - second input array of the same size and type as src1 .

c - output array of the same size and type as src1 .

flags - operation flags; currently, the only supported flag is cv::DFT_ROWS, which indicates that each row of src1 and src2 is an independent 1D Fourier spectrum. If you do not want to use this flag, then simply add a 0 as value.

conjB - optional flag that conjugates the second input array before the multiplication (true) or not (false).

mulSpectrums

@Namespace(value="cv")
public static void mulSpectrums(@ByVal
                                                       opencv_core.Mat a,
                                                       @ByVal
                                                       opencv_core.Mat b,
                                                       @ByVal
                                                       opencv_core.Mat c,
                                                       int flags)

mulSpectrums

@Namespace(value="cv")
public static void mulSpectrums(@ByVal
                                                       opencv_core.UMat a,
                                                       @ByVal
                                                       opencv_core.UMat b,
                                                       @ByVal
                                                       opencv_core.UMat c,
                                                       int flags,
                                                       @Cast(value="bool")
                                                       boolean conjB)

mulSpectrums

@Namespace(value="cv")
public static void mulSpectrums(@ByVal
                                                       opencv_core.UMat a,
                                                       @ByVal
                                                       opencv_core.UMat b,
                                                       @ByVal
                                                       opencv_core.UMat c,
                                                       int flags)

mulSpectrums

@Namespace(value="cv")
public static void mulSpectrums(@ByVal
                                                       opencv_core.GpuMat a,
                                                       @ByVal
                                                       opencv_core.GpuMat b,
                                                       @ByVal
                                                       opencv_core.GpuMat c,
                                                       int flags,
                                                       @Cast(value="bool")
                                                       boolean conjB)

mulSpectrums

@Namespace(value="cv")
public static void mulSpectrums(@ByVal
                                                       opencv_core.GpuMat a,
                                                       @ByVal
                                                       opencv_core.GpuMat b,
                                                       @ByVal
                                                       opencv_core.GpuMat c,
                                                       int flags)

getOptimalDFTSize
```
@Namespace(value="cv")
public static int getOptimalDFTSize(int vecsize)
```
\brief Returns the optimal DFT size for a given vector size.
DFT performance is not a monotonic function of a vector size. Therefore, when you calculate convolution of two arrays or perform the spectral analysis of an array, it usually makes sense to pad the input data with zeros to get a bit larger array that can be transformed much faster than the original one. Arrays whose size is a power-of-two (2, 4, 8, 16, 32, ...) are the fastest to process. Though, the arrays whose size is a product of 2's, 3's, and 5's (for example, 300 = 5\*5\*3\*2\*2) are also processed quite efficiently.
The function cv::getOptimalDFTSize returns the minimum number N that is greater than or equal to vecsize so that the DFT of a vector of size N can be processed efficiently. In the current implementation N = 2 ^p^ \* 3 ^q^ \* 5 ^r^ for some integer p, q, r.
The function returns a negative number if vecsize is too large (very close to INT_MAX ).
While the function cannot be used directly to estimate the optimal vector size for DCT transform (since the current DCT implementation supports only even-size vectors), it can be easily processed as getOptimalDFTSize((vecsize+1)/2)\*2.

Parameters:

vecsize - vector size. \sa dft , dct , idft , idct , mulSpectrums

theRNG
```
@Namespace(value="cv")
 @ByRef
public static opencv_core.RNG theRNG()
```
\brief Returns the default random number generator.
The function cv::theRNG returns the default random number generator. For each thread, there is a separate random number generator, so you can use the function safely in multi-thread environments. If you just need to get a single random number using this generator or initialize an array, you can use randu or randn instead. But if you are going to generate many random numbers inside a loop, it is much faster to use this function to retrieve the generator and then use RNG::operator _Tp() . \sa RNG, randu, randn

setRNGSeed
```
@Namespace(value="cv")
public static void setRNGSeed(int seed)
```
\brief Sets state of default random number generator.
The function cv::setRNGSeed sets state of default random number generator to custom value.

Parameters:

seed - new state for default random number generator \sa RNG, randu, randn

randu

@Namespace(value="cv")
public static void randu(@ByVal
                                                opencv_core.Mat dst,
                                                @ByVal
                                                opencv_core.Mat low,
                                                @ByVal
                                                opencv_core.Mat high)

\brief Generates a single uniformly-distributed random number or an array of random numbers.

Non-template variant of the function fills the matrix dst with uniformly-distributed random numbers from the specified range: \f[\texttt{low} _c \leq \texttt{dst} (I)_c < \texttt{high} _c\f]

Parameters:: dst - output array of random numbers; the array must be pre-allocated.; low - inclusive lower boundary of the generated random numbers.; high - exclusive upper boundary of the generated random numbers. \sa RNG, randn, theRNG

randu

@Namespace(value="cv")
public static void randu(@ByVal
                                                opencv_core.UMat dst,
                                                @ByVal
                                                opencv_core.UMat low,
                                                @ByVal
                                                opencv_core.UMat high)

randu

@Namespace(value="cv")
public static void randu(@ByVal
                                                opencv_core.GpuMat dst,
                                                @ByVal
                                                opencv_core.GpuMat low,
                                                @ByVal
                                                opencv_core.GpuMat high)

randn
```
@Namespace(value="cv")
public static void randn(@ByVal
                                                opencv_core.Mat dst,
                                                @ByVal
                                                opencv_core.Mat mean,
                                                @ByVal
                                                opencv_core.Mat stddev)
```
\brief Fills the array with normally distributed random numbers.
The function cv::randn fills the matrix dst with normally distributed random numbers with the specified mean vector and the standard deviation matrix. The generated random numbers are clipped to fit the value range of the output array data type.

Parameters:

dst - output array of random numbers; the array must be pre-allocated and have 1 to 4 channels.

mean - mean value (expectation) of the generated random numbers.

stddev - standard deviation of the generated random numbers; it can be either a vector (in which case a diagonal standard deviation matrix is assumed) or a square matrix. \sa RNG, randu

randn

@Namespace(value="cv")
public static void randn(@ByVal
                                                opencv_core.UMat dst,
                                                @ByVal
                                                opencv_core.UMat mean,
                                                @ByVal
                                                opencv_core.UMat stddev)

randn

@Namespace(value="cv")
public static void randn(@ByVal
                                                opencv_core.GpuMat dst,
                                                @ByVal
                                                opencv_core.GpuMat mean,
                                                @ByVal
                                                opencv_core.GpuMat stddev)

randShuffle
```
@Namespace(value="cv")
public static void randShuffle(@ByVal
                                                      opencv_core.Mat dst,
                                                      double iterFactor,
                                                      opencv_core.RNG rng)
```
\brief Shuffles the array elements randomly.
The function cv::randShuffle shuffles the specified 1D array by randomly choosing pairs of elements and swapping them. The number of such swap operations will be dst.rows\*dst.cols\*iterFactor .

Parameters:

dst - input/output numerical 1D array.

iterFactor - scale factor that determines the number of random swap operations (see the details below).

rng - optional random number generator used for shuffling; if it is zero, theRNG () is used instead. \sa RNG, sort

randShuffle

@Namespace(value="cv")
public static void randShuffle(@ByVal
                                                      opencv_core.Mat dst)

randShuffle

@Namespace(value="cv")
public static void randShuffle(@ByVal
                                                      opencv_core.UMat dst,
                                                      double iterFactor,
                                                      opencv_core.RNG rng)

randShuffle

@Namespace(value="cv")
public static void randShuffle(@ByVal
                                                      opencv_core.UMat dst)

randShuffle

@Namespace(value="cv")
public static void randShuffle(@ByVal
                                                      opencv_core.GpuMat dst,
                                                      double iterFactor,
                                                      opencv_core.RNG rng)

randShuffle

@Namespace(value="cv")
public static void randShuffle(@ByVal
                                                      opencv_core.GpuMat dst)

kmeans
```
@Namespace(value="cv")
public static double kmeans(@ByVal
                                                   opencv_core.Mat data,
                                                   int K,
                                                   @ByVal
                                                   opencv_core.Mat bestLabels,
                                                   @ByVal
                                                   opencv_core.TermCriteria criteria,
                                                   int attempts,
                                                   int flags,
                                                   @ByVal(nullValue="cv::OutputArray(cv::noArray())")
                                                   opencv_core.Mat centers)
```
\brief Finds centers of clusters and groups input samples around the clusters.
The function kmeans implements a k-means algorithm that finds the centers of cluster_count clusters and groups the input samples around the clusters. As an output, \f$\texttt{labels}_i\f$ contains a 0-based cluster index for the sample stored in the \f$i^{th}\f$ row of the samples matrix.
\note - (Python) An example on K-means clustering can be found at opencv_source_code/samples/python/kmeans.py

Parameters:

data - Data for clustering. An array of N-Dimensional points with float coordinates is needed. Examples of this array can be: - Mat points(count, 2, CV_32F); - Mat points(count, 1, CV_32FC2); - Mat points(1, count, CV_32FC2); - std::vector\ points(sampleCount);

K - Number of clusters to split the set by.

bestLabels - Input/output integer array that stores the cluster indices for every sample.

criteria - The algorithm termination criteria, that is, the maximum number of iterations and/or the desired accuracy. The accuracy is specified as criteria.epsilon. As soon as each of the cluster centers moves by less than criteria.epsilon on some iteration, the algorithm stops.

attempts - Flag to specify the number of times the algorithm is executed using different initial labellings. The algorithm returns the labels that yield the best compactness (see the last function parameter).

flags - Flag that can take values of cv::KmeansFlags

centers - Output matrix of the cluster centers, one row per each cluster center.

Returns:

The function returns the compactness measure that is computed as \f[\sum _i \| \texttt{samples} _i - \texttt{centers} _{ \texttt{labels} _i} \| ^2\f] after every attempt. The best (minimum) value is chosen and the corresponding labels and the compactness value are returned by the function. Basically, you can use only the core of the function, set the number of attempts to 1, initialize labels each time using a custom algorithm, pass them with the ( flags = #KMEANS_USE_INITIAL_LABELS ) flag, and then choose the best (most-compact) clustering.

kmeans

@Namespace(value="cv")
public static double kmeans(@ByVal
                                                   opencv_core.Mat data,
                                                   int K,
                                                   @ByVal
                                                   opencv_core.Mat bestLabels,
                                                   @ByVal
                                                   opencv_core.TermCriteria criteria,
                                                   int attempts,
                                                   int flags)

kmeans

@Namespace(value="cv")
public static double kmeans(@ByVal
                                                   opencv_core.UMat data,
                                                   int K,
                                                   @ByVal
                                                   opencv_core.UMat bestLabels,
                                                   @ByVal
                                                   opencv_core.TermCriteria criteria,
                                                   int attempts,
                                                   int flags,
                                                   @ByVal(nullValue="cv::OutputArray(cv::noArray())")
                                                   opencv_core.UMat centers)

kmeans

@Namespace(value="cv")
public static double kmeans(@ByVal
                                                   opencv_core.UMat data,
                                                   int K,
                                                   @ByVal
                                                   opencv_core.UMat bestLabels,
                                                   @ByVal
                                                   opencv_core.TermCriteria criteria,
                                                   int attempts,
                                                   int flags)

kmeans

@Namespace(value="cv")
public static double kmeans(@ByVal
                                                   opencv_core.GpuMat data,
                                                   int K,
                                                   @ByVal
                                                   opencv_core.GpuMat bestLabels,
                                                   @ByVal
                                                   opencv_core.TermCriteria criteria,
                                                   int attempts,
                                                   int flags,
                                                   @ByVal(nullValue="cv::OutputArray(cv::noArray())")
                                                   opencv_core.GpuMat centers)

kmeans

@Namespace(value="cv")
public static double kmeans(@ByVal
                                                   opencv_core.GpuMat data,
                                                   int K,
                                                   @ByVal
                                                   opencv_core.GpuMat bestLabels,
                                                   @ByVal
                                                   opencv_core.TermCriteria criteria,
                                                   int attempts,
                                                   int flags)

shiftLeft

@Namespace(value="cv")
 @opencv_core.Str
 @Name(value="operator <<")
public static org.bytedeco.javacpp.BytePointer shiftLeft(@opencv_core.Str
                                                                                                                              org.bytedeco.javacpp.BytePointer out,
                                                                                                                              @opencv_core.Ptr
                                                                                                                              opencv_core.Formatted fmtd)

shiftLeft

@Namespace(value="cv")
 @opencv_core.Str
 @Name(value="operator <<")
public static String shiftLeft(@opencv_core.Str
                                                                                                    String out,
                                                                                                    @opencv_core.Ptr
                                                                                                    opencv_core.Formatted fmtd)

shiftLeft

@Namespace(value="cv")
 @opencv_core.Str
 @Name(value="operator <<")
public static org.bytedeco.javacpp.BytePointer shiftLeft(@opencv_core.Str
                                                                                                                              org.bytedeco.javacpp.BytePointer out,
                                                                                                                              @Const @ByRef
                                                                                                                              opencv_core.Mat mtx)

shiftLeft

@Namespace(value="cv")
 @opencv_core.Str
 @Name(value="operator <<")
public static String shiftLeft(@opencv_core.Str
                                                                                                    String out,
                                                                                                    @Const @ByRef
                                                                                                    opencv_core.Mat mtx)

createContinuous

@Namespace(value="cv::cuda")
public static void createContinuous(int rows,
                                                                 int cols,
                                                                 int type,
                                                                 @ByVal
                                                                 opencv_core.Mat arr)

\brief Creates a continuous matrix.

Parameters:: rows - Row count.; cols - Column count.; type - Type of the matrix.; arr - Destination matrix. This parameter changes only if it has a proper type and area ( \f$\texttt{rows} \times \texttt{cols}\f$ ).
Matrix is called continuous if its elements are stored continuously, that is, without gaps at the end of each row.

createContinuous

@Namespace(value="cv::cuda")
public static void createContinuous(int rows,
                                                                 int cols,
                                                                 int type,
                                                                 @ByVal
                                                                 opencv_core.UMat arr)

createContinuous

@Namespace(value="cv::cuda")
public static void createContinuous(int rows,
                                                                 int cols,
                                                                 int type,
                                                                 @ByVal
                                                                 opencv_core.GpuMat arr)

ensureSizeIsEnough

@Namespace(value="cv::cuda")
public static void ensureSizeIsEnough(int rows,
                                                                   int cols,
                                                                   int type,
                                                                   @ByVal
                                                                   opencv_core.Mat arr)

\brief Ensures that the size of a matrix is big enough and the matrix has a proper type.

Parameters:: rows - Minimum desired number of rows.; cols - Minimum desired number of columns.; type - Desired matrix type.; arr - Destination matrix.
The function does not reallocate memory if the matrix has proper attributes already.

ensureSizeIsEnough

@Namespace(value="cv::cuda")
public static void ensureSizeIsEnough(int rows,
                                                                   int cols,
                                                                   int type,
                                                                   @ByVal
                                                                   opencv_core.UMat arr)

ensureSizeIsEnough

@Namespace(value="cv::cuda")
public static void ensureSizeIsEnough(int rows,
                                                                   int cols,
                                                                   int type,
                                                                   @ByVal
                                                                   opencv_core.GpuMat arr)

setBufferPoolUsage

@Namespace(value="cv::cuda")
public static void setBufferPoolUsage(@Cast(value="bool")
                                                                   boolean on)

BufferPool management (must be called before Stream creation)

setBufferPoolConfig

@Namespace(value="cv::cuda")
public static void setBufferPoolConfig(int deviceId,
                                                                    @Cast(value="size_t")
                                                                    long stackSize,
                                                                    int stackCount)

registerPageLocked

@Namespace(value="cv::cuda")
public static void registerPageLocked(@ByRef
                                                                   opencv_core.Mat m)

\brief Page-locks the memory of matrix and maps it for the device(s).

Parameters:: m - Input matrix.

unregisterPageLocked

@Namespace(value="cv::cuda")
public static void unregisterPageLocked(@ByRef
                                                                     opencv_core.Mat m)

\brief Unmaps the memory of matrix and makes it pageable again.

Parameters:: m - Input matrix.

getCudaEnabledDeviceCount
```
@Namespace(value="cv::cuda")
public static int getCudaEnabledDeviceCount()
```
\addtogroup cudacore_init /** \{
/** \brief Returns the number of installed CUDA-enabled devices.
Use this function before any other CUDA functions calls. If OpenCV is compiled without CUDA support, this function returns 0. If the CUDA driver is not installed, or is incompatible, this function returns -1.

setDevice
```
@Namespace(value="cv::cuda")
public static void setDevice(int device)
```
\brief Sets a device and initializes it for the current thread.

Parameters:

device - System index of a CUDA device starting with 0.
If the call of this function is omitted, a default device is initialized at the fist CUDA usage.

getDevice
```
@Namespace(value="cv::cuda")
public static int getDevice()
```
\brief Returns the current device index set by cuda::setDevice or initialized by default.

resetDevice
```
@Namespace(value="cv::cuda")
public static void resetDevice()
```
\brief Explicitly destroys and cleans up all resources associated with the current device in the current process.
Any subsequent API call to this device will reinitialize the device.

deviceSupports

@Namespace(value="cv::cuda")
 @Cast(value="bool")
public static boolean deviceSupports(@Cast(value="cv::cuda::FeatureSet")
                                                                                       int feature_set)

checks whether current device supports the given feature

printCudaDeviceInfo

@Namespace(value="cv::cuda")
public static void printCudaDeviceInfo(int device)

printShortCudaDeviceInfo

@Namespace(value="cv::cuda")
public static void printShortCudaDeviceInfo(int device)

haveOpenCL

@Namespace(value="cv::ocl")
 @Cast(value="bool")
public static boolean haveOpenCL()

\addtogroup core_opencl \{

useOpenCL

@Namespace(value="cv::ocl")
 @Cast(value="bool")
public static boolean useOpenCL()

haveAmdBlas

@Namespace(value="cv::ocl")
 @Cast(value="bool")
public static boolean haveAmdBlas()

haveAmdFft

@Namespace(value="cv::ocl")
 @Cast(value="bool")
public static boolean haveAmdFft()

setUseOpenCL

@Namespace(value="cv::ocl")
public static void setUseOpenCL(@Cast(value="bool")
                                                            boolean flag)

finish

@Namespace(value="cv::ocl")
public static void finish()

haveSVM

@Namespace(value="cv::ocl")
 @Cast(value="bool")
public static boolean haveSVM()

attachContext
```
@Namespace(value="cv::ocl")
public static void attachContext(@opencv_core.Str
                                                             org.bytedeco.javacpp.BytePointer platformName,
                                                             org.bytedeco.javacpp.Pointer platformID,
                                                             org.bytedeco.javacpp.Pointer context,
                                                             org.bytedeco.javacpp.Pointer deviceID)
```
\brief Attaches OpenCL context to OpenCV \note OpenCV will check if available OpenCL platform has platformName name, then assign context to OpenCV and call clRetainContext function. The deviceID device will be used as target device and new command queue will be created.

Parameters:

platformName - name of OpenCL platform to attach, this string is used to check if platform is available to OpenCV at runtime

platformID - ID of platform attached context was created for

context - OpenCL context to be attached to OpenCV

deviceID - ID of device, must be created from attached context

attachContext

@Namespace(value="cv::ocl")
public static void attachContext(@opencv_core.Str
                                                             String platformName,
                                                             org.bytedeco.javacpp.Pointer platformID,
                                                             org.bytedeco.javacpp.Pointer context,
                                                             org.bytedeco.javacpp.Pointer deviceID)

convertFromBuffer

@Namespace(value="cv::ocl")
public static void convertFromBuffer(org.bytedeco.javacpp.Pointer cl_mem_buffer,
                                                                 @Cast(value="size_t")
                                                                 long step,
                                                                 int rows,
                                                                 int cols,
                                                                 int type,
                                                                 @ByRef
                                                                 opencv_core.UMat dst)

\brief Convert OpenCL buffer to UMat \note OpenCL buffer (cl_mem_buffer) should contain 2D image data, compatible with OpenCV. Memory content is not copied from clBuffer to UMat. Instead, buffer handle assigned to UMat and clRetainMemObject is called.

Parameters:: cl_mem_buffer - source clBuffer handle; step - num of bytes in single row; rows - number of rows; cols - number of cols; type - OpenCV type of image; dst - destination UMat

convertFromImage

@Namespace(value="cv::ocl")
public static void convertFromImage(org.bytedeco.javacpp.Pointer cl_mem_image,
                                                                @ByRef
                                                                opencv_core.UMat dst)

\brief Convert OpenCL image2d_t to UMat \note OpenCL image2d_t (cl_mem_image), should be compatible with OpenCV UMat formats. Memory content is copied from image to UMat with clEnqueueCopyImageToBuffer function.

Parameters:: cl_mem_image - source image2d_t handle; dst - destination UMat

convertTypeStr

@Namespace(value="cv::ocl")
 @Cast(value="const char*")
public static org.bytedeco.javacpp.BytePointer convertTypeStr(int sdepth,
                                                                                                                      int ddepth,
                                                                                                                      int cn,
                                                                                                                      @Cast(value="char*")
                                                                                                                      org.bytedeco.javacpp.BytePointer buf)

convertTypeStr

@Namespace(value="cv::ocl")
public static String convertTypeStr(int sdepth,
                                                                int ddepth,
                                                                int cn,
                                                                @Cast(value="char*")
                                                                ByteBuffer buf)

convertTypeStr

@Namespace(value="cv::ocl")
 @Cast(value="const char*")
public static org.bytedeco.javacpp.BytePointer convertTypeStr(int sdepth,
                                                                                                                      int ddepth,
                                                                                                                      int cn,
                                                                                                                      @Cast(value="char*")
                                                                                                                      byte[] buf)

typeToStr

@Namespace(value="cv::ocl")
 @Cast(value="const char*")
public static org.bytedeco.javacpp.BytePointer typeToStr(int t)

memopTypeToStr

@Namespace(value="cv::ocl")
 @Cast(value="const char*")
public static org.bytedeco.javacpp.BytePointer memopTypeToStr(int t)

vecopTypeToStr

@Namespace(value="cv::ocl")
 @Cast(value="const char*")
public static org.bytedeco.javacpp.BytePointer vecopTypeToStr(int t)

getOpenCLErrorString

@Namespace(value="cv::ocl")
 @Cast(value="const char*")
public static org.bytedeco.javacpp.BytePointer getOpenCLErrorString(int errorCode)

kernelToStr

@Namespace(value="cv::ocl")
 @opencv_core.Str
public static org.bytedeco.javacpp.BytePointer kernelToStr(@ByVal
                                                                                                         opencv_core.Mat _kernel,
                                                                                                         int ddepth,
                                                                                                         @Cast(value="const char*")
                                                                                                         org.bytedeco.javacpp.BytePointer name)

kernelToStr

@Namespace(value="cv::ocl")
 @opencv_core.Str
public static org.bytedeco.javacpp.BytePointer kernelToStr(@ByVal
                                                                                                         opencv_core.Mat _kernel)

kernelToStr

@Namespace(value="cv::ocl")
 @opencv_core.Str
public static String kernelToStr(@ByVal
                                                                               opencv_core.Mat _kernel,
                                                                               int ddepth,
                                                                               String name)

kernelToStr

@Namespace(value="cv::ocl")
 @opencv_core.Str
public static String kernelToStr(@ByVal
                                                                               opencv_core.UMat _kernel,
                                                                               int ddepth,
                                                                               String name)

kernelToStr

@Namespace(value="cv::ocl")
 @opencv_core.Str
public static String kernelToStr(@ByVal
                                                                               opencv_core.UMat _kernel)

kernelToStr

@Namespace(value="cv::ocl")
 @opencv_core.Str
public static org.bytedeco.javacpp.BytePointer kernelToStr(@ByVal
                                                                                                         opencv_core.UMat _kernel,
                                                                                                         int ddepth,
                                                                                                         @Cast(value="const char*")
                                                                                                         org.bytedeco.javacpp.BytePointer name)

kernelToStr

@Namespace(value="cv::ocl")
 @opencv_core.Str
public static org.bytedeco.javacpp.BytePointer kernelToStr(@ByVal
                                                                                                         opencv_core.GpuMat _kernel,
                                                                                                         int ddepth,
                                                                                                         @Cast(value="const char*")
                                                                                                         org.bytedeco.javacpp.BytePointer name)

kernelToStr

@Namespace(value="cv::ocl")
 @opencv_core.Str
public static org.bytedeco.javacpp.BytePointer kernelToStr(@ByVal
                                                                                                         opencv_core.GpuMat _kernel)

kernelToStr

@Namespace(value="cv::ocl")
 @opencv_core.Str
public static String kernelToStr(@ByVal
                                                                               opencv_core.GpuMat _kernel,
                                                                               int ddepth,
                                                                               String name)

getPlatfomsInfo

@Namespace(value="cv::ocl")
public static void getPlatfomsInfo(@StdVector
                                                               opencv_core.PlatformInfo platform_info)

predictOptimalVectorWidth

@Namespace(value="cv::ocl")
public static int predictOptimalVectorWidth(@ByVal
                                                                        opencv_core.Mat src1,
                                                                        @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                                        opencv_core.Mat src2,
                                                                        @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                                        opencv_core.Mat src3,
                                                                        @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                                        opencv_core.Mat src4,
                                                                        @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                                        opencv_core.Mat src5,
                                                                        @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                                        opencv_core.Mat src6,
                                                                        @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                                        opencv_core.Mat src7,
                                                                        @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                                        opencv_core.Mat src8,
                                                                        @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                                        opencv_core.Mat src9,
                                                                        @Cast(value="cv::ocl::OclVectorStrategy")
                                                                        int strat)

predictOptimalVectorWidth

@Namespace(value="cv::ocl")
public static int predictOptimalVectorWidth(@ByVal
                                                                        opencv_core.Mat src1)

predictOptimalVectorWidth

@Namespace(value="cv::ocl")
public static int predictOptimalVectorWidth(@ByVal
                                                                        opencv_core.UMat src1,
                                                                        @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                                        opencv_core.UMat src2,
                                                                        @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                                        opencv_core.UMat src3,
                                                                        @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                                        opencv_core.UMat src4,
                                                                        @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                                        opencv_core.UMat src5,
                                                                        @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                                        opencv_core.UMat src6,
                                                                        @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                                        opencv_core.UMat src7,
                                                                        @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                                        opencv_core.UMat src8,
                                                                        @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                                        opencv_core.UMat src9,
                                                                        @Cast(value="cv::ocl::OclVectorStrategy")
                                                                        int strat)

predictOptimalVectorWidth

@Namespace(value="cv::ocl")
public static int predictOptimalVectorWidth(@ByVal
                                                                        opencv_core.UMat src1)

predictOptimalVectorWidth

@Namespace(value="cv::ocl")
public static int predictOptimalVectorWidth(@ByVal
                                                                        opencv_core.GpuMat src1,
                                                                        @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                                        opencv_core.GpuMat src2,
                                                                        @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                                        opencv_core.GpuMat src3,
                                                                        @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                                        opencv_core.GpuMat src4,
                                                                        @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                                        opencv_core.GpuMat src5,
                                                                        @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                                        opencv_core.GpuMat src6,
                                                                        @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                                        opencv_core.GpuMat src7,
                                                                        @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                                        opencv_core.GpuMat src8,
                                                                        @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                                        opencv_core.GpuMat src9,
                                                                        @Cast(value="cv::ocl::OclVectorStrategy")
                                                                        int strat)

predictOptimalVectorWidth

@Namespace(value="cv::ocl")
public static int predictOptimalVectorWidth(@ByVal
                                                                        opencv_core.GpuMat src1)

checkOptimalVectorWidth

@Namespace(value="cv::ocl")
public static int checkOptimalVectorWidth(@Const
                                                                      org.bytedeco.javacpp.IntPointer vectorWidths,
                                                                      @ByVal
                                                                      opencv_core.Mat src1,
                                                                      @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                                      opencv_core.Mat src2,
                                                                      @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                                      opencv_core.Mat src3,
                                                                      @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                                      opencv_core.Mat src4,
                                                                      @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                                      opencv_core.Mat src5,
                                                                      @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                                      opencv_core.Mat src6,
                                                                      @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                                      opencv_core.Mat src7,
                                                                      @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                                      opencv_core.Mat src8,
                                                                      @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                                      opencv_core.Mat src9,
                                                                      @Cast(value="cv::ocl::OclVectorStrategy")
                                                                      int strat)

checkOptimalVectorWidth

@Namespace(value="cv::ocl")
public static int checkOptimalVectorWidth(@Const
                                                                      org.bytedeco.javacpp.IntPointer vectorWidths,
                                                                      @ByVal
                                                                      opencv_core.Mat src1)

checkOptimalVectorWidth

@Namespace(value="cv::ocl")
public static int checkOptimalVectorWidth(@Const
                                                                      IntBuffer vectorWidths,
                                                                      @ByVal
                                                                      opencv_core.Mat src1,
                                                                      @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                                      opencv_core.Mat src2,
                                                                      @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                                      opencv_core.Mat src3,
                                                                      @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                                      opencv_core.Mat src4,
                                                                      @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                                      opencv_core.Mat src5,
                                                                      @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                                      opencv_core.Mat src6,
                                                                      @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                                      opencv_core.Mat src7,
                                                                      @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                                      opencv_core.Mat src8,
                                                                      @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                                      opencv_core.Mat src9,
                                                                      @Cast(value="cv::ocl::OclVectorStrategy")
                                                                      int strat)

checkOptimalVectorWidth

@Namespace(value="cv::ocl")
public static int checkOptimalVectorWidth(@Const
                                                                      IntBuffer vectorWidths,
                                                                      @ByVal
                                                                      opencv_core.Mat src1)

checkOptimalVectorWidth

@Namespace(value="cv::ocl")
public static int checkOptimalVectorWidth(@Const
                                                                      int[] vectorWidths,
                                                                      @ByVal
                                                                      opencv_core.Mat src1,
                                                                      @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                                      opencv_core.Mat src2,
                                                                      @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                                      opencv_core.Mat src3,
                                                                      @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                                      opencv_core.Mat src4,
                                                                      @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                                      opencv_core.Mat src5,
                                                                      @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                                      opencv_core.Mat src6,
                                                                      @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                                      opencv_core.Mat src7,
                                                                      @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                                      opencv_core.Mat src8,
                                                                      @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                                      opencv_core.Mat src9,
                                                                      @Cast(value="cv::ocl::OclVectorStrategy")
                                                                      int strat)

checkOptimalVectorWidth

@Namespace(value="cv::ocl")
public static int checkOptimalVectorWidth(@Const
                                                                      int[] vectorWidths,
                                                                      @ByVal
                                                                      opencv_core.Mat src1)

checkOptimalVectorWidth

@Namespace(value="cv::ocl")
public static int checkOptimalVectorWidth(@Const
                                                                      org.bytedeco.javacpp.IntPointer vectorWidths,
                                                                      @ByVal
                                                                      opencv_core.UMat src1,
                                                                      @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                                      opencv_core.UMat src2,
                                                                      @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                                      opencv_core.UMat src3,
                                                                      @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                                      opencv_core.UMat src4,
                                                                      @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                                      opencv_core.UMat src5,
                                                                      @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                                      opencv_core.UMat src6,
                                                                      @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                                      opencv_core.UMat src7,
                                                                      @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                                      opencv_core.UMat src8,
                                                                      @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                                      opencv_core.UMat src9,
                                                                      @Cast(value="cv::ocl::OclVectorStrategy")
                                                                      int strat)

checkOptimalVectorWidth

@Namespace(value="cv::ocl")
public static int checkOptimalVectorWidth(@Const
                                                                      org.bytedeco.javacpp.IntPointer vectorWidths,
                                                                      @ByVal
                                                                      opencv_core.UMat src1)

checkOptimalVectorWidth

@Namespace(value="cv::ocl")
public static int checkOptimalVectorWidth(@Const
                                                                      IntBuffer vectorWidths,
                                                                      @ByVal
                                                                      opencv_core.UMat src1,
                                                                      @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                                      opencv_core.UMat src2,
                                                                      @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                                      opencv_core.UMat src3,
                                                                      @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                                      opencv_core.UMat src4,
                                                                      @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                                      opencv_core.UMat src5,
                                                                      @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                                      opencv_core.UMat src6,
                                                                      @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                                      opencv_core.UMat src7,
                                                                      @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                                      opencv_core.UMat src8,
                                                                      @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                                      opencv_core.UMat src9,
                                                                      @Cast(value="cv::ocl::OclVectorStrategy")
                                                                      int strat)

checkOptimalVectorWidth

@Namespace(value="cv::ocl")
public static int checkOptimalVectorWidth(@Const
                                                                      IntBuffer vectorWidths,
                                                                      @ByVal
                                                                      opencv_core.UMat src1)

checkOptimalVectorWidth

@Namespace(value="cv::ocl")
public static int checkOptimalVectorWidth(@Const
                                                                      int[] vectorWidths,
                                                                      @ByVal
                                                                      opencv_core.UMat src1,
                                                                      @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                                      opencv_core.UMat src2,
                                                                      @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                                      opencv_core.UMat src3,
                                                                      @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                                      opencv_core.UMat src4,
                                                                      @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                                      opencv_core.UMat src5,
                                                                      @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                                      opencv_core.UMat src6,
                                                                      @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                                      opencv_core.UMat src7,
                                                                      @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                                      opencv_core.UMat src8,
                                                                      @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                                      opencv_core.UMat src9,
                                                                      @Cast(value="cv::ocl::OclVectorStrategy")
                                                                      int strat)

checkOptimalVectorWidth

@Namespace(value="cv::ocl")
public static int checkOptimalVectorWidth(@Const
                                                                      int[] vectorWidths,
                                                                      @ByVal
                                                                      opencv_core.UMat src1)

checkOptimalVectorWidth

@Namespace(value="cv::ocl")
public static int checkOptimalVectorWidth(@Const
                                                                      org.bytedeco.javacpp.IntPointer vectorWidths,
                                                                      @ByVal
                                                                      opencv_core.GpuMat src1,
                                                                      @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                                      opencv_core.GpuMat src2,
                                                                      @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                                      opencv_core.GpuMat src3,
                                                                      @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                                      opencv_core.GpuMat src4,
                                                                      @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                                      opencv_core.GpuMat src5,
                                                                      @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                                      opencv_core.GpuMat src6,
                                                                      @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                                      opencv_core.GpuMat src7,
                                                                      @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                                      opencv_core.GpuMat src8,
                                                                      @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                                      opencv_core.GpuMat src9,
                                                                      @Cast(value="cv::ocl::OclVectorStrategy")
                                                                      int strat)

checkOptimalVectorWidth

@Namespace(value="cv::ocl")
public static int checkOptimalVectorWidth(@Const
                                                                      org.bytedeco.javacpp.IntPointer vectorWidths,
                                                                      @ByVal
                                                                      opencv_core.GpuMat src1)

checkOptimalVectorWidth

@Namespace(value="cv::ocl")
public static int checkOptimalVectorWidth(@Const
                                                                      IntBuffer vectorWidths,
                                                                      @ByVal
                                                                      opencv_core.GpuMat src1,
                                                                      @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                                      opencv_core.GpuMat src2,
                                                                      @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                                      opencv_core.GpuMat src3,
                                                                      @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                                      opencv_core.GpuMat src4,
                                                                      @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                                      opencv_core.GpuMat src5,
                                                                      @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                                      opencv_core.GpuMat src6,
                                                                      @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                                      opencv_core.GpuMat src7,
                                                                      @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                                      opencv_core.GpuMat src8,
                                                                      @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                                      opencv_core.GpuMat src9,
                                                                      @Cast(value="cv::ocl::OclVectorStrategy")
                                                                      int strat)

checkOptimalVectorWidth

@Namespace(value="cv::ocl")
public static int checkOptimalVectorWidth(@Const
                                                                      IntBuffer vectorWidths,
                                                                      @ByVal
                                                                      opencv_core.GpuMat src1)

checkOptimalVectorWidth

@Namespace(value="cv::ocl")
public static int checkOptimalVectorWidth(@Const
                                                                      int[] vectorWidths,
                                                                      @ByVal
                                                                      opencv_core.GpuMat src1,
                                                                      @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                                      opencv_core.GpuMat src2,
                                                                      @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                                      opencv_core.GpuMat src3,
                                                                      @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                                      opencv_core.GpuMat src4,
                                                                      @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                                      opencv_core.GpuMat src5,
                                                                      @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                                      opencv_core.GpuMat src6,
                                                                      @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                                      opencv_core.GpuMat src7,
                                                                      @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                                      opencv_core.GpuMat src8,
                                                                      @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                                      opencv_core.GpuMat src9,
                                                                      @Cast(value="cv::ocl::OclVectorStrategy")
                                                                      int strat)

checkOptimalVectorWidth

@Namespace(value="cv::ocl")
public static int checkOptimalVectorWidth(@Const
                                                                      int[] vectorWidths,
                                                                      @ByVal
                                                                      opencv_core.GpuMat src1)

predictOptimalVectorWidthMax

@Namespace(value="cv::ocl")
public static int predictOptimalVectorWidthMax(@ByVal
                                                                           opencv_core.Mat src1,
                                                                           @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                                           opencv_core.Mat src2,
                                                                           @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                                           opencv_core.Mat src3,
                                                                           @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                                           opencv_core.Mat src4,
                                                                           @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                                           opencv_core.Mat src5,
                                                                           @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                                           opencv_core.Mat src6,
                                                                           @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                                           opencv_core.Mat src7,
                                                                           @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                                           opencv_core.Mat src8,
                                                                           @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                                           opencv_core.Mat src9)

predictOptimalVectorWidthMax

@Namespace(value="cv::ocl")
public static int predictOptimalVectorWidthMax(@ByVal
                                                                           opencv_core.Mat src1)

predictOptimalVectorWidthMax

@Namespace(value="cv::ocl")
public static int predictOptimalVectorWidthMax(@ByVal
                                                                           opencv_core.UMat src1,
                                                                           @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                                           opencv_core.UMat src2,
                                                                           @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                                           opencv_core.UMat src3,
                                                                           @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                                           opencv_core.UMat src4,
                                                                           @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                                           opencv_core.UMat src5,
                                                                           @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                                           opencv_core.UMat src6,
                                                                           @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                                           opencv_core.UMat src7,
                                                                           @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                                           opencv_core.UMat src8,
                                                                           @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                                           opencv_core.UMat src9)

predictOptimalVectorWidthMax

@Namespace(value="cv::ocl")
public static int predictOptimalVectorWidthMax(@ByVal
                                                                           opencv_core.UMat src1)

predictOptimalVectorWidthMax

@Namespace(value="cv::ocl")
public static int predictOptimalVectorWidthMax(@ByVal
                                                                           opencv_core.GpuMat src1,
                                                                           @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                                           opencv_core.GpuMat src2,
                                                                           @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                                           opencv_core.GpuMat src3,
                                                                           @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                                           opencv_core.GpuMat src4,
                                                                           @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                                           opencv_core.GpuMat src5,
                                                                           @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                                           opencv_core.GpuMat src6,
                                                                           @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                                           opencv_core.GpuMat src7,
                                                                           @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                                           opencv_core.GpuMat src8,
                                                                           @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                                           opencv_core.GpuMat src9)

predictOptimalVectorWidthMax

@Namespace(value="cv::ocl")
public static int predictOptimalVectorWidthMax(@ByVal
                                                                           opencv_core.GpuMat src1)

buildOptionsAddMatrixDescription

@Namespace(value="cv::ocl")
public static void buildOptionsAddMatrixDescription(@opencv_core.Str
                                                                                org.bytedeco.javacpp.BytePointer buildOptions,
                                                                                @opencv_core.Str
                                                                                org.bytedeco.javacpp.BytePointer name,
                                                                                @ByVal
                                                                                opencv_core.Mat _m)

buildOptionsAddMatrixDescription

@Namespace(value="cv::ocl")
public static void buildOptionsAddMatrixDescription(@opencv_core.Str
                                                                                String buildOptions,
                                                                                @opencv_core.Str
                                                                                String name,
                                                                                @ByVal
                                                                                opencv_core.Mat _m)

buildOptionsAddMatrixDescription

@Namespace(value="cv::ocl")
public static void buildOptionsAddMatrixDescription(@opencv_core.Str
                                                                                String buildOptions,
                                                                                @opencv_core.Str
                                                                                String name,
                                                                                @ByVal
                                                                                opencv_core.UMat _m)

buildOptionsAddMatrixDescription

@Namespace(value="cv::ocl")
public static void buildOptionsAddMatrixDescription(@opencv_core.Str
                                                                                org.bytedeco.javacpp.BytePointer buildOptions,
                                                                                @opencv_core.Str
                                                                                org.bytedeco.javacpp.BytePointer name,
                                                                                @ByVal
                                                                                opencv_core.UMat _m)

buildOptionsAddMatrixDescription

@Namespace(value="cv::ocl")
public static void buildOptionsAddMatrixDescription(@opencv_core.Str
                                                                                org.bytedeco.javacpp.BytePointer buildOptions,
                                                                                @opencv_core.Str
                                                                                org.bytedeco.javacpp.BytePointer name,
                                                                                @ByVal
                                                                                opencv_core.GpuMat _m)

buildOptionsAddMatrixDescription

@Namespace(value="cv::ocl")
public static void buildOptionsAddMatrixDescription(@opencv_core.Str
                                                                                String buildOptions,
                                                                                @opencv_core.Str
                                                                                String name,
                                                                                @ByVal
                                                                                opencv_core.GpuMat _m)

getOpenCLAllocator

@Namespace(value="cv::ocl")
public static opencv_core.MatAllocator getOpenCLAllocator()

addPut

@Namespace(value="cv")
 @ByRef
 @Name(value="operator +=")
public static opencv_core.Mat addPut(@ByRef
                                                                                                opencv_core.Mat a,
                                                                                                @Const @ByRef
                                                                                                opencv_core.Mat b)

\cond IGNORED

addPut

@Namespace(value="cv")
 @ByRef
 @Name(value="operator +=")
public static opencv_core.Mat addPut(@ByRef
                                                                                                opencv_core.Mat a,
                                                                                                @Const @ByRef
                                                                                                opencv_core.Scalar b)

subtractPut

@Namespace(value="cv")
 @ByRef
 @Name(value="operator -=")
public static opencv_core.Mat subtractPut(@ByRef
                                                                                                     opencv_core.Mat a,
                                                                                                     @Const @ByRef
                                                                                                     opencv_core.Mat b)

subtractPut

@Namespace(value="cv")
 @ByRef
 @Name(value="operator -=")
public static opencv_core.Mat subtractPut(@ByRef
                                                                                                     opencv_core.Mat a,
                                                                                                     @Const @ByRef
                                                                                                     opencv_core.Scalar b)

multiplyPut

@Namespace(value="cv")
 @ByRef
 @Name(value="operator *=")
public static opencv_core.Mat multiplyPut(@ByRef
                                                                                                     opencv_core.Mat a,
                                                                                                     @Const @ByRef
                                                                                                     opencv_core.Mat b)

multiplyPut

@Namespace(value="cv")
 @ByRef
 @Name(value="operator *=")
public static opencv_core.Mat multiplyPut(@ByRef
                                                                                                     opencv_core.Mat a,
                                                                                                     double b)

dividePut

@Namespace(value="cv")
 @ByRef
 @Name(value="operator /=")
public static opencv_core.Mat dividePut(@ByRef
                                                                                                   opencv_core.Mat a,
                                                                                                   @Const @ByRef
                                                                                                   opencv_core.Mat b)

dividePut

@Namespace(value="cv")
 @ByRef
 @Name(value="operator /=")
public static opencv_core.Mat dividePut(@ByRef
                                                                                                   opencv_core.Mat a,
                                                                                                   double b)

andPut

@Namespace(value="cv")
 @ByRef
 @Name(value="operator &=")
public static opencv_core.Mat andPut(@ByRef
                                                                                                opencv_core.Mat a,
                                                                                                @Const @ByRef
                                                                                                opencv_core.Mat b)

andPut

@Namespace(value="cv")
 @ByRef
 @Name(value="operator &=")
public static opencv_core.Mat andPut(@ByRef
                                                                                                opencv_core.Mat a,
                                                                                                @Const @ByRef
                                                                                                opencv_core.Scalar b)

orPut

@Namespace(value="cv")
 @ByRef
 @Name(value="operator |=")
public static opencv_core.Mat orPut(@ByRef
                                                                                               opencv_core.Mat a,
                                                                                               @Const @ByRef
                                                                                               opencv_core.Mat b)

orPut

@Namespace(value="cv")
 @ByRef
 @Name(value="operator |=")
public static opencv_core.Mat orPut(@ByRef
                                                                                               opencv_core.Mat a,
                                                                                               @Const @ByRef
                                                                                               opencv_core.Scalar b)

xorPut

@Namespace(value="cv")
 @ByRef
 @Name(value="operator ^=")
public static opencv_core.Mat xorPut(@ByRef
                                                                                                opencv_core.Mat a,
                                                                                                @Const @ByRef
                                                                                                opencv_core.Mat b)

xorPut

@Namespace(value="cv")
 @ByRef
 @Name(value="operator ^=")
public static opencv_core.Mat xorPut(@ByRef
                                                                                                opencv_core.Mat a,
                                                                                                @Const @ByRef
                                                                                                opencv_core.Scalar b)

intRand
```
@Namespace(value="cv")
 @Name(value="randu<int>")
public static int intRand()
```
returns the next unifomly-distributed random number of the specified type

floatRand

@Namespace(value="cv")
 @Name(value="randu<float>")
public static float floatRand()

doubleRand

@Namespace(value="cv")
 @Name(value="randu<double>")
public static double doubleRand()

format
```
@Namespace(value="cv")
 @opencv_core.Str
public static org.bytedeco.javacpp.BytePointer format(@Cast(value="const char*")
                                                                                               org.bytedeco.javacpp.BytePointer fmt)
```
\brief Returns a text string formatted using the printf-like expression.
The function acts like sprintf but forms and returns an STL string. It can be used to form an error message in the Exception constructor.

Parameters:

fmt - printf-compatible formatting specifiers.

format

@Namespace(value="cv")
 @opencv_core.Str
public static String format(String fmt)

format

@Namespace(value="cv")
 @opencv_core.Ptr
public static opencv_core.Formatted format(@ByVal
                                                                                    opencv_core.Mat mtx,
                                                                                    int fmt)

format

@Namespace(value="cv")
 @opencv_core.Ptr
public static opencv_core.Formatted format(@ByVal
                                                                                    opencv_core.UMat mtx,
                                                                                    int fmt)

format

@Namespace(value="cv")
 @opencv_core.Ptr
public static opencv_core.Formatted format(@ByVal
                                                                                    opencv_core.GpuMat mtx,
                                                                                    int fmt)

print

@Namespace(value="cv")
public static int print(@opencv_core.Ptr
                                               opencv_core.Formatted fmtd,
                                               @Cast(value="FILE*")
                                               org.bytedeco.javacpp.Pointer stream)

print

@Namespace(value="cv")
public static int print(@opencv_core.Ptr
                                               opencv_core.Formatted fmtd)

print

@Namespace(value="cv")
public static int print(@Const @ByRef
                                               opencv_core.Mat mtx,
                                               @Cast(value="FILE*")
                                               org.bytedeco.javacpp.Pointer stream)

print

@Namespace(value="cv")
public static int print(@Const @ByRef
                                               opencv_core.Mat mtx)

print

@Namespace(value="cv")
public static int print(@Const @ByRef
                                               opencv_core.UMat mtx,
                                               @Cast(value="FILE*")
                                               org.bytedeco.javacpp.Pointer stream)

print

@Namespace(value="cv")
public static int print(@Const @ByRef
                                               opencv_core.UMat mtx)

noArray
```
public static opencv_core.Mat noArray()
```
\brief This type is very similar to InputArray except that it is used for input/output and output function parameters.
Just like with InputArray, OpenCV users should not care about OutputArray, they just pass Mat, vector<T> etc. to the functions. The same limitation as for InputArray: *Do not explicitly create OutputArray instances* applies here too.
If you want to make your function polymorphic (i.e. accept different arrays as output parameters), it is also not very difficult. Take the sample above as the reference. Note that _OutputArray::create() needs to be called before _OutputArray::getMat(). This way you guarantee that the output array is properly allocated.
Optional output parameters. If you do not need certain output array to be computed and returned to you, pass cv::noArray(), just like you would in the case of optional input array. At the implementation level, use _OutputArray::needed() to check if certain output array needs to be computed or not.
There are several synonyms for OutputArray that are used to assist automatic Python/Java/... wrapper generators:
```
    typedef OutputArray OutputArrayOfArrays;
    typedef OutputArray InputOutputArray;
    typedef OutputArray InputOutputArrayOfArrays;
```

add

@Namespace(value="cv")
 @ByVal
 @Name(value="operator +")
public static opencv_core.MatExpr add(@Const @ByRef
                                                                                                opencv_core.Mat a,
                                                                                                @Const @ByRef
                                                                                                opencv_core.Mat b)

\} core_basic

\relates cv::MatExpr \{

add

@Namespace(value="cv")
 @ByVal
 @Name(value="operator +")
public static opencv_core.MatExpr add(@Const @ByRef
                                                                                                opencv_core.Mat a,
                                                                                                @Const @ByRef
                                                                                                opencv_core.Scalar s)

add

@Namespace(value="cv")
 @ByVal
 @Name(value="operator +")
public static opencv_core.MatExpr add(@Const @ByRef
                                                                                                opencv_core.Scalar s,
                                                                                                @Const @ByRef
                                                                                                opencv_core.Mat a)

add

@Namespace(value="cv")
 @ByVal
 @Name(value="operator +")
public static opencv_core.MatExpr add(@Const @ByRef
                                                                                                opencv_core.MatExpr e,
                                                                                                @Const @ByRef
                                                                                                opencv_core.Mat m)

add

@Namespace(value="cv")
 @ByVal
 @Name(value="operator +")
public static opencv_core.MatExpr add(@Const @ByRef
                                                                                                opencv_core.Mat m,
                                                                                                @Const @ByRef
                                                                                                opencv_core.MatExpr e)

add

@Namespace(value="cv")
 @ByVal
 @Name(value="operator +")
public static opencv_core.MatExpr add(@Const @ByRef
                                                                                                opencv_core.MatExpr e,
                                                                                                @Const @ByRef
                                                                                                opencv_core.Scalar s)

add

@Namespace(value="cv")
 @ByVal
 @Name(value="operator +")
public static opencv_core.MatExpr add(@Const @ByRef
                                                                                                opencv_core.Scalar s,
                                                                                                @Const @ByRef
                                                                                                opencv_core.MatExpr e)

add

@Namespace(value="cv")
 @ByVal
 @Name(value="operator +")
public static opencv_core.MatExpr add(@Const @ByRef
                                                                                                opencv_core.MatExpr e1,
                                                                                                @Const @ByRef
                                                                                                opencv_core.MatExpr e2)

subtract

@Namespace(value="cv")
 @ByVal
 @Name(value="operator -")
public static opencv_core.MatExpr subtract(@Const @ByRef
                                                                                                     opencv_core.Mat a,
                                                                                                     @Const @ByRef
                                                                                                     opencv_core.Mat b)

subtract

@Namespace(value="cv")
 @ByVal
 @Name(value="operator -")
public static opencv_core.MatExpr subtract(@Const @ByRef
                                                                                                     opencv_core.Mat a,
                                                                                                     @Const @ByRef
                                                                                                     opencv_core.Scalar s)

subtract

@Namespace(value="cv")
 @ByVal
 @Name(value="operator -")
public static opencv_core.MatExpr subtract(@Const @ByRef
                                                                                                     opencv_core.Scalar s,
                                                                                                     @Const @ByRef
                                                                                                     opencv_core.Mat a)

subtract

@Namespace(value="cv")
 @ByVal
 @Name(value="operator -")
public static opencv_core.MatExpr subtract(@Const @ByRef
                                                                                                     opencv_core.MatExpr e,
                                                                                                     @Const @ByRef
                                                                                                     opencv_core.Mat m)

subtract

@Namespace(value="cv")
 @ByVal
 @Name(value="operator -")
public static opencv_core.MatExpr subtract(@Const @ByRef
                                                                                                     opencv_core.Mat m,
                                                                                                     @Const @ByRef
                                                                                                     opencv_core.MatExpr e)

subtract

@Namespace(value="cv")
 @ByVal
 @Name(value="operator -")
public static opencv_core.MatExpr subtract(@Const @ByRef
                                                                                                     opencv_core.MatExpr e,
                                                                                                     @Const @ByRef
                                                                                                     opencv_core.Scalar s)

subtract

@Namespace(value="cv")
 @ByVal
 @Name(value="operator -")
public static opencv_core.MatExpr subtract(@Const @ByRef
                                                                                                     opencv_core.Scalar s,
                                                                                                     @Const @ByRef
                                                                                                     opencv_core.MatExpr e)

subtract

@Namespace(value="cv")
 @ByVal
 @Name(value="operator -")
public static opencv_core.MatExpr subtract(@Const @ByRef
                                                                                                     opencv_core.MatExpr e1,
                                                                                                     @Const @ByRef
                                                                                                     opencv_core.MatExpr e2)

subtract

@Namespace(value="cv")
 @ByVal
 @Name(value="operator -")
public static opencv_core.MatExpr subtract(@Const @ByRef
                                                                                                     opencv_core.Mat m)

subtract

@Namespace(value="cv")
 @ByVal
 @Name(value="operator -")
public static opencv_core.MatExpr subtract(@Const @ByRef
                                                                                                     opencv_core.MatExpr e)

multiply

@Namespace(value="cv")
 @ByVal
 @Name(value="operator *")
public static opencv_core.MatExpr multiply(@Const @ByRef
                                                                                                     opencv_core.Mat a,
                                                                                                     @Const @ByRef
                                                                                                     opencv_core.Mat b)

multiply

@Namespace(value="cv")
 @ByVal
 @Name(value="operator *")
public static opencv_core.MatExpr multiply(@Const @ByRef
                                                                                                     opencv_core.Mat a,
                                                                                                     double s)

multiply

@Namespace(value="cv")
 @ByVal
 @Name(value="operator *")
public static opencv_core.MatExpr multiply(double s,
                                                                                                     @Const @ByRef
                                                                                                     opencv_core.Mat a)

multiply

@Namespace(value="cv")
 @ByVal
 @Name(value="operator *")
public static opencv_core.MatExpr multiply(@Const @ByRef
                                                                                                     opencv_core.MatExpr e,
                                                                                                     @Const @ByRef
                                                                                                     opencv_core.Mat m)

multiply

@Namespace(value="cv")
 @ByVal
 @Name(value="operator *")
public static opencv_core.MatExpr multiply(@Const @ByRef
                                                                                                     opencv_core.Mat m,
                                                                                                     @Const @ByRef
                                                                                                     opencv_core.MatExpr e)

multiply

@Namespace(value="cv")
 @ByVal
 @Name(value="operator *")
public static opencv_core.MatExpr multiply(@Const @ByRef
                                                                                                     opencv_core.MatExpr e,
                                                                                                     double s)

multiply

@Namespace(value="cv")
 @ByVal
 @Name(value="operator *")
public static opencv_core.MatExpr multiply(double s,
                                                                                                     @Const @ByRef
                                                                                                     opencv_core.MatExpr e)

multiply

@Namespace(value="cv")
 @ByVal
 @Name(value="operator *")
public static opencv_core.MatExpr multiply(@Const @ByRef
                                                                                                     opencv_core.MatExpr e1,
                                                                                                     @Const @ByRef
                                                                                                     opencv_core.MatExpr e2)

divide

@Namespace(value="cv")
 @ByVal
 @Name(value="operator /")
public static opencv_core.MatExpr divide(@Const @ByRef
                                                                                                   opencv_core.Mat a,
                                                                                                   @Const @ByRef
                                                                                                   opencv_core.Mat b)

divide

@Namespace(value="cv")
 @ByVal
 @Name(value="operator /")
public static opencv_core.MatExpr divide(@Const @ByRef
                                                                                                   opencv_core.Mat a,
                                                                                                   double s)

divide

@Namespace(value="cv")
 @ByVal
 @Name(value="operator /")
public static opencv_core.MatExpr divide(double s,
                                                                                                   @Const @ByRef
                                                                                                   opencv_core.Mat a)

divide

@Namespace(value="cv")
 @ByVal
 @Name(value="operator /")
public static opencv_core.MatExpr divide(@Const @ByRef
                                                                                                   opencv_core.MatExpr e,
                                                                                                   @Const @ByRef
                                                                                                   opencv_core.Mat m)

divide

@Namespace(value="cv")
 @ByVal
 @Name(value="operator /")
public static opencv_core.MatExpr divide(@Const @ByRef
                                                                                                   opencv_core.Mat m,
                                                                                                   @Const @ByRef
                                                                                                   opencv_core.MatExpr e)

divide

@Namespace(value="cv")
 @ByVal
 @Name(value="operator /")
public static opencv_core.MatExpr divide(@Const @ByRef
                                                                                                   opencv_core.MatExpr e,
                                                                                                   double s)

divide

@Namespace(value="cv")
 @ByVal
 @Name(value="operator /")
public static opencv_core.MatExpr divide(double s,
                                                                                                   @Const @ByRef
                                                                                                   opencv_core.MatExpr e)

divide

@Namespace(value="cv")
 @ByVal
 @Name(value="operator /")
public static opencv_core.MatExpr divide(@Const @ByRef
                                                                                                   opencv_core.MatExpr e1,
                                                                                                   @Const @ByRef
                                                                                                   opencv_core.MatExpr e2)

lessThan

@Namespace(value="cv")
 @ByVal
 @Name(value="operator <")
public static opencv_core.MatExpr lessThan(@Const @ByRef
                                                                                                     opencv_core.Mat a,
                                                                                                     @Const @ByRef
                                                                                                     opencv_core.Mat b)

lessThan

@Namespace(value="cv")
 @ByVal
 @Name(value="operator <")
public static opencv_core.MatExpr lessThan(@Const @ByRef
                                                                                                     opencv_core.Mat a,
                                                                                                     double s)

lessThan

@Namespace(value="cv")
 @ByVal
 @Name(value="operator <")
public static opencv_core.MatExpr lessThan(double s,
                                                                                                     @Const @ByRef
                                                                                                     opencv_core.Mat a)

lessThanEquals

@Namespace(value="cv")
 @ByVal
 @Name(value="operator <=")
public static opencv_core.MatExpr lessThanEquals(@Const @ByRef
                                                                                                            opencv_core.Mat a,
                                                                                                            @Const @ByRef
                                                                                                            opencv_core.Mat b)

lessThanEquals

@Namespace(value="cv")
 @ByVal
 @Name(value="operator <=")
public static opencv_core.MatExpr lessThanEquals(@Const @ByRef
                                                                                                            opencv_core.Mat a,
                                                                                                            double s)

lessThanEquals

@Namespace(value="cv")
 @ByVal
 @Name(value="operator <=")
public static opencv_core.MatExpr lessThanEquals(double s,
                                                                                                            @Const @ByRef
                                                                                                            opencv_core.Mat a)

equals

@Namespace(value="cv")
 @ByVal
 @Name(value="operator ==")
public static opencv_core.MatExpr equals(@Const @ByRef
                                                                                                    opencv_core.Mat a,
                                                                                                    @Const @ByRef
                                                                                                    opencv_core.Mat b)

equals

@Namespace(value="cv")
 @ByVal
 @Name(value="operator ==")
public static opencv_core.MatExpr equals(@Const @ByRef
                                                                                                    opencv_core.Mat a,
                                                                                                    double s)

equals

@Namespace(value="cv")
 @ByVal
 @Name(value="operator ==")
public static opencv_core.MatExpr equals(double s,
                                                                                                    @Const @ByRef
                                                                                                    opencv_core.Mat a)

notEquals

@Namespace(value="cv")
 @ByVal
 @Name(value="operator !=")
public static opencv_core.MatExpr notEquals(@Const @ByRef
                                                                                                       opencv_core.Mat a,
                                                                                                       @Const @ByRef
                                                                                                       opencv_core.Mat b)

notEquals

@Namespace(value="cv")
 @ByVal
 @Name(value="operator !=")
public static opencv_core.MatExpr notEquals(@Const @ByRef
                                                                                                       opencv_core.Mat a,
                                                                                                       double s)

notEquals

@Namespace(value="cv")
 @ByVal
 @Name(value="operator !=")
public static opencv_core.MatExpr notEquals(double s,
                                                                                                       @Const @ByRef
                                                                                                       opencv_core.Mat a)

greaterThanEquals

@Namespace(value="cv")
 @ByVal
 @Name(value="operator >=")
public static opencv_core.MatExpr greaterThanEquals(@Const @ByRef
                                                                                                               opencv_core.Mat a,
                                                                                                               @Const @ByRef
                                                                                                               opencv_core.Mat b)

greaterThanEquals

@Namespace(value="cv")
 @ByVal
 @Name(value="operator >=")
public static opencv_core.MatExpr greaterThanEquals(@Const @ByRef
                                                                                                               opencv_core.Mat a,
                                                                                                               double s)

greaterThanEquals

@Namespace(value="cv")
 @ByVal
 @Name(value="operator >=")
public static opencv_core.MatExpr greaterThanEquals(double s,
                                                                                                               @Const @ByRef
                                                                                                               opencv_core.Mat a)

greaterThan

@Namespace(value="cv")
 @ByVal
 @Name(value="operator >")
public static opencv_core.MatExpr greaterThan(@Const @ByRef
                                                                                                        opencv_core.Mat a,
                                                                                                        @Const @ByRef
                                                                                                        opencv_core.Mat b)

greaterThan

@Namespace(value="cv")
 @ByVal
 @Name(value="operator >")
public static opencv_core.MatExpr greaterThan(@Const @ByRef
                                                                                                        opencv_core.Mat a,
                                                                                                        double s)

greaterThan

@Namespace(value="cv")
 @ByVal
 @Name(value="operator >")
public static opencv_core.MatExpr greaterThan(double s,
                                                                                                        @Const @ByRef
                                                                                                        opencv_core.Mat a)

and

@Namespace(value="cv")
 @ByVal
 @Name(value="operator &")
public static opencv_core.MatExpr and(@Const @ByRef
                                                                                                opencv_core.Mat a,
                                                                                                @Const @ByRef
                                                                                                opencv_core.Mat b)

and

@Namespace(value="cv")
 @ByVal
 @Name(value="operator &")
public static opencv_core.MatExpr and(@Const @ByRef
                                                                                                opencv_core.Mat a,
                                                                                                @Const @ByRef
                                                                                                opencv_core.Scalar s)

and

@Namespace(value="cv")
 @ByVal
 @Name(value="operator &")
public static opencv_core.MatExpr and(@Const @ByRef
                                                                                                opencv_core.Scalar s,
                                                                                                @Const @ByRef
                                                                                                opencv_core.Mat a)

or

@Namespace(value="cv")
 @ByVal
 @Name(value="operator |")
public static opencv_core.MatExpr or(@Const @ByRef
                                                                                               opencv_core.Mat a,
                                                                                               @Const @ByRef
                                                                                               opencv_core.Mat b)

or

@Namespace(value="cv")
 @ByVal
 @Name(value="operator |")
public static opencv_core.MatExpr or(@Const @ByRef
                                                                                               opencv_core.Mat a,
                                                                                               @Const @ByRef
                                                                                               opencv_core.Scalar s)

or

@Namespace(value="cv")
 @ByVal
 @Name(value="operator |")
public static opencv_core.MatExpr or(@Const @ByRef
                                                                                               opencv_core.Scalar s,
                                                                                               @Const @ByRef
                                                                                               opencv_core.Mat a)

xor

@Namespace(value="cv")
 @ByVal
 @Name(value="operator ^")
public static opencv_core.MatExpr xor(@Const @ByRef
                                                                                                opencv_core.Mat a,
                                                                                                @Const @ByRef
                                                                                                opencv_core.Mat b)

xor

@Namespace(value="cv")
 @ByVal
 @Name(value="operator ^")
public static opencv_core.MatExpr xor(@Const @ByRef
                                                                                                opencv_core.Mat a,
                                                                                                @Const @ByRef
                                                                                                opencv_core.Scalar s)

xor

@Namespace(value="cv")
 @ByVal
 @Name(value="operator ^")
public static opencv_core.MatExpr xor(@Const @ByRef
                                                                                                opencv_core.Scalar s,
                                                                                                @Const @ByRef
                                                                                                opencv_core.Mat a)

not

@Namespace(value="cv")
 @ByVal
 @Name(value="operator ~")
public static opencv_core.MatExpr not(@Const @ByRef
                                                                                                opencv_core.Mat m)

min

@Namespace(value="cv")
 @ByVal
public static opencv_core.MatExpr min(@Const @ByRef
                                                                     opencv_core.Mat a,
                                                                     @Const @ByRef
                                                                     opencv_core.Mat b)

min

@Namespace(value="cv")
 @ByVal
public static opencv_core.MatExpr min(@Const @ByRef
                                                                     opencv_core.Mat a,
                                                                     double s)

min

@Namespace(value="cv")
 @ByVal
public static opencv_core.MatExpr min(double s,
                                                                     @Const @ByRef
                                                                     opencv_core.Mat a)

max

@Namespace(value="cv")
 @ByVal
public static opencv_core.MatExpr max(@Const @ByRef
                                                                     opencv_core.Mat a,
                                                                     @Const @ByRef
                                                                     opencv_core.Mat b)

max

@Namespace(value="cv")
 @ByVal
public static opencv_core.MatExpr max(@Const @ByRef
                                                                     opencv_core.Mat a,
                                                                     double s)

max

@Namespace(value="cv")
 @ByVal
public static opencv_core.MatExpr max(double s,
                                                                     @Const @ByRef
                                                                     opencv_core.Mat a)

abs
```
@Namespace(value="cv")
 @ByVal
public static opencv_core.MatExpr abs(@Const @ByRef
                                                                     opencv_core.Mat m)
```
\brief Calculates an absolute value of each matrix element.
abs is a meta-function that is expanded to one of absdiff or convertScaleAbs forms: - C = abs(A-B) is equivalent to absdiff(A, B, C) - C = abs(A) is equivalent to absdiff(A, Scalar::all(0), C) - C = Mat_<Vec<uchar,n> >(abs(A*alpha + beta)) is equivalent to convertScaleAbs(A, C, alpha, beta)
The output matrix has the same size and the same type as the input one except for the last case, where C is depth=CV_8U .

Parameters:

m - matrix. \sa \ref MatrixExpressions, absdiff, convertScaleAbs

abs

@Namespace(value="cv")
 @ByVal
public static opencv_core.MatExpr abs(@Const @ByRef
                                                                     opencv_core.MatExpr e)

\overload

Parameters:: e - matrix expression.

write

@Namespace(value="cv")
public static void write(@ByRef
                                                opencv_core.FileStorage fs,
                                                @opencv_core.Str
                                                org.bytedeco.javacpp.BytePointer name,
                                                int value)

\} core_xml

/////////////////// XML & YAML I/O implementation //////////////////

\relates cv::FileStorage \{

write

@Namespace(value="cv")
public static void write(@ByRef
                                                opencv_core.FileStorage fs,
                                                @opencv_core.Str
                                                String name,
                                                int value)

write

@Namespace(value="cv")
public static void write(@ByRef
                                                opencv_core.FileStorage fs,
                                                @opencv_core.Str
                                                org.bytedeco.javacpp.BytePointer name,
                                                float value)

write

@Namespace(value="cv")
public static void write(@ByRef
                                                opencv_core.FileStorage fs,
                                                @opencv_core.Str
                                                String name,
                                                float value)

write

@Namespace(value="cv")
public static void write(@ByRef
                                                opencv_core.FileStorage fs,
                                                @opencv_core.Str
                                                org.bytedeco.javacpp.BytePointer name,
                                                double value)

write

@Namespace(value="cv")
public static void write(@ByRef
                                                opencv_core.FileStorage fs,
                                                @opencv_core.Str
                                                String name,
                                                double value)

write

@Namespace(value="cv")
public static void write(@ByRef
                                                opencv_core.FileStorage fs,
                                                @opencv_core.Str
                                                org.bytedeco.javacpp.BytePointer name,
                                                @opencv_core.Str
                                                org.bytedeco.javacpp.BytePointer value)

write

@Namespace(value="cv")
public static void write(@ByRef
                                                opencv_core.FileStorage fs,
                                                @opencv_core.Str
                                                String name,
                                                @opencv_core.Str
                                                String value)

write

@Namespace(value="cv")
public static void write(@ByRef
                                                opencv_core.FileStorage fs,
                                                @opencv_core.Str
                                                org.bytedeco.javacpp.BytePointer name,
                                                @Const @ByRef
                                                opencv_core.Mat value)

write

@Namespace(value="cv")
public static void write(@ByRef
                                                opencv_core.FileStorage fs,
                                                @opencv_core.Str
                                                String name,
                                                @Const @ByRef
                                                opencv_core.Mat value)

write

@Namespace(value="cv")
public static void write(@ByRef
                                                opencv_core.FileStorage fs,
                                                @opencv_core.Str
                                                org.bytedeco.javacpp.BytePointer name,
                                                @Const @ByRef
                                                opencv_core.SparseMat value)

write

@Namespace(value="cv")
public static void write(@ByRef
                                                opencv_core.FileStorage fs,
                                                @opencv_core.Str
                                                String name,
                                                @Const @ByRef
                                                opencv_core.SparseMat value)

write

@Namespace(value="cv")
public static void write(@ByRef
                                                opencv_core.FileStorage fs,
                                                @opencv_core.Str
                                                org.bytedeco.javacpp.BytePointer name,
                                                @Const @ByRef
                                                opencv_core.KeyPointVector value)

write

@Namespace(value="cv")
public static void write(@ByRef
                                                opencv_core.FileStorage fs,
                                                @opencv_core.Str
                                                String name,
                                                @Const @ByRef
                                                opencv_core.KeyPointVector value)

write

@Namespace(value="cv")
public static void write(@ByRef
                                                opencv_core.FileStorage fs,
                                                @opencv_core.Str
                                                org.bytedeco.javacpp.BytePointer name,
                                                @Const @ByRef
                                                opencv_core.DMatchVector value)

write

@Namespace(value="cv")
public static void write(@ByRef
                                                opencv_core.FileStorage fs,
                                                @opencv_core.Str
                                                String name,
                                                @Const @ByRef
                                                opencv_core.DMatchVector value)

writeScalar

@Namespace(value="cv")
public static void writeScalar(@ByRef
                                                      opencv_core.FileStorage fs,
                                                      int value)

writeScalar

@Namespace(value="cv")
public static void writeScalar(@ByRef
                                                      opencv_core.FileStorage fs,
                                                      float value)

writeScalar

@Namespace(value="cv")
public static void writeScalar(@ByRef
                                                      opencv_core.FileStorage fs,
                                                      double value)

writeScalar

@Namespace(value="cv")
public static void writeScalar(@ByRef
                                                      opencv_core.FileStorage fs,
                                                      @opencv_core.Str
                                                      org.bytedeco.javacpp.BytePointer value)

writeScalar

@Namespace(value="cv")
public static void writeScalar(@ByRef
                                                      opencv_core.FileStorage fs,
                                                      @opencv_core.Str
                                                      String value)

read

@Namespace(value="cv")
public static void read(@Const @ByRef
                                               opencv_core.FileNode node,
                                               @ByRef
                                               org.bytedeco.javacpp.IntPointer value,
                                               int default_value)

\relates cv::FileNode \{

read

@Namespace(value="cv")
public static void read(@Const @ByRef
                                               opencv_core.FileNode node,
                                               @ByRef
                                               IntBuffer value,
                                               int default_value)

read

@Namespace(value="cv")
public static void read(@Const @ByRef
                                               opencv_core.FileNode node,
                                               @ByRef
                                               int[] value,
                                               int default_value)

read

@Namespace(value="cv")
public static void read(@Const @ByRef
                                               opencv_core.FileNode node,
                                               @ByRef
                                               org.bytedeco.javacpp.FloatPointer value,
                                               float default_value)

read

@Namespace(value="cv")
public static void read(@Const @ByRef
                                               opencv_core.FileNode node,
                                               @ByRef
                                               FloatBuffer value,
                                               float default_value)

read

@Namespace(value="cv")
public static void read(@Const @ByRef
                                               opencv_core.FileNode node,
                                               @ByRef
                                               float[] value,
                                               float default_value)

read

@Namespace(value="cv")
public static void read(@Const @ByRef
                                               opencv_core.FileNode node,
                                               @ByRef
                                               org.bytedeco.javacpp.DoublePointer value,
                                               double default_value)

read

@Namespace(value="cv")
public static void read(@Const @ByRef
                                               opencv_core.FileNode node,
                                               @ByRef
                                               DoubleBuffer value,
                                               double default_value)

read

@Namespace(value="cv")
public static void read(@Const @ByRef
                                               opencv_core.FileNode node,
                                               @ByRef
                                               double[] value,
                                               double default_value)

read

@Namespace(value="cv")
public static void read(@Const @ByRef
                                               opencv_core.FileNode node,
                                               @opencv_core.Str
                                               org.bytedeco.javacpp.BytePointer value,
                                               @opencv_core.Str
                                               org.bytedeco.javacpp.BytePointer default_value)

read

@Namespace(value="cv")
public static void read(@Const @ByRef
                                               opencv_core.FileNode node,
                                               @opencv_core.Str
                                               String value,
                                               @opencv_core.Str
                                               String default_value)

read

@Namespace(value="cv")
public static void read(@Const @ByRef
                                               opencv_core.FileNode node,
                                               @ByRef
                                               opencv_core.Mat mat,
                                               @Const @ByRef(nullValue="cv::Mat()")
                                               opencv_core.Mat default_mat)

read

@Namespace(value="cv")
public static void read(@Const @ByRef
                                               opencv_core.FileNode node,
                                               @ByRef
                                               opencv_core.Mat mat)

read

@Namespace(value="cv")
public static void read(@Const @ByRef
                                               opencv_core.FileNode node,
                                               @ByRef
                                               opencv_core.SparseMat mat,
                                               @Const @ByRef(nullValue="cv::SparseMat()")
                                               opencv_core.SparseMat default_mat)

read

@Namespace(value="cv")
public static void read(@Const @ByRef
                                               opencv_core.FileNode node,
                                               @ByRef
                                               opencv_core.SparseMat mat)

read

@Namespace(value="cv")
public static void read(@Const @ByRef
                                               opencv_core.FileNode node,
                                               @ByRef
                                               opencv_core.KeyPointVector keypoints)

read

@Namespace(value="cv")
public static void read(@Const @ByRef
                                               opencv_core.FileNode node,
                                               @ByRef
                                               opencv_core.DMatchVector matches)

read

@Namespace(value="cv")
public static void read(@Const @ByRef
                                               opencv_core.FileNode node,
                                               @ByRef
                                               opencv_core.KeyPoint value,
                                               @Const @ByRef
                                               opencv_core.KeyPoint default_value)

read

@Namespace(value="cv")
public static void read(@Const @ByRef
                                               opencv_core.FileNode node,
                                               @ByRef
                                               opencv_core.DMatch value,
                                               @Const @ByRef
                                               opencv_core.DMatch default_value)

read

@Namespace(value="cv")
public static void read(@Const @ByRef
                                               opencv_core.FileNode node,
                                               @ByRef
                                               opencv_core.Range value,
                                               @Const @ByRef
                                               opencv_core.Range default_value)

shiftLeft

@Namespace(value="cv")
 @ByRef
 @Name(value="operator <<")
public static opencv_core.FileStorage shiftLeft(@ByRef
                                                                                                           opencv_core.FileStorage fs,
                                                                                                           @opencv_core.Str
                                                                                                           org.bytedeco.javacpp.BytePointer str)

/** \brief Writes string to a file storage. \relates cv::FileStorage

shiftLeft

@Namespace(value="cv")
 @ByRef
 @Name(value="operator <<")
public static opencv_core.FileStorage shiftLeft(@ByRef
                                                                                                           opencv_core.FileStorage fs,
                                                                                                           @opencv_core.Str
                                                                                                           String str)

write

@Namespace(value="cv")
public static void write(@ByRef
                                                opencv_core.FileStorage fs,
                                                int value)

\endcond

\relates cv::FileStorage \{

write

@Namespace(value="cv")
public static void write(@ByRef
                                                opencv_core.FileStorage fs,
                                                float value)

write

@Namespace(value="cv")
public static void write(@ByRef
                                                opencv_core.FileStorage fs,
                                                double value)

write

@Namespace(value="cv")
public static void write(@ByRef
                                                opencv_core.FileStorage fs,
                                                @opencv_core.Str
                                                org.bytedeco.javacpp.BytePointer value)

write

@Namespace(value="cv")
public static void write(@ByRef
                                                opencv_core.FileStorage fs,
                                                @opencv_core.Str
                                                String value)

write

@Namespace(value="cv")
public static void write(@ByRef
                                                opencv_core.FileStorage fs,
                                                @Const @ByRef
                                                opencv_core.Range r)

write

@Namespace(value="cv")
public static void write(@ByRef
                                                opencv_core.FileStorage fs,
                                                @opencv_core.Str
                                                org.bytedeco.javacpp.BytePointer name,
                                                @Const @ByRef
                                                opencv_core.Range r)

write

@Namespace(value="cv")
public static void write(@ByRef
                                                opencv_core.FileStorage fs,
                                                @opencv_core.Str
                                                String name,
                                                @Const @ByRef
                                                opencv_core.Range r)

write

@Namespace(value="cv")
public static void write(@ByRef
                                                opencv_core.FileStorage fs,
                                                @opencv_core.Str
                                                org.bytedeco.javacpp.BytePointer name,
                                                @Const @ByRef
                                                opencv_core.KeyPoint kpt)

write

@Namespace(value="cv")
public static void write(@ByRef
                                                opencv_core.FileStorage fs,
                                                @opencv_core.Str
                                                String name,
                                                @Const @ByRef
                                                opencv_core.KeyPoint kpt)

write

@Namespace(value="cv")
public static void write(@ByRef
                                                opencv_core.FileStorage fs,
                                                @opencv_core.Str
                                                org.bytedeco.javacpp.BytePointer name,
                                                @Const @ByRef
                                                opencv_core.DMatch m)

write

@Namespace(value="cv")
public static void write(@ByRef
                                                opencv_core.FileStorage fs,
                                                @opencv_core.Str
                                                String name,
                                                @Const @ByRef
                                                opencv_core.DMatch m)

write

@Namespace(value="cv")
public static void write(@ByRef
                                                opencv_core.FileStorage fs,
                                                @Const @ByRef
                                                opencv_core.KeyPoint kpt)

write

@Namespace(value="cv")
public static void write(@ByRef
                                                opencv_core.FileStorage fs,
                                                @Const @ByRef
                                                opencv_core.DMatch m)

write

@Namespace(value="cv")
public static void write(@ByRef
                                                opencv_core.FileStorage fs,
                                                @Const @ByRef
                                                opencv_core.KeyPointVector vec)

write

@Namespace(value="cv")
public static void write(@ByRef
                                                opencv_core.FileStorage fs,
                                                @Const @ByRef
                                                opencv_core.DMatchVector vec)

read

@Namespace(value="cv")
public static void read(@Const @ByRef
                                               opencv_core.FileNode node,
                                               @Cast(value="bool*") @ByRef
                                               org.bytedeco.javacpp.BoolPointer value,
                                               @Cast(value="bool")
                                               boolean default_value)

\} FileStorage

\relates cv::FileNode \{

read

@Namespace(value="cv")
public static void read(@Const @ByRef
                                               opencv_core.FileNode node,
                                               @Cast(value="bool*") @ByRef
                                               boolean[] value,
                                               @Cast(value="bool")
                                               boolean default_value)

read

@Namespace(value="cv")
public static void read(@Const @ByRef
                                               opencv_core.FileNode node,
                                               @Cast(value="uchar*") @ByRef
                                               org.bytedeco.javacpp.BytePointer value,
                                               @Cast(value="uchar")
                                               byte default_value)

read

@Namespace(value="cv")
public static void read(@Const @ByRef
                                               opencv_core.FileNode node,
                                               @Cast(value="uchar*") @ByRef
                                               ByteBuffer value,
                                               @Cast(value="uchar")
                                               byte default_value)

read

@Namespace(value="cv")
public static void read(@Const @ByRef
                                               opencv_core.FileNode node,
                                               @Cast(value="uchar*") @ByRef
                                               byte[] value,
                                               @Cast(value="uchar")
                                               byte default_value)

read

@Namespace(value="cv")
public static void read(@Const @ByRef
                                               opencv_core.FileNode node,
                                               @Cast(value="ushort*") @ByRef
                                               org.bytedeco.javacpp.ShortPointer value,
                                               @Cast(value="ushort")
                                               short default_value)

read

@Namespace(value="cv")
public static void read(@Const @ByRef
                                               opencv_core.FileNode node,
                                               @Cast(value="ushort*") @ByRef
                                               ShortBuffer value,
                                               @Cast(value="ushort")
                                               short default_value)

read

@Namespace(value="cv")
public static void read(@Const @ByRef
                                               opencv_core.FileNode node,
                                               @Cast(value="ushort*") @ByRef
                                               short[] value,
                                               @Cast(value="ushort")
                                               short default_value)

read

@Namespace(value="cv")
public static void read(@Const @ByRef
                                               opencv_core.FileNode node,
                                               @ByRef
                                               opencv_core.KeyPointVector vec,
                                               @Const @ByRef
                                               opencv_core.KeyPointVector default_value)

read

@Namespace(value="cv")
public static void read(@Const @ByRef
                                               opencv_core.FileNode node,
                                               @ByRef
                                               opencv_core.DMatchVector vec,
                                               @Const @ByRef
                                               opencv_core.DMatchVector default_value)

shiftLeft

@Namespace(value="cv")
 @ByRef
 @Name(value="operator <<")
public static opencv_core.FileStorage shiftLeft(@ByRef
                                                                                                           opencv_core.FileStorage fs,
                                                                                                           @Cast(value="char*")
                                                                                                           ByteBuffer value)

\brief Writes data to a file storage.

shiftLeft

@Namespace(value="cv")
 @ByRef
 @Name(value="operator <<")
public static opencv_core.FileStorage shiftLeft(@ByRef
                                                                                                           opencv_core.FileStorage fs,
                                                                                                           @Cast(value="char*")
                                                                                                           byte[] value)

shiftRight

@Namespace(value="cv")
 @Name(value="operator >>")
public static void shiftRight(@Const @ByRef
                                                                                 opencv_core.FileNode n,
                                                                                 @ByRef
                                                                                 opencv_core.KeyPoint kpt)

\brief Reads KeyPoint from a file storage.

shiftRight

@Namespace(value="cv")
 @Name(value="operator >>")
public static void shiftRight(@Const @ByRef
                                                                                 opencv_core.FileNode n,
                                                                                 @ByRef
                                                                                 opencv_core.KeyPointVector vec)

shiftRight

@Namespace(value="cv")
 @Name(value="operator >>")
public static void shiftRight(@Const @ByRef
                                                                                 opencv_core.FileNode n,
                                                                                 @ByRef
                                                                                 opencv_core.DMatchVector vec)

shiftRight

@Namespace(value="cv")
 @Name(value="operator >>")
public static void shiftRight(@Const @ByRef
                                                                                 opencv_core.FileNode n,
                                                                                 @ByRef
                                                                                 opencv_core.DMatch m)

\brief Reads DMatch from a file storage.

equals

@Namespace(value="cv")
 @Cast(value="bool")
 @Name(value="operator ==")
public static boolean equals(@Const @ByRef
                                                                                                     opencv_core.FileNodeIterator it1,
                                                                                                     @Const @ByRef
                                                                                                     opencv_core.FileNodeIterator it2)

\} FileNode

\relates cv::FileNodeIterator \{

notEquals

@Namespace(value="cv")
 @Cast(value="bool")
 @Name(value="operator !=")
public static boolean notEquals(@Const @ByRef
                                                                                                        opencv_core.FileNodeIterator it1,
                                                                                                        @Const @ByRef
                                                                                                        opencv_core.FileNodeIterator it2)

subtract

@Namespace(value="cv")
 @Cast(value="ptrdiff_t")
 @Name(value="operator -")
public static long subtract(@Const @ByRef
                                                                                                        opencv_core.FileNodeIterator it1,
                                                                                                        @Const @ByRef
                                                                                                        opencv_core.FileNodeIterator it2)

lessThan

@Namespace(value="cv")
 @Cast(value="bool")
 @Name(value="operator <")
public static boolean lessThan(@Const @ByRef
                                                                                                      opencv_core.FileNodeIterator it1,
                                                                                                      @Const @ByRef
                                                                                                      opencv_core.FileNodeIterator it2)

solveLP
```
@Namespace(value="cv")
public static int solveLP(@Const @ByRef
                                                 opencv_core.Mat Func,
                                                 @Const @ByRef
                                                 opencv_core.Mat Constr,
                                                 @ByRef
                                                 opencv_core.Mat z)
```
\brief Solve given (non-integer) linear programming problem using the Simplex Algorithm (Simplex Method).
What we mean here by "linear programming problem" (or LP problem, for short) can be formulated as:
\f[\mbox{Maximize } c\cdot x\\ \mbox{Subject to:}\\ Ax\leq b\\ x\geq 0\f]
Where \f$c\f$ is fixed 1-by-n row-vector, \f$A\f$ is fixed m-by-n matrix, \f$b\f$ is fixed m-by-1 column vector and \f$x\f$ is an arbitrary n-by-1 column vector, which satisfies the constraints.
Simplex algorithm is one of many algorithms that are designed to handle this sort of problems efficiently. Although it is not optimal in theoretical sense (there exist algorithms that can solve any problem written as above in polynomial time, while simplex method degenerates to exponential time for some special cases), it is well-studied, easy to implement and is shown to work well for real-life purposes.
The particular implementation is taken almost verbatim from **Introduction to Algorithms, third edition** by T. H. Cormen, C. E. Leiserson, R. L. Rivest and Clifford Stein. In particular, the Bland's rule is used to prevent cycling.

Parameters:

Func - This row-vector corresponds to \f$c\f$ in the LP problem formulation (see above). It should contain 32- or 64-bit floating point numbers. As a convenience, column-vector may be also submitted, in the latter case it is understood to correspond to \f$c^T\f$.

Constr - m-by-n+1 matrix, whose rightmost column corresponds to \f$b\f$ in formulation above and the remaining to \f$A\f$. It should contain 32- or 64-bit floating point numbers.

z - The solution will be returned here as a column-vector - it corresponds to \f$c\f$ in the formulation above. It will contain 64-bit floating point numbers.

Returns:

One of cv::SolveLPResult

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_HAL_ERROR_OK

CV_HAL_ERROR_NOT_IMPLEMENTED

CV_HAL_ERROR_UNKNOWN

CV_CN_MAX

CV_CN_SHIFT

CV_DEPTH_MAX

CV_8U

CV_8S

CV_16U

CV_16S

CV_32S

CV_32F

CV_64F

CV_USRTYPE1

CV_MAT_DEPTH_MASK

CV_8UC1

CV_8UC2

CV_8UC3

CV_8UC4

CV_8SC1

CV_8SC2

CV_8SC3

CV_8SC4

CV_16UC1

CV_16UC2

CV_16UC3

CV_16UC4

CV_16SC1

CV_16SC2

CV_16SC3

CV_16SC4

CV_32SC1

CV_32SC2

CV_32SC3

CV_32SC4

CV_32FC1

CV_32FC2

CV_32FC3

CV_32FC4

CV_64FC1

CV_64FC2

CV_64FC3

CV_64FC4

CV_HAL_CMP_EQ

CV_HAL_CMP_GT

CV_HAL_CMP_GE

CV_HAL_CMP_LT

CV_HAL_CMP_LE

CV_HAL_CMP_NE

CV_HAL_BORDER_CONSTANT

CV_HAL_BORDER_REPLICATE

CV_HAL_BORDER_REFLECT

CV_HAL_BORDER_WRAP

CV_HAL_BORDER_REFLECT_101

CV_HAL_BORDER_TRANSPARENT

CV_HAL_BORDER_ISOLATED

CV_HAL_DFT_INVERSE

CV_HAL_DFT_SCALE

CV_HAL_DFT_ROWS

CV_HAL_DFT_COMPLEX_OUTPUT

CV_HAL_DFT_REAL_OUTPUT

CV_HAL_DFT_TWO_STAGE

CV_HAL_DFT_STAGE_COLS

CV_HAL_DFT_IS_CONTINUOUS

CV_HAL_DFT_IS_INPLACE

CV_HAL_SVD_NO_UV

CV_HAL_SVD_SHORT_UV

CV_HAL_SVD_MODIFY_A

CV_HAL_SVD_FULL_UV