opencv_core (JavaCPP Presets for OpenCV 4.5.5-1.5.7 API)

java.lang.Object
- org.bytedeco.opencv.presets.opencv_core
- - org.bytedeco.opencv.helper.opencv_core
  - - org.bytedeco.opencv.global.opencv_core

All Implemented Interfaces:

LoadEnabled, InfoMapper
```
public class opencv_core
extends opencv_core
```

Nested Class Summary
- Nested classes/interfaces inherited from class org.bytedeco.opencv.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::AccessFlag
`static int`	`ACCESS_MASK` enum cv::AccessFlag
`static int`	`ACCESS_READ` enum cv::AccessFlag
`static int`	`ACCESS_RW` enum cv::AccessFlag
`static int`	`ACCESS_WRITE` enum cv::AccessFlag
`static int`	`ALGORITHM` enum struct cv::Param
`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`	`BOOLEAN` enum struct cv::Param
`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_5124FMAPS` enum CpuFeatures
`static int`	`CPU_AVX_5124VNNIW` enum CpuFeatures
`static int`	`CPU_AVX_512BITALG` 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_512VBMI2` enum CpuFeatures
`static int`	`CPU_AVX_512VL` enum CpuFeatures
`static int`	`CPU_AVX_512VNNI` enum CpuFeatures
`static int`	`CPU_AVX_512VPOPCNTDQ` enum CpuFeatures
`static int`	`CPU_AVX2` enum CpuFeatures
`static int`	`CPU_AVX512_CLX` enum CpuFeatures
`static int`	`CPU_AVX512_CNL` enum CpuFeatures
`static int`	`CPU_AVX512_COMMON` enum CpuFeatures
`static int`	`CPU_AVX512_ICL` enum CpuFeatures
`static int`	`CPU_AVX512_KNL` enum CpuFeatures
`static int`	`CPU_AVX512_KNM` 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_MSA` enum CpuFeatures
`static int`	`CPU_NEON` enum CpuFeatures
`static int`	`CPU_POPCNT` enum CpuFeatures
`static int`	`CPU_RISCVV` enum CpuFeatures
`static int`	`CPU_RVV` 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`	`CPU_VSX3` enum CpuFeatures
`static int`	`CV_16F`
`static int`	`CV_16FC1`
`static int`	`CV_16FC2`
`static int`	`CV_16FC3`
`static int`	`CV_16FC4`
`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_5124FMAPS`
`static int`	`CV_CPU_AVX_5124VNNIW`
`static int`	`CV_CPU_AVX_512BITALG`
`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_512VBMI2`
`static int`	`CV_CPU_AVX_512VL`
`static int`	`CV_CPU_AVX_512VNNI`
`static int`	`CV_CPU_AVX_512VPOPCNTDQ`
`static int`	`CV_CPU_AVX2`
`static int`	`CV_CPU_AVX512_CLX`
`static int`	`CV_CPU_AVX512_CNL`
`static int`	`CV_CPU_AVX512_COMMON`
`static int`	`CV_CPU_AVX512_ICL`
`static int`	`CV_CPU_AVX512_KNL`
`static int`	`CV_CPU_AVX512_KNM`
`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_MSA`
`static int`	`CV_CPU_NEON`
`static int`	`CV_CPU_NONE` \endcond
`static int`	`CV_CPU_POPCNT`
`static int`	`CV_CPU_RISCVV`
`static int`	`CV_CPU_RVV`
`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_CPU_VSX3`
`static int`	`CV_CXX_MOVE_SEMANTICS` \ C++ 11 * \
`static int`	`CV_CXX_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_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`
`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` \brief Set Order is not preserved.
`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_MAGIC_VAL`
`static int`	`CV_STRONG_ALIGNMENT`
`static int`	`CV_STRUCT_INITIALIZER`
`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` Graph is "derived" from the set (this is set a of vertices) and includes another set (edges)
`static String`	`CV_TYPE_NAME_IMAGE`
`static String`	`CV_TYPE_NAME_MAT`
`static String`	`CV_TYPE_NAME_MATND`
`static String`	`CV_TYPE_NAME_SEQ` Pointer to the first sequence block.
`static String`	`CV_TYPE_NAME_SEQ_TREE`
`static String`	`CV_TYPE_NAME_SPARSE_MAT`
`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 CvSlice`	`CV_WHOLE_ARR`
`static 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`	`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`	`FLOAT` enum struct cv::Param
`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`	`INT` enum struct cv::Param
`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`	`MaskIsTiled` enum cv::Error::Code
`static int`	`MAT` enum struct cv::Param
`static int`	`MAT_VECTOR` enum struct cv::Param
`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`	`OPENCV_USE_FASTMATH_BUILTINS` \addtogroup core_utils \{
`static int`	`OpenGlApiCallError` enum cv::Error::Code
`static int`	`OpenGlNotSupported` enum cv::Error::Code
`static int`	`REAL` enum struct cv::Param
`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`	`SCALAR` enum struct cv::Param
`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`	`STRING` enum struct cv::Param
`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`	`UCHAR` enum struct cv::Param
`static int`	`UINT64` enum struct cv::Param
`static int`	`UNSIGNED_INT` enum struct cv::Param
`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 MatExpr`	`abs(Mat m)` \brief Calculates an absolute value of each matrix element.
`static MatExpr`	`abs(MatExpr e)` \overload
`static short`	`abs(short a)`
`static void`	`absdiff(GpuMat src1, GpuMat src2, GpuMat dst)`
`static void`	`absdiff(Mat src1, Mat src2, Mat dst)` \brief Calculates the per-element absolute difference between two arrays or between an array and a scalar.
`static void`	`absdiff(UMat src1, UMat src2, UMat dst)`
`static void`	`absdiff16s(short[] src1, long step1, short[] src2, long step2, short[] dst, long step, int width, int height, Pointer arg8)`
`static void`	`absdiff16s(ShortBuffer src1, long step1, ShortBuffer src2, long step2, ShortBuffer dst, long step, int width, int height, Pointer arg8)`
`static void`	`absdiff16s(ShortPointer src1, long step1, ShortPointer src2, long step2, ShortPointer dst, long step, int width, int height, Pointer arg8)`
`static void`	`absdiff16u(short[] src1, long step1, short[] src2, long step2, short[] dst, long step, int width, int height, Pointer arg8)`
`static void`	`absdiff16u(ShortBuffer src1, long step1, ShortBuffer src2, long step2, ShortBuffer dst, long step, int width, int height, Pointer arg8)`
`static void`	`absdiff16u(ShortPointer src1, long step1, ShortPointer src2, long step2, ShortPointer dst, long step, int width, int height, Pointer arg8)`
`static void`	`absdiff32f(float[] src1, long step1, float[] src2, long step2, float[] dst, long step, int width, int height, Pointer arg8)`
`static void`	`absdiff32f(FloatBuffer src1, long step1, FloatBuffer src2, long step2, FloatBuffer dst, long step, int width, int height, Pointer arg8)`
`static void`	`absdiff32f(FloatPointer src1, long step1, FloatPointer src2, long step2, FloatPointer dst, long step, int width, int height, Pointer arg8)`
`static void`	`absdiff32s(int[] src1, long step1, int[] src2, long step2, int[] dst, long step, int width, int height, Pointer arg8)`
`static void`	`absdiff32s(IntBuffer src1, long step1, IntBuffer src2, long step2, IntBuffer dst, long step, int width, int height, Pointer arg8)`
`static void`	`absdiff32s(IntPointer src1, long step1, IntPointer src2, long step2, IntPointer dst, long step, int width, int height, Pointer arg8)`
`static void`	`absdiff64f(double[] src1, long step1, double[] src2, long step2, double[] dst, long step, int width, int height, Pointer arg8)`
`static void`	`absdiff64f(DoubleBuffer src1, long step1, DoubleBuffer src2, long step2, DoubleBuffer dst, long step, int width, int height, Pointer arg8)`
`static void`	`absdiff64f(DoublePointer src1, long step1, DoublePointer src2, long step2, DoublePointer dst, long step, int width, int height, Pointer arg8)`
`static void`	`absdiff8s(byte[] src1, long step1, byte[] src2, long step2, byte[] dst, long step, int width, int height, Pointer arg8)`
`static void`	`absdiff8s(ByteBuffer src1, long step1, ByteBuffer src2, long step2, ByteBuffer dst, long step, int width, int height, Pointer arg8)`
`static void`	`absdiff8s(BytePointer src1, long step1, BytePointer src2, long step2, BytePointer dst, long step, int width, int height, Pointer arg8)`
`static void`	`absdiff8u(byte[] src1, long step1, byte[] src2, long step2, byte[] dst, long step, int width, int height, Pointer arg8)`
`static void`	`absdiff8u(ByteBuffer src1, long step1, ByteBuffer src2, long step2, ByteBuffer dst, long step, int width, int height, Pointer arg8)`
`static void`	`absdiff8u(BytePointer src1, long step1, BytePointer src2, long step2, BytePointer dst, long step, int width, int height, Pointer arg8)`
`static void`	`add(GpuMat src1, GpuMat src2, GpuMat dst)`
`static void`	`add(GpuMat src1, GpuMat src2, GpuMat dst, GpuMat mask, int dtype)`
`static Range`	`add(int delta, Range r1)`
`static MatExpr`	`add(MatExpr e, Mat m)`
`static MatExpr`	`add(MatExpr e1, MatExpr e2)`
`static MatExpr`	`add(MatExpr e, Scalar s)`
`static MatExpr`	`add(Mat a, Mat b)` \} core_basic
`static MatExpr`	`add(Mat m, MatExpr e)`
`static void`	`add(Mat src1, Mat src2, Mat dst)`
`static void`	`add(Mat src1, Mat src2, Mat dst, Mat mask, int dtype)` \brief Calculates the per-element sum of two arrays or an array and a scalar.
`static MatExpr`	`add(Mat a, Scalar s)`
`static Range`	`add(Range r1, int delta)`
`static MatExpr`	`add(Scalar s, Mat a)`
`static MatExpr`	`add(Scalar s, MatExpr e)`
`static void`	`add(UMat src1, UMat src2, UMat dst)`
`static void`	`add(UMat src1, UMat src2, UMat dst, UMat mask, int dtype)`
`static void`	`add16s(short[] src1, long step1, short[] src2, long step2, short[] dst, long step, int width, int height, Pointer arg8)`
`static void`	`add16s(ShortBuffer src1, long step1, ShortBuffer src2, long step2, ShortBuffer dst, long step, int width, int height, Pointer arg8)`
`static void`	`add16s(ShortPointer src1, long step1, ShortPointer src2, long step2, ShortPointer dst, long step, int width, int height, Pointer arg8)`
`static void`	`add16u(short[] src1, long step1, short[] src2, long step2, short[] dst, long step, int width, int height, Pointer arg8)`
`static void`	`add16u(ShortBuffer src1, long step1, ShortBuffer src2, long step2, ShortBuffer dst, long step, int width, int height, Pointer arg8)`
`static void`	`add16u(ShortPointer src1, long step1, ShortPointer src2, long step2, ShortPointer dst, long step, int width, int height, Pointer arg8)`
`static void`	`add32f(float[] src1, long step1, float[] src2, long step2, float[] dst, long step, int width, int height, Pointer arg8)`
`static void`	`add32f(FloatBuffer src1, long step1, FloatBuffer src2, long step2, FloatBuffer dst, long step, int width, int height, Pointer arg8)`
`static void`	`add32f(FloatPointer src1, long step1, FloatPointer src2, long step2, FloatPointer dst, long step, int width, int height, Pointer arg8)`
`static void`	`add32s(int[] src1, long step1, int[] src2, long step2, int[] dst, long step, int width, int height, Pointer arg8)`
`static void`	`add32s(IntBuffer src1, long step1, IntBuffer src2, long step2, IntBuffer dst, long step, int width, int height, Pointer arg8)`
`static void`	`add32s(IntPointer src1, long step1, IntPointer src2, long step2, IntPointer dst, long step, int width, int height, Pointer arg8)`
`static void`	`add64f(double[] src1, long step1, double[] src2, long step2, double[] dst, long step, int width, int height, Pointer arg8)`
`static void`	`add64f(DoubleBuffer src1, long step1, DoubleBuffer src2, long step2, DoubleBuffer dst, long step, int width, int height, Pointer arg8)`
`static void`	`add64f(DoublePointer src1, long step1, DoublePointer src2, long step2, DoublePointer dst, long step, int width, int height, Pointer arg8)`
`static void`	`add8s(byte[] src1, long step1, byte[] src2, long step2, byte[] dst, long step, int width, int height, Pointer arg8)`
`static void`	`add8s(ByteBuffer src1, long step1, ByteBuffer src2, long step2, ByteBuffer dst, long step, int width, int height, Pointer arg8)`
`static void`	`add8s(BytePointer src1, long step1, BytePointer src2, long step2, BytePointer dst, long step, int width, int height, Pointer arg8)`
`static void`	`add8u(byte[] src1, long step1, byte[] src2, long step2, byte[] dst, long step, int width, int height, Pointer arg8)`
`static void`	`add8u(ByteBuffer src1, long step1, ByteBuffer src2, long step2, ByteBuffer dst, long step, int width, int height, Pointer arg8)`
`static void`	`add8u(BytePointer src1, long step1, BytePointer src2, long step2, BytePointer dst, long step, int width, int height, Pointer arg8)`
`static Mat`	`addPut(Mat a, Mat b)` \cond IGNORED
`static Mat`	`addPut(Mat a, Scalar b)`
`static void`	`addRNGBias32f(float[] arr, float[] scaleBiasPairs, int len)`
`static void`	`addRNGBias32f(FloatBuffer arr, FloatBuffer scaleBiasPairs, int len)`
`static void`	`addRNGBias32f(FloatPointer arr, FloatPointer scaleBiasPairs, int len)`
`static void`	`addRNGBias64f(double[] arr, double[] scaleBiasPairs, int len)`
`static void`	`addRNGBias64f(DoubleBuffer arr, DoubleBuffer scaleBiasPairs, int len)`
`static void`	`addRNGBias64f(DoublePointer arr, DoublePointer scaleBiasPairs, int len)`
`static void`	`addSamplesDataSearchPath(BytePointer path)` \brief Override search data path by adding new search location
`static void`	`addSamplesDataSearchPath(String path)`
`static void`	`addSamplesDataSearchSubDirectory(BytePointer subdir)` \brief Append samples search data sub directory
`static void`	`addSamplesDataSearchSubDirectory(String subdir)`
`static void`	`addWeighted(GpuMat src1, double alpha, GpuMat src2, double beta, double gamma, GpuMat dst)`
`static void`	`addWeighted(GpuMat src1, double alpha, GpuMat src2, double beta, double gamma, GpuMat dst, int dtype)`
`static void`	`addWeighted(Mat src1, double alpha, Mat src2, double beta, double gamma, Mat dst)`
`static void`	`addWeighted(Mat src1, double alpha, Mat src2, double beta, double gamma, Mat dst, int dtype)` \brief Calculates the weighted sum of two arrays.
`static void`	`addWeighted(UMat src1, double alpha, UMat src2, double beta, double gamma, UMat dst)`
`static void`	`addWeighted(UMat src1, double alpha, UMat src2, double beta, double gamma, UMat dst, int dtype)`
`static void`	`addWeighted16s(short[] src1, long step1, short[] src2, long step2, short[] dst, long step, int width, int height, Pointer scalars)`
`static void`	`addWeighted16s(ShortBuffer src1, long step1, ShortBuffer src2, long step2, ShortBuffer dst, long step, int width, int height, Pointer scalars)`
`static void`	`addWeighted16s(ShortPointer src1, long step1, ShortPointer src2, long step2, ShortPointer dst, long step, int width, int height, Pointer scalars)`
`static void`	`addWeighted16u(short[] src1, long step1, short[] src2, long step2, short[] dst, long step, int width, int height, Pointer scalars)`
`static void`	`addWeighted16u(ShortBuffer src1, long step1, ShortBuffer src2, long step2, ShortBuffer dst, long step, int width, int height, Pointer scalars)`
`static void`	`addWeighted16u(ShortPointer src1, long step1, ShortPointer src2, long step2, ShortPointer dst, long step, int width, int height, Pointer scalars)`
`static void`	`addWeighted32f(float[] src1, long step1, float[] src2, long step2, float[] dst, long step, int width, int height, Pointer scalars)`
`static void`	`addWeighted32f(FloatBuffer src1, long step1, FloatBuffer src2, long step2, FloatBuffer dst, long step, int width, int height, Pointer scalars)`
`static void`	`addWeighted32f(FloatPointer src1, long step1, FloatPointer src2, long step2, FloatPointer dst, long step, int width, int height, Pointer scalars)`
`static void`	`addWeighted32s(int[] src1, long step1, int[] src2, long step2, int[] dst, long step, int width, int height, Pointer scalars)`
`static void`	`addWeighted32s(IntBuffer src1, long step1, IntBuffer src2, long step2, IntBuffer dst, long step, int width, int height, Pointer scalars)`
`static void`	`addWeighted32s(IntPointer src1, long step1, IntPointer src2, long step2, IntPointer dst, long step, int width, int height, Pointer scalars)`
`static void`	`addWeighted64f(double[] src1, long step1, double[] src2, long step2, double[] dst, long step, int width, int height, Pointer scalars)`
`static void`	`addWeighted64f(DoubleBuffer src1, long step1, DoubleBuffer src2, long step2, DoubleBuffer dst, long step, int width, int height, Pointer scalars)`
`static void`	`addWeighted64f(DoublePointer src1, long step1, DoublePointer src2, long step2, DoublePointer dst, long step, int width, int height, Pointer scalars)`
`static void`	`addWeighted8s(byte[] src1, long step1, byte[] src2, long step2, byte[] dst, long step, int width, int height, Pointer scalars)`
`static void`	`addWeighted8s(ByteBuffer src1, long step1, ByteBuffer src2, long step2, ByteBuffer dst, long step, int width, int height, Pointer scalars)`
`static void`	`addWeighted8s(BytePointer src1, long step1, BytePointer src2, long step2, BytePointer dst, long step, int width, int height, Pointer scalars)`
`static void`	`addWeighted8u(byte[] src1, long step1, byte[] src2, long step2, byte[] dst, long step, int width, int height, Pointer _scalars)`
`static void`	`addWeighted8u(ByteBuffer src1, long step1, ByteBuffer src2, long step2, ByteBuffer dst, long step, int width, int height, Pointer _scalars)`
`static void`	`addWeighted8u(BytePointer src1, long step1, BytePointer src2, long step2, BytePointer dst, long step, int width, int height, Pointer _scalars)`
`static long`	`alignSize(long sz, int n)` \brief Aligns a buffer size to the specified number of bytes.
`static int`	`and(int a, int b)`
`static MatExpr`	`and(Mat a, Mat b)`
`static MatExpr`	`and(Mat a, Scalar s)`
`static Range`	`and(Range r1, Range r2)`
`static MatExpr`	`and(Scalar s, Mat a)`
`static void`	`and8u(byte[] src1, long step1, byte[] src2, long step2, byte[] dst, long step, int width, int height, Pointer arg8)`
`static void`	`and8u(ByteBuffer src1, long step1, ByteBuffer src2, long step2, ByteBuffer dst, long step, int width, int height, Pointer arg8)`
`static void`	`and8u(BytePointer src1, long step1, BytePointer src2, long step2, BytePointer dst, long step, int width, int height, Pointer arg8)`
`static int[]`	`andPut(int[] _this, int val)`
`static IntBuffer`	`andPut(IntBuffer _this, int val)`
`static IntPointer`	`andPut(IntPointer _this, int val)`
`static Mat`	`andPut(Mat a, Mat b)`
`static Mat`	`andPut(Mat a, Scalar b)`
`static Range`	`andPut(Range r1, Range r2)`
`static void`	`attachContext(BytePointer platformName, Pointer platformID, Pointer context, 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, Pointer platformID, Pointer context, Pointer deviceID)`
`static void`	`batchDistance(GpuMat src1, GpuMat src2, GpuMat dist, int dtype, GpuMat nidx)`
`static void`	`batchDistance(GpuMat src1, GpuMat src2, GpuMat dist, int dtype, GpuMat nidx, int normType, int K, GpuMat mask, int update, boolean crosscheck)`
`static void`	`batchDistance(Mat src1, Mat src2, Mat dist, int dtype, Mat nidx)`
`static void`	`batchDistance(Mat src1, Mat src2, Mat dist, int dtype, Mat nidx, int normType, int K, Mat mask, int update, boolean crosscheck)` \brief naive nearest neighbor finder
`static void`	`batchDistance(UMat src1, UMat src2, UMat dist, int dtype, UMat nidx)`
`static void`	`batchDistance(UMat src1, UMat src2, UMat dist, int dtype, UMat nidx, int normType, int K, UMat mask, int update, boolean crosscheck)`
`static void`	`bitwise_and(GpuMat src1, GpuMat src2, GpuMat dst)`
`static void`	`bitwise_and(GpuMat src1, GpuMat src2, GpuMat dst, GpuMat mask)`
`static void`	`bitwise_and(Mat src1, Mat src2, Mat dst)`
`static void`	`bitwise_and(Mat src1, Mat src2, Mat dst, 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(UMat src1, UMat src2, UMat dst)`
`static void`	`bitwise_and(UMat src1, UMat src2, UMat dst, UMat mask)`
`static void`	`bitwise_not(GpuMat src, GpuMat dst)`
`static void`	`bitwise_not(GpuMat src, GpuMat dst, GpuMat mask)`
`static void`	`bitwise_not(Mat src, Mat dst)`
`static void`	`bitwise_not(Mat src, Mat dst, Mat mask)` \brief Inverts every bit of an array.
`static void`	`bitwise_not(UMat src, UMat dst)`
`static void`	`bitwise_not(UMat src, UMat dst, UMat mask)`
`static void`	`bitwise_or(GpuMat src1, GpuMat src2, GpuMat dst)`
`static void`	`bitwise_or(GpuMat src1, GpuMat src2, GpuMat dst, GpuMat mask)`
`static void`	`bitwise_or(Mat src1, Mat src2, Mat dst)`
`static void`	`bitwise_or(Mat src1, Mat src2, Mat dst, Mat mask)` \brief Calculates the per-element bit-wise disjunction of two arrays or an array and a scalar.
`static void`	`bitwise_or(UMat src1, UMat src2, UMat dst)`
`static void`	`bitwise_or(UMat src1, UMat src2, UMat dst, UMat mask)`
`static void`	`bitwise_xor(GpuMat src1, GpuMat src2, GpuMat dst)`
`static void`	`bitwise_xor(GpuMat src1, GpuMat src2, GpuMat dst, GpuMat mask)`
`static void`	`bitwise_xor(Mat src1, Mat src2, Mat dst)`
`static void`	`bitwise_xor(Mat src1, Mat src2, Mat dst, 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(UMat src1, UMat src2, UMat dst)`
`static void`	`bitwise_xor(UMat src1, UMat src2, UMat dst, UMat mask)`
`static int`	`borderInterpolate(int p, int len, int borderType)` \} core
`static void`	`buildOptionsAddMatrixDescription(BytePointer buildOptions, BytePointer name, GpuMat _m)`
`static void`	`buildOptionsAddMatrixDescription(BytePointer buildOptions, BytePointer name, Mat _m)`
`static void`	`buildOptionsAddMatrixDescription(BytePointer buildOptions, BytePointer name, UMat _m)`
`static void`	`buildOptionsAddMatrixDescription(String buildOptions, String name, GpuMat _m)`
`static void`	`buildOptionsAddMatrixDescription(String buildOptions, String name, Mat _m)`
`static void`	`buildOptionsAddMatrixDescription(String buildOptions, String name, UMat _m)`
`static void`	`calcCovarMatrix(GpuMat samples, GpuMat covar, GpuMat mean, int flags)`
`static void`	`calcCovarMatrix(GpuMat samples, GpuMat covar, GpuMat mean, int flags, int ctype)`
`static void`	`calcCovarMatrix(Mat samples, int nsamples, Mat covar, Mat mean, int flags)`
`static void`	`calcCovarMatrix(Mat samples, int nsamples, Mat covar, Mat mean, int flags, int ctype)` \brief Calculates the covariance matrix of a set of vectors.
`static void`	`calcCovarMatrix(Mat samples, Mat covar, Mat mean, int flags)`
`static void`	`calcCovarMatrix(Mat samples, Mat covar, Mat mean, int flags, int ctype)` \overload \note use #COVAR_ROWS or #COVAR_COLS flag
`static void`	`calcCovarMatrix(UMat samples, UMat covar, UMat mean, int flags)`
`static void`	`calcCovarMatrix(UMat samples, UMat covar, UMat mean, int flags, int ctype)`
`static void`	`cartToPolar(GpuMat x, GpuMat y, GpuMat magnitude, GpuMat angle)`
`static void`	`cartToPolar(GpuMat x, GpuMat y, GpuMat magnitude, GpuMat angle, boolean angleInDegrees)`
`static void`	`cartToPolar(Mat x, Mat y, Mat magnitude, Mat angle)`
`static void`	`cartToPolar(Mat x, Mat y, Mat magnitude, Mat angle, boolean angleInDegrees)` \brief Calculates the magnitude and angle of 2D vectors.
`static void`	`cartToPolar(UMat x, UMat y, UMat magnitude, UMat angle)`
`static void`	`cartToPolar(UMat x, UMat y, UMat magnitude, UMat angle, boolean angleInDegrees)`
`static byte`	`char_tolower(byte ch)` \cond IGNORED
`static byte`	`char_toupper(byte ch)`
`static boolean`	`checkHardwareSupport(int feature)` \brief Returns true if the specified feature is supported by the host hardware.
`static int`	`checkOptimalVectorWidth(int[] vectorWidths, GpuMat src1)`
`static int`	`checkOptimalVectorWidth(int[] vectorWidths, GpuMat src1, GpuMat src2, GpuMat src3, GpuMat src4, GpuMat src5, GpuMat src6, GpuMat src7, GpuMat src8, GpuMat src9, int strat)`
`static int`	`checkOptimalVectorWidth(int[] vectorWidths, Mat src1)`
`static int`	`checkOptimalVectorWidth(int[] vectorWidths, Mat src1, Mat src2, Mat src3, Mat src4, Mat src5, Mat src6, Mat src7, Mat src8, Mat src9, int strat)`
`static int`	`checkOptimalVectorWidth(int[] vectorWidths, UMat src1)`
`static int`	`checkOptimalVectorWidth(int[] vectorWidths, UMat src1, UMat src2, UMat src3, UMat src4, UMat src5, UMat src6, UMat src7, UMat src8, UMat src9, int strat)`
`static int`	`checkOptimalVectorWidth(IntBuffer vectorWidths, GpuMat src1)`
`static int`	`checkOptimalVectorWidth(IntBuffer vectorWidths, GpuMat src1, GpuMat src2, GpuMat src3, GpuMat src4, GpuMat src5, GpuMat src6, GpuMat src7, GpuMat src8, GpuMat src9, int strat)`
`static int`	`checkOptimalVectorWidth(IntBuffer vectorWidths, Mat src1)`
`static int`	`checkOptimalVectorWidth(IntBuffer vectorWidths, Mat src1, Mat src2, Mat src3, Mat src4, Mat src5, Mat src6, Mat src7, Mat src8, Mat src9, int strat)`
`static int`	`checkOptimalVectorWidth(IntBuffer vectorWidths, UMat src1)`
`static int`	`checkOptimalVectorWidth(IntBuffer vectorWidths, UMat src1, UMat src2, UMat src3, UMat src4, UMat src5, UMat src6, UMat src7, UMat src8, UMat src9, int strat)`
`static int`	`checkOptimalVectorWidth(IntPointer vectorWidths, GpuMat src1)`
`static int`	`checkOptimalVectorWidth(IntPointer vectorWidths, GpuMat src1, GpuMat src2, GpuMat src3, GpuMat src4, GpuMat src5, GpuMat src6, GpuMat src7, GpuMat src8, GpuMat src9, int strat)`
`static int`	`checkOptimalVectorWidth(IntPointer vectorWidths, Mat src1)`
`static int`	`checkOptimalVectorWidth(IntPointer vectorWidths, Mat src1, Mat src2, Mat src3, Mat src4, Mat src5, Mat src6, Mat src7, Mat src8, Mat src9, int strat)`
`static int`	`checkOptimalVectorWidth(IntPointer vectorWidths, UMat src1)`
`static int`	`checkOptimalVectorWidth(IntPointer vectorWidths, UMat src1, UMat src2, UMat src3, UMat src4, UMat src5, UMat src6, UMat src7, UMat src8, UMat src9, int strat)`
`static boolean`	`checkRange(GpuMat a)`
`static boolean`	`checkRange(GpuMat a, boolean quiet, Point pos, double minVal, double maxVal)`
`static boolean`	`checkRange(Mat a)`
`static boolean`	`checkRange(Mat a, boolean quiet, Point pos, double minVal, double maxVal)` \brief Checks every element of an input array for invalid values.
`static boolean`	`checkRange(UMat a)`
`static boolean`	`checkRange(UMat a, boolean quiet, 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(DoublePointer A, long astep, int m, DoublePointer b, long bstep, int n)`
`static boolean`	`Cholesky(float[] A, long astep, int m, float[] b, long bstep, int n)`
`static boolean`	`Cholesky(FloatBuffer A, long astep, int m, FloatBuffer b, long bstep, int n)`
`static boolean`	`Cholesky(FloatPointer A, long astep, int m, FloatPointer b, long bstep, int n)`
`static 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(FloatPointer A, long astep, int m, 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(DoublePointer A, long astep, int m, DoublePointer b, long bstep, int n)`
`static void`	`clearSeq(CvSeq seq)`
`static void`	`cmp16s(short[] src1, long step1, short[] src2, long step2, byte[] dst, long step, int width, int height, Pointer _cmpop)`
`static void`	`cmp16s(ShortBuffer src1, long step1, ShortBuffer src2, long step2, ByteBuffer dst, long step, int width, int height, Pointer _cmpop)`
`static void`	`cmp16s(ShortPointer src1, long step1, ShortPointer src2, long step2, BytePointer dst, long step, int width, int height, Pointer _cmpop)`
`static void`	`cmp16u(short[] src1, long step1, short[] src2, long step2, byte[] dst, long step, int width, int height, Pointer _cmpop)`
`static void`	`cmp16u(ShortBuffer src1, long step1, ShortBuffer src2, long step2, ByteBuffer dst, long step, int width, int height, Pointer _cmpop)`
`static void`	`cmp16u(ShortPointer src1, long step1, ShortPointer src2, long step2, BytePointer dst, long step, int width, int height, Pointer _cmpop)`
`static void`	`cmp32f(float[] src1, long step1, float[] src2, long step2, byte[] dst, long step, int width, int height, Pointer _cmpop)`
`static void`	`cmp32f(FloatBuffer src1, long step1, FloatBuffer src2, long step2, ByteBuffer dst, long step, int width, int height, Pointer _cmpop)`
`static void`	`cmp32f(FloatPointer src1, long step1, FloatPointer src2, long step2, BytePointer dst, long step, int width, int height, Pointer _cmpop)`
`static void`	`cmp32s(int[] src1, long step1, int[] src2, long step2, byte[] dst, long step, int width, int height, Pointer _cmpop)`
`static void`	`cmp32s(IntBuffer src1, long step1, IntBuffer src2, long step2, ByteBuffer dst, long step, int width, int height, Pointer _cmpop)`
`static void`	`cmp32s(IntPointer src1, long step1, IntPointer src2, long step2, BytePointer dst, long step, int width, int height, Pointer _cmpop)`
`static void`	`cmp64f(double[] src1, long step1, double[] src2, long step2, byte[] dst, long step, int width, int height, Pointer _cmpop)`
`static void`	`cmp64f(DoubleBuffer src1, long step1, DoubleBuffer src2, long step2, ByteBuffer dst, long step, int width, int height, Pointer _cmpop)`
`static void`	`cmp64f(DoublePointer src1, long step1, DoublePointer src2, long step2, BytePointer dst, long step, int width, int height, Pointer _cmpop)`
`static void`	`cmp8s(byte[] src1, long step1, byte[] src2, long step2, byte[] dst, long step, int width, int height, Pointer _cmpop)`
`static void`	`cmp8s(ByteBuffer src1, long step1, ByteBuffer src2, long step2, ByteBuffer dst, long step, int width, int height, Pointer _cmpop)`
`static void`	`cmp8s(BytePointer src1, long step1, BytePointer src2, long step2, BytePointer dst, long step, int width, int height, Pointer _cmpop)`
`static void`	`cmp8u(byte[] src1, long step1, byte[] src2, long step2, byte[] dst, long step, int width, int height, Pointer _cmpop)`
`static void`	`cmp8u(ByteBuffer src1, long step1, ByteBuffer src2, long step2, ByteBuffer dst, long step, int width, int height, Pointer _cmpop)`
`static void`	`cmp8u(BytePointer src1, long step1, BytePointer src2, long step2, BytePointer dst, long step, int width, int height, Pointer _cmpop)`
`static void`	`compare(GpuMat src1, GpuMat src2, GpuMat dst, int cmpop)`
`static void`	`compare(Mat src1, Mat src2, Mat dst, int cmpop)` \brief Performs the per-element comparison of two arrays or an array and scalar value.
`static void`	`compare(UMat src1, UMat src2, UMat dst, int cmpop)`
`static void`	`completeSymm(GpuMat m)`
`static void`	`completeSymm(GpuMat m, boolean lowerToUpper)`
`static void`	`completeSymm(Mat m)`
`static void`	`completeSymm(Mat m, boolean lowerToUpper)` \brief Copies the lower or the upper half of a square matrix to its another half.
`static void`	`completeSymm(UMat m)`
`static void`	`completeSymm(UMat m, boolean lowerToUpper)`
`static void`	`convertFp16(GpuMat src, GpuMat dst)`
`static void`	`convertFp16(Mat src, Mat dst)` \brief Converts an array to half precision floating number.
`static void`	`convertFp16(UMat src, UMat dst)`
`static void`	`convertFromBuffer(Pointer cl_mem_buffer, long step, int rows, int cols, int type, 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(Pointer cl_mem_image, 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(GpuMat src, GpuMat dst)`
`static void`	`convertScaleAbs(GpuMat src, GpuMat dst, double alpha, double beta)`
`static void`	`convertScaleAbs(Mat src, Mat dst)`
`static void`	`convertScaleAbs(Mat src, Mat dst, double alpha, double beta)` \brief Scales, calculates absolute values, and converts the result to 8-bit.
`static void`	`convertScaleAbs(UMat src, UMat dst)`
`static void`	`convertScaleAbs(UMat src, UMat dst, double alpha, double beta)`
`static BytePointer`	`convertTypeStr(int sdepth, int ddepth, int cn, byte[] buf)`
`static String`	`convertTypeStr(int sdepth, int ddepth, int cn, ByteBuffer buf)`
`static BytePointer`	`convertTypeStr(int sdepth, int ddepth, int cn, BytePointer buf)` Deprecated.
`static void`	`copyMakeBorder(GpuMat src, GpuMat dst, int top, int bottom, int left, int right, int borderType)`
`static void`	`copyMakeBorder(GpuMat src, GpuMat dst, int top, int bottom, int left, int right, int borderType, Scalar value)`
`static void`	`copyMakeBorder(Mat src, Mat dst, int top, int bottom, int left, int right, int borderType)`
`static void`	`copyMakeBorder(Mat src, Mat dst, int top, int bottom, int left, int right, int borderType, Scalar value)` \brief Forms a border around an image.
`static void`	`copyMakeBorder(UMat src, UMat dst, int top, int bottom, int left, int right, int borderType)`
`static void`	`copyMakeBorder(UMat src, UMat dst, int top, int bottom, int left, int right, int borderType, Scalar value)`
`static void`	`copyTo(GpuMat src, GpuMat dst, GpuMat mask)`
`static void`	`copyTo(Mat src, Mat dst, Mat mask)` \brief This is an overloaded member function, provided for convenience (python) Copies the matrix to another one.
`static void`	`copyTo(UMat src, UMat dst, UMat mask)`
`static int`	`countNonZero(GpuMat src)`
`static int`	`countNonZero(Mat src)` \brief Counts non-zero array elements.
`static int`	`countNonZero(UMat src)`
`static void`	`createContinuous(int rows, int cols, int type, GpuMat arr)`
`static void`	`createContinuous(int rows, int cols, int type, Mat arr)` \brief Creates a continuous matrix.
`static void`	`createContinuous(int rows, int cols, int type, UMat arr)`
`static double`	`cubeRoot(double val)` \overload
`static float`	`cubeRoot(float val)` \brief Computes the cube root of an argument.
`static int`	`CV_16FC1()`
`static int`	`CV_16FC2()`
`static int`	`CV_16FC3()`
`static int`	`CV_16FC4()`
`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)` replaced with CV_Assert(expr) in Debug configuration
`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_SEQ_ELTYPE_PPOINT()` &(x,y)
`static int`	`CV_SEQ_ELTYPE_PTR()`
`static int`	`CV_SET_ELEM_FREE_FLAG()`
`static int`	`CV_STRUCT_INITIALIZER()` \}
`static String`	`CV_VERSION()`
`static int`	`CV_XADD(int[] addr, int delta)`
`static int`	`CV_XADD(IntBuffer addr, int delta)`
`static int`	`CV_XADD(IntPointer addr, int delta)` \ exchange-add operation for atomic operations on reference counters * \
`static void`	`cvAbsDiff(CvArr src1, CvArr src2, CvArr dst)` dst(x,y,c) = abs(src1(x,y,c) - src2(x,y,c))
`static void`	`cvAbsDiffS(CvArr src, CvArr dst, CvScalar value)` dst(x,y,c) = abs(src(x,y,c) - value(c))
`static void`	`cvAdd(CvArr src1, CvArr src2, CvArr dst)`
`static void`	`cvAdd(CvArr src1, CvArr src2, CvArr dst, CvArr mask)` dst(mask) = src1(mask) + src2(mask)
`static void`	`cvAddS(CvArr src, CvScalar value, CvArr dst)`
`static void`	`cvAddS(CvArr src, CvScalar value, CvArr dst, CvArr mask)` dst(mask) = src(mask) + value
`static void`	`cvAddWeighted(CvArr src1, double alpha, CvArr src2, double beta, double gamma, CvArr dst)` dst = src1 * alpha + src2 * beta + gamma
`static Pointer`	`cvAlloc(long size)` `malloc` wrapper.
`static void`	`cvAnd(CvArr src1, CvArr src2, CvArr dst)`
`static void`	`cvAnd(CvArr src1, CvArr src2, CvArr dst, CvArr mask)` dst(idx) = src1(idx) & src2(idx)
`static void`	`cvAndS(CvArr src, CvScalar value, CvArr dst)`
`static void`	`cvAndS(CvArr src, CvScalar value, CvArr dst, CvArr mask)` dst(idx) = src(idx) & value
`static Mat`	`cvarrToMat(CvArr arr)`
`static Mat`	`cvarrToMat(CvArr arr, boolean copyData, boolean allowND, int coiMode, Pointer buf)` \addtogroup core_c_glue \{
`static Mat`	`cvarrToMatND(CvArr arr)`
`static Mat`	`cvarrToMatND(CvArr arr, boolean copyData, int coiMode)`
`static CvScalar`	`cvAvg(CvArr arr)`
`static CvScalar`	`cvAvg(CvArr arr, CvArr mask)` Calculates mean value of array elements
`static void`	`cvAvgSdv(CvArr arr, CvScalar mean, CvScalar std_dev)`
`static void`	`cvAvgSdv(CvArr arr, CvScalar mean, CvScalar std_dev, CvArr mask)` Calculates mean and standard deviation of pixel values
`static void`	`cvBackProjectPCA(CvArr proj, CvArr mean, CvArr eigenvects, CvArr result)`
`static CvBox2D`	`cvBox2D()`
`static CvBox2D`	`cvBox2D(CvPoint2D32f c, CvSize2D32f s, float a)`
`static CvBox2D`	`cvBox2D(float[] c, CvSize2D32f s, float a)`
`static CvBox2D`	`cvBox2D(FloatBuffer c, CvSize2D32f s, float a)`
`static CvBox2D`	`cvBox2D(RotatedRect rr)`
`static void`	`cvCalcCovarMatrix(CvArr vects, int count, CvArr cov_mat, CvArr avg, int flags)`
`static void`	`cvCalcCovarMatrix(PointerPointer vects, int count, CvArr cov_mat, CvArr avg, int flags)` Calculates covariation matrix for a set of vectors
`static void`	`cvCalcPCA(CvArr data, CvArr mean, CvArr eigenvals, CvArr eigenvects, int flags)`
`static void`	`cvCartToPolar(CvArr x, CvArr y, CvArr magnitude)`
`static void`	`cvCartToPolar(CvArr x, CvArr y, CvArr magnitude, 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(Pointer reader, int direction)` Internal sequence functions
`static int`	`cvCheckArr(CvArr arr)`
`static int`	`cvCheckArr(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(CvArr arg1, int arg2, double arg3, double arg4)`
`static int`	`cvCheckHardwareSupport(int feature)` CPU capabilities
`static CvTermCriteria`	`cvCheckTermCriteria(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(CvGraph graph)` Remove all vertices and edges from the graph
`static void`	`cvClearMemStorage(CvMemStorage storage)` Clears memory storage.
`static void`	`cvClearND(CvArr arr, int[] idx)`
`static void`	`cvClearND(CvArr arr, IntBuffer idx)`
`static void`	`cvClearND(CvArr arr, IntPointer idx)` clears element of ND dense array, in case of sparse arrays it deletes the specified node
`static void`	`cvClearSeq(CvSeq seq)` Removes all the elements from the sequence.
`static void`	`cvClearSet(CvSet set_header)` Removes all the elements from the set
`static Pointer`	`cvClone(Pointer struct_ptr)` \brief Makes a clone of an object.
`static CvGraph`	`cvCloneGraph(CvGraph graph, CvMemStorage storage)` Creates a copy of graph
`static IplImage`	`cvCloneImage(IplImage image)` Creates a copy of IPL image (widthStep may differ)
`static CvMat`	`cvCloneMat(CvMat mat)` Creates an exact copy of the input matrix (except, may be, step value)
`static CvMatND`	`cvCloneMatND(CvMatND mat)` Creates a copy of CvMatND (except, may be, steps)
`static CvSeq`	`cvCloneSeq(CvSeq seq)`
`static CvSeq`	`cvCloneSeq(CvSeq seq, CvMemStorage storage)`
`static CvSparseMat`	`cvCloneSparseMat(CvSparseMat mat)` Creates a copy of CvSparseMat (except, may be, zero items)
`static void`	`cvCmp(CvArr src1, CvArr src2, CvArr dst, int cmp_op)` dst(idx) = src1(idx) _cmp_op_ src2(idx)
`static void`	`cvCmpS(CvArr src, double value, CvArr dst, int cmp_op)` dst(idx) = src1(idx) _cmp_op_ value
`static void`	`cvCompleteSymm(CvMat matrix)`
`static void`	`cvCompleteSymm(CvMat matrix, int LtoR)` Completes the symmetric matrix from the lower (LtoR=0) or from the upper (LtoR!=0) part
`static void`	`cvConvert(CvArr src, CvArr dst)`
`static void`	`cvConvertScale(CvArr src, CvArr dst)`
`static void`	`cvConvertScale(CvArr src, CvArr dst, double scale, double shift)` \brief Converts one array to another with optional linear transformation.
`static void`	`cvConvertScaleAbs(CvArr src, CvArr dst)`
`static void`	`cvConvertScaleAbs(CvArr src, 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(CvArr src, CvArr dst)`
`static void`	`cvCopy(CvArr src, CvArr dst, CvArr mask)` \brief Copies one array to another.
`static int`	`cvCountNonZero(CvArr arr)` Calculates number of non-zero pixels
`static CvMemStorage`	`cvCreateChildMemStorage(CvMemStorage parent)` Creates a memory storage that will borrow memory blocks from parent storage
`static void`	`cvCreateData(CvArr arr)` \brief Allocates array data
`static CvGraph`	`cvCreateGraph(int graph_flags, int header_size, int vtx_size, int edge_size, CvMemStorage storage)` Creates new graph
`static CvGraphScanner`	`cvCreateGraphScanner(CvGraph graph)`
`static CvGraphScanner`	`cvCreateGraphScanner(CvGraph graph, CvGraphVtx vtx, int mask)` Creates new graph scanner.
`static IplImage`	`cvCreateImage(CvSize size, int depth, int channels)` \brief Creates an image header and allocates the image data.
`static IplImage`	`cvCreateImageHeader(CvSize size, int depth, int channels)` \brief Creates an image header but does not allocate the image data.
`static CvMat`	`cvCreateMat(int rows, int cols, int type)` \brief Creates a matrix header and allocates the matrix data.
`static CvMat`	`cvCreateMatHeader(int rows, int cols, int type)` \brief Creates a matrix header but does not allocate the matrix data.
`static CvMatND`	`cvCreateMatND(int dims, int[] sizes, int type)`
`static CvMatND`	`cvCreateMatND(int dims, IntBuffer sizes, int type)`
`static CvMatND`	`cvCreateMatND(int dims, IntPointer sizes, int type)` \brief Creates the header and allocates the data for a multi-dimensional dense array.
`static CvMatND`	`cvCreateMatNDHeader(int dims, int[] sizes, int type)`
`static CvMatND`	`cvCreateMatNDHeader(int dims, IntBuffer sizes, int type)`
`static CvMatND`	`cvCreateMatNDHeader(int dims, IntPointer sizes, int type)` \brief Creates a new matrix header but does not allocate the matrix data.
`static CvMemStorage`	`cvCreateMemStorage()`
`static CvMemStorage`	`cvCreateMemStorage(int block_size)` Creates new memory storage.
`static CvSeq`	`cvCreateSeq(int seq_flags, long header_size, long elem_size, CvMemStorage storage)` Creates new empty sequence that will reside in the specified storage
`static void`	`cvCreateSeqBlock(CvSeqWriter writer)`
`static CvSet`	`cvCreateSet(int set_flags, int header_size, int elem_size, CvMemStorage storage)` Creates a new set
`static CvSparseMat`	`cvCreateSparseMat(int dims, int[] sizes, int type)`
`static CvSparseMat`	`cvCreateSparseMat(int dims, IntBuffer sizes, int type)`
`static CvSparseMat`	`cvCreateSparseMat(int dims, IntPointer sizes, int type)` \brief Creates sparse array.
`static CvSparseMat`	`cvCreateSparseMat(SparseMat m)`
`static void`	`cvCrossProduct(CvArr src1, CvArr src2, CvArr dst)` \brief Calculates the cross product of two 3D vectors.
`static void`	`cvCvtScale(CvArr arg1, CvArr arg2, double arg3, double arg4)`
`static void`	`cvCvtScaleAbs(CvArr arg1, CvArr arg2, double arg3, double arg4)`
`static Pointer`	`cvCvtSeqToArray(CvSeq seq, Pointer elements)`
`static Pointer`	`cvCvtSeqToArray(CvSeq seq, Pointer elements, CvSlice slice)` Copies sequence content to a continuous piece of memory
`static void`	`cvDCT(CvArr src, CvArr dst, int flags)` Discrete Cosine Transform
`static void`	`cvDecRefData(CvArr arr)` \brief Decrements an array data reference counter.
`static double`	`cvDet(CvArr mat)` Calculates determinant of input matrix
`static void`	`cvDFT(CvArr src, CvArr dst, int flags)`
`static void`	`cvDFT(CvArr src, CvArr dst, int flags, int nonzero_rows)` Discrete Fourier Transform: complex->complex, real->ccs (forward), ccs->real (inverse)
`static void`	`cvDiv(CvArr src1, CvArr src2, CvArr dst)`
`static void`	`cvDiv(CvArr src1, CvArr src2, 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(CvArr src1, CvArr src2)` \brief Calculates the dot product of two arrays in Euclidean metrics.
`static void`	`cvEigenVV(CvArr mat, CvArr evects, CvArr evals)`
`static void`	`cvEigenVV(CvArr mat, CvArr evects, CvArr evals, double eps, int lowindex, int highindex)` Finds eigen values and vectors of a symmetric matrix
`static CvSeq`	`cvEndWriteSeq(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`	`cvError(int status, BytePointer func_name, BytePointer err_msg, 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 BytePointer`	`cvErrorStr(int status)` Retrieves textual description of the error given its code
`static void`	`cvExp(CvArr src, CvArr dst)` Does exponention: dst(idx) = exp(src(idx)).
`static float`	`cvFastArctan(float y, float x)` Fast arctangent calculation
`static void`	`cvFFT(CvArr arg1, CvArr arg2, int arg3, int arg4)`
`static CvGraphEdge`	`cvFindGraphEdge(CvGraph graph, int start_idx, int end_idx)` Find edge connecting two vertices
`static CvGraphEdge`	`cvFindGraphEdgeByPtr(CvGraph graph, CvGraphVtx start_vtx, CvGraphVtx end_vtx)`
`static void`	`cvFlip(CvArr src)`
`static void`	`cvFlip(CvArr src, 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(CvSeqWriter writer)` Updates sequence header.
`static void`	`cvFree_(Pointer ptr)` `free` wrapper.
`static void`	`cvGEMM(CvArr src1, CvArr src2, double alpha, CvArr src3, double beta, CvArr dst)`
`static void`	`cvGEMM(CvArr src1, CvArr src2, double alpha, CvArr src3, double beta, CvArr dst, int tABC)` Extended matrix transform: dst = alphaop(A)op(B) + beta*op(C), where op(X) is X or X^T
`static CvScalar`	`cvGet1D(CvArr arr, int idx0)` \brief Return a specific array element.
`static CvScalar`	`cvGet2D(CvArr arr, int idx0, int idx1)` \overload
`static CvScalar`	`cvGet3D(CvArr arr, int idx0, int idx1, int idx2)` \overload
`static CvMat`	`cvGetCol(CvArr arr, CvMat submat, int col)` \overload
`static CvMat`	`cvGetCols(CvArr arr, CvMat submat, int start_col, int end_col)` \brief Returns one of more array columns.
`static CvMat`	`cvGetDiag(CvArr arr, CvMat submat)`
`static CvMat`	`cvGetDiag(CvArr arr, CvMat submat, int diag)` \brief Returns one of array diagonals.
`static int`	`cvGetDims(CvArr arr)`
`static int`	`cvGetDims(CvArr arr, int[] sizes)`
`static int`	`cvGetDims(CvArr arr, IntBuffer sizes)`
`static int`	`cvGetDims(CvArr arr, IntPointer sizes)` \brief Return number of array dimensions
`static int`	`cvGetDimSize(CvArr arr, int index)` \brief Returns array size along the specified dimension.
`static int`	`cvGetElemType(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(BytePointer errcode_desc, BytePointer description, BytePointer filename, IntPointer line)`
`static int`	`cvGetErrInfo(PointerPointer errcode_desc, PointerPointer description, PointerPointer filename, 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 IplImage`	`cvGetImage(CvArr arr, IplImage image_header)` \brief Returns image header for arbitrary array.
`static int`	`cvGetImageCOI(IplImage image)` \brief Returns the index of the channel of interest.
`static CvRect`	`cvGetImageROI(IplImage image)` \brief Returns the image ROI.
`static CvMat`	`cvGetMat(CvArr arr, CvMat header)`
`static CvMat`	`cvGetMat(CvArr arr, CvMat header, int[] coi, int allowND)`
`static CvMat`	`cvGetMat(CvArr arr, CvMat header, IntBuffer coi, int allowND)`
`static CvMat`	`cvGetMat(CvArr arr, CvMat header, IntPointer coi, int allowND)` \brief Returns matrix header for arbitrary array.
`static CvScalar`	`cvGetND(CvArr arr, int[] idx)`
`static CvScalar`	`cvGetND(CvArr arr, IntBuffer idx)`
`static CvScalar`	`cvGetND(CvArr arr, IntPointer idx)` \overload
`static CvSparseNode`	`cvGetNextSparseNode(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(CvArr arr, byte[] data)`
`static void`	`cvGetRawData(CvArr arr, byte[] data, int[] step, CvSize roi_size)`
`static void`	`cvGetRawData(CvArr arr, ByteBuffer data)`
`static void`	`cvGetRawData(CvArr arr, ByteBuffer data, IntBuffer step, CvSize roi_size)`
`static void`	`cvGetRawData(CvArr arr, BytePointer data)`
`static void`	`cvGetRawData(CvArr arr, BytePointer data, IntPointer step, CvSize roi_size)`
`static void`	`cvGetRawData(CvArr arr, PointerPointer data, IntPointer step, CvSize roi_size)` \brief Retrieves low-level information about the array.
`static double`	`cvGetReal1D(CvArr arr, int idx0)` \brief Return a specific element of single-channel 1D, 2D, 3D or nD array.
`static double`	`cvGetReal2D(CvArr arr, int idx0, int idx1)` \overload
`static double`	`cvGetReal3D(CvArr arr, int idx0, int idx1, int idx2)` \overload
`static double`	`cvGetRealND(CvArr arr, int[] idx)`
`static double`	`cvGetRealND(CvArr arr, IntBuffer idx)`
`static double`	`cvGetRealND(CvArr arr, IntPointer idx)` \overload
`static CvMat`	`cvGetRow(CvArr arr, CvMat submat, int row)` \overload
`static CvMat`	`cvGetRows(CvArr arr, CvMat submat, int start_row, int end_row)`
`static CvMat`	`cvGetRows(CvArr arr, CvMat submat, int start_row, int end_row, int delta_row)` \brief Returns array row or row span.
`static BytePointer`	`cvGetSeqElem(CvSeq seq, int index)` Retrieves pointer to specified sequence element.
`static int`	`cvGetSeqReaderPos(CvSeqReader reader)` Returns current sequence reader position (currently observed sequence element)
`static CvSetElem`	`cvGetSetElem(CvSet set_header, int idx)` Returns a set element by index.
`static CvSize`	`cvGetSize(CvArr arr)` \brief Returns size of matrix or image ROI.
`static CvMat`	`cvGetSubArr(CvArr arg1, CvMat arg2, CvRect arg3)`
`static CvMat`	`cvGetSubRect(CvArr arr, CvMat submat, 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(CvGraph graph, int start_idx, int end_idx)`
`static int`	`cvGraphAddEdge(CvGraph graph, int start_idx, int end_idx, CvGraphEdge edge, CvGraphEdge inserted_edge)`
`static int`	`cvGraphAddEdge(CvGraph graph, int start_idx, int end_idx, CvGraphEdge edge, 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(CvGraph graph, CvGraphVtx start_vtx, CvGraphVtx end_vtx)`
`static int`	`cvGraphAddEdgeByPtr(CvGraph graph, CvGraphVtx start_vtx, CvGraphVtx end_vtx, CvGraphEdge edge, CvGraphEdge inserted_edge)`
`static int`	`cvGraphAddEdgeByPtr(CvGraph graph, CvGraphVtx start_vtx, CvGraphVtx end_vtx, CvGraphEdge edge, PointerPointer inserted_edge)`
`static int`	`cvGraphAddVtx(CvGraph graph)`
`static int`	`cvGraphAddVtx(CvGraph graph, CvGraphVtx vtx, CvGraphVtx inserted_vtx)`
`static int`	`cvGraphAddVtx(CvGraph graph, CvGraphVtx vtx, PointerPointer inserted_vtx)` Adds new vertex to the graph
`static CvGraphEdge`	`cvGraphFindEdge(CvGraph arg1, int arg2, int arg3)`
`static CvGraphEdge`	`cvGraphFindEdgeByPtr(CvGraph arg1, CvGraphVtx arg2, CvGraphVtx arg3)`
`static void`	`cvGraphRemoveEdge(CvGraph graph, int start_idx, int end_idx)` Remove edge connecting two vertices
`static void`	`cvGraphRemoveEdgeByPtr(CvGraph graph, CvGraphVtx start_vtx, CvGraphVtx end_vtx)`
`static int`	`cvGraphRemoveVtx(CvGraph graph, int index)` Removes vertex from the graph together with all incident edges
`static int`	`cvGraphRemoveVtxByPtr(CvGraph graph, CvGraphVtx vtx)`
`static int`	`cvGraphVtxDegree(CvGraph graph, int vtx_idx)` Count number of edges incident to the vertex
`static int`	`cvGraphVtxDegreeByPtr(CvGraph graph, CvGraphVtx vtx)`
`static int`	`cvGuiBoxReport(int status, BytePointer func_name, BytePointer err_msg, BytePointer file_name, int line, Pointer userdata)` Output to MessageBox(WIN32)
`static int`	`cvGuiBoxReport(int status, String func_name, String err_msg, String file_name, int line, Pointer userdata)`
`static int`	`cvIncRefData(CvArr arr)` \brief Increments array data reference counter.
`static IplImage`	`cvInitImageHeader(IplImage image, CvSize size, int depth, int channels)`
`static IplImage`	`cvInitImageHeader(IplImage image, CvSize size, int depth, int channels, int origin, int align)` \brief Initializes an image header that was previously allocated.
`static CvMat`	`cvInitMatHeader(CvMat mat, int rows, int cols, int type)`
`static CvMat`	`cvInitMatHeader(CvMat mat, int rows, int cols, int type, Pointer data, int step)` \brief Initializes a pre-allocated matrix header.
`static CvMatND`	`cvInitMatNDHeader(CvMatND mat, int dims, int[] sizes, int type)`
`static CvMatND`	`cvInitMatNDHeader(CvMatND mat, int dims, int[] sizes, int type, Pointer data)`
`static CvMatND`	`cvInitMatNDHeader(CvMatND mat, int dims, IntBuffer sizes, int type)`
`static CvMatND`	`cvInitMatNDHeader(CvMatND mat, int dims, IntBuffer sizes, int type, Pointer data)`
`static CvMatND`	`cvInitMatNDHeader(CvMatND mat, int dims, IntPointer sizes, int type)`
`static CvMatND`	`cvInitMatNDHeader(CvMatND mat, int dims, IntPointer sizes, int type, Pointer data)` \brief Initializes a pre-allocated multi-dimensional array header.
`static int`	`cvInitNArrayIterator(int count, CvArr arrs, CvArr mask, CvMatND stubs, CvNArrayIterator array_iterator)`
`static int`	`cvInitNArrayIterator(int count, CvArr arrs, CvArr mask, CvMatND stubs, CvNArrayIterator array_iterator, int flags)`
`static int`	`cvInitNArrayIterator(int count, PointerPointer arrs, CvArr mask, CvMatND stubs, CvNArrayIterator array_iterator, int flags)` initializes iterator that traverses through several arrays simultaneously (the function together with cvNextArraySlice is used for N-ari element-wise operations)
`static CvSparseNode`	`cvInitSparseMatIterator(CvSparseMat mat, CvSparseMatIterator mat_iterator)` \brief Initializes sparse array elements iterator.
`static void`	`cvInitTreeNodeIterator(CvTreeNodeIterator tree_iterator, Pointer first, int max_level)`
`static void`	`cvInRange(CvArr src, CvArr lower, CvArr upper, CvArr dst)` dst(idx) = lower(idx) <= src(idx) < upper(idx)
`static void`	`cvInRangeS(CvArr src, CvScalar lower, CvScalar upper, CvArr dst)` dst(idx) = lower <= src(idx) < upper
`static void`	`cvInsertNodeIntoTree(Pointer node, Pointer parent, Pointer frame)` Inserts sequence into tree with specified "parent" sequence.
`static void`	`cvInv(CvArr arg1, CvArr arg2, int arg3)`
`static double`	`cvInvert(CvArr src, CvArr dst)`
`static double`	`cvInvert(CvArr src, CvArr dst, int method)` Inverts matrix
`static int`	`cvIplDepth(int type)`
`static IplImage`	`cvIplImage()`
`static IplImage`	`cvIplImage(Mat m)`
`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(CvArr samples, int cluster_count, CvArr labels, CvTermCriteria termcrit)`
`static int`	`cvKMeans2(CvArr samples, int cluster_count, CvArr labels, CvTermCriteria termcrit, int attempts, long[] rng, int flags, CvArr _centers, double[] compactness)`
`static int`	`cvKMeans2(CvArr samples, int cluster_count, CvArr labels, CvTermCriteria termcrit, int attempts, LongBuffer rng, int flags, CvArr _centers, DoubleBuffer compactness)`
`static int`	`cvKMeans2(CvArr samples, int cluster_count, CvArr labels, CvTermCriteria termcrit, int attempts, LongPointer rng, int flags, CvArr _centers, DoublePointer compactness)`
`static void`	`cvLog(CvArr src, CvArr dst)` Calculates natural logarithms: dst(idx) = log(abs(src(idx))).
`static void`	`cvLUT(CvArr src, CvArr dst, CvArr lut)` Does look-up transformation.
`static double`	`cvMahalanobis(CvArr vec1, CvArr vec2, CvArr mat)` Calculates Mahalanobis(weighted) distance
`static double`	`cvMahalonobis(CvArr arg1, CvArr arg2, CvArr arg3)`
`static CvSeq`	`cvMakeSeqHeaderForArray(int seq_type, int header_size, int elem_size, Pointer elements, int total, CvSeq seq, CvSeqBlock block)` Creates sequence header for array.
`static CvMat`	`cvMat()`
`static CvMat`	`cvMat(CvMat m)`
`static CvMat`	`cvMat(int rows, int cols, int type)`
`static CvMat`	`cvMat(int rows, int cols, int type, Pointer data)` Inline constructor.
`static CvMat`	`cvMat(Mat m)`
`static void`	`cvMatMul(CvArr src1, CvArr src2, CvArr dst)`
`static void`	`cvMatMulAdd(CvArr src1, CvArr src2, CvArr src3, CvArr dst)` Matrix transform: dst = A*B + C, C is optional
`static void`	`cvMatMulAddEx(CvArr arg1, CvArr arg2, double arg3, CvArr arg4, double arg5, CvArr arg6, int arg7)`
`static void`	`cvMatMulAddS(CvArr arg1, CvArr arg2, CvMat arg3, CvMat arg4)`
`static CvMatND`	`cvMatND()`
`static CvMatND`	`cvMatND(Mat m)`
`static void`	`cvMax(CvArr src1, CvArr src2, CvArr dst)` dst(idx) = max(src1(idx),src2(idx))
`static void`	`cvMaxS(CvArr src, double value, CvArr dst)` dst(idx) = max(src(idx),value)
`static Pointer`	`cvMemStorageAlloc(CvMemStorage storage, long size)` Allocates continuous buffer of the specified size in the storage
`static void`	`cvMerge(CvArr src0, CvArr src1, CvArr src2, CvArr src3, 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(CvMat mat, int row, int col)` \brief Returns the particular element of single-channel floating-point matrix.
`static void`	`cvMin(CvArr src1, CvArr src2, CvArr dst)` dst(idx) = min(src1(idx),src2(idx))
`static void`	`cvMinMaxLoc(CvArr arr, double[] min_val, double[] max_val)`
`static void`	`cvMinMaxLoc(CvArr arr, double[] min_val, double[] max_val, int[] min_loc, int[] max_loc, CvArr mask)`
`static void`	`cvMinMaxLoc(CvArr arr, DoubleBuffer min_val, DoubleBuffer max_val)`
`static void`	`cvMinMaxLoc(CvArr arr, DoubleBuffer min_val, DoubleBuffer max_val, IntBuffer min_loc, IntBuffer max_loc, CvArr mask)`
`static void`	`cvMinMaxLoc(CvArr arr, DoublePointer min_val, DoublePointer max_val)`
`static void`	`cvMinMaxLoc(CvArr arr, DoublePointer min_val, DoublePointer max_val, CvPoint min_loc, CvPoint max_loc, CvArr mask)` Finds global minimum, maximum and their positions
`static void`	`cvMinS(CvArr src, double value, CvArr dst)` dst(idx) = min(src(idx),value)
`static void`	`cvMirror(CvArr arg1, CvArr arg2, int arg3)`
`static void`	`cvMixChannels(CvArr src, int src_count, CvArr dst, int dst_count, int[] from_to, int pair_count)`
`static void`	`cvMixChannels(CvArr src, int src_count, CvArr dst, int dst_count, IntBuffer from_to, int pair_count)`
`static void`	`cvMixChannels(CvArr src, int src_count, CvArr dst, int dst_count, IntPointer from_to, int pair_count)`
`static void`	`cvMixChannels(PointerPointer src, int src_count, PointerPointer dst, int dst_count, IntPointer from_to, int pair_count)` Copies several channels from input arrays to certain channels of output arrays
`static void`	`cvmSet(CvMat mat, int row, int col, double value)` \brief Sets a specific element of a single-channel floating-point matrix.
`static void`	`cvMul(CvArr src1, CvArr src2, CvArr dst)`
`static void`	`cvMul(CvArr src1, CvArr src2, CvArr dst, double scale)` dst(idx) = src1(idx) * src2(idx) * scale (scaled element-wise multiplication of 2 arrays)
`static void`	`cvMulSpectrums(CvArr src1, CvArr src2, CvArr dst, int flags)` Multiply results of DFTs: DFT(X)DFT(Y) or DFT(X)conj(DFT(Y))
`static void`	`cvMulTransposed(CvArr src, CvArr dst, int order)`
`static void`	`cvMulTransposed(CvArr src, CvArr dst, int order, CvArr delta, double scale)` Calculates (A-delta)(A-delta)^T (order=0) or (A-delta)^T(A-delta) (order=1)
`static int`	`cvNextGraphItem(CvGraphScanner scanner)` Get next graph element
`static int`	`cvNextNArraySlice(CvNArrayIterator array_iterator)` returns zero value if iteration is finished, non-zero (slice length) otherwise
`static Pointer`	`cvNextTreeNode(CvTreeNodeIterator tree_iterator)`
`static double`	`cvNorm(CvArr arr1)`
`static double`	`cvNorm(CvArr arr1, CvArr arr2, int norm_type, CvArr mask)` Finds norm, difference norm or relative difference norm for an array (or two arrays)
`static void`	`cvNormalize(CvArr src, CvArr dst)`
`static void`	`cvNormalize(CvArr src, CvArr dst, double a, double b, int norm_type, CvArr mask)`
`static void`	`cvNot(CvArr src, CvArr dst)` dst(idx) = ~src(idx)
`static int`	`cvNulDevReport(int status, BytePointer func_name, BytePointer err_msg, BytePointer file_name, int line, Pointer userdata)` Output nothing
`static int`	`cvNulDevReport(int status, String func_name, String err_msg, String file_name, int line, Pointer userdata)`
`static void`	`cvOr(CvArr src1, CvArr src2, CvArr dst)`
`static void`	`cvOr(CvArr src1, CvArr src2, CvArr dst, CvArr mask)` dst(idx) = src1(idx) \| src2(idx)
`static void`	`cvOrS(CvArr src, CvScalar value, CvArr dst)`
`static void`	`cvOrS(CvArr src, CvScalar value, CvArr dst, CvArr mask)` dst(idx) = src(idx) \| value
`static void`	`cvPerspectiveTransform(CvArr src, CvArr dst, CvMat mat)` Does perspective transform on every element of input array
`static CvPoint`	`cvPoint(int x, int y)` constructs CvPoint structure.
`static CvPoint`	`cvPoint(Point pt)`
`static CvPoint2D32f`	`cvPoint2D32f(double x, double y)` constructs CvPoint2D32f structure.
`static CvPoint2D64f`	`cvPoint2D64f(double x, double y)` constructs CvPoint2D64f structure.
`static CvPoint3D32f`	`cvPoint3D32f(double x, double y, double z)` constructs CvPoint3D32f structure.
`static CvPoint3D64f`	`cvPoint3D64f(double x, double y, double z)` constructs CvPoint3D64f structure.
`static CvPoint`	`cvPointFrom32f(CvPoint2D32f point)` converts CvPoint2D32f to CvPoint.
`static int[]`	`cvPointFrom32f(float[] point)`
`static IntBuffer`	`cvPointFrom32f(FloatBuffer point)`
`static CvPoint2D32f`	`cvPointTo32f(CvPoint point)` converts CvPoint to CvPoint2D32f.
`static float[]`	`cvPointTo32f(int[] point)`
`static FloatBuffer`	`cvPointTo32f(IntBuffer point)`
`static void`	`cvPolarToCart(CvArr magnitude, CvArr angle, CvArr x, CvArr y)`
`static void`	`cvPolarToCart(CvArr magnitude, CvArr angle, CvArr x, CvArr y, int angle_in_degrees)` Does polar->cartesian coordinates conversion.
`static void`	`cvPow(CvArr src, CvArr dst, double power)` Does powering: dst(idx) = src(idx)^power
`static Pointer`	`cvPrevTreeNode(CvTreeNodeIterator tree_iterator)`
`static void`	`cvProjectPCA(CvArr data, CvArr mean, CvArr eigenvects, CvArr result)`
`static BytePointer`	`cvPtr1D(CvArr arr, int idx0)`
`static byte[]`	`cvPtr1D(CvArr arr, int idx0, int[] type)`
`static ByteBuffer`	`cvPtr1D(CvArr arr, int idx0, IntBuffer type)`
`static BytePointer`	`cvPtr1D(CvArr arr, int idx0, IntPointer type)` \brief Return pointer to a particular array element.
`static BytePointer`	`cvPtr2D(CvArr arr, int idx0, int idx1)`
`static byte[]`	`cvPtr2D(CvArr arr, int idx0, int idx1, int[] type)`
`static ByteBuffer`	`cvPtr2D(CvArr arr, int idx0, int idx1, IntBuffer type)`
`static BytePointer`	`cvPtr2D(CvArr arr, int idx0, int idx1, IntPointer type)` \overload
`static BytePointer`	`cvPtr3D(CvArr arr, int idx0, int idx1, int idx2)`
`static byte[]`	`cvPtr3D(CvArr arr, int idx0, int idx1, int idx2, int[] type)`
`static ByteBuffer`	`cvPtr3D(CvArr arr, int idx0, int idx1, int idx2, IntBuffer type)`
`static BytePointer`	`cvPtr3D(CvArr arr, int idx0, int idx1, int idx2, IntPointer type)` \overload
`static byte[]`	`cvPtrND(CvArr arr, int[] idx)`
`static byte[]`	`cvPtrND(CvArr arr, int[] idx, int[] type, int create_node, int[] precalc_hashval)`
`static ByteBuffer`	`cvPtrND(CvArr arr, IntBuffer idx)`
`static ByteBuffer`	`cvPtrND(CvArr arr, IntBuffer idx, IntBuffer type, int create_node, IntBuffer precalc_hashval)`
`static BytePointer`	`cvPtrND(CvArr arr, IntPointer idx)`
`static BytePointer`	`cvPtrND(CvArr arr, IntPointer idx, IntPointer type, int create_node, IntPointer precalc_hashval)` \overload
`static void`	`cvRandArr(long[] rng, CvArr arr, int dist_type, CvScalar param1, CvScalar param2)`
`static void`	`cvRandArr(LongBuffer rng, CvArr arr, int dist_type, CvScalar param1, CvScalar param2)`
`static void`	`cvRandArr(LongPointer rng, CvArr arr, int dist_type, CvScalar param1, 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(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(LongPointer rng)` \brief Returns a floating-point random number and updates RNG.
`static void`	`cvRandShuffle(CvArr mat, long[] rng)`
`static void`	`cvRandShuffle(CvArr mat, long[] rng, double iter_factor)`
`static void`	`cvRandShuffle(CvArr mat, LongBuffer rng)`
`static void`	`cvRandShuffle(CvArr mat, LongBuffer rng, double iter_factor)`
`static void`	`cvRandShuffle(CvArr mat, LongPointer rng)`
`static void`	`cvRandShuffle(CvArr mat, LongPointer rng, double iter_factor)`
`static CvArr`	`cvRange(CvArr mat, double start, double end)` Fills matrix with given range of numbers
`static void`	`cvRawDataToScalar(Pointer data, int type, CvScalar scalar)`
`static CvScalar`	`cvRealScalar(double val0)`
`static CvRect`	`cvRect(int x, int y, int width, int height)` constructs CvRect structure.
`static CvRect`	`cvRect(Rect rc)`
`static IplROI`	`cvRectToROI(CvRect rect, int coi)`
`static CvErrorCallback`	`cvRedirectError(CvErrorCallback error_handler)`
`static CvErrorCallback`	`cvRedirectError(CvErrorCallback error_handler, Pointer userdata, Pointer prev_userdata)`
`static CvErrorCallback`	`cvRedirectError(CvErrorCallback error_handler, Pointer userdata, PointerPointer prev_userdata)` Assigns a new error-handling function
`static void`	`cvReduce(CvArr src, CvArr dst)`
`static void`	`cvReduce(CvArr src, CvArr dst, int dim, int op)`
`static void`	`cvRelease(Pointer struct_ptr)`
`static void`	`cvRelease(PointerPointer struct_ptr)` \brief Releases an object.
`static void`	`cvReleaseData(CvArr arr)` \brief Releases array data.
`static void`	`cvReleaseGraphScanner(CvGraphScanner scanner)`
`static void`	`cvReleaseGraphScanner(PointerPointer scanner)` Releases graph scanner.
`static void`	`cvReleaseImage(IplImage image)`
`static void`	`cvReleaseImage(PointerPointer image)` \brief Deallocates the image header and the image data.
`static void`	`cvReleaseImageHeader(IplImage image)`
`static void`	`cvReleaseImageHeader(PointerPointer image)` \brief Deallocates an image header.
`static void`	`cvReleaseMat(CvMat mat)`
`static void`	`cvReleaseMat(PointerPointer mat)` \brief Deallocates a matrix.
`static void`	`cvReleaseMatND(CvMatND mat)`
`static void`	`cvReleaseMatND(PointerPointer mat)` \brief Deallocates a multi-dimensional array.
`static void`	`cvReleaseMemStorage(CvMemStorage storage)`
`static void`	`cvReleaseMemStorage(PointerPointer storage)` Releases memory storage.
`static void`	`cvReleaseSparseMat(CvSparseMat mat)`
`static void`	`cvReleaseSparseMat(PointerPointer mat)` \brief Deallocates sparse array.
`static void`	`cvRemoveNodeFromTree(Pointer node, Pointer frame)` Removes contour from tree (together with the contour children).
`static void`	`cvRepeat(CvArr src, CvArr dst)` Repeats source 2d array several times in both horizontal and vertical direction to fill destination array
`static void`	`cvResetImageROI(IplImage image)` \brief Resets the image ROI to include the entire image and releases the ROI structure.
`static CvMat`	`cvReshape(CvArr arr, CvMat header, int new_cn)`
`static CvMat`	`cvReshape(CvArr arr, CvMat header, int new_cn, int new_rows)` \brief Changes shape of matrix/image without copying data.
`static CvArr`	`cvReshapeMatND(CvArr arr, int sizeof_header, CvArr header, int new_cn, int new_dims, int[] new_sizes)`
`static CvArr`	`cvReshapeMatND(CvArr arr, int sizeof_header, CvArr header, int new_cn, int new_dims, IntBuffer new_sizes)`
`static CvArr`	`cvReshapeMatND(CvArr arr, int sizeof_header, CvArr header, int new_cn, int new_dims, IntPointer new_sizes)` \brief Changes the shape of a multi-dimensional array without copying the data.
`static void`	`cvRestoreMemStoragePos(CvMemStorage storage, CvMemStoragePos pos)` Restore a storage "free memory" position
`static long`	`cvRNG()`
`static long`	`cvRNG(long seed)` \brief Initializes a random number generator state.
`static CvRect`	`cvROIToRect(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`	`cvSaveMemStoragePos(CvMemStorage storage, CvMemStoragePos pos)` Remember a storage "free memory" position
`static CvScalar`	`cvScalar()`
`static CvScalar`	`cvScalar(double val0)`
`static CvScalar`	`cvScalar(double val0, double val1, double val2, double val3)`
`static CvScalar`	`cvScalar(Scalar s)`
`static CvScalar`	`cvScalarAll(double val0123)`
`static void`	`cvScalarToRawData(CvScalar scalar, Pointer data, int type)`
`static void`	`cvScalarToRawData(CvScalar scalar, Pointer data, int type, int extend_to_12)` low-level scalar <-> raw data conversion functions
`static void`	`cvScale(CvArr arg1, CvArr arg2, double arg3, double arg4)`
`static void`	`cvScaleAdd(CvArr src1, CvScalar scale, CvArr src2, CvArr dst)` dst = src1 * scale + src2
`static int`	`cvSeqElemIdx(CvSeq seq, Pointer element)`
`static int`	`cvSeqElemIdx(CvSeq seq, Pointer element, CvSeqBlock block)`
`static int`	`cvSeqElemIdx(CvSeq seq, Pointer element, PointerPointer block)` Calculates index of the specified sequence element.
`static BytePointer`	`cvSeqInsert(CvSeq seq, int before_index)`
`static BytePointer`	`cvSeqInsert(CvSeq seq, int before_index, Pointer element)` Inserts a new element in the middle of sequence.
`static void`	`cvSeqInsertSlice(CvSeq seq, int before_index, CvArr from_arr)` Inserts a sequence or array into another sequence
`static void`	`cvSeqInvert(CvSeq seq)` Reverses order of sequence elements in-place
`static int`	`cvSeqPartition(CvSeq seq, CvMemStorage storage, CvSeq labels, CvCmpFunc is_equal, Pointer userdata)`
`static int`	`cvSeqPartition(CvSeq seq, CvMemStorage storage, PointerPointer labels, CvCmpFunc is_equal, Pointer userdata)` Splits sequence into one or more equivalence classes using the specified criteria
`static void`	`cvSeqPop(CvSeq seq)`
`static void`	`cvSeqPop(CvSeq seq, Pointer element)` Removes the last element from sequence and optionally saves it
`static void`	`cvSeqPopFront(CvSeq seq)`
`static void`	`cvSeqPopFront(CvSeq seq, Pointer element)` Removes the first element from sequence and optioanally saves it
`static void`	`cvSeqPopMulti(CvSeq seq, Pointer elements, int count)`
`static void`	`cvSeqPopMulti(CvSeq seq, Pointer elements, int count, int in_front)` Removes several elements from the end of sequence and optionally saves them
`static BytePointer`	`cvSeqPush(CvSeq seq)`
`static BytePointer`	`cvSeqPush(CvSeq seq, Pointer element)` Adds new element to the end of sequence.
`static BytePointer`	`cvSeqPushFront(CvSeq seq)`
`static BytePointer`	`cvSeqPushFront(CvSeq seq, Pointer element)` Adds new element to the beginning of sequence.
`static void`	`cvSeqPushMulti(CvSeq seq, Pointer elements, int count)`
`static void`	`cvSeqPushMulti(CvSeq seq, Pointer elements, int count, int in_front)` Adds several new elements to the end of sequence
`static void`	`cvSeqRemove(CvSeq seq, int index)` Removes specified sequence element
`static void`	`cvSeqRemoveSlice(CvSeq seq, CvSlice slice)` Removes sequence slice
`static byte[]`	`cvSeqSearch(CvSeq seq, Pointer elem, CvCmpFunc func, int is_sorted, int[] elem_idx)`
`static byte[]`	`cvSeqSearch(CvSeq seq, Pointer elem, CvCmpFunc func, int is_sorted, int[] elem_idx, Pointer userdata)`
`static ByteBuffer`	`cvSeqSearch(CvSeq seq, Pointer elem, CvCmpFunc func, int is_sorted, IntBuffer elem_idx)`
`static ByteBuffer`	`cvSeqSearch(CvSeq seq, Pointer elem, CvCmpFunc func, int is_sorted, IntBuffer elem_idx, Pointer userdata)`
`static BytePointer`	`cvSeqSearch(CvSeq seq, Pointer elem, CvCmpFunc func, int is_sorted, IntPointer elem_idx)`
`static BytePointer`	`cvSeqSearch(CvSeq seq, Pointer elem, CvCmpFunc func, int is_sorted, IntPointer elem_idx, Pointer userdata)` Finds element in a [sorted] sequence
`static CvSeq`	`cvSeqSlice(CvSeq seq, CvSlice slice)`
`static CvSeq`	`cvSeqSlice(CvSeq seq, CvSlice slice, CvMemStorage storage, int copy_data)` Extracts sequence slice (with or without copying sequence elements)
`static void`	`cvSeqSort(CvSeq seq, CvCmpFunc func)`
`static void`	`cvSeqSort(CvSeq seq, CvCmpFunc func, Pointer userdata)` Sorts sequence in-place given element comparison function
`static void`	`cvSet(CvArr arr, CvScalar value)`
`static void`	`cvSet(CvArr arr, CvScalar value, CvArr mask)` \brief Sets every element of an array to a given value.
`static void`	`cvSet1D(CvArr arr, int idx0, CvScalar value)` \brief Change the particular array element.
`static void`	`cvSet2D(CvArr arr, int idx0, int idx1, CvScalar value)` \overload
`static void`	`cvSet3D(CvArr arr, int idx0, int idx1, int idx2, CvScalar value)` \overload
`static int`	`cvSetAdd(CvSet set_header)`
`static int`	`cvSetAdd(CvSet set_header, CvSetElem elem, CvSetElem inserted_elem)`
`static int`	`cvSetAdd(CvSet set_header, CvSetElem elem, PointerPointer inserted_elem)` Adds new element to the set and returns pointer to it
`static void`	`cvSetData(CvArr arr, 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(CvArr mat)`
`static void`	`cvSetIdentity(CvArr mat, CvScalar value)` Makes an identity matrix (mat_ij = i == j)
`static void`	`cvSetImageCOI(IplImage image, int coi)` \brief Sets the channel of interest in an IplImage.
`static void`	`cvSetImageROI(IplImage image, CvRect rect)` \brief Sets an image Region Of Interest (ROI) for a given rectangle.
`static void`	`cvSetIPLAllocators(Cv_iplCreateImageHeader create_header, Cv_iplAllocateImageData allocate_data, Cv_iplDeallocate _deallocate, Cv_iplCreateROI create_roi, Cv_iplCloneImage clone_image)` \brief Makes OpenCV use IPL functions for allocating IplImage and IplROI structures.
`static void`	`cvSetND(CvArr arr, int[] idx, CvScalar value)`
`static void`	`cvSetND(CvArr arr, IntBuffer idx, CvScalar value)`
`static void`	`cvSetND(CvArr arr, IntPointer idx, CvScalar value)` \overload
`static CvSetElem`	`cvSetNew(CvSet set_header)` Fast variant of cvSetAdd
`static void`	`cvSetNumThreads()`
`static void`	`cvSetNumThreads(int threads)`
`static void`	`cvSetReal1D(CvArr arr, int idx0, double value)` \brief Change a specific array element.
`static void`	`cvSetReal2D(CvArr arr, int idx0, int idx1, double value)` \overload
`static void`	`cvSetReal3D(CvArr arr, int idx0, int idx1, int idx2, double value)` \overload
`static void`	`cvSetRealND(CvArr arr, int[] idx, double value)`
`static void`	`cvSetRealND(CvArr arr, IntBuffer idx, double value)`
`static void`	`cvSetRealND(CvArr arr, IntPointer idx, double value)` \overload
`static void`	`cvSetRemove(CvSet set_header, int index)` Removes element from the set by its index
`static void`	`cvSetRemoveByPtr(CvSet set_header, Pointer elem)` Removes set element given its pointer
`static void`	`cvSetSeqBlockSize(CvSeq seq, int delta_elems)` Changes default size (granularity) of sequence blocks.
`static void`	`cvSetSeqReaderPos(CvSeqReader reader, int index)`
`static void`	`cvSetSeqReaderPos(CvSeqReader reader, int index, int is_relative)` Changes sequence reader position.
`static void`	`cvSetZero(CvArr arr)` \brief Clears the array.
`static CvSize`	`cvSize(int width, int height)` constructs CvSize structure.
`static CvSize`	`cvSize(Size sz)`
`static CvSize2D32f`	`cvSize2D32f(double width, double height)` constructs CvSize2D32f structure.
`static CvSlice`	`cvSlice(int start, int end)`
`static CvSlice`	`cvSlice(Range r)`
`static int`	`cvSliceLength(CvSlice slice, CvSeq seq)` Calculates length of sequence slice (with support of negative indices).
`static int`	`cvSolve(CvArr src1, CvArr src2, CvArr dst)`
`static int`	`cvSolve(CvArr src1, CvArr src2, 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(CvMat coeffs, CvMat roots)` Finds real roots of a cubic equation
`static void`	`cvSolvePoly(CvMat coeffs, CvMat roots2)`
`static void`	`cvSolvePoly(CvMat coeffs, CvMat roots2, int maxiter, int fig)` Finds all real and complex roots of a polynomial equation
`static void`	`cvSort(CvArr src)`
`static void`	`cvSort(CvArr src, CvArr dst, CvArr idxmat, int flags)`
`static void`	`cvSplit(CvArr src, CvArr dst0, CvArr dst1, CvArr dst2, CvArr dst3)` Splits a multi-channel array into the set of single-channel arrays or extracts particular [color] plane
`static void`	`cvStartAppendToSeq(CvSeq seq, CvSeqWriter writer)` Initializes sequence writer.
`static void`	`cvStartReadSeq(CvSeq seq, CvSeqReader reader)`
`static void`	`cvStartReadSeq(CvSeq seq, CvSeqReader reader, int reverse)` Initializes sequence reader.
`static void`	`cvStartWriteSeq(int seq_flags, int header_size, int elem_size, CvMemStorage storage, CvSeqWriter writer)` Combination of cvCreateSeq and cvStartAppendToSeq
`static int`	`cvStdErrReport(int status, BytePointer func_name, BytePointer err_msg, BytePointer file_name, int line, Pointer userdata)` Output to console(fprintf(stderr,...))
`static int`	`cvStdErrReport(int status, String func_name, String err_msg, String file_name, int line, Pointer userdata)`
`static void`	`cvSub(CvArr src1, CvArr src2, CvArr dst)`
`static void`	`cvSub(CvArr src1, CvArr src2, CvArr dst, CvArr mask)` dst(mask) = src1(mask) - src2(mask)
`static void`	`cvSubRS(CvArr src, CvScalar value, CvArr dst)`
`static void`	`cvSubRS(CvArr src, CvScalar value, CvArr dst, CvArr mask)` dst(mask) = value - src(mask)
`static void`	`cvSubS(CvArr src, CvScalar value, CvArr dst)`
`static void`	`cvSubS(CvArr src, CvScalar value, CvArr dst, CvArr mask)` dst(mask) = src(mask) - value = src(mask) + (-value)
`static CvScalar`	`cvSum(CvArr arr)` Finds sum of array elements
`static void`	`cvSVBkSb(CvArr W, CvArr U, CvArr V, CvArr B, CvArr X, int flags)` Performs Singular Value Back Substitution (solves A*X = B): flags must be the same as in cvSVD
`static void`	`cvSVD(CvArr A, CvArr W)`
`static void`	`cvSVD(CvArr A, CvArr W, CvArr U, CvArr V, int flags)` Performs Singular Value Decomposition of a matrix
`static void`	`cvT(CvArr arg1, CvArr arg2)`
`static void`	`cvt16f32f(float16_t src, float[] dst, int len)`
`static void`	`cvt16f32f(float16_t src, FloatBuffer dst, int len)`
`static void`	`cvt16f32f(float16_t src, FloatPointer dst, int len)`
`static void`	`cvt32f16f(float[] src, float16_t dst, int len)`
`static void`	`cvt32f16f(FloatBuffer src, float16_t dst, int len)`
`static void`	`cvt32f16f(FloatPointer src, float16_t dst, int len)`
`static CvTermCriteria`	`cvTermCriteria(int type, int max_iter, double epsilon)`
`static CvTermCriteria`	`cvTermCriteria(TermCriteria t)`
`static CvScalar`	`cvTrace(CvArr mat)` Calculates trace of the matrix (sum of elements on the main diagonal)
`static void`	`cvTransform(CvArr src, CvArr dst, CvMat transmat)`
`static void`	`cvTransform(CvArr src, CvArr dst, CvMat transmat, CvMat shiftvec)` Transforms each element of source array and stores resultant vectors in destination array
`static void`	`cvTranspose(CvArr src, CvArr dst)` Transposes matrix.
`static CvSeq`	`cvTreeToNodeSeq(Pointer first, int header_size, CvMemStorage storage)` Gathers pointers to all the sequences, accessible from the `first`, to the single sequence
`static int`	`cvUseOptimized(int on_off)` Loads optimized functions from IPP, MKL etc.
`static void`	`cvXor(CvArr src1, CvArr src2, CvArr dst)`
`static void`	`cvXor(CvArr src1, CvArr src2, CvArr dst, CvArr mask)` dst(idx) = src1(idx) ^ src2(idx)
`static void`	`cvXorS(CvArr src, CvScalar value, CvArr dst)`
`static void`	`cvXorS(CvArr src, CvScalar value, CvArr dst, CvArr mask)` dst(idx) = src(idx) ^ value
`static void`	`cvZero(CvArr arg1)`
`static void`	`dct(GpuMat src, GpuMat dst)`
`static void`	`dct(GpuMat src, GpuMat dst, int flags)`
`static void`	`dct(Mat src, Mat dst)`
`static void`	`dct(Mat src, Mat dst, int flags)` \brief Performs a forward or inverse discrete Cosine transform of 1D or 2D array.
`static void`	`dct(UMat src, UMat dst)`
`static void`	`dct(UMat src, UMat dst, int flags)`
`static double`	`determinant(GpuMat mtx)`
`static double`	`determinant(Mat mtx)` \brief Returns the determinant of a square floating-point matrix.
`static double`	`determinant(UMat mtx)`
`static boolean`	`deviceSupports(int feature_set)` checks whether current device supports the given feature
`static void`	`dft(GpuMat src, GpuMat dst)`
`static void`	`dft(GpuMat src, GpuMat dst, int flags, int nonzeroRows)`
`static void`	`dft(Mat src, Mat dst)`
`static void`	`dft(Mat src, 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(UMat src, UMat dst)`
`static void`	`dft(UMat src, 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, Pointer scale)`
`static void`	`div16s(ShortBuffer src1, long step1, ShortBuffer src2, long step2, ShortBuffer dst, long step, int width, int height, Pointer scale)`
`static void`	`div16s(ShortPointer src1, long step1, ShortPointer src2, long step2, ShortPointer dst, long step, int width, int height, Pointer scale)`
`static void`	`div16u(short[] src1, long step1, short[] src2, long step2, short[] dst, long step, int width, int height, Pointer scale)`
`static void`	`div16u(ShortBuffer src1, long step1, ShortBuffer src2, long step2, ShortBuffer dst, long step, int width, int height, Pointer scale)`
`static void`	`div16u(ShortPointer src1, long step1, ShortPointer src2, long step2, ShortPointer dst, long step, int width, int height, Pointer scale)`
`static void`	`div32f(float[] src1, long step1, float[] src2, long step2, float[] dst, long step, int width, int height, Pointer scale)`
`static void`	`div32f(FloatBuffer src1, long step1, FloatBuffer src2, long step2, FloatBuffer dst, long step, int width, int height, Pointer scale)`
`static void`	`div32f(FloatPointer src1, long step1, FloatPointer src2, long step2, FloatPointer dst, long step, int width, int height, Pointer scale)`
`static void`	`div32s(int[] src1, long step1, int[] src2, long step2, int[] dst, long step, int width, int height, Pointer scale)`
`static void`	`div32s(IntBuffer src1, long step1, IntBuffer src2, long step2, IntBuffer dst, long step, int width, int height, Pointer scale)`
`static void`	`div32s(IntPointer src1, long step1, IntPointer src2, long step2, IntPointer dst, long step, int width, int height, Pointer scale)`
`static void`	`div64f(double[] src1, long step1, double[] src2, long step2, double[] dst, long step, int width, int height, Pointer scale)`
`static void`	`div64f(DoubleBuffer src1, long step1, DoubleBuffer src2, long step2, DoubleBuffer dst, long step, int width, int height, Pointer scale)`
`static void`	`div64f(DoublePointer src1, long step1, DoublePointer src2, long step2, DoublePointer dst, long step, int width, int height, Pointer scale)`
`static void`	`div8s(byte[] src1, long step1, byte[] src2, long step2, byte[] dst, long step, int width, int height, Pointer scale)`
`static void`	`div8s(ByteBuffer src1, long step1, ByteBuffer src2, long step2, ByteBuffer dst, long step, int width, int height, Pointer scale)`
`static void`	`div8s(BytePointer src1, long step1, BytePointer src2, long step2, BytePointer dst, long step, int width, int height, Pointer scale)`
`static void`	`div8u(byte[] src1, long step1, byte[] src2, long step2, byte[] dst, long step, int width, int height, Pointer scale)`
`static void`	`div8u(ByteBuffer src1, long step1, ByteBuffer src2, long step2, ByteBuffer dst, long step, int width, int height, Pointer scale)`
`static void`	`div8u(BytePointer src1, long step1, BytePointer src2, long step2, BytePointer dst, long step, int width, int height, Pointer scale)`
`static void`	`divide(double scale, GpuMat src2, GpuMat dst)`
`static void`	`divide(double scale, GpuMat src2, GpuMat dst, int dtype)`
`static MatExpr`	`divide(double s, Mat a)`
`static MatExpr`	`divide(double s, MatExpr e)`
`static void`	`divide(double scale, Mat src2, Mat dst)`
`static void`	`divide(double scale, Mat src2, Mat dst, int dtype)` \overload
`static void`	`divide(double scale, UMat src2, UMat dst)`
`static void`	`divide(double scale, UMat src2, UMat dst, int dtype)`
`static void`	`divide(GpuMat src1, GpuMat src2, GpuMat dst)`
`static void`	`divide(GpuMat src1, GpuMat src2, GpuMat dst, double scale, int dtype)`
`static MatExpr`	`divide(Mat a, double s)`
`static MatExpr`	`divide(MatExpr e, double s)`
`static MatExpr`	`divide(MatExpr e, Mat m)`
`static MatExpr`	`divide(MatExpr e1, MatExpr e2)`
`static MatExpr`	`divide(Mat a, Mat b)`
`static MatExpr`	`divide(Mat m, MatExpr e)`
`static void`	`divide(Mat src1, Mat src2, Mat dst)`
`static void`	`divide(Mat src1, Mat src2, Mat dst, double scale, int dtype)` \brief Performs per-element division of two arrays or a scalar by an array.
`static void`	`divide(UMat src1, UMat src2, UMat dst)`
`static void`	`divide(UMat src1, UMat src2, UMat dst, double scale, int dtype)`
`static Mat`	`dividePut(Mat a, double b)`
`static Mat`	`dividePut(Mat a, 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(GpuMat src, GpuMat eigenvalues)`
`static boolean`	`eigen(GpuMat src, GpuMat eigenvalues, GpuMat eigenvectors)`
`static boolean`	`eigen(Mat src, Mat eigenvalues)`
`static boolean`	`eigen(Mat src, Mat eigenvalues, Mat eigenvectors)` \brief Calculates eigenvalues and eigenvectors of a symmetric matrix.
`static boolean`	`eigen(UMat src, UMat eigenvalues)`
`static boolean`	`eigen(UMat src, UMat eigenvalues, UMat eigenvectors)`
`static void`	`eigenNonSymmetric(GpuMat src, GpuMat eigenvalues, GpuMat eigenvectors)`
`static void`	`eigenNonSymmetric(Mat src, Mat eigenvalues, Mat eigenvectors)` \brief Calculates eigenvalues and eigenvectors of a non-symmetric matrix (real eigenvalues only).
`static void`	`eigenNonSymmetric(UMat src, UMat eigenvalues, UMat eigenvectors)`
`static void`	`ensureSizeIsEnough(int rows, int cols, int type, GpuMat arr)`
`static void`	`ensureSizeIsEnough(int rows, int cols, int type, 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, UMat arr)`
`static MatExpr`	`equals(double s, Mat a)`
`static boolean`	`equals(FileNodeIterator it1, FileNodeIterator it2)` \} FileNode
`static boolean`	`equals(int a, int b)`
`static MatExpr`	`equals(Mat a, double s)`
`static MatExpr`	`equals(Mat a, Mat b)`
`static boolean`	`equals(NodeData lhs, NodeData rhs)`
`static boolean`	`equals(Range r1, Range r2)` \brief measure dissimilarity between two sample sets computes the complement of the Jaccard Index as described in .
`static void`	`error(int _code, BytePointer _err, BytePointer _func, BytePointer _file, int _line)` \} core_array
`static void`	`error(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(DoublePointer src, 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(FloatPointer src, FloatPointer dst, int n)`
`static void`	`exp(GpuMat src, GpuMat dst)`
`static void`	`exp(Mat src, Mat dst)` \brief Calculates the exponent of every array element.
`static void`	`exp(UMat src, UMat dst)`
`static void`	`exp32f(float[] src, float[] dst, int n)`
`static void`	`exp32f(FloatBuffer src, FloatBuffer dst, int n)`
`static void`	`exp32f(FloatPointer src, 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(DoublePointer src, DoublePointer dst, int n)`
`static void`	`extractChannel(GpuMat src, GpuMat dst, int coi)`
`static void`	`extractChannel(Mat src, Mat dst, int coi)` \brief Extracts a single channel from src (coi is 0-based index)
`static void`	`extractChannel(UMat src, UMat dst, int coi)`
`static void`	`extractImageCOI(CvArr arr, GpuMat coiimg)`
`static void`	`extractImageCOI(CvArr arr, GpuMat coiimg, int coi)`
`static void`	`extractImageCOI(CvArr arr, Mat coiimg)`
`static void`	`extractImageCOI(CvArr arr, Mat coiimg, int coi)` extracts Channel of Interest from CvMat or IplImage and makes cv::Mat out of it.
`static void`	`extractImageCOI(CvArr arr, UMat coiimg)`
`static void`	`extractImageCOI(CvArr arr, 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(FloatPointer y, FloatPointer x, 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(FloatPointer y, FloatPointer x, 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(DoublePointer y, DoublePointer x, DoublePointer dst, int n, boolean angleInDegrees)`
`static void`	`fastFree(Pointer ptr)` \brief Deallocates a memory buffer.
`static Pointer`	`fastMalloc(long bufSize)` \addtogroup core_utils \{
`static BytePointer`	`findFile(BytePointer relative_path)`
`static BytePointer`	`findFile(BytePointer relative_path, boolean required, boolean silentMode)` \{
`static String`	`findFile(String relative_path)`
`static String`	`findFile(String relative_path, boolean required, boolean silentMode)`
`static BytePointer`	`findFileOrKeep(BytePointer relative_path)`
`static BytePointer`	`findFileOrKeep(BytePointer relative_path, boolean silentMode)`
`static String`	`findFileOrKeep(String relative_path)`
`static String`	`findFileOrKeep(String relative_path, boolean silentMode)`
`static void`	`findNonZero(GpuMat src, GpuMat idx)`
`static void`	`findNonZero(Mat src, Mat idx)` \brief Returns the list of locations of non-zero pixels
`static void`	`findNonZero(UMat src, UMat idx)`
`static void`	`finish()`
`static void`	`flip(GpuMat src, GpuMat dst, int flipCode)`
`static void`	`flip(Mat src, Mat dst, int flipCode)` \brief Flips a 2D array around vertical, horizontal, or both axes.
`static void`	`flip(UMat src, UMat dst, int flipCode)`
`static float16_t`	`float16SaturateCast(byte v)`
`static float16_t`	`float16SaturateCast(double v)`
`static float16_t`	`float16SaturateCast(float v)`
`static float16_t`	`float16SaturateCast(float16_t v)`
`static float16_t`	`float16SaturateCast(int v)`
`static float16_t`	`float16SaturateCast(long v)`
`static float16_t`	`float16SaturateCast(short v)`
`static float`	`floatRand()`
`static BytePointer`	`format(BytePointer fmt)` \brief Returns a text string formatted using the printf-like expression.
`static Formatted`	`format(GpuMat mtx, int fmt)`
`static Formatted`	`format(Mat mtx, int fmt)`
`static String`	`format(String fmt)`
`static Formatted`	`format(UMat mtx, int fmt)`
`static void`	`gemm(GpuMat src1, GpuMat src2, double alpha, GpuMat src3, double beta, GpuMat dst)`
`static void`	`gemm(GpuMat src1, GpuMat src2, double alpha, GpuMat src3, double beta, GpuMat dst, int flags)`
`static void`	`gemm(Mat src1, Mat src2, double alpha, Mat src3, double beta, Mat dst)`
`static void`	`gemm(Mat src1, Mat src2, double alpha, Mat src3, double beta, Mat dst, int flags)` \brief Performs generalized matrix multiplication.
`static void`	`gemm(UMat src1, UMat src2, double alpha, UMat src3, double beta, UMat dst)`
`static void`	`gemm(UMat src1, UMat src2, double alpha, UMat src3, double beta, 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(FloatPointer src1, long src1_step, FloatPointer src2, long src2_step, float alpha, FloatPointer src3, long src3_step, float beta, 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(FloatPointer src1, long src1_step, FloatPointer src2, long src2_step, float alpha, FloatPointer src3, long src3_step, float beta, 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(DoublePointer src1, long src1_step, DoublePointer src2, long src2_step, double alpha, DoublePointer src3, long src3_step, double beta, 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(DoublePointer src1, long src1_step, DoublePointer src2, long src2_step, double alpha, DoublePointer src3, long src3_step, double beta, DoublePointer dst, long dst_step, int m_a, int n_a, int n_d, int flags)`
`static BytePointer`	`getBuildInformation()` \brief Returns full configuration time cmake output.
`static 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 BytePointer`	`getHardwareFeatureName(int feature)` \brief Returns feature name by ID
`static BytePointer`	`getIppErrorLocation()`
`static long`	`getIppFeatures()` \cond IGNORED
`static int`	`getIppStatus()`
`static 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 MatAllocator`	`getOpenCLAllocator()`
`static BytePointer`	`getOpenCLErrorString(int errorCode)`
`static int`	`getOptimalDFTSize(int vecsize)` \brief Returns the optimal DFT size for a given vector size.
`static void`	`getPlatfomsInfo(PlatformInfo platform_info)`
`static BytePointer`	`getSeqElem(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.
`static long`	`getTickCount()` \brief Returns the number of ticks.
`static double`	`getTickFrequency()` \brief Returns the number of ticks per second.
`static 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 BytePointer`	`getVersionString()` \brief Returns library version string
`static void`	`glob(BytePointer pattern, StringVector result)`
`static void`	`glob(BytePointer pattern, StringVector result, boolean recursive)`
`static void`	`glob(String pattern, StringVector result)`
`static void`	`glob(String pattern, StringVector result, boolean recursive)`
`static MatExpr`	`greaterThan(double s, Mat a)`
`static MatExpr`	`greaterThan(Mat a, double s)`
`static MatExpr`	`greaterThan(Mat a, Mat b)`
`static MatExpr`	`greaterThanEquals(double s, Mat a)`
`static MatExpr`	`greaterThanEquals(Mat a, double s)`
`static MatExpr`	`greaterThanEquals(Mat a, Mat b)`
`static boolean`	`haveAmdBlas()`
`static boolean`	`haveAmdFft()`
`static boolean`	`haveOpenCL()` \addtogroup core_opencl \{
`static boolean`	`haveSVM()`
`static void`	`hconcat(GpuMat src1, GpuMat src2, GpuMat dst)`
`static void`	`hconcat(GpuMatVector src, GpuMat dst)`
`static void`	`hconcat(GpuMatVector src, Mat dst)`
`static void`	`hconcat(GpuMatVector src, UMat dst)`
`static void`	`hconcat(Mat src, long nsrc, GpuMat dst)`
`static void`	`hconcat(Mat src, long nsrc, Mat dst)` \brief Applies horizontal concatenation to given matrices.
`static void`	`hconcat(Mat src, long nsrc, UMat dst)`
`static void`	`hconcat(Mat src1, Mat src2, Mat dst)` \overload
`static void`	`hconcat(MatVector src, GpuMat dst)`
`static void`	`hconcat(MatVector src, Mat dst)` \overload
`static void`	`hconcat(MatVector src, UMat dst)`
`static void`	`hconcat(UMat src1, UMat src2, UMat dst)`
`static void`	`hconcat(UMatVector src, GpuMat dst)`
`static void`	`hconcat(UMatVector src, Mat dst)`
`static void`	`hconcat(UMatVector src, UMat dst)`
`static void`	`idct(GpuMat src, GpuMat dst)`
`static void`	`idct(GpuMat src, GpuMat dst, int flags)`
`static void`	`idct(Mat src, Mat dst)`
`static void`	`idct(Mat src, Mat dst, int flags)` \brief Calculates the inverse Discrete Cosine Transform of a 1D or 2D array.
`static void`	`idct(UMat src, UMat dst)`
`static void`	`idct(UMat src, UMat dst, int flags)`
`static void`	`idft(GpuMat src, GpuMat dst)`
`static void`	`idft(GpuMat src, GpuMat dst, int flags, int nonzeroRows)`
`static void`	`idft(Mat src, Mat dst)`
`static void`	`idft(Mat src, Mat dst, int flags, int nonzeroRows)` \brief Calculates the inverse Discrete Fourier Transform of a 1D or 2D array.
`static void`	`idft(UMat src, UMat dst)`
`static void`	`idft(UMat src, UMat dst, int flags, int nonzeroRows)`
`static void`	`inRange(GpuMat src, GpuMat lowerb, GpuMat upperb, GpuMat dst)`
`static void`	`inRange(Mat src, Mat lowerb, Mat upperb, Mat dst)` \brief Checks if array elements lie between the elements of two other arrays.
`static void`	`inRange(UMat src, UMat lowerb, UMat upperb, UMat dst)`
`static void`	`insertChannel(GpuMat src, GpuMat dst, int coi)`
`static void`	`insertChannel(Mat src, Mat dst, int coi)` \brief Inserts a single channel to dst (coi is 0-based index)
`static void`	`insertChannel(UMat src, UMat dst, int coi)`
`static void`	`insertImageCOI(GpuMat coiimg, CvArr arr)`
`static void`	`insertImageCOI(GpuMat coiimg, CvArr arr, int coi)`
`static void`	`insertImageCOI(Mat coiimg, CvArr arr)`
`static void`	`insertImageCOI(Mat coiimg, CvArr arr, int coi)` inserts single-channel cv::Mat into a multi-channel CvMat or IplImage
`static void`	`insertImageCOI(UMat coiimg, CvArr arr)`
`static void`	`insertImageCOI(UMat coiimg, CvArr arr, int coi)`
`static long`	`int64SaturateCast(byte v)`
`static long`	`int64SaturateCast(double v)`
`static long`	`int64SaturateCast(float v)`
`static long`	`int64SaturateCast(float16_t v)`
`static long`	`int64SaturateCast(int v)`
`static long`	`int64SaturateCast(long v)`
`static long`	`int64SaturateCast(short v)`
`static int`	`intRand()` returns the next uniformly-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(float16_t v)`
`static int`	`intSaturate(int v)`
`static int`	`intSaturate(long v)`
`static int`	`intSaturate(short v)`
`static double`	`invert(GpuMat src, GpuMat dst)`
`static double`	`invert(GpuMat src, GpuMat dst, int flags)`
`static double`	`invert(Mat src, Mat dst)`
`static double`	`invert(Mat src, Mat dst, int flags)` \brief Finds the inverse or pseudo-inverse of a matrix.
`static double`	`invert(UMat src, UMat dst)`
`static double`	`invert(UMat src, 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(DoublePointer src, 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(FloatPointer src, 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(FloatPointer src, 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(DoublePointer src, DoublePointer dst, int len)`
`static int`	`IPL_IMAGE_MAGIC_VAL()`
`static BytePointer`	`kernelToStr(GpuMat _kernel)`
`static BytePointer`	`kernelToStr(GpuMat _kernel, int ddepth, BytePointer name)`
`static String`	`kernelToStr(GpuMat _kernel, int ddepth, String name)`
`static BytePointer`	`kernelToStr(Mat _kernel)`
`static BytePointer`	`kernelToStr(Mat _kernel, int ddepth, BytePointer name)`
`static String`	`kernelToStr(Mat _kernel, int ddepth, String name)`
`static String`	`kernelToStr(UMat _kernel)`
`static BytePointer`	`kernelToStr(UMat _kernel, int ddepth, BytePointer name)`
`static String`	`kernelToStr(UMat _kernel, int ddepth, String name)`
`static double`	`kmeans(GpuMat data, int K, GpuMat bestLabels, TermCriteria criteria, int attempts, int flags)`
`static double`	`kmeans(GpuMat data, int K, GpuMat bestLabels, TermCriteria criteria, int attempts, int flags, GpuMat centers)`
`static double`	`kmeans(Mat data, int K, Mat bestLabels, TermCriteria criteria, int attempts, int flags)`
`static double`	`kmeans(Mat data, int K, Mat bestLabels, TermCriteria criteria, int attempts, int flags, Mat centers)` \brief Finds centers of clusters and groups input samples around the clusters.
`static double`	`kmeans(UMat data, int K, UMat bestLabels, TermCriteria criteria, int attempts, int flags)`
`static double`	`kmeans(UMat data, int K, UMat bestLabels, TermCriteria criteria, int attempts, int flags, UMat centers)`
`static MatExpr`	`lessThan(double s, Mat a)`
`static boolean`	`lessThan(FileNodeIterator it1, FileNodeIterator it2)`
`static MatExpr`	`lessThan(Mat a, double s)`
`static MatExpr`	`lessThan(Mat a, Mat b)`
`static MatExpr`	`lessThanEquals(double s, Mat a)`
`static MatExpr`	`lessThanEquals(Mat a, double s)`
`static MatExpr`	`lessThanEquals(Mat a, Mat b)`
`static void`	`log(double[] src, double[] dst, int n)`
`static void`	`log(DoubleBuffer src, DoubleBuffer dst, int n)`
`static void`	`log(DoublePointer src, 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(FloatPointer src, FloatPointer dst, int n)`
`static void`	`log(GpuMat src, GpuMat dst)`
`static void`	`log(Mat src, Mat dst)` \brief Calculates the natural logarithm of every array element.
`static void`	`log(UMat src, UMat dst)`
`static void`	`log32f(float[] src, float[] dst, int n)`
`static void`	`log32f(FloatBuffer src, FloatBuffer dst, int n)`
`static void`	`log32f(FloatPointer src, 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(DoublePointer src, 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(DoublePointer A, long astep, int m, DoublePointer b, long bstep, int n)`
`static int`	`LU(float[] A, long astep, int m, float[] b, long bstep, int n)`
`static int`	`LU(FloatBuffer A, long astep, int m, FloatBuffer b, long bstep, int n)`
`static int`	`LU(FloatPointer A, long astep, int m, FloatPointer b, long bstep, int n)` \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(FloatPointer A, long astep, int m, 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(DoublePointer A, long astep, int m, DoublePointer b, long bstep, int n)`
`static void`	`LUT(GpuMat src, GpuMat lut, GpuMat dst)`
`static void`	`LUT(Mat src, Mat lut, Mat dst)` \brief Performs a look-up table transform of an array.
`static void`	`LUT(UMat src, UMat lut, 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(DoublePointer x, DoublePointer y, 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(FloatPointer x, FloatPointer y, FloatPointer dst, int n)`
`static void`	`magnitude(GpuMat x, GpuMat y, GpuMat magnitude)`
`static void`	`magnitude(Mat x, Mat y, Mat magnitude)` \brief Calculates the magnitude of 2D vectors.
`static void`	`magnitude(UMat x, UMat y, 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(FloatPointer x, FloatPointer y, 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(DoublePointer x, DoublePointer y, DoublePointer dst, int n)`
`static double`	`Mahalanobis(GpuMat v1, GpuMat v2, GpuMat icovar)`
`static double`	`Mahalanobis(Mat v1, Mat v2, Mat icovar)` \brief Calculates the Mahalanobis distance between two vectors.
`static double`	`Mahalanobis(UMat v1, UMat v2, UMat icovar)`
`static MatExpr`	`max(double s, Mat a)`
`static MatExpr`	`max(Mat a, double s)`
`static MatExpr`	`max(Mat a, Mat b)`
`static void`	`max(Mat src1, Mat src2, Mat dst)` \overload needed to avoid conflicts with const _Tp& std::min(const _Tp&, const _Tp&, _Compare)
`static void`	`max(UMat src1, UMat src2, 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, Pointer arg8)`
`static void`	`max16s(ShortBuffer src1, long step1, ShortBuffer src2, long step2, ShortBuffer dst, long step, int width, int height, Pointer arg8)`
`static void`	`max16s(ShortPointer src1, long step1, ShortPointer src2, long step2, ShortPointer dst, long step, int width, int height, Pointer arg8)`
`static void`	`max16u(short[] src1, long step1, short[] src2, long step2, short[] dst, long step, int width, int height, Pointer arg8)`
`static void`	`max16u(ShortBuffer src1, long step1, ShortBuffer src2, long step2, ShortBuffer dst, long step, int width, int height, Pointer arg8)`
`static void`	`max16u(ShortPointer src1, long step1, ShortPointer src2, long step2, ShortPointer dst, long step, int width, int height, Pointer arg8)`
`static void`	`max32f(float[] src1, long step1, float[] src2, long step2, float[] dst, long step, int width, int height, Pointer arg8)`
`static void`	`max32f(FloatBuffer src1, long step1, FloatBuffer src2, long step2, FloatBuffer dst, long step, int width, int height, Pointer arg8)`
`static void`	`max32f(FloatPointer src1, long step1, FloatPointer src2, long step2, FloatPointer dst, long step, int width, int height, Pointer arg8)`
`static void`	`max32s(int[] src1, long step1, int[] src2, long step2, int[] dst, long step, int width, int height, Pointer arg8)`
`static void`	`max32s(IntBuffer src1, long step1, IntBuffer src2, long step2, IntBuffer dst, long step, int width, int height, Pointer arg8)`
`static void`	`max32s(IntPointer src1, long step1, IntPointer src2, long step2, IntPointer dst, long step, int width, int height, Pointer arg8)`
`static void`	`max64f(double[] src1, long step1, double[] src2, long step2, double[] dst, long step, int width, int height, Pointer arg8)`
`static void`	`max64f(DoubleBuffer src1, long step1, DoubleBuffer src2, long step2, DoubleBuffer dst, long step, int width, int height, Pointer arg8)`
`static void`	`max64f(DoublePointer src1, long step1, DoublePointer src2, long step2, DoublePointer dst, long step, int width, int height, Pointer arg8)`
`static void`	`max8s(byte[] src1, long step1, byte[] src2, long step2, byte[] dst, long step, int width, int height, Pointer arg8)`
`static void`	`max8s(ByteBuffer src1, long step1, ByteBuffer src2, long step2, ByteBuffer dst, long step, int width, int height, Pointer arg8)`
`static void`	`max8s(BytePointer src1, long step1, BytePointer src2, long step2, BytePointer dst, long step, int width, int height, Pointer arg8)`
`static void`	`max8u(byte[] src1, long step1, byte[] src2, long step2, byte[] dst, long step, int width, int height, Pointer arg8)`
`static void`	`max8u(ByteBuffer src1, long step1, ByteBuffer src2, long step2, ByteBuffer dst, long step, int width, int height, Pointer arg8)`
`static void`	`max8u(BytePointer src1, long step1, BytePointer src2, long step2, BytePointer dst, long step, int width, int height, Pointer arg8)`
`static Scalar`	`mean(GpuMat src)`
`static Scalar`	`mean(GpuMat src, GpuMat mask)`
`static Scalar`	`mean(Mat src)`
`static Scalar`	`mean(Mat src, Mat mask)` \brief Calculates an average (mean) of array elements.
`static Scalar`	`mean(UMat src)`
`static Scalar`	`mean(UMat src, UMat mask)`
`static void`	`meanStdDev(GpuMat src, GpuMat mean, GpuMat stddev)`
`static void`	`meanStdDev(GpuMat src, GpuMat mean, GpuMat stddev, GpuMat mask)`
`static void`	`meanStdDev(Mat src, Mat mean, Mat stddev)`
`static void`	`meanStdDev(Mat src, Mat mean, Mat stddev, Mat mask)` Calculates a mean and standard deviation of array elements.
`static void`	`meanStdDev(UMat src, UMat mean, UMat stddev)`
`static void`	`meanStdDev(UMat src, UMat mean, UMat stddev, UMat mask)`
`static BytePointer`	`memopTypeToStr(int t)`
`static void`	`merge(GpuMatVector mv, GpuMat dst)`
`static void`	`merge(GpuMatVector mv, Mat dst)`
`static void`	`merge(GpuMatVector mv, UMat dst)`
`static void`	`merge(Mat mv, long count, GpuMat dst)`
`static void`	`merge(Mat mv, long count, Mat dst)` \brief Creates one multi-channel array out of several single-channel ones.
`static void`	`merge(Mat mv, long count, UMat dst)`
`static void`	`merge(MatVector mv, GpuMat dst)`
`static void`	`merge(MatVector mv, Mat dst)` \overload
`static void`	`merge(MatVector mv, UMat dst)`
`static void`	`merge(UMatVector mv, GpuMat dst)`
`static void`	`merge(UMatVector mv, Mat dst)`
`static void`	`merge(UMatVector mv, UMat dst)`
`static void`	`merge16u(PointerPointer src, 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(ShortPointer src, 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(IntPointer src, IntPointer dst, int len, int cn)`
`static void`	`merge32s(PointerPointer src, 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(LongPointer src, LongPointer dst, int len, int cn)`
`static void`	`merge64s(PointerPointer src, 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(BytePointer src, BytePointer dst, int len, int cn)`
`static void`	`merge8u(PointerPointer src, BytePointer dst, int len, int cn)`
`static MatExpr`	`min(double s, Mat a)`
`static MatExpr`	`min(Mat a, double s)`
`static MatExpr`	`min(Mat a, Mat b)`
`static void`	`min(Mat src1, Mat src2, Mat dst)` \overload needed to avoid conflicts with const _Tp& std::min(const _Tp&, const _Tp&, _Compare)
`static void`	`min(UMat src1, UMat src2, 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, Pointer arg8)`
`static void`	`min16s(ShortBuffer src1, long step1, ShortBuffer src2, long step2, ShortBuffer dst, long step, int width, int height, Pointer arg8)`
`static void`	`min16s(ShortPointer src1, long step1, ShortPointer src2, long step2, ShortPointer dst, long step, int width, int height, Pointer arg8)`
`static void`	`min16u(short[] src1, long step1, short[] src2, long step2, short[] dst, long step, int width, int height, Pointer arg8)`
`static void`	`min16u(ShortBuffer src1, long step1, ShortBuffer src2, long step2, ShortBuffer dst, long step, int width, int height, Pointer arg8)`
`static void`	`min16u(ShortPointer src1, long step1, ShortPointer src2, long step2, ShortPointer dst, long step, int width, int height, Pointer arg8)`
`static void`	`min32f(float[] src1, long step1, float[] src2, long step2, float[] dst, long step, int width, int height, Pointer arg8)`
`static void`	`min32f(FloatBuffer src1, long step1, FloatBuffer src2, long step2, FloatBuffer dst, long step, int width, int height, Pointer arg8)`
`static void`	`min32f(FloatPointer src1, long step1, FloatPointer src2, long step2, FloatPointer dst, long step, int width, int height, Pointer arg8)`
`static void`	`min32s(int[] src1, long step1, int[] src2, long step2, int[] dst, long step, int width, int height, Pointer arg8)`
`static void`	`min32s(IntBuffer src1, long step1, IntBuffer src2, long step2, IntBuffer dst, long step, int width, int height, Pointer arg8)`
`static void`	`min32s(IntPointer src1, long step1, IntPointer src2, long step2, IntPointer dst, long step, int width, int height, Pointer arg8)`
`static void`	`min64f(double[] src1, long step1, double[] src2, long step2, double[] dst, long step, int width, int height, Pointer arg8)`
`static void`	`min64f(DoubleBuffer src1, long step1, DoubleBuffer src2, long step2, DoubleBuffer dst, long step, int width, int height, Pointer arg8)`
`static void`	`min64f(DoublePointer src1, long step1, DoublePointer src2, long step2, DoublePointer dst, long step, int width, int height, Pointer arg8)`
`static void`	`min8s(byte[] src1, long step1, byte[] src2, long step2, byte[] dst, long step, int width, int height, Pointer arg8)`
`static void`	`min8s(ByteBuffer src1, long step1, ByteBuffer src2, long step2, ByteBuffer dst, long step, int width, int height, Pointer arg8)`
`static void`	`min8s(BytePointer src1, long step1, BytePointer src2, long step2, BytePointer dst, long step, int width, int height, Pointer arg8)`
`static void`	`min8u(byte[] src1, long step1, byte[] src2, long step2, byte[] dst, long step, int width, int height, Pointer arg8)`
`static void`	`min8u(ByteBuffer src1, long step1, ByteBuffer src2, long step2, ByteBuffer dst, long step, int width, int height, Pointer arg8)`
`static void`	`min8u(BytePointer src1, long step1, BytePointer src2, long step2, BytePointer dst, long step, int width, int height, Pointer arg8)`
`static void`	`minMaxIdx(GpuMat src, double[] minVal)`
`static void`	`minMaxIdx(GpuMat src, double[] minVal, double[] maxVal, int[] minIdx, int[] maxIdx, GpuMat mask)`
`static void`	`minMaxIdx(GpuMat src, DoubleBuffer minVal)`
`static void`	`minMaxIdx(GpuMat src, DoubleBuffer minVal, DoubleBuffer maxVal, IntBuffer minIdx, IntBuffer maxIdx, GpuMat mask)`
`static void`	`minMaxIdx(GpuMat src, DoublePointer minVal)`
`static void`	`minMaxIdx(GpuMat src, DoublePointer minVal, DoublePointer maxVal, IntPointer minIdx, IntPointer maxIdx, GpuMat mask)`
`static void`	`minMaxIdx(Mat src, double[] minVal)`
`static void`	`minMaxIdx(Mat src, double[] minVal, double[] maxVal, int[] minIdx, int[] maxIdx, Mat mask)`
`static void`	`minMaxIdx(Mat src, DoubleBuffer minVal)`
`static void`	`minMaxIdx(Mat src, DoubleBuffer minVal, DoubleBuffer maxVal, IntBuffer minIdx, IntBuffer maxIdx, Mat mask)`
`static void`	`minMaxIdx(Mat src, DoublePointer minVal)`
`static void`	`minMaxIdx(Mat src, DoublePointer minVal, DoublePointer maxVal, IntPointer minIdx, IntPointer maxIdx, Mat mask)` \brief Finds the global minimum and maximum in an array
`static void`	`minMaxIdx(UMat src, double[] minVal)`
`static void`	`minMaxIdx(UMat src, double[] minVal, double[] maxVal, int[] minIdx, int[] maxIdx, UMat mask)`
`static void`	`minMaxIdx(UMat src, DoubleBuffer minVal)`
`static void`	`minMaxIdx(UMat src, DoubleBuffer minVal, DoubleBuffer maxVal, IntBuffer minIdx, IntBuffer maxIdx, UMat mask)`
`static void`	`minMaxIdx(UMat src, DoublePointer minVal)`
`static void`	`minMaxIdx(UMat src, DoublePointer minVal, DoublePointer maxVal, IntPointer minIdx, IntPointer maxIdx, UMat mask)`
`static void`	`minMaxLoc(GpuMat src, double[] minVal)`
`static void`	`minMaxLoc(GpuMat src, double[] minVal, double[] maxVal, Point minLoc, Point maxLoc, GpuMat mask)`
`static void`	`minMaxLoc(GpuMat src, DoubleBuffer minVal)`
`static void`	`minMaxLoc(GpuMat src, DoubleBuffer minVal, DoubleBuffer maxVal, Point minLoc, Point maxLoc, GpuMat mask)`
`static void`	`minMaxLoc(GpuMat src, DoublePointer minVal)`
`static void`	`minMaxLoc(GpuMat src, DoublePointer minVal, DoublePointer maxVal, Point minLoc, Point maxLoc, GpuMat mask)`
`static void`	`minMaxLoc(Mat src, double[] minVal)`
`static void`	`minMaxLoc(Mat src, double[] minVal, double[] maxVal, Point minLoc, Point maxLoc, Mat mask)`
`static void`	`minMaxLoc(Mat src, DoubleBuffer minVal)`
`static void`	`minMaxLoc(Mat src, DoubleBuffer minVal, DoubleBuffer maxVal, Point minLoc, Point maxLoc, Mat mask)`
`static void`	`minMaxLoc(Mat src, DoublePointer minVal)`
`static void`	`minMaxLoc(Mat src, DoublePointer minVal, DoublePointer maxVal, Point minLoc, Point maxLoc, Mat mask)` \brief Finds the global minimum and maximum in an array.
`static void`	`minMaxLoc(SparseMat a, double[] minVal, double[] maxVal)`
`static void`	`minMaxLoc(SparseMat a, double[] minVal, double[] maxVal, int[] minIdx, int[] maxIdx)`
`static void`	`minMaxLoc(SparseMat a, DoubleBuffer minVal, DoubleBuffer maxVal)`
`static void`	`minMaxLoc(SparseMat a, DoubleBuffer minVal, DoubleBuffer maxVal, IntBuffer minIdx, IntBuffer maxIdx)`
`static void`	`minMaxLoc(SparseMat a, DoublePointer minVal, DoublePointer maxVal)`
`static void`	`minMaxLoc(SparseMat a, DoublePointer minVal, DoublePointer maxVal, IntPointer minIdx, IntPointer maxIdx)` \overload
`static void`	`minMaxLoc(UMat src, double[] minVal)`
`static void`	`minMaxLoc(UMat src, double[] minVal, double[] maxVal, Point minLoc, Point maxLoc, UMat mask)`
`static void`	`minMaxLoc(UMat src, DoubleBuffer minVal)`
`static void`	`minMaxLoc(UMat src, DoubleBuffer minVal, DoubleBuffer maxVal, Point minLoc, Point maxLoc, UMat mask)`
`static void`	`minMaxLoc(UMat src, DoublePointer minVal)`
`static void`	`minMaxLoc(UMat src, DoublePointer minVal, DoublePointer maxVal, Point minLoc, Point maxLoc, UMat mask)`
`static void`	`mixChannels(GpuMatVector src, GpuMatVector dst, int[] fromTo)`
`static void`	`mixChannels(GpuMatVector src, GpuMatVector dst, int[] fromTo, long npairs)`
`static void`	`mixChannels(Mat src, long nsrcs, Mat dst, long ndsts, int[] fromTo, long npairs)`
`static void`	`mixChannels(Mat src, long nsrcs, Mat dst, long ndsts, IntBuffer fromTo, long npairs)`
`static void`	`mixChannels(Mat src, long nsrcs, Mat dst, long ndsts, IntPointer fromTo, long npairs)` \brief Copies specified channels from input arrays to the specified channels of output arrays.
`static void`	`mixChannels(MatVector src, MatVector dst, IntPointer fromTo)` \overload
`static void`	`mixChannels(MatVector src, MatVector dst, IntPointer fromTo, long npairs)` \overload
`static void`	`mixChannels(UMatVector src, UMatVector dst, IntBuffer fromTo)`
`static void`	`mixChannels(UMatVector src, 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, Pointer scale)`
`static void`	`mul16s(ShortBuffer src1, long step1, ShortBuffer src2, long step2, ShortBuffer dst, long step, int width, int height, Pointer scale)`
`static void`	`mul16s(ShortPointer src1, long step1, ShortPointer src2, long step2, ShortPointer dst, long step, int width, int height, Pointer scale)`
`static void`	`mul16u(short[] src1, long step1, short[] src2, long step2, short[] dst, long step, int width, int height, Pointer scale)`
`static void`	`mul16u(ShortBuffer src1, long step1, ShortBuffer src2, long step2, ShortBuffer dst, long step, int width, int height, Pointer scale)`
`static void`	`mul16u(ShortPointer src1, long step1, ShortPointer src2, long step2, ShortPointer dst, long step, int width, int height, Pointer scale)`
`static void`	`mul32f(float[] src1, long step1, float[] src2, long step2, float[] dst, long step, int width, int height, Pointer scale)`
`static void`	`mul32f(FloatBuffer src1, long step1, FloatBuffer src2, long step2, FloatBuffer dst, long step, int width, int height, Pointer scale)`
`static void`	`mul32f(FloatPointer src1, long step1, FloatPointer src2, long step2, FloatPointer dst, long step, int width, int height, Pointer scale)`
`static void`	`mul32s(int[] src1, long step1, int[] src2, long step2, int[] dst, long step, int width, int height, Pointer scale)`
`static void`	`mul32s(IntBuffer src1, long step1, IntBuffer src2, long step2, IntBuffer dst, long step, int width, int height, Pointer scale)`
`static void`	`mul32s(IntPointer src1, long step1, IntPointer src2, long step2, IntPointer dst, long step, int width, int height, Pointer scale)`
`static void`	`mul64f(double[] src1, long step1, double[] src2, long step2, double[] dst, long step, int width, int height, Pointer scale)`
`static void`	`mul64f(DoubleBuffer src1, long step1, DoubleBuffer src2, long step2, DoubleBuffer dst, long step, int width, int height, Pointer scale)`
`static void`	`mul64f(DoublePointer src1, long step1, DoublePointer src2, long step2, DoublePointer dst, long step, int width, int height, Pointer scale)`
`static void`	`mul8s(byte[] src1, long step1, byte[] src2, long step2, byte[] dst, long step, int width, int height, Pointer scale)`
`static void`	`mul8s(ByteBuffer src1, long step1, ByteBuffer src2, long step2, ByteBuffer dst, long step, int width, int height, Pointer scale)`
`static void`	`mul8s(BytePointer src1, long step1, BytePointer src2, long step2, BytePointer dst, long step, int width, int height, Pointer scale)`
`static void`	`mul8u(byte[] src1, long step1, byte[] src2, long step2, byte[] dst, long step, int width, int height, Pointer scale)`
`static void`	`mul8u(ByteBuffer src1, long step1, ByteBuffer src2, long step2, ByteBuffer dst, long step, int width, int height, Pointer scale)`
`static void`	`mul8u(BytePointer src1, long step1, BytePointer src2, long step2, BytePointer dst, long step, int width, int height, Pointer scale)`
`static void`	`mulSpectrums(GpuMat a, GpuMat b, GpuMat c, int flags)`
`static void`	`mulSpectrums(GpuMat a, GpuMat b, GpuMat c, int flags, boolean conjB)`
`static void`	`mulSpectrums(Mat a, Mat b, Mat c, int flags)`
`static void`	`mulSpectrums(Mat a, Mat b, Mat c, int flags, boolean conjB)` \brief Performs the per-element multiplication of two Fourier spectrums.
`static void`	`mulSpectrums(UMat a, UMat b, UMat c, int flags)`
`static void`	`mulSpectrums(UMat a, UMat b, UMat c, int flags, boolean conjB)`
`static MatExpr`	`multiply(double s, Mat a)`
`static MatExpr`	`multiply(double s, MatExpr e)`
`static void`	`multiply(GpuMat src1, GpuMat src2, GpuMat dst)`
`static void`	`multiply(GpuMat src1, GpuMat src2, GpuMat dst, double scale, int dtype)`
`static MatExpr`	`multiply(Mat a, double s)`
`static MatExpr`	`multiply(MatExpr e, double s)`
`static MatExpr`	`multiply(MatExpr e, Mat m)`
`static MatExpr`	`multiply(MatExpr e1, MatExpr e2)`
`static MatExpr`	`multiply(Mat a, Mat b)`
`static MatExpr`	`multiply(Mat m, MatExpr e)`
`static void`	`multiply(Mat src1, Mat src2, Mat dst)`
`static void`	`multiply(Mat src1, Mat src2, Mat dst, double scale, int dtype)` \brief Calculates the per-element scaled product of two arrays.
`static void`	`multiply(UMat src1, UMat src2, UMat dst)`
`static void`	`multiply(UMat src1, UMat src2, UMat dst, double scale, int dtype)`
`static Mat`	`multiplyPut(Mat a, double b)`
`static Mat`	`multiplyPut(Mat a, Mat b)`
`static void`	`mulTransposed(GpuMat src, GpuMat dst, boolean aTa)`
`static void`	`mulTransposed(GpuMat src, GpuMat dst, boolean aTa, GpuMat delta, double scale, int dtype)`
`static void`	`mulTransposed(Mat src, Mat dst, boolean aTa)`
`static void`	`mulTransposed(Mat src, Mat dst, boolean aTa, Mat delta, double scale, int dtype)` \brief Calculates the product of a matrix and its transposition.
`static void`	`mulTransposed(UMat src, UMat dst, boolean aTa)`
`static void`	`mulTransposed(UMat src, UMat dst, boolean aTa, UMat delta, double scale, int dtype)`
`static Mat`	`noArray()` Helper to wrap custom types.
`static double`	`norm(GpuMat src1)`
`static double`	`norm(GpuMat src1, GpuMat src2)`
`static double`	`norm(GpuMat src1, GpuMat src2, int normType, GpuMat mask)`
`static double`	`norm(GpuMat src1, int normType, GpuMat mask)`
`static double`	`norm(Mat src1)`
`static double`	`norm(Mat src1, int normType, Mat mask)` \brief Calculates the absolute norm of an array.
`static double`	`norm(Mat src1, Mat src2)`
`static double`	`norm(Mat src1, Mat src2, int normType, Mat mask)` \brief Calculates an absolute difference norm or a relative difference norm.
`static double`	`norm(SparseMat src, int normType)` \overload
`static double`	`norm(UMat src1)`
`static double`	`norm(UMat src1, int normType, UMat mask)`
`static double`	`norm(UMat src1, UMat src2)`
`static double`	`norm(UMat src1, UMat src2, int normType, UMat mask)`
`static void`	`normalize(GpuMat src, GpuMat dst)`
`static void`	`normalize(GpuMat src, GpuMat dst, double alpha, double beta, int norm_type, int dtype, GpuMat mask)`
`static void`	`normalize(Mat src, Mat dst)`
`static void`	`normalize(Mat src, Mat dst, double alpha, double beta, int norm_type, int dtype, Mat mask)` \brief Normalizes the norm or value range of an array.
`static void`	`normalize(SparseMat src, SparseMat dst, double alpha, int normType)` \overload
`static void`	`normalize(UMat src, UMat dst)`
`static void`	`normalize(UMat src, UMat dst, double alpha, double beta, int norm_type, int dtype, 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(BytePointer a, BytePointer b, int n)`
`static int`	`normHamming(BytePointer a, BytePointer b, int n, int cellSize)`
`static int`	`normHamming(BytePointer a, int n)` \addtogroup core_hal_functions \{
`static int`	`normHamming(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_(BytePointer a, BytePointer b, int n)`
`static float`	`normL1_(float[] a, float[] b, int n)`
`static float`	`normL1_(FloatBuffer a, FloatBuffer b, int n)`
`static float`	`normL1_(FloatPointer a, FloatPointer b, int n)`
`static float`	`normL2Sqr_(float[] a, float[] b, int n)`
`static float`	`normL2Sqr_(FloatBuffer a, FloatBuffer b, int n)`
`static float`	`normL2Sqr_(FloatPointer a, FloatPointer b, int n)`
`static boolean`	`not(int val)`
`static MatExpr`	`not(Mat m)`
`static boolean`	`not(Range r)`
`static void`	`not8u(byte[] src1, long step1, byte[] src2, long step2, byte[] dst, long step, int width, int height, Pointer arg8)`
`static void`	`not8u(ByteBuffer src1, long step1, ByteBuffer src2, long step2, ByteBuffer dst, long step, int width, int height, Pointer arg8)`
`static void`	`not8u(BytePointer src1, long step1, BytePointer src2, long step2, BytePointer dst, long step, int width, int height, Pointer arg8)`
`static MatExpr`	`notEquals(double s, Mat a)`
`static boolean`	`notEquals(FileNodeIterator it1, FileNodeIterator it2)`
`static boolean`	`notEquals(int a, int b)`
`static MatExpr`	`notEquals(Mat a, double s)`
`static MatExpr`	`notEquals(Mat a, Mat b)`
`static boolean`	`notEquals(Range r1, Range r2)`
`static int`	`or(int a, int b)`
`static MatExpr`	`or(Mat a, Mat b)`
`static MatExpr`	`or(Mat a, Scalar s)`
`static MatExpr`	`or(Scalar s, Mat a)`
`static void`	`or8u(byte[] src1, long step1, byte[] src2, long step2, byte[] dst, long step, int width, int height, Pointer arg8)`
`static void`	`or8u(ByteBuffer src1, long step1, ByteBuffer src2, long step2, ByteBuffer dst, long step, int width, int height, Pointer arg8)`
`static void`	`or8u(BytePointer src1, long step1, BytePointer src2, long step2, BytePointer dst, long step, int width, int height, Pointer arg8)`
`static int[]`	`orPut(int[] _this, int val)`
`static IntBuffer`	`orPut(IntBuffer _this, int val)`
`static IntPointer`	`orPut(IntPointer _this, int val)`
`static Mat`	`orPut(Mat a, Mat b)`
`static Mat`	`orPut(Mat a, Scalar b)`
`static void`	`parallel_for_(Range range, opencv_core.Functor functor)`
`static void`	`parallel_for_(Range range, opencv_core.Functor functor, double nstripes)` \ingroup core_parallel
`static void`	`parallel_for_(Range range, ParallelLoopBody body)`
`static void`	`parallel_for_(Range range, ParallelLoopBody body, double nstripes)` \brief Parallel data processor
`static void`	`patchNaNs(GpuMat a)`
`static void`	`patchNaNs(GpuMat a, double val)`
`static void`	`patchNaNs(Mat a)`
`static void`	`patchNaNs(Mat a, double val)` \brief converts NaNs to the given number
`static void`	`patchNaNs(UMat a)`
`static void`	`patchNaNs(UMat a, double val)`
`static void`	`PCABackProject(GpuMat data, GpuMat mean, GpuMat eigenvectors, GpuMat result)`
`static void`	`PCABackProject(Mat data, Mat mean, Mat eigenvectors, Mat result)` wrap PCA::backProject
`static void`	`PCABackProject(UMat data, UMat mean, UMat eigenvectors, UMat result)`
`static void`	`PCACompute(GpuMat data, GpuMat mean, GpuMat eigenvectors)`
`static void`	`PCACompute(GpuMat data, GpuMat mean, GpuMat eigenvectors, double retainedVariance)`
`static void`	`PCACompute(GpuMat data, GpuMat mean, GpuMat eigenvectors, int maxComponents)`
`static void`	`PCACompute(Mat data, Mat mean, Mat eigenvectors)`
`static void`	`PCACompute(Mat data, Mat mean, Mat eigenvectors, double retainedVariance)` wrap PCA::operator()
`static void`	`PCACompute(Mat data, Mat mean, Mat eigenvectors, int maxComponents)` wrap PCA::operator()
`static void`	`PCACompute(UMat data, UMat mean, UMat eigenvectors)`
`static void`	`PCACompute(UMat data, UMat mean, UMat eigenvectors, double retainedVariance)`
`static void`	`PCACompute(UMat data, UMat mean, UMat eigenvectors, int maxComponents)`
`static void`	`PCACompute2(GpuMat data, GpuMat mean, GpuMat eigenvectors, GpuMat eigenvalues)`
`static void`	`PCACompute2(GpuMat data, GpuMat mean, GpuMat eigenvectors, GpuMat eigenvalues, double retainedVariance)`
`static void`	`PCACompute2(GpuMat data, GpuMat mean, GpuMat eigenvectors, GpuMat eigenvalues, int maxComponents)`
`static void`	`PCACompute2(Mat data, Mat mean, Mat eigenvectors, Mat eigenvalues)`
`static void`	`PCACompute2(Mat data, Mat mean, Mat eigenvectors, Mat eigenvalues, double retainedVariance)` wrap PCA::operator() and add eigenvalues output parameter
`static void`	`PCACompute2(Mat data, Mat mean, Mat eigenvectors, Mat eigenvalues, int maxComponents)` wrap PCA::operator() and add eigenvalues output parameter
`static void`	`PCACompute2(UMat data, UMat mean, UMat eigenvectors, UMat eigenvalues)`
`static void`	`PCACompute2(UMat data, UMat mean, UMat eigenvectors, UMat eigenvalues, double retainedVariance)`
`static void`	`PCACompute2(UMat data, UMat mean, UMat eigenvectors, UMat eigenvalues, int maxComponents)`
`static void`	`PCAProject(GpuMat data, GpuMat mean, GpuMat eigenvectors, GpuMat result)`
`static void`	`PCAProject(Mat data, Mat mean, Mat eigenvectors, Mat result)` wrap PCA::project
`static void`	`PCAProject(UMat data, UMat mean, UMat eigenvectors, UMat result)`
`static void`	`perspectiveTransform(GpuMat src, GpuMat dst, GpuMat m)`
`static void`	`perspectiveTransform(Mat src, Mat dst, Mat m)` \brief Performs the perspective matrix transformation of vectors.
`static void`	`perspectiveTransform(UMat src, UMat dst, UMat m)`
`static void`	`phase(GpuMat x, GpuMat y, GpuMat angle)`
`static void`	`phase(GpuMat x, GpuMat y, GpuMat angle, boolean angleInDegrees)`
`static void`	`phase(Mat x, Mat y, Mat angle)`
`static void`	`phase(Mat x, Mat y, Mat angle, boolean angleInDegrees)` \brief Calculates the rotation angle of 2D vectors.
`static void`	`phase(UMat x, UMat y, UMat angle)`
`static void`	`phase(UMat x, UMat y, UMat angle, boolean angleInDegrees)`
`static void`	`polarToCart(GpuMat magnitude, GpuMat angle, GpuMat x, GpuMat y)`
`static void`	`polarToCart(GpuMat magnitude, GpuMat angle, GpuMat x, GpuMat y, boolean angleInDegrees)`
`static void`	`polarToCart(Mat magnitude, Mat angle, Mat x, Mat y)`
`static void`	`polarToCart(Mat magnitude, Mat angle, Mat x, Mat y, boolean angleInDegrees)` \brief Calculates x and y coordinates of 2D vectors from their magnitude and angle.
`static void`	`polarToCart(UMat magnitude, UMat angle, UMat x, UMat y)`
`static void`	`polarToCart(UMat magnitude, UMat angle, UMat x, UMat y, boolean angleInDegrees)`
`static void`	`pow(GpuMat src, double power, GpuMat dst)`
`static void`	`pow(Mat src, double power, Mat dst)` \brief Raises every array element to a power.
`static void`	`pow(UMat src, double power, UMat dst)`
`static int`	`predictOptimalVectorWidth(GpuMat src1)`
`static int`	`predictOptimalVectorWidth(GpuMat src1, GpuMat src2, GpuMat src3, GpuMat src4, GpuMat src5, GpuMat src6, GpuMat src7, GpuMat src8, GpuMat src9, int strat)`
`static int`	`predictOptimalVectorWidth(Mat src1)`
`static int`	`predictOptimalVectorWidth(Mat src1, Mat src2, Mat src3, Mat src4, Mat src5, Mat src6, Mat src7, Mat src8, Mat src9, int strat)`
`static int`	`predictOptimalVectorWidth(UMat src1)`
`static int`	`predictOptimalVectorWidth(UMat src1, UMat src2, UMat src3, UMat src4, UMat src5, UMat src6, UMat src7, UMat src8, UMat src9, int strat)`
`static int`	`predictOptimalVectorWidthMax(GpuMat src1)`
`static int`	`predictOptimalVectorWidthMax(GpuMat src1, GpuMat src2, GpuMat src3, GpuMat src4, GpuMat src5, GpuMat src6, GpuMat src7, GpuMat src8, GpuMat src9)`
`static int`	`predictOptimalVectorWidthMax(Mat src1)`
`static int`	`predictOptimalVectorWidthMax(Mat src1, Mat src2, Mat src3, Mat src4, Mat src5, Mat src6, Mat src7, Mat src8, Mat src9)`
`static int`	`predictOptimalVectorWidthMax(UMat src1)`
`static int`	`predictOptimalVectorWidthMax(UMat src1, UMat src2, UMat src3, UMat src4, UMat src5, UMat src6, UMat src7, UMat src8, UMat src9)`
`static int`	`print(Formatted fmtd)`
`static int`	`print(Formatted fmtd, Pointer stream)`
`static int`	`print(Mat mtx)`
`static int`	`print(Mat mtx, Pointer stream)`
`static int`	`print(UMat mtx)`
`static int`	`print(UMat mtx, Pointer stream)`
`static void`	`printCudaDeviceInfo(int device)`
`static void`	`printShortCudaDeviceInfo(int device)`
`static double`	`PSNR(GpuMat src1, GpuMat src2)`
`static double`	`PSNR(GpuMat src1, GpuMat src2, double R)`
`static double`	`PSNR(Mat src1, Mat src2)`
`static double`	`PSNR(Mat src1, Mat src2, double R)` \brief Computes the Peak Signal-to-Noise Ratio (PSNR) image quality metric.
`static double`	`PSNR(UMat src1, UMat src2)`
`static double`	`PSNR(UMat src1, UMat src2, double R)`
`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(FloatPointer A, long astep, int m, int n, int k, FloatPointer b, long bstep, 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(DoublePointer A, long astep, int m, int n, int k, DoublePointer b, long bstep, DoublePointer hFactors)`
`static void`	`randn(GpuMat dst, GpuMat mean, GpuMat stddev)`
`static void`	`randn(Mat dst, Mat mean, Mat stddev)` \brief Fills the array with normally distributed random numbers.
`static void`	`randn(UMat dst, UMat mean, UMat stddev)`
`static void`	`randShuffle(GpuMat dst)`
`static void`	`randShuffle(GpuMat dst, double iterFactor, RNG rng)`
`static void`	`randShuffle(Mat dst)`
`static void`	`randShuffle(Mat dst, double iterFactor, RNG rng)` \brief Shuffles the array elements randomly.
`static void`	`randShuffle(UMat dst)`
`static void`	`randShuffle(UMat dst, double iterFactor, RNG rng)`
`static void`	`randu(GpuMat dst, GpuMat low, GpuMat high)`
`static void`	`randu(Mat dst, Mat low, Mat high)` \brief Generates a single uniformly-distributed random number or an array of random numbers.
`static void`	`randu(UMat dst, UMat low, UMat high)`
`static void`	`read(FileNode node, boolean[] value, boolean default_value)`
`static void`	`read(FileNode node, BoolPointer value, boolean default_value)` \} FileStorage
`static void`	`read(FileNode node, byte[] value, byte default_value)`
`static void`	`read(FileNode node, ByteBuffer value, byte default_value)`
`static void`	`read(FileNode node, BytePointer value, byte default_value)`
`static void`	`read(FileNode node, BytePointer value, BytePointer default_value)`
`static void`	`read(FileNode node, BytePointer value, String default_value)`
`static void`	`read(FileNode node, DMatch value, DMatch default_value)`
`static void`	`read(FileNode node, DMatchVector matches)`
`static void`	`read(FileNode node, DMatchVector vec, DMatchVector default_value)`
`static void`	`read(FileNode node, double[] value, double default_value)`
`static void`	`read(FileNode node, DoubleBuffer value, double default_value)`
`static void`	`read(FileNode node, DoublePointer value, double default_value)`
`static void`	`read(FileNode node, float[] value, float default_value)`
`static void`	`read(FileNode node, FloatBuffer value, float default_value)`
`static void`	`read(FileNode node, FloatPointer value, float default_value)`
`static void`	`read(FileNode node, int[] value, int default_value)`
`static void`	`read(FileNode node, IntBuffer value, int default_value)`
`static void`	`read(FileNode node, IntPointer value, int default_value)` \}
`static void`	`read(FileNode node, KeyPoint value, KeyPoint default_value)`
`static void`	`read(FileNode node, KeyPointVector keypoints)`
`static void`	`read(FileNode node, KeyPointVector vec, KeyPointVector default_value)`
`static void`	`read(FileNode node, Mat mat)`
`static void`	`read(FileNode node, Mat mat, Mat default_mat)`
`static void`	`read(FileNode node, Range value, Range default_value)`
`static void`	`read(FileNode node, short[] value, short default_value)`
`static void`	`read(FileNode node, ShortBuffer value, short default_value)`
`static void`	`read(FileNode node, ShortPointer value, short default_value)`
`static void`	`read(FileNode node, SparseMat mat)`
`static void`	`read(FileNode node, SparseMat mat, SparseMat default_mat)`
`static void`	`recip16s(short[] arg0, long arg1, short[] src2, long step2, short[] dst, long step, int width, int height, Pointer scale)`
`static void`	`recip16s(ShortBuffer arg0, long arg1, ShortBuffer src2, long step2, ShortBuffer dst, long step, int width, int height, Pointer scale)`
`static void`	`recip16s(ShortPointer arg0, long arg1, ShortPointer src2, long step2, ShortPointer dst, long step, int width, int height, Pointer scale)`
`static void`	`recip16u(short[] arg0, long arg1, short[] src2, long step2, short[] dst, long step, int width, int height, Pointer scale)`
`static void`	`recip16u(ShortBuffer arg0, long arg1, ShortBuffer src2, long step2, ShortBuffer dst, long step, int width, int height, Pointer scale)`
`static void`	`recip16u(ShortPointer arg0, long arg1, ShortPointer src2, long step2, ShortPointer dst, long step, int width, int height, Pointer scale)`
`static void`	`recip32f(float[] arg0, long arg1, float[] src2, long step2, float[] dst, long step, int width, int height, Pointer scale)`
`static void`	`recip32f(FloatBuffer arg0, long arg1, FloatBuffer src2, long step2, FloatBuffer dst, long step, int width, int height, Pointer scale)`
`static void`	`recip32f(FloatPointer arg0, long arg1, FloatPointer src2, long step2, FloatPointer dst, long step, int width, int height, Pointer scale)`
`static void`	`recip32s(int[] arg0, long arg1, int[] src2, long step2, int[] dst, long step, int width, int height, Pointer scale)`
`static void`	`recip32s(IntBuffer arg0, long arg1, IntBuffer src2, long step2, IntBuffer dst, long step, int width, int height, Pointer scale)`
`static void`	`recip32s(IntPointer arg0, long arg1, IntPointer src2, long step2, IntPointer dst, long step, int width, int height, Pointer scale)`
`static void`	`recip64f(double[] arg0, long arg1, double[] src2, long step2, double[] dst, long step, int width, int height, Pointer scale)`
`static void`	`recip64f(DoubleBuffer arg0, long arg1, DoubleBuffer src2, long step2, DoubleBuffer dst, long step, int width, int height, Pointer scale)`
`static void`	`recip64f(DoublePointer arg0, long arg1, DoublePointer src2, long step2, DoublePointer dst, long step, int width, int height, Pointer scale)`
`static void`	`recip8s(byte[] arg0, long arg1, byte[] src2, long step2, byte[] dst, long step, int width, int height, Pointer scale)`
`static void`	`recip8s(ByteBuffer arg0, long arg1, ByteBuffer src2, long step2, ByteBuffer dst, long step, int width, int height, Pointer scale)`
`static void`	`recip8s(BytePointer arg0, long arg1, BytePointer src2, long step2, BytePointer dst, long step, int width, int height, Pointer scale)`
`static void`	`recip8u(byte[] arg0, long arg1, byte[] src2, long step2, byte[] dst, long step, int width, int height, Pointer scale)`
`static void`	`recip8u(ByteBuffer arg0, long arg1, ByteBuffer src2, long step2, ByteBuffer dst, long step, int width, int height, Pointer scale)`
`static void`	`recip8u(BytePointer arg0, long arg1, BytePointer src2, long step2, BytePointer dst, long step, int width, int height, Pointer scale)`
`static ErrorCallback`	`redirectError(ErrorCallback errCallback)`
`static ErrorCallback`	`redirectError(ErrorCallback errCallback, Pointer userdata, Pointer prevUserdata)`
`static ErrorCallback`	`redirectError(ErrorCallback errCallback, Pointer userdata, PointerPointer prevUserdata)` \brief Sets the new error handler and the optional user data.
`static void`	`reduce(GpuMat src, GpuMat dst, int dim, int rtype)`
`static void`	`reduce(GpuMat src, GpuMat dst, int dim, int rtype, int dtype)`
`static void`	`reduce(Mat src, Mat dst, int dim, int rtype)`
`static void`	`reduce(Mat src, Mat dst, int dim, int rtype, int dtype)` \brief Reduces a matrix to a vector.
`static void`	`reduce(UMat src, UMat dst, int dim, int rtype)`
`static void`	`reduce(UMat src, UMat dst, int dim, int rtype, int dtype)`
`static void`	`reduceArgMax(GpuMat src, GpuMat dst, int axis)`
`static void`	`reduceArgMax(GpuMat src, GpuMat dst, int axis, boolean lastIndex)`
`static void`	`reduceArgMax(Mat src, Mat dst, int axis)`
`static void`	`reduceArgMax(Mat src, Mat dst, int axis, boolean lastIndex)` \brief Finds indices of max elements along provided axis \note - If input or output array is not continuous, this function will create an internal copy.
`static void`	`reduceArgMax(UMat src, UMat dst, int axis)`
`static void`	`reduceArgMax(UMat src, UMat dst, int axis, boolean lastIndex)`
`static void`	`reduceArgMin(GpuMat src, GpuMat dst, int axis)`
`static void`	`reduceArgMin(GpuMat src, GpuMat dst, int axis, boolean lastIndex)`
`static void`	`reduceArgMin(Mat src, Mat dst, int axis)`
`static void`	`reduceArgMin(Mat src, Mat dst, int axis, boolean lastIndex)` \brief Finds indices of min elements along provided axis \note - If input or output array is not continuous, this function will create an internal copy.
`static void`	`reduceArgMin(UMat src, UMat dst, int axis)`
`static void`	`reduceArgMin(UMat src, UMat dst, int axis, boolean lastIndex)`
`static void`	`registerPageLocked(Mat m)` \brief Page-locks the memory of matrix and maps it for the device(s).
`static void`	`repeat(GpuMat src, int ny, int nx, GpuMat dst)`
`static Mat`	`repeat(Mat src, int ny, int nx)` \overload
`static void`	`repeat(Mat src, int ny, int nx, Mat dst)` \brief Fills the output array with repeated copies of the input array.
`static void`	`repeat(UMat src, int ny, int nx, 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(GpuMat src, GpuMat dst, int rotateCode)`
`static void`	`rotate(Mat src, Mat dst, int rotateCode)` \brief Rotates a 2D array in multiples of 90 degrees.
`static void`	`rotate(UMat src, UMat dst, int rotateCode)`
`static int`	`roundUp(int a, int b)` \brief Round first value up to the nearest multiple of second value.
`static long`	`roundUp(long a, int b)` \overload
`static void`	`scaleAdd(GpuMat src1, double alpha, GpuMat src2, GpuMat dst)`
`static void`	`scaleAdd(Mat src1, double alpha, Mat src2, Mat dst)` \brief Calculates the sum of a scaled array and another array.
`static void`	`scaleAdd(UMat src1, double alpha, UMat src2, UMat dst)`
`static byte`	`scharSaturateCast(byte v)`
`static byte`	`scharSaturateCast(double v)`
`static byte`	`scharSaturateCast(float v)`
`static byte`	`scharSaturateCast(float16_t v)`
`static byte`	`scharSaturateCast(int v)`
`static byte`	`scharSaturateCast(long v)`
`static byte`	`scharSaturateCast(short v)`
`static void`	`seqInsertSlice(CvSeq seq, int before_index, CvArr from_arr)`
`static void`	`seqPop(CvSeq seq)`
`static void`	`seqPop(CvSeq seq, Pointer element)`
`static void`	`seqPopFront(CvSeq seq)`
`static void`	`seqPopFront(CvSeq seq, Pointer element)`
`static BytePointer`	`seqPush(CvSeq seq)`
`static BytePointer`	`seqPush(CvSeq seq, Pointer element)` STL-style Sequence Iterator inherited from the CvSeqReader structure
`static BytePointer`	`seqPushFront(CvSeq seq)`
`static BytePointer`	`seqPushFront(CvSeq seq, Pointer element)`
`static void`	`seqRemove(CvSeq seq, int index)`
`static void`	`seqRemoveSlice(CvSeq seq, 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(GpuMat mtx)`
`static void`	`setIdentity(GpuMat mtx, Scalar s)`
`static void`	`setIdentity(Mat mtx)`
`static void`	`setIdentity(Mat mtx, Scalar s)` \brief Initializes a scaled identity matrix.
`static void`	`setIdentity(UMat mtx)`
`static void`	`setIdentity(UMat mtx, Scalar s)`
`static void`	`setIppStatus(int status)`
`static void`	`setIppStatus(int status, BytePointer funcname, 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_NotExact(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 BytePointer`	`shiftLeft(BytePointer out, Formatted fmtd)`
`static BytePointer`	`shiftLeft(BytePointer out, Mat mtx)`
`static FileStorage`	`shiftLeft(FileStorage fs, byte[] value)`
`static FileStorage`	`shiftLeft(FileStorage fs, ByteBuffer value)` \brief Writes data to a file storage.
`static FileStorage`	`shiftLeft(FileStorage fs, BytePointer str)` \}
`static FileStorage`	`shiftLeft(FileStorage fs, String str)`
`static Pointer`	`shiftLeft(Pointer out, TickMeter tm)` \brief output operator
`static String`	`shiftLeft(String out, Formatted fmtd)`
`static String`	`shiftLeft(String out, Mat mtx)`
`static void`	`shiftRight(FileNode n, DMatch m)` \brief Reads DMatch from a file storage.
`static void`	`shiftRight(FileNode n, DMatchVector vec)`
`static void`	`shiftRight(FileNode n, KeyPoint kpt)` \brief Reads KeyPoint from a file storage.
`static void`	`shiftRight(FileNode n, KeyPointVector vec)`
`static short`	`shortSaturateCast(byte v)`
`static short`	`shortSaturateCast(double v)`
`static short`	`shortSaturateCast(float v)`
`static short`	`shortSaturateCast(float16_t v)`
`static short`	`shortSaturateCast(int v)`
`static short`	`shortSaturateCast(long v)`
`static short`	`shortSaturateCast(short v)`
`static boolean`	`solve(GpuMat src1, GpuMat src2, GpuMat dst)`
`static boolean`	`solve(GpuMat src1, GpuMat src2, GpuMat dst, int flags)`
`static boolean`	`solve(Mat src1, Mat src2, Mat dst)`
`static boolean`	`solve(Mat src1, Mat src2, Mat dst, int flags)` \brief Solves one or more linear systems or least-squares problems.
`static boolean`	`solve(UMat src1, UMat src2, UMat dst)`
`static boolean`	`solve(UMat src1, UMat src2, UMat dst, int flags)`
`static int`	`solveCubic(GpuMat coeffs, GpuMat roots)`
`static int`	`solveCubic(Mat coeffs, Mat roots)` \brief Finds the real roots of a cubic equation.
`static int`	`solveCubic(UMat coeffs, UMat roots)`
`static int`	`solveLP(GpuMat Func, GpuMat Constr, GpuMat z)`
`static int`	`solveLP(Mat Func, Mat Constr, Mat z)` \brief Solve given (non-integer) linear programming problem using the Simplex Algorithm (Simplex Method).
`static int`	`solveLP(UMat Func, UMat Constr, UMat z)`
`static double`	`solvePoly(GpuMat coeffs, GpuMat roots)`
`static double`	`solvePoly(GpuMat coeffs, GpuMat roots, int maxIters)`
`static double`	`solvePoly(Mat coeffs, Mat roots)`
`static double`	`solvePoly(Mat coeffs, Mat roots, int maxIters)` \brief Finds the real or complex roots of a polynomial equation.
`static double`	`solvePoly(UMat coeffs, UMat roots)`
`static double`	`solvePoly(UMat coeffs, UMat roots, int maxIters)`
`static void`	`sort(GpuMat src, GpuMat dst, int flags)`
`static void`	`sort(Mat src, Mat dst, int flags)` \brief Sorts each row or each column of a matrix.
`static void`	`sort(UMat src, UMat dst, int flags)`
`static void`	`sortIdx(GpuMat src, GpuMat dst, int flags)`
`static void`	`sortIdx(Mat src, Mat dst, int flags)` \brief Sorts each row or each column of a matrix.
`static void`	`sortIdx(UMat src, UMat dst, int flags)`
`static void`	`split(GpuMat m, GpuMatVector mv)`
`static void`	`split(GpuMat m, MatVector mv)`
`static void`	`split(GpuMat m, UMatVector mv)`
`static void`	`split(Mat m, GpuMatVector mv)`
`static void`	`split(Mat src, Mat mvbegin)` \brief Divides a multi-channel array into several single-channel arrays.
`static void`	`split(Mat m, MatVector mv)` \overload
`static void`	`split(Mat m, UMatVector mv)`
`static void`	`split(UMat m, GpuMatVector mv)`
`static void`	`split(UMat m, MatVector mv)`
`static void`	`split(UMat m, 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(ShortPointer src, PointerPointer dst, int len, int cn)`
`static void`	`split16u(ShortPointer src, 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(IntPointer src, IntPointer dst, int len, int cn)`
`static void`	`split32s(IntPointer src, 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(LongPointer src, LongPointer dst, int len, int cn)`
`static void`	`split64s(LongPointer src, 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(BytePointer src, BytePointer dst, int len, int cn)`
`static void`	`split8u(BytePointer src, 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(DoublePointer src, 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(FloatPointer src, FloatPointer dst, int len)`
`static void`	`sqrt(GpuMat src, GpuMat dst)`
`static void`	`sqrt(Mat src, Mat dst)` \brief Calculates a square root of array elements.
`static void`	`sqrt(UMat src, UMat dst)`
`static void`	`sqrt32f(float[] src, float[] dst, int len)`
`static void`	`sqrt32f(FloatBuffer src, FloatBuffer dst, int len)`
`static void`	`sqrt32f(FloatPointer src, 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(DoublePointer src, DoublePointer dst, int len)`
`static void`	`sub16s(short[] src1, long step1, short[] src2, long step2, short[] dst, long step, int width, int height, Pointer arg8)`
`static void`	`sub16s(ShortBuffer src1, long step1, ShortBuffer src2, long step2, ShortBuffer dst, long step, int width, int height, Pointer arg8)`
`static void`	`sub16s(ShortPointer src1, long step1, ShortPointer src2, long step2, ShortPointer dst, long step, int width, int height, Pointer arg8)`
`static void`	`sub16u(short[] src1, long step1, short[] src2, long step2, short[] dst, long step, int width, int height, Pointer arg8)`
`static void`	`sub16u(ShortBuffer src1, long step1, ShortBuffer src2, long step2, ShortBuffer dst, long step, int width, int height, Pointer arg8)`
`static void`	`sub16u(ShortPointer src1, long step1, ShortPointer src2, long step2, ShortPointer dst, long step, int width, int height, Pointer arg8)`
`static void`	`sub32f(float[] src1, long step1, float[] src2, long step2, float[] dst, long step, int width, int height, Pointer arg8)`
`static void`	`sub32f(FloatBuffer src1, long step1, FloatBuffer src2, long step2, FloatBuffer dst, long step, int width, int height, Pointer arg8)`
`static void`	`sub32f(FloatPointer src1, long step1, FloatPointer src2, long step2, FloatPointer dst, long step, int width, int height, Pointer arg8)`
`static void`	`sub32s(int[] src1, long step1, int[] src2, long step2, int[] dst, long step, int width, int height, Pointer arg8)`
`static void`	`sub32s(IntBuffer src1, long step1, IntBuffer src2, long step2, IntBuffer dst, long step, int width, int height, Pointer arg8)`
`static void`	`sub32s(IntPointer src1, long step1, IntPointer src2, long step2, IntPointer dst, long step, int width, int height, Pointer arg8)`
`static void`	`sub64f(double[] src1, long step1, double[] src2, long step2, double[] dst, long step, int width, int height, Pointer arg8)`
`static void`	`sub64f(DoubleBuffer src1, long step1, DoubleBuffer src2, long step2, DoubleBuffer dst, long step, int width, int height, Pointer arg8)`
`static void`	`sub64f(DoublePointer src1, long step1, DoublePointer src2, long step2, DoublePointer dst, long step, int width, int height, Pointer arg8)`
`static void`	`sub8s(byte[] src1, long step1, byte[] src2, long step2, byte[] dst, long step, int width, int height, Pointer arg8)`
`static void`	`sub8s(ByteBuffer src1, long step1, ByteBuffer src2, long step2, ByteBuffer dst, long step, int width, int height, Pointer arg8)`
`static void`	`sub8s(BytePointer src1, long step1, BytePointer src2, long step2, BytePointer dst, long step, int width, int height, Pointer arg8)`
`static void`	`sub8u(byte[] src1, long step1, byte[] src2, long step2, byte[] dst, long step, int width, int height, Pointer arg8)`
`static void`	`sub8u(ByteBuffer src1, long step1, ByteBuffer src2, long step2, ByteBuffer dst, long step, int width, int height, Pointer arg8)`
`static void`	`sub8u(BytePointer src1, long step1, BytePointer src2, long step2, BytePointer dst, long step, int width, int height, Pointer arg8)`
`static long`	`subtract(FileNodeIterator it1, FileNodeIterator it2)`
`static void`	`subtract(GpuMat src1, GpuMat src2, GpuMat dst)`
`static void`	`subtract(GpuMat src1, GpuMat src2, GpuMat dst, GpuMat mask, int dtype)`
`static MatExpr`	`subtract(Mat m)`
`static MatExpr`	`subtract(MatExpr e)`
`static MatExpr`	`subtract(MatExpr e, Mat m)`
`static MatExpr`	`subtract(MatExpr e1, MatExpr e2)`
`static MatExpr`	`subtract(MatExpr e, Scalar s)`
`static MatExpr`	`subtract(Mat a, Mat b)`
`static MatExpr`	`subtract(Mat m, MatExpr e)`
`static void`	`subtract(Mat src1, Mat src2, Mat dst)`
`static void`	`subtract(Mat src1, Mat src2, Mat dst, Mat mask, int dtype)` \brief Calculates the per-element difference between two arrays or array and a scalar.
`static MatExpr`	`subtract(Mat a, Scalar s)`
`static Range`	`subtract(Range r1, int delta)`
`static MatExpr`	`subtract(Scalar s, Mat a)`
`static MatExpr`	`subtract(Scalar s, MatExpr e)`
`static void`	`subtract(UMat src1, UMat src2, UMat dst)`
`static void`	`subtract(UMat src1, UMat src2, UMat dst, UMat mask, int dtype)`
`static Mat`	`subtractPut(Mat a, Mat b)`
`static Mat`	`subtractPut(Mat a, Scalar b)`
`static Scalar`	`sumElems(GpuMat src)`
`static Scalar`	`sumElems(Mat src)` \brief Calculates the sum of array elements.
`static Scalar`	`sumElems(UMat src)`
`static void`	`SVBackSubst(GpuMat w, GpuMat u, GpuMat vt, GpuMat rhs, GpuMat dst)`
`static void`	`SVBackSubst(Mat w, Mat u, Mat vt, Mat rhs, Mat dst)` wrap SVD::backSubst
`static void`	`SVBackSubst(UMat w, UMat u, UMat vt, UMat rhs, 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(FloatPointer At, long astep, FloatPointer W, FloatPointer U, long ustep, 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(DoublePointer At, long astep, DoublePointer W, DoublePointer U, long ustep, DoublePointer Vt, long vstep, int m, int n, int flags)`
`static void`	`SVDecomp(GpuMat src, GpuMat w, GpuMat u, GpuMat vt)`
`static void`	`SVDecomp(GpuMat src, GpuMat w, GpuMat u, GpuMat vt, int flags)`
`static void`	`SVDecomp(Mat src, Mat w, Mat u, Mat vt)`
`static void`	`SVDecomp(Mat src, Mat w, Mat u, Mat vt, int flags)` wrap SVD::compute
`static void`	`SVDecomp(UMat src, UMat w, UMat u, UMat vt)`
`static void`	`SVDecomp(UMat src, UMat w, UMat u, UMat vt, int flags)`
`static void`	`swap(Mat a, Mat b)` \} core_array
`static void`	`swap(UMat a, UMat b)` \overload
`static BytePointer`	`tempfile()`
`static BytePointer`	`tempfile(BytePointer suffix)`
`static String`	`tempfile(String suffix)`
`static RNG`	`theRNG()` \brief Returns the default random number generator.
`static BytePointer`	`toLowerCase(BytePointer str)` \endcond
`static String`	`toLowerCase(String str)`
`static BytePointer`	`toUpperCase(BytePointer str)`
`static String`	`toUpperCase(String str)`
`static Scalar`	`trace(GpuMat mtx)`
`static Scalar`	`trace(Mat mtx)` \brief Returns the trace of a matrix.
`static Scalar`	`trace(UMat mtx)`
`static void`	`transform(GpuMat src, GpuMat dst, GpuMat m)`
`static void`	`transform(Mat src, Mat dst, Mat m)` \brief Performs the matrix transformation of every array element.
`static void`	`transform(UMat src, UMat dst, UMat m)`
`static void`	`transpose(GpuMat src, GpuMat dst)`
`static void`	`transpose(Mat src, Mat dst)` \brief Transposes a matrix.
`static void`	`transpose(UMat src, UMat dst)`
`static 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(float16_t 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(float16_t v)`
`static int`	`uint64SaturateCast(int v)`
`static int`	`uint64SaturateCast(long v)`
`static int`	`uint64SaturateCast(short v)`
`static void`	`unregisterPageLocked(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(float16_t 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_NotExact()`
`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(float16_t v)`
`static short`	`ushortSaturateCast(int v)`
`static short`	`ushortSaturateCast(long v)`
`static short`	`ushortSaturateCast(short v)`
`static void`	`vconcat(GpuMat src1, GpuMat src2, GpuMat dst)`
`static void`	`vconcat(GpuMatVector src, GpuMat dst)`
`static void`	`vconcat(GpuMatVector src, Mat dst)`
`static void`	`vconcat(GpuMatVector src, UMat dst)`
`static void`	`vconcat(Mat src, long nsrc, GpuMat dst)`
`static void`	`vconcat(Mat src, long nsrc, Mat dst)` \brief Applies vertical concatenation to given matrices.
`static void`	`vconcat(Mat src, long nsrc, UMat dst)`
`static void`	`vconcat(Mat src1, Mat src2, Mat dst)` \overload
`static void`	`vconcat(MatVector src, GpuMat dst)`
`static void`	`vconcat(MatVector src, Mat dst)` \overload
`static void`	`vconcat(MatVector src, UMat dst)`
`static void`	`vconcat(UMat src1, UMat src2, UMat dst)`
`static void`	`vconcat(UMatVector src, GpuMat dst)`
`static void`	`vconcat(UMatVector src, Mat dst)`
`static void`	`vconcat(UMatVector src, UMat dst)`
`static BytePointer`	`vecopTypeToStr(int t)`
`static void`	`write(FileStorage fs, BytePointer value)`
`static void`	`write(FileStorage fs, BytePointer name, BytePointer value)`
`static void`	`write(FileStorage fs, BytePointer name, DMatch m)`
`static void`	`write(FileStorage fs, BytePointer name, DMatchVector value)`
`static void`	`write(FileStorage fs, BytePointer name, double value)`
`static void`	`write(FileStorage fs, BytePointer name, float value)`
`static void`	`write(FileStorage fs, BytePointer name, int value)` \} core_xml
`static void`	`write(FileStorage fs, BytePointer name, KeyPoint kpt)`
`static void`	`write(FileStorage fs, BytePointer name, KeyPointVector value)`
`static void`	`write(FileStorage fs, BytePointer name, Mat value)`
`static void`	`write(FileStorage fs, BytePointer name, Range r)`
`static void`	`write(FileStorage fs, BytePointer name, SparseMat value)`
`static void`	`write(FileStorage fs, DMatch m)`
`static void`	`write(FileStorage fs, DMatchVector vec)`
`static void`	`write(FileStorage fs, double value)`
`static void`	`write(FileStorage fs, float value)`
`static void`	`write(FileStorage fs, int value)` \endcond
`static void`	`write(FileStorage fs, KeyPoint kpt)`
`static void`	`write(FileStorage fs, KeyPointVector vec)`
`static void`	`write(FileStorage fs, Range r)`
`static void`	`write(FileStorage fs, String value)`
`static void`	`write(FileStorage fs, String name, DMatch m)`
`static void`	`write(FileStorage fs, String name, DMatchVector value)`
`static void`	`write(FileStorage fs, String name, double value)`
`static void`	`write(FileStorage fs, String name, float value)`
`static void`	`write(FileStorage fs, String name, int value)`
`static void`	`write(FileStorage fs, String name, KeyPoint kpt)`
`static void`	`write(FileStorage fs, String name, KeyPointVector value)`
`static void`	`write(FileStorage fs, String name, Mat value)`
`static void`	`write(FileStorage fs, String name, Range r)`
`static void`	`write(FileStorage fs, String name, SparseMat value)`
`static void`	`write(FileStorage fs, String name, String value)`
`static void`	`writeScalar(FileStorage fs, BytePointer value)`
`static void`	`writeScalar(FileStorage fs, double value)`
`static void`	`writeScalar(FileStorage fs, float value)`
`static void`	`writeScalar(FileStorage fs, int value)`
`static void`	`writeScalar(FileStorage fs, String value)`
`static int`	`xor(int a, int b)`
`static MatExpr`	`xor(Mat a, Mat b)`
`static MatExpr`	`xor(Mat a, Scalar s)`
`static MatExpr`	`xor(Scalar s, Mat a)`
`static void`	`xor8u(byte[] src1, long step1, byte[] src2, long step2, byte[] dst, long step, int width, int height, Pointer arg8)`
`static void`	`xor8u(ByteBuffer src1, long step1, ByteBuffer src2, long step2, ByteBuffer dst, long step, int width, int height, Pointer arg8)`
`static void`	`xor8u(BytePointer src1, long step1, BytePointer src2, long step2, BytePointer dst, long step, int width, int height, Pointer arg8)`
`static int[]`	`xorPut(int[] _this, int val)`
`static IntBuffer`	`xorPut(IntBuffer _this, int val)`
`static IntPointer`	`xorPut(IntPointer _this, int val)`
`static Mat`	`xorPut(Mat a, Mat b)`
`static Mat`	`xorPut(Mat a, Scalar b)`

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

Methods inherited from class org.bytedeco.opencv.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_16F
```
public static final int CV_16F
```
  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_16FC1
```
public static final int CV_16FC1
```
- CV_16FC2
```
public static final int CV_16FC2
```
- CV_16FC3
```
public static final int CV_16FC3
```
- CV_16FC4
```
public static final int CV_16FC4
```
- CV_HAL_CMP_EQ
```
public static final int CV_HAL_CMP_EQ
```
  \}
  \name Comparison operation
  
  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
  
  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
```
  \endcond
  
  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_AVX_512VBMI2
```
public static final int CV_CPU_AVX_512VBMI2
```
  See Also:
  
  Constant Field Values
- CV_CPU_AVX_512VNNI
```
public static final int CV_CPU_AVX_512VNNI
```
  See Also:
  
  Constant Field Values
- CV_CPU_AVX_512BITALG
```
public static final int CV_CPU_AVX_512BITALG
```
  See Also:
  
  Constant Field Values
- CV_CPU_AVX_512VPOPCNTDQ
```
public static final int CV_CPU_AVX_512VPOPCNTDQ
```
  See Also:
  
  Constant Field Values
- CV_CPU_AVX_5124VNNIW
```
public static final int CV_CPU_AVX_5124VNNIW
```
  See Also:
  
  Constant Field Values
- CV_CPU_AVX_5124FMAPS
```
public static final int CV_CPU_AVX_5124FMAPS
```
  See Also:
  
  Constant Field Values
- CV_CPU_NEON
```
public static final int CV_CPU_NEON
```
  See Also:
  
  Constant Field Values
- CV_CPU_MSA
```
public static final int CV_CPU_MSA
```
  See Also:
  
  Constant Field Values
- CV_CPU_RISCVV
```
public static final int CV_CPU_RISCVV
```
  See Also:
  
  Constant Field Values
- CV_CPU_VSX
```
public static final int CV_CPU_VSX
```
  See Also:
  
  Constant Field Values
- CV_CPU_VSX3
```
public static final int CV_CPU_VSX3
```
  See Also:
  
  Constant Field Values
- CV_CPU_RVV
```
public static final int CV_CPU_RVV
```
  See Also:
  
  Constant Field Values
- CV_CPU_AVX512_SKX
```
public static final int CV_CPU_AVX512_SKX
```
  See Also:
  
  Constant Field Values
- CV_CPU_AVX512_COMMON
```
public static final int CV_CPU_AVX512_COMMON
```
  See Also:
  
  Constant Field Values
- CV_CPU_AVX512_KNL
```
public static final int CV_CPU_AVX512_KNL
```
  See Also:
  
  Constant Field Values
- CV_CPU_AVX512_KNM
```
public static final int CV_CPU_AVX512_KNM
```
  See Also:
  
  Constant Field Values
- CV_CPU_AVX512_CNL
```
public static final int CV_CPU_AVX512_CNL
```
  See Also:
  
  Constant Field Values
- CV_CPU_AVX512_CLX
```
public static final int CV_CPU_AVX512_CLX
```
  See Also:
  
  Constant Field Values
- CV_CPU_AVX512_ICL
```
public static final int CV_CPU_AVX512_ICL
```
  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_AVX_512VBMI2
```
public static final int CPU_AVX_512VBMI2
```
  enum CpuFeatures
  
  See Also:
  
  Constant Field Values
- CPU_AVX_512VNNI
```
public static final int CPU_AVX_512VNNI
```
  enum CpuFeatures
  
  See Also:
  
  Constant Field Values
- CPU_AVX_512BITALG
```
public static final int CPU_AVX_512BITALG
```
  enum CpuFeatures
  
  See Also:
  
  Constant Field Values
- CPU_AVX_512VPOPCNTDQ
```
public static final int CPU_AVX_512VPOPCNTDQ
```
  enum CpuFeatures
  
  See Also:
  
  Constant Field Values
- CPU_AVX_5124VNNIW
```
public static final int CPU_AVX_5124VNNIW
```
  enum CpuFeatures
  
  See Also:
  
  Constant Field Values
- CPU_AVX_5124FMAPS
```
public static final int CPU_AVX_5124FMAPS
```
  enum CpuFeatures
  
  See Also:
  
  Constant Field Values
- CPU_NEON
```
public static final int CPU_NEON
```
  enum CpuFeatures
  
  See Also:
  
  Constant Field Values
- CPU_MSA
```
public static final int CPU_MSA
```
  enum CpuFeatures
  
  See Also:
  
  Constant Field Values
- CPU_RISCVV
```
public static final int CPU_RISCVV
```
  enum CpuFeatures
  
  See Also:
  
  Constant Field Values
- CPU_VSX
```
public static final int CPU_VSX
```
  enum CpuFeatures
  
  See Also:
  
  Constant Field Values
- CPU_VSX3
```
public static final int CPU_VSX3
```
  enum CpuFeatures
  
  See Also:
  
  Constant Field Values
- CPU_RVV
```
public static final int CPU_RVV
```
  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_AVX512_COMMON
```
public static final int CPU_AVX512_COMMON
```
  enum CpuFeatures
  
  See Also:
  
  Constant Field Values
- CPU_AVX512_KNL
```
public static final int CPU_AVX512_KNL
```
  enum CpuFeatures
  
  See Also:
  
  Constant Field Values
- CPU_AVX512_KNM
```
public static final int CPU_AVX512_KNM
```
  enum CpuFeatures
  
  See Also:
  
  Constant Field Values
- CPU_AVX512_CNL
```
public static final int CPU_AVX512_CNL
```
  enum CpuFeatures
  
  See Also:
  
  Constant Field Values
- CPU_AVX512_CLX
```
public static final int CPU_AVX512_CLX
```
  enum CpuFeatures
  
  See Also:
  
  Constant Field Values
- CPU_AVX512_ICL
```
public static final int CPU_AVX512_ICL
```
  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_STRONG_ALIGNMENT
```
public static final int CV_STRONG_ALIGNMENT
```
  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++ 11 * \
  
  See Also:
  
  Constant Field Values
- CV_CXX_STD_ARRAY
```
public static final int CV_CXX_STD_ARRAY
```
  See Also:
  
  Constant Field Values
- OPENCV_USE_FASTMATH_BUILTINS
```
public static final int OPENCV_USE_FASTMATH_BUILTINS
```
  \addtogroup core_utils \{
  /****************************************************************************************\ fast math * \
  
  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_STRUCT_INITIALIZER
```
public static final int CV_STRUCT_INITIALIZER
```
- 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 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 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
```
  Pointer to the first sequence block.
  
  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
```
  \brief Set Order is not preserved. There can be gaps between sequence elements. After the element has been inserted it stays in the same place all the time. The MSB(most-significant or sign bit) of the first field (flags) is 0 iff the element exists.
  
  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
```
  Graph is "derived" from the set (this is set a of vertices) and includes another set (edges)
  
  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
```
- CV_SEQ_ELTYPE_PPOINT
```
public static final int CV_SEQ_ELTYPE_PPOINT
```
- 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_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
- 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
- INT
```
public static final int INT
```
  enum struct cv::Param
  
  See Also:
  
  Constant Field Values
- BOOLEAN
```
public static final int BOOLEAN
```
  enum struct cv::Param
  
  See Also:
  
  Constant Field Values
- REAL
```
public static final int REAL
```
  enum struct cv::Param
  
  See Also:
  
  Constant Field Values
- STRING
```
public static final int STRING
```
  enum struct cv::Param
  
  See Also:
  
  Constant Field Values
- MAT
```
public static final int MAT
```
  enum struct cv::Param
  
  See Also:
  
  Constant Field Values
- MAT_VECTOR
```
public static final int MAT_VECTOR
```
  enum struct cv::Param
  
  See Also:
  
  Constant Field Values
- ALGORITHM
```
public static final int ALGORITHM
```
  enum struct cv::Param
  
  See Also:
  
  Constant Field Values
- FLOAT
```
public static final int FLOAT
```
  enum struct cv::Param
  
  See Also:
  
  Constant Field Values
- UNSIGNED_INT
```
public static final int UNSIGNED_INT
```
  enum struct cv::Param
  
  See Also:
  
  Constant Field Values
- UINT64
```
public static final int UINT64
```
  enum struct cv::Param
  
  See Also:
  
  Constant Field Values
- UCHAR
```
public static final int UCHAR
```
  enum struct cv::Param
  
  See Also:
  
  Constant Field Values
- SCALAR
```
public static final int SCALAR
```
  enum struct cv::Param
  
  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::AccessFlag
  
  See Also:
  
  Constant Field Values
- ACCESS_WRITE
```
public static final int ACCESS_WRITE
```
  enum cv::AccessFlag
  
  See Also:
  
  Constant Field Values
- ACCESS_RW
```
public static final int ACCESS_RW
```
  enum cv::AccessFlag
  
  See Also:
  
  Constant Field Values
- ACCESS_MASK
```
public static final int ACCESS_MASK
```
  enum cv::AccessFlag
  
  See Also:
  
  Constant Field Values
- ACCESS_FAST
```
public static final int ACCESS_FAST
```
  enum cv::AccessFlag
  
  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_16FC1

@MemberGetter
public static int CV_16FC1()

CV_16FC2

@MemberGetter
public static int CV_16FC2()

CV_16FC3

@MemberGetter
public static int CV_16FC3()

CV_16FC4

@MemberGetter
public static int CV_16FC4()

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)

CV_XADD
```
public static int CV_XADD(IntPointer addr,
                          int delta)
```
\ exchange-add operation for atomic operations on reference counters * \

CV_XADD

public static int CV_XADD(IntBuffer addr,
                          int delta)

CV_XADD

public static int CV_XADD(int[] addr,
                          int delta)

normHamming

@Namespace(value="cv::hal")
public static int normHamming(@Cast(value="const uchar*")
                                                          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*")
                                                          BytePointer a,
                                                          @Cast(value="const uchar*")
                                                          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*")
                                                          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*")
                                                          BytePointer a,
                                                          @Cast(value="const uchar*")
                                                          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(FloatPointer A,
                                                    @Cast(value="size_t")
                                                    long astep,
                                                    int m,
                                                    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(DoublePointer A,
                                                    @Cast(value="size_t")
                                                    long astep,
                                                    int m,
                                                    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(FloatPointer A,
                                                                                   @Cast(value="size_t")
                                                                                   long astep,
                                                                                   int m,
                                                                                   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(DoublePointer A,
                                                                                   @Cast(value="size_t")
                                                                                   long astep,
                                                                                   int m,
                                                                                   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(FloatPointer At,
                                                      @Cast(value="size_t")
                                                      long astep,
                                                      FloatPointer W,
                                                      FloatPointer U,
                                                      @Cast(value="size_t")
                                                      long ustep,
                                                      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(DoublePointer At,
                                                      @Cast(value="size_t")
                                                      long astep,
                                                      DoublePointer W,
                                                      DoublePointer U,
                                                      @Cast(value="size_t")
                                                      long ustep,
                                                      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(FloatPointer A,
                                                    @Cast(value="size_t")
                                                    long astep,
                                                    int m,
                                                    int n,
                                                    int k,
                                                    FloatPointer b,
                                                    @Cast(value="size_t")
                                                    long bstep,
                                                    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(DoublePointer A,
                                                    @Cast(value="size_t")
                                                    long astep,
                                                    int m,
                                                    int n,
                                                    int k,
                                                    DoublePointer b,
                                                    @Cast(value="size_t")
                                                    long bstep,
                                                    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
                                                       FloatPointer src1,
                                                       @Cast(value="size_t")
                                                       long src1_step,
                                                       @Const
                                                       FloatPointer src2,
                                                       @Cast(value="size_t")
                                                       long src2_step,
                                                       float alpha,
                                                       @Const
                                                       FloatPointer src3,
                                                       @Cast(value="size_t")
                                                       long src3_step,
                                                       float beta,
                                                       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
                                                       DoublePointer src1,
                                                       @Cast(value="size_t")
                                                       long src1_step,
                                                       @Const
                                                       DoublePointer src2,
                                                       @Cast(value="size_t")
                                                       long src2_step,
                                                       double alpha,
                                                       @Const
                                                       DoublePointer src3,
                                                       @Cast(value="size_t")
                                                       long src3_step,
                                                       double beta,
                                                       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
                                                        FloatPointer src1,
                                                        @Cast(value="size_t")
                                                        long src1_step,
                                                        @Const
                                                        FloatPointer src2,
                                                        @Cast(value="size_t")
                                                        long src2_step,
                                                        float alpha,
                                                        @Const
                                                        FloatPointer src3,
                                                        @Cast(value="size_t")
                                                        long src3_step,
                                                        float beta,
                                                        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
                                                        DoublePointer src1,
                                                        @Cast(value="size_t")
                                                        long src1_step,
                                                        @Const
                                                        DoublePointer src2,
                                                        @Cast(value="size_t")
                                                        long src2_step,
                                                        double alpha,
                                                        @Const
                                                        DoublePointer src3,
                                                        @Cast(value="size_t")
                                                        long src3_step,
                                                        double beta,
                                                        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*")
                                                      BytePointer a,
                                                      @Cast(value="const uchar*")
                                                      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
                                                        FloatPointer a,
                                                        @Const
                                                        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
                                                           FloatPointer a,
                                                           @Const
                                                           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
                                                      FloatPointer src,
                                                      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
                                                      DoublePointer src,
                                                      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
                                                      FloatPointer src,
                                                      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
                                                      DoublePointer src,
                                                      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
                                                           FloatPointer y,
                                                           @Const
                                                           FloatPointer x,
                                                           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
                                                           DoublePointer y,
                                                           @Const
                                                           DoublePointer x,
                                                           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
                                                            FloatPointer x,
                                                            @Const
                                                            FloatPointer y,
                                                            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
                                                            DoublePointer x,
                                                            @Const
                                                            DoublePointer y,
                                                            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
                                                       FloatPointer src,
                                                       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
                                                       DoublePointer src,
                                                       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
                                                          FloatPointer src,
                                                          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
                                                          DoublePointer src,
                                                          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*")
                                                       BytePointer src,
                                                       @Cast(value="uchar**")
                                                       PointerPointer dst,
                                                       int len,
                                                       int cn)

split8u

@Namespace(value="cv::hal")
public static void split8u(@Cast(value="const uchar*")
                                                       BytePointer src,
                                                       @Cast(value="uchar**") @ByPtrPtr
                                                       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*")
                                                        ShortPointer src,
                                                        @Cast(value="ushort**")
                                                        PointerPointer dst,
                                                        int len,
                                                        int cn)

split16u

@Namespace(value="cv::hal")
public static void split16u(@Cast(value="const ushort*")
                                                        ShortPointer src,
                                                        @Cast(value="ushort**") @ByPtrPtr
                                                        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
                                                        IntPointer src,
                                                        @Cast(value="int**")
                                                        PointerPointer dst,
                                                        int len,
                                                        int cn)

split32s

@Namespace(value="cv::hal")
public static void split32s(@Const
                                                        IntPointer src,
                                                        @ByPtrPtr
                                                        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*")
                                                        LongPointer src,
                                                        @Cast(value="int64**")
                                                        PointerPointer dst,
                                                        int len,
                                                        int cn)

split64s

@Namespace(value="cv::hal")
public static void split64s(@Cast(value="const int64*")
                                                        LongPointer src,
                                                        @Cast(value="int64**") @ByPtrPtr
                                                        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**")
                                                       PointerPointer src,
                                                       @Cast(value="uchar*")
                                                       BytePointer dst,
                                                       int len,
                                                       int cn)

merge8u

@Namespace(value="cv::hal")
public static void merge8u(@Cast(value="const uchar**") @ByPtrPtr
                                                       BytePointer src,
                                                       @Cast(value="uchar*")
                                                       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**")
                                                        PointerPointer src,
                                                        @Cast(value="ushort*")
                                                        ShortPointer dst,
                                                        int len,
                                                        int cn)

merge16u

@Namespace(value="cv::hal")
public static void merge16u(@Cast(value="const ushort**") @ByPtrPtr
                                                        ShortPointer src,
                                                        @Cast(value="ushort*")
                                                        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**")
                                                        PointerPointer src,
                                                        IntPointer dst,
                                                        int len,
                                                        int cn)

merge32s

@Namespace(value="cv::hal")
public static void merge32s(@Const @ByPtrPtr
                                                        IntPointer src,
                                                        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**")
                                                        PointerPointer src,
                                                        @Cast(value="int64*")
                                                        LongPointer dst,
                                                        int len,
                                                        int cn)

merge64s

@Namespace(value="cv::hal")
public static void merge64s(@Cast(value="const int64**") @ByPtrPtr
                                                        LongPointer src,
                                                        @Cast(value="int64*")
                                                        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*")
                                                     BytePointer src1,
                                                     @Cast(value="size_t")
                                                     long step1,
                                                     @Cast(value="const uchar*")
                                                     BytePointer src2,
                                                     @Cast(value="size_t")
                                                     long step2,
                                                     @Cast(value="uchar*")
                                                     BytePointer dst,
                                                     @Cast(value="size_t")
                                                     long step,
                                                     int width,
                                                     int height,
                                                     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,
                                                     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,
                                                     Pointer arg8)

add8s

@Namespace(value="cv::hal")
public static void add8s(@Cast(value="const schar*")
                                                     BytePointer src1,
                                                     @Cast(value="size_t")
                                                     long step1,
                                                     @Cast(value="const schar*")
                                                     BytePointer src2,
                                                     @Cast(value="size_t")
                                                     long step2,
                                                     @Cast(value="schar*")
                                                     BytePointer dst,
                                                     @Cast(value="size_t")
                                                     long step,
                                                     int width,
                                                     int height,
                                                     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,
                                                     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,
                                                     Pointer arg8)

add16u

@Namespace(value="cv::hal")
public static void add16u(@Cast(value="const ushort*")
                                                      ShortPointer src1,
                                                      @Cast(value="size_t")
                                                      long step1,
                                                      @Cast(value="const ushort*")
                                                      ShortPointer src2,
                                                      @Cast(value="size_t")
                                                      long step2,
                                                      @Cast(value="ushort*")
                                                      ShortPointer dst,
                                                      @Cast(value="size_t")
                                                      long step,
                                                      int width,
                                                      int height,
                                                      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,
                                                      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,
                                                      Pointer arg8)

add16s

@Namespace(value="cv::hal")
public static void add16s(@Const
                                                      ShortPointer src1,
                                                      @Cast(value="size_t")
                                                      long step1,
                                                      @Const
                                                      ShortPointer src2,
                                                      @Cast(value="size_t")
                                                      long step2,
                                                      ShortPointer dst,
                                                      @Cast(value="size_t")
                                                      long step,
                                                      int width,
                                                      int height,
                                                      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,
                                                      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,
                                                      Pointer arg8)

add32s

@Namespace(value="cv::hal")
public static void add32s(@Const
                                                      IntPointer src1,
                                                      @Cast(value="size_t")
                                                      long step1,
                                                      @Const
                                                      IntPointer src2,
                                                      @Cast(value="size_t")
                                                      long step2,
                                                      IntPointer dst,
                                                      @Cast(value="size_t")
                                                      long step,
                                                      int width,
                                                      int height,
                                                      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,
                                                      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,
                                                      Pointer arg8)

add32f

@Namespace(value="cv::hal")
public static void add32f(@Const
                                                      FloatPointer src1,
                                                      @Cast(value="size_t")
                                                      long step1,
                                                      @Const
                                                      FloatPointer src2,
                                                      @Cast(value="size_t")
                                                      long step2,
                                                      FloatPointer dst,
                                                      @Cast(value="size_t")
                                                      long step,
                                                      int width,
                                                      int height,
                                                      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,
                                                      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,
                                                      Pointer arg8)

add64f

@Namespace(value="cv::hal")
public static void add64f(@Const
                                                      DoublePointer src1,
                                                      @Cast(value="size_t")
                                                      long step1,
                                                      @Const
                                                      DoublePointer src2,
                                                      @Cast(value="size_t")
                                                      long step2,
                                                      DoublePointer dst,
                                                      @Cast(value="size_t")
                                                      long step,
                                                      int width,
                                                      int height,
                                                      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,
                                                      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,
                                                      Pointer arg8)

sub8u

@Namespace(value="cv::hal")
public static void sub8u(@Cast(value="const uchar*")
                                                     BytePointer src1,
                                                     @Cast(value="size_t")
                                                     long step1,
                                                     @Cast(value="const uchar*")
                                                     BytePointer src2,
                                                     @Cast(value="size_t")
                                                     long step2,
                                                     @Cast(value="uchar*")
                                                     BytePointer dst,
                                                     @Cast(value="size_t")
                                                     long step,
                                                     int width,
                                                     int height,
                                                     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,
                                                     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,
                                                     Pointer arg8)

sub8s

@Namespace(value="cv::hal")
public static void sub8s(@Cast(value="const schar*")
                                                     BytePointer src1,
                                                     @Cast(value="size_t")
                                                     long step1,
                                                     @Cast(value="const schar*")
                                                     BytePointer src2,
                                                     @Cast(value="size_t")
                                                     long step2,
                                                     @Cast(value="schar*")
                                                     BytePointer dst,
                                                     @Cast(value="size_t")
                                                     long step,
                                                     int width,
                                                     int height,
                                                     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,
                                                     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,
                                                     Pointer arg8)

sub16u

@Namespace(value="cv::hal")
public static void sub16u(@Cast(value="const ushort*")
                                                      ShortPointer src1,
                                                      @Cast(value="size_t")
                                                      long step1,
                                                      @Cast(value="const ushort*")
                                                      ShortPointer src2,
                                                      @Cast(value="size_t")
                                                      long step2,
                                                      @Cast(value="ushort*")
                                                      ShortPointer dst,
                                                      @Cast(value="size_t")
                                                      long step,
                                                      int width,
                                                      int height,
                                                      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,
                                                      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,
                                                      Pointer arg8)

sub16s

@Namespace(value="cv::hal")
public static void sub16s(@Const
                                                      ShortPointer src1,
                                                      @Cast(value="size_t")
                                                      long step1,
                                                      @Const
                                                      ShortPointer src2,
                                                      @Cast(value="size_t")
                                                      long step2,
                                                      ShortPointer dst,
                                                      @Cast(value="size_t")
                                                      long step,
                                                      int width,
                                                      int height,
                                                      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,
                                                      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,
                                                      Pointer arg8)

sub32s

@Namespace(value="cv::hal")
public static void sub32s(@Const
                                                      IntPointer src1,
                                                      @Cast(value="size_t")
                                                      long step1,
                                                      @Const
                                                      IntPointer src2,
                                                      @Cast(value="size_t")
                                                      long step2,
                                                      IntPointer dst,
                                                      @Cast(value="size_t")
                                                      long step,
                                                      int width,
                                                      int height,
                                                      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,
                                                      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,
                                                      Pointer arg8)

sub32f

@Namespace(value="cv::hal")
public static void sub32f(@Const
                                                      FloatPointer src1,
                                                      @Cast(value="size_t")
                                                      long step1,
                                                      @Const
                                                      FloatPointer src2,
                                                      @Cast(value="size_t")
                                                      long step2,
                                                      FloatPointer dst,
                                                      @Cast(value="size_t")
                                                      long step,
                                                      int width,
                                                      int height,
                                                      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,
                                                      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,
                                                      Pointer arg8)

sub64f

@Namespace(value="cv::hal")
public static void sub64f(@Const
                                                      DoublePointer src1,
                                                      @Cast(value="size_t")
                                                      long step1,
                                                      @Const
                                                      DoublePointer src2,
                                                      @Cast(value="size_t")
                                                      long step2,
                                                      DoublePointer dst,
                                                      @Cast(value="size_t")
                                                      long step,
                                                      int width,
                                                      int height,
                                                      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,
                                                      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,
                                                      Pointer arg8)

max8u

@Namespace(value="cv::hal")
public static void max8u(@Cast(value="const uchar*")
                                                     BytePointer src1,
                                                     @Cast(value="size_t")
                                                     long step1,
                                                     @Cast(value="const uchar*")
                                                     BytePointer src2,
                                                     @Cast(value="size_t")
                                                     long step2,
                                                     @Cast(value="uchar*")
                                                     BytePointer dst,
                                                     @Cast(value="size_t")
                                                     long step,
                                                     int width,
                                                     int height,
                                                     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,
                                                     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,
                                                     Pointer arg8)

max8s

@Namespace(value="cv::hal")
public static void max8s(@Cast(value="const schar*")
                                                     BytePointer src1,
                                                     @Cast(value="size_t")
                                                     long step1,
                                                     @Cast(value="const schar*")
                                                     BytePointer src2,
                                                     @Cast(value="size_t")
                                                     long step2,
                                                     @Cast(value="schar*")
                                                     BytePointer dst,
                                                     @Cast(value="size_t")
                                                     long step,
                                                     int width,
                                                     int height,
                                                     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,
                                                     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,
                                                     Pointer arg8)

max16u

@Namespace(value="cv::hal")
public static void max16u(@Cast(value="const ushort*")
                                                      ShortPointer src1,
                                                      @Cast(value="size_t")
                                                      long step1,
                                                      @Cast(value="const ushort*")
                                                      ShortPointer src2,
                                                      @Cast(value="size_t")
                                                      long step2,
                                                      @Cast(value="ushort*")
                                                      ShortPointer dst,
                                                      @Cast(value="size_t")
                                                      long step,
                                                      int width,
                                                      int height,
                                                      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,
                                                      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,
                                                      Pointer arg8)

max16s

@Namespace(value="cv::hal")
public static void max16s(@Const
                                                      ShortPointer src1,
                                                      @Cast(value="size_t")
                                                      long step1,
                                                      @Const
                                                      ShortPointer src2,
                                                      @Cast(value="size_t")
                                                      long step2,
                                                      ShortPointer dst,
                                                      @Cast(value="size_t")
                                                      long step,
                                                      int width,
                                                      int height,
                                                      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,
                                                      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,
                                                      Pointer arg8)

max32s

@Namespace(value="cv::hal")
public static void max32s(@Const
                                                      IntPointer src1,
                                                      @Cast(value="size_t")
                                                      long step1,
                                                      @Const
                                                      IntPointer src2,
                                                      @Cast(value="size_t")
                                                      long step2,
                                                      IntPointer dst,
                                                      @Cast(value="size_t")
                                                      long step,
                                                      int width,
                                                      int height,
                                                      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,
                                                      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,
                                                      Pointer arg8)

max32f

@Namespace(value="cv::hal")
public static void max32f(@Const
                                                      FloatPointer src1,
                                                      @Cast(value="size_t")
                                                      long step1,
                                                      @Const
                                                      FloatPointer src2,
                                                      @Cast(value="size_t")
                                                      long step2,
                                                      FloatPointer dst,
                                                      @Cast(value="size_t")
                                                      long step,
                                                      int width,
                                                      int height,
                                                      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,
                                                      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,
                                                      Pointer arg8)

max64f

@Namespace(value="cv::hal")
public static void max64f(@Const
                                                      DoublePointer src1,
                                                      @Cast(value="size_t")
                                                      long step1,
                                                      @Const
                                                      DoublePointer src2,
                                                      @Cast(value="size_t")
                                                      long step2,
                                                      DoublePointer dst,
                                                      @Cast(value="size_t")
                                                      long step,
                                                      int width,
                                                      int height,
                                                      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,
                                                      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,
                                                      Pointer arg8)

min8u

@Namespace(value="cv::hal")
public static void min8u(@Cast(value="const uchar*")
                                                     BytePointer src1,
                                                     @Cast(value="size_t")
                                                     long step1,
                                                     @Cast(value="const uchar*")
                                                     BytePointer src2,
                                                     @Cast(value="size_t")
                                                     long step2,
                                                     @Cast(value="uchar*")
                                                     BytePointer dst,
                                                     @Cast(value="size_t")
                                                     long step,
                                                     int width,
                                                     int height,
                                                     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,
                                                     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,
                                                     Pointer arg8)

min8s

@Namespace(value="cv::hal")
public static void min8s(@Cast(value="const schar*")
                                                     BytePointer src1,
                                                     @Cast(value="size_t")
                                                     long step1,
                                                     @Cast(value="const schar*")
                                                     BytePointer src2,
                                                     @Cast(value="size_t")
                                                     long step2,
                                                     @Cast(value="schar*")
                                                     BytePointer dst,
                                                     @Cast(value="size_t")
                                                     long step,
                                                     int width,
                                                     int height,
                                                     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,
                                                     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,
                                                     Pointer arg8)

min16u

@Namespace(value="cv::hal")
public static void min16u(@Cast(value="const ushort*")
                                                      ShortPointer src1,
                                                      @Cast(value="size_t")
                                                      long step1,
                                                      @Cast(value="const ushort*")
                                                      ShortPointer src2,
                                                      @Cast(value="size_t")
                                                      long step2,
                                                      @Cast(value="ushort*")
                                                      ShortPointer dst,
                                                      @Cast(value="size_t")
                                                      long step,
                                                      int width,
                                                      int height,
                                                      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,
                                                      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,
                                                      Pointer arg8)

min16s

@Namespace(value="cv::hal")
public static void min16s(@Const
                                                      ShortPointer src1,
                                                      @Cast(value="size_t")
                                                      long step1,
                                                      @Const
                                                      ShortPointer src2,
                                                      @Cast(value="size_t")
                                                      long step2,
                                                      ShortPointer dst,
                                                      @Cast(value="size_t")
                                                      long step,
                                                      int width,
                                                      int height,
                                                      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,
                                                      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,
                                                      Pointer arg8)

min32s

@Namespace(value="cv::hal")
public static void min32s(@Const
                                                      IntPointer src1,
                                                      @Cast(value="size_t")
                                                      long step1,
                                                      @Const
                                                      IntPointer src2,
                                                      @Cast(value="size_t")
                                                      long step2,
                                                      IntPointer dst,
                                                      @Cast(value="size_t")
                                                      long step,
                                                      int width,
                                                      int height,
                                                      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,
                                                      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,
                                                      Pointer arg8)

min32f

@Namespace(value="cv::hal")
public static void min32f(@Const
                                                      FloatPointer src1,
                                                      @Cast(value="size_t")
                                                      long step1,
                                                      @Const
                                                      FloatPointer src2,
                                                      @Cast(value="size_t")
                                                      long step2,
                                                      FloatPointer dst,
                                                      @Cast(value="size_t")
                                                      long step,
                                                      int width,
                                                      int height,
                                                      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,
                                                      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,
                                                      Pointer arg8)

min64f

@Namespace(value="cv::hal")
public static void min64f(@Const
                                                      DoublePointer src1,
                                                      @Cast(value="size_t")
                                                      long step1,
                                                      @Const
                                                      DoublePointer src2,
                                                      @Cast(value="size_t")
                                                      long step2,
                                                      DoublePointer dst,
                                                      @Cast(value="size_t")
                                                      long step,
                                                      int width,
                                                      int height,
                                                      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,
                                                      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,
                                                      Pointer arg8)

absdiff8u

@Namespace(value="cv::hal")
public static void absdiff8u(@Cast(value="const uchar*")
                                                         BytePointer src1,
                                                         @Cast(value="size_t")
                                                         long step1,
                                                         @Cast(value="const uchar*")
                                                         BytePointer src2,
                                                         @Cast(value="size_t")
                                                         long step2,
                                                         @Cast(value="uchar*")
                                                         BytePointer dst,
                                                         @Cast(value="size_t")
                                                         long step,
                                                         int width,
                                                         int height,
                                                         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,
                                                         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,
                                                         Pointer arg8)

absdiff8s

@Namespace(value="cv::hal")
public static void absdiff8s(@Cast(value="const schar*")
                                                         BytePointer src1,
                                                         @Cast(value="size_t")
                                                         long step1,
                                                         @Cast(value="const schar*")
                                                         BytePointer src2,
                                                         @Cast(value="size_t")
                                                         long step2,
                                                         @Cast(value="schar*")
                                                         BytePointer dst,
                                                         @Cast(value="size_t")
                                                         long step,
                                                         int width,
                                                         int height,
                                                         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,
                                                         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,
                                                         Pointer arg8)

absdiff16u

@Namespace(value="cv::hal")
public static void absdiff16u(@Cast(value="const ushort*")
                                                          ShortPointer src1,
                                                          @Cast(value="size_t")
                                                          long step1,
                                                          @Cast(value="const ushort*")
                                                          ShortPointer src2,
                                                          @Cast(value="size_t")
                                                          long step2,
                                                          @Cast(value="ushort*")
                                                          ShortPointer dst,
                                                          @Cast(value="size_t")
                                                          long step,
                                                          int width,
                                                          int height,
                                                          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,
                                                          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,
                                                          Pointer arg8)

absdiff16s

@Namespace(value="cv::hal")
public static void absdiff16s(@Const
                                                          ShortPointer src1,
                                                          @Cast(value="size_t")
                                                          long step1,
                                                          @Const
                                                          ShortPointer src2,
                                                          @Cast(value="size_t")
                                                          long step2,
                                                          ShortPointer dst,
                                                          @Cast(value="size_t")
                                                          long step,
                                                          int width,
                                                          int height,
                                                          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,
                                                          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,
                                                          Pointer arg8)

absdiff32s

@Namespace(value="cv::hal")
public static void absdiff32s(@Const
                                                          IntPointer src1,
                                                          @Cast(value="size_t")
                                                          long step1,
                                                          @Const
                                                          IntPointer src2,
                                                          @Cast(value="size_t")
                                                          long step2,
                                                          IntPointer dst,
                                                          @Cast(value="size_t")
                                                          long step,
                                                          int width,
                                                          int height,
                                                          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,
                                                          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,
                                                          Pointer arg8)

absdiff32f

@Namespace(value="cv::hal")
public static void absdiff32f(@Const
                                                          FloatPointer src1,
                                                          @Cast(value="size_t")
                                                          long step1,
                                                          @Const
                                                          FloatPointer src2,
                                                          @Cast(value="size_t")
                                                          long step2,
                                                          FloatPointer dst,
                                                          @Cast(value="size_t")
                                                          long step,
                                                          int width,
                                                          int height,
                                                          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,
                                                          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,
                                                          Pointer arg8)

absdiff64f

@Namespace(value="cv::hal")
public static void absdiff64f(@Const
                                                          DoublePointer src1,
                                                          @Cast(value="size_t")
                                                          long step1,
                                                          @Const
                                                          DoublePointer src2,
                                                          @Cast(value="size_t")
                                                          long step2,
                                                          DoublePointer dst,
                                                          @Cast(value="size_t")
                                                          long step,
                                                          int width,
                                                          int height,
                                                          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,
                                                          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,
                                                          Pointer arg8)

and8u

@Namespace(value="cv::hal")
public static void and8u(@Cast(value="const uchar*")
                                                     BytePointer src1,
                                                     @Cast(value="size_t")
                                                     long step1,
                                                     @Cast(value="const uchar*")
                                                     BytePointer src2,
                                                     @Cast(value="size_t")
                                                     long step2,
                                                     @Cast(value="uchar*")
                                                     BytePointer dst,
                                                     @Cast(value="size_t")
                                                     long step,
                                                     int width,
                                                     int height,
                                                     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,
                                                     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,
                                                     Pointer arg8)

or8u

@Namespace(value="cv::hal")
public static void or8u(@Cast(value="const uchar*")
                                                    BytePointer src1,
                                                    @Cast(value="size_t")
                                                    long step1,
                                                    @Cast(value="const uchar*")
                                                    BytePointer src2,
                                                    @Cast(value="size_t")
                                                    long step2,
                                                    @Cast(value="uchar*")
                                                    BytePointer dst,
                                                    @Cast(value="size_t")
                                                    long step,
                                                    int width,
                                                    int height,
                                                    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,
                                                    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,
                                                    Pointer arg8)

xor8u

@Namespace(value="cv::hal")
public static void xor8u(@Cast(value="const uchar*")
                                                     BytePointer src1,
                                                     @Cast(value="size_t")
                                                     long step1,
                                                     @Cast(value="const uchar*")
                                                     BytePointer src2,
                                                     @Cast(value="size_t")
                                                     long step2,
                                                     @Cast(value="uchar*")
                                                     BytePointer dst,
                                                     @Cast(value="size_t")
                                                     long step,
                                                     int width,
                                                     int height,
                                                     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,
                                                     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,
                                                     Pointer arg8)

not8u

@Namespace(value="cv::hal")
public static void not8u(@Cast(value="const uchar*")
                                                     BytePointer src1,
                                                     @Cast(value="size_t")
                                                     long step1,
                                                     @Cast(value="const uchar*")
                                                     BytePointer src2,
                                                     @Cast(value="size_t")
                                                     long step2,
                                                     @Cast(value="uchar*")
                                                     BytePointer dst,
                                                     @Cast(value="size_t")
                                                     long step,
                                                     int width,
                                                     int height,
                                                     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,
                                                     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,
                                                     Pointer arg8)

cmp8u

@Namespace(value="cv::hal")
public static void cmp8u(@Cast(value="const uchar*")
                                                     BytePointer src1,
                                                     @Cast(value="size_t")
                                                     long step1,
                                                     @Cast(value="const uchar*")
                                                     BytePointer src2,
                                                     @Cast(value="size_t")
                                                     long step2,
                                                     @Cast(value="uchar*")
                                                     BytePointer dst,
                                                     @Cast(value="size_t")
                                                     long step,
                                                     int width,
                                                     int height,
                                                     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,
                                                     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,
                                                     Pointer _cmpop)

cmp8s

@Namespace(value="cv::hal")
public static void cmp8s(@Cast(value="const schar*")
                                                     BytePointer src1,
                                                     @Cast(value="size_t")
                                                     long step1,
                                                     @Cast(value="const schar*")
                                                     BytePointer src2,
                                                     @Cast(value="size_t")
                                                     long step2,
                                                     @Cast(value="uchar*")
                                                     BytePointer dst,
                                                     @Cast(value="size_t")
                                                     long step,
                                                     int width,
                                                     int height,
                                                     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,
                                                     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,
                                                     Pointer _cmpop)

cmp16u

@Namespace(value="cv::hal")
public static void cmp16u(@Cast(value="const ushort*")
                                                      ShortPointer src1,
                                                      @Cast(value="size_t")
                                                      long step1,
                                                      @Cast(value="const ushort*")
                                                      ShortPointer src2,
                                                      @Cast(value="size_t")
                                                      long step2,
                                                      @Cast(value="uchar*")
                                                      BytePointer dst,
                                                      @Cast(value="size_t")
                                                      long step,
                                                      int width,
                                                      int height,
                                                      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,
                                                      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,
                                                      Pointer _cmpop)

cmp16s

@Namespace(value="cv::hal")
public static void cmp16s(@Const
                                                      ShortPointer src1,
                                                      @Cast(value="size_t")
                                                      long step1,
                                                      @Const
                                                      ShortPointer src2,
                                                      @Cast(value="size_t")
                                                      long step2,
                                                      @Cast(value="uchar*")
                                                      BytePointer dst,
                                                      @Cast(value="size_t")
                                                      long step,
                                                      int width,
                                                      int height,
                                                      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,
                                                      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,
                                                      Pointer _cmpop)

cmp32s

@Namespace(value="cv::hal")
public static void cmp32s(@Const
                                                      IntPointer src1,
                                                      @Cast(value="size_t")
                                                      long step1,
                                                      @Const
                                                      IntPointer src2,
                                                      @Cast(value="size_t")
                                                      long step2,
                                                      @Cast(value="uchar*")
                                                      BytePointer dst,
                                                      @Cast(value="size_t")
                                                      long step,
                                                      int width,
                                                      int height,
                                                      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,
                                                      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,
                                                      Pointer _cmpop)

cmp32f

@Namespace(value="cv::hal")
public static void cmp32f(@Const
                                                      FloatPointer src1,
                                                      @Cast(value="size_t")
                                                      long step1,
                                                      @Const
                                                      FloatPointer src2,
                                                      @Cast(value="size_t")
                                                      long step2,
                                                      @Cast(value="uchar*")
                                                      BytePointer dst,
                                                      @Cast(value="size_t")
                                                      long step,
                                                      int width,
                                                      int height,
                                                      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,
                                                      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,
                                                      Pointer _cmpop)

cmp64f

@Namespace(value="cv::hal")
public static void cmp64f(@Const
                                                      DoublePointer src1,
                                                      @Cast(value="size_t")
                                                      long step1,
                                                      @Const
                                                      DoublePointer src2,
                                                      @Cast(value="size_t")
                                                      long step2,
                                                      @Cast(value="uchar*")
                                                      BytePointer dst,
                                                      @Cast(value="size_t")
                                                      long step,
                                                      int width,
                                                      int height,
                                                      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,
                                                      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,
                                                      Pointer _cmpop)

mul8u

@Namespace(value="cv::hal")
public static void mul8u(@Cast(value="const uchar*")
                                                     BytePointer src1,
                                                     @Cast(value="size_t")
                                                     long step1,
                                                     @Cast(value="const uchar*")
                                                     BytePointer src2,
                                                     @Cast(value="size_t")
                                                     long step2,
                                                     @Cast(value="uchar*")
                                                     BytePointer dst,
                                                     @Cast(value="size_t")
                                                     long step,
                                                     int width,
                                                     int height,
                                                     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,
                                                     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,
                                                     Pointer scale)

mul8s

@Namespace(value="cv::hal")
public static void mul8s(@Cast(value="const schar*")
                                                     BytePointer src1,
                                                     @Cast(value="size_t")
                                                     long step1,
                                                     @Cast(value="const schar*")
                                                     BytePointer src2,
                                                     @Cast(value="size_t")
                                                     long step2,
                                                     @Cast(value="schar*")
                                                     BytePointer dst,
                                                     @Cast(value="size_t")
                                                     long step,
                                                     int width,
                                                     int height,
                                                     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,
                                                     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,
                                                     Pointer scale)

mul16u

@Namespace(value="cv::hal")
public static void mul16u(@Cast(value="const ushort*")
                                                      ShortPointer src1,
                                                      @Cast(value="size_t")
                                                      long step1,
                                                      @Cast(value="const ushort*")
                                                      ShortPointer src2,
                                                      @Cast(value="size_t")
                                                      long step2,
                                                      @Cast(value="ushort*")
                                                      ShortPointer dst,
                                                      @Cast(value="size_t")
                                                      long step,
                                                      int width,
                                                      int height,
                                                      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,
                                                      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,
                                                      Pointer scale)

mul16s

@Namespace(value="cv::hal")
public static void mul16s(@Const
                                                      ShortPointer src1,
                                                      @Cast(value="size_t")
                                                      long step1,
                                                      @Const
                                                      ShortPointer src2,
                                                      @Cast(value="size_t")
                                                      long step2,
                                                      ShortPointer dst,
                                                      @Cast(value="size_t")
                                                      long step,
                                                      int width,
                                                      int height,
                                                      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,
                                                      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,
                                                      Pointer scale)

mul32s

@Namespace(value="cv::hal")
public static void mul32s(@Const
                                                      IntPointer src1,
                                                      @Cast(value="size_t")
                                                      long step1,
                                                      @Const
                                                      IntPointer src2,
                                                      @Cast(value="size_t")
                                                      long step2,
                                                      IntPointer dst,
                                                      @Cast(value="size_t")
                                                      long step,
                                                      int width,
                                                      int height,
                                                      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,
                                                      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,
                                                      Pointer scale)

mul32f

@Namespace(value="cv::hal")
public static void mul32f(@Const
                                                      FloatPointer src1,
                                                      @Cast(value="size_t")
                                                      long step1,
                                                      @Const
                                                      FloatPointer src2,
                                                      @Cast(value="size_t")
                                                      long step2,
                                                      FloatPointer dst,
                                                      @Cast(value="size_t")
                                                      long step,
                                                      int width,
                                                      int height,
                                                      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,
                                                      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,
                                                      Pointer scale)

mul64f

@Namespace(value="cv::hal")
public static void mul64f(@Const
                                                      DoublePointer src1,
                                                      @Cast(value="size_t")
                                                      long step1,
                                                      @Const
                                                      DoublePointer src2,
                                                      @Cast(value="size_t")
                                                      long step2,
                                                      DoublePointer dst,
                                                      @Cast(value="size_t")
                                                      long step,
                                                      int width,
                                                      int height,
                                                      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,
                                                      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,
                                                      Pointer scale)

div8u

@Namespace(value="cv::hal")
public static void div8u(@Cast(value="const uchar*")
                                                     BytePointer src1,
                                                     @Cast(value="size_t")
                                                     long step1,
                                                     @Cast(value="const uchar*")
                                                     BytePointer src2,
                                                     @Cast(value="size_t")
                                                     long step2,
                                                     @Cast(value="uchar*")
                                                     BytePointer dst,
                                                     @Cast(value="size_t")
                                                     long step,
                                                     int width,
                                                     int height,
                                                     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,
                                                     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,
                                                     Pointer scale)

div8s

@Namespace(value="cv::hal")
public static void div8s(@Cast(value="const schar*")
                                                     BytePointer src1,
                                                     @Cast(value="size_t")
                                                     long step1,
                                                     @Cast(value="const schar*")
                                                     BytePointer src2,
                                                     @Cast(value="size_t")
                                                     long step2,
                                                     @Cast(value="schar*")
                                                     BytePointer dst,
                                                     @Cast(value="size_t")
                                                     long step,
                                                     int width,
                                                     int height,
                                                     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,
                                                     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,
                                                     Pointer scale)

div16u

@Namespace(value="cv::hal")
public static void div16u(@Cast(value="const ushort*")
                                                      ShortPointer src1,
                                                      @Cast(value="size_t")
                                                      long step1,
                                                      @Cast(value="const ushort*")
                                                      ShortPointer src2,
                                                      @Cast(value="size_t")
                                                      long step2,
                                                      @Cast(value="ushort*")
                                                      ShortPointer dst,
                                                      @Cast(value="size_t")
                                                      long step,
                                                      int width,
                                                      int height,
                                                      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,
                                                      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,
                                                      Pointer scale)

div16s

@Namespace(value="cv::hal")
public static void div16s(@Const
                                                      ShortPointer src1,
                                                      @Cast(value="size_t")
                                                      long step1,
                                                      @Const
                                                      ShortPointer src2,
                                                      @Cast(value="size_t")
                                                      long step2,
                                                      ShortPointer dst,
                                                      @Cast(value="size_t")
                                                      long step,
                                                      int width,
                                                      int height,
                                                      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,
                                                      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,
                                                      Pointer scale)

div32s

@Namespace(value="cv::hal")
public static void div32s(@Const
                                                      IntPointer src1,
                                                      @Cast(value="size_t")
                                                      long step1,
                                                      @Const
                                                      IntPointer src2,
                                                      @Cast(value="size_t")
                                                      long step2,
                                                      IntPointer dst,
                                                      @Cast(value="size_t")
                                                      long step,
                                                      int width,
                                                      int height,
                                                      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,
                                                      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,
                                                      Pointer scale)

div32f

@Namespace(value="cv::hal")
public static void div32f(@Const
                                                      FloatPointer src1,
                                                      @Cast(value="size_t")
                                                      long step1,
                                                      @Const
                                                      FloatPointer src2,
                                                      @Cast(value="size_t")
                                                      long step2,
                                                      FloatPointer dst,
                                                      @Cast(value="size_t")
                                                      long step,
                                                      int width,
                                                      int height,
                                                      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,
                                                      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,
                                                      Pointer scale)

div64f

@Namespace(value="cv::hal")
public static void div64f(@Const
                                                      DoublePointer src1,
                                                      @Cast(value="size_t")
                                                      long step1,
                                                      @Const
                                                      DoublePointer src2,
                                                      @Cast(value="size_t")
                                                      long step2,
                                                      DoublePointer dst,
                                                      @Cast(value="size_t")
                                                      long step,
                                                      int width,
                                                      int height,
                                                      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,
                                                      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,
                                                      Pointer scale)

recip8u

@Namespace(value="cv::hal")
public static void recip8u(@Cast(value="const uchar*")
                                                       BytePointer arg0,
                                                       @Cast(value="size_t")
                                                       long arg1,
                                                       @Cast(value="const uchar*")
                                                       BytePointer src2,
                                                       @Cast(value="size_t")
                                                       long step2,
                                                       @Cast(value="uchar*")
                                                       BytePointer dst,
                                                       @Cast(value="size_t")
                                                       long step,
                                                       int width,
                                                       int height,
                                                       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,
                                                       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,
                                                       Pointer scale)

recip8s

@Namespace(value="cv::hal")
public static void recip8s(@Cast(value="const schar*")
                                                       BytePointer arg0,
                                                       @Cast(value="size_t")
                                                       long arg1,
                                                       @Cast(value="const schar*")
                                                       BytePointer src2,
                                                       @Cast(value="size_t")
                                                       long step2,
                                                       @Cast(value="schar*")
                                                       BytePointer dst,
                                                       @Cast(value="size_t")
                                                       long step,
                                                       int width,
                                                       int height,
                                                       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,
                                                       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,
                                                       Pointer scale)

recip16u

@Namespace(value="cv::hal")
public static void recip16u(@Cast(value="const ushort*")
                                                        ShortPointer arg0,
                                                        @Cast(value="size_t")
                                                        long arg1,
                                                        @Cast(value="const ushort*")
                                                        ShortPointer src2,
                                                        @Cast(value="size_t")
                                                        long step2,
                                                        @Cast(value="ushort*")
                                                        ShortPointer dst,
                                                        @Cast(value="size_t")
                                                        long step,
                                                        int width,
                                                        int height,
                                                        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,
                                                        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,
                                                        Pointer scale)

recip16s

@Namespace(value="cv::hal")
public static void recip16s(@Const
                                                        ShortPointer arg0,
                                                        @Cast(value="size_t")
                                                        long arg1,
                                                        @Const
                                                        ShortPointer src2,
                                                        @Cast(value="size_t")
                                                        long step2,
                                                        ShortPointer dst,
                                                        @Cast(value="size_t")
                                                        long step,
                                                        int width,
                                                        int height,
                                                        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,
                                                        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,
                                                        Pointer scale)

recip32s

@Namespace(value="cv::hal")
public static void recip32s(@Const
                                                        IntPointer arg0,
                                                        @Cast(value="size_t")
                                                        long arg1,
                                                        @Const
                                                        IntPointer src2,
                                                        @Cast(value="size_t")
                                                        long step2,
                                                        IntPointer dst,
                                                        @Cast(value="size_t")
                                                        long step,
                                                        int width,
                                                        int height,
                                                        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,
                                                        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,
                                                        Pointer scale)

recip32f

@Namespace(value="cv::hal")
public static void recip32f(@Const
                                                        FloatPointer arg0,
                                                        @Cast(value="size_t")
                                                        long arg1,
                                                        @Const
                                                        FloatPointer src2,
                                                        @Cast(value="size_t")
                                                        long step2,
                                                        FloatPointer dst,
                                                        @Cast(value="size_t")
                                                        long step,
                                                        int width,
                                                        int height,
                                                        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,
                                                        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,
                                                        Pointer scale)

recip64f

@Namespace(value="cv::hal")
public static void recip64f(@Const
                                                        DoublePointer arg0,
                                                        @Cast(value="size_t")
                                                        long arg1,
                                                        @Const
                                                        DoublePointer src2,
                                                        @Cast(value="size_t")
                                                        long step2,
                                                        DoublePointer dst,
                                                        @Cast(value="size_t")
                                                        long step,
                                                        int width,
                                                        int height,
                                                        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,
                                                        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,
                                                        Pointer scale)

addWeighted8u

@Namespace(value="cv::hal")
public static void addWeighted8u(@Cast(value="const uchar*")
                                                             BytePointer src1,
                                                             @Cast(value="size_t")
                                                             long step1,
                                                             @Cast(value="const uchar*")
                                                             BytePointer src2,
                                                             @Cast(value="size_t")
                                                             long step2,
                                                             @Cast(value="uchar*")
                                                             BytePointer dst,
                                                             @Cast(value="size_t")
                                                             long step,
                                                             int width,
                                                             int height,
                                                             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,
                                                             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,
                                                             Pointer _scalars)

addWeighted8s

@Namespace(value="cv::hal")
public static void addWeighted8s(@Cast(value="const schar*")
                                                             BytePointer src1,
                                                             @Cast(value="size_t")
                                                             long step1,
                                                             @Cast(value="const schar*")
                                                             BytePointer src2,
                                                             @Cast(value="size_t")
                                                             long step2,
                                                             @Cast(value="schar*")
                                                             BytePointer dst,
                                                             @Cast(value="size_t")
                                                             long step,
                                                             int width,
                                                             int height,
                                                             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,
                                                             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,
                                                             Pointer scalars)

addWeighted16u

@Namespace(value="cv::hal")
public static void addWeighted16u(@Cast(value="const ushort*")
                                                              ShortPointer src1,
                                                              @Cast(value="size_t")
                                                              long step1,
                                                              @Cast(value="const ushort*")
                                                              ShortPointer src2,
                                                              @Cast(value="size_t")
                                                              long step2,
                                                              @Cast(value="ushort*")
                                                              ShortPointer dst,
                                                              @Cast(value="size_t")
                                                              long step,
                                                              int width,
                                                              int height,
                                                              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,
                                                              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,
                                                              Pointer scalars)

addWeighted16s

@Namespace(value="cv::hal")
public static void addWeighted16s(@Const
                                                              ShortPointer src1,
                                                              @Cast(value="size_t")
                                                              long step1,
                                                              @Const
                                                              ShortPointer src2,
                                                              @Cast(value="size_t")
                                                              long step2,
                                                              ShortPointer dst,
                                                              @Cast(value="size_t")
                                                              long step,
                                                              int width,
                                                              int height,
                                                              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,
                                                              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,
                                                              Pointer scalars)

addWeighted32s

@Namespace(value="cv::hal")
public static void addWeighted32s(@Const
                                                              IntPointer src1,
                                                              @Cast(value="size_t")
                                                              long step1,
                                                              @Const
                                                              IntPointer src2,
                                                              @Cast(value="size_t")
                                                              long step2,
                                                              IntPointer dst,
                                                              @Cast(value="size_t")
                                                              long step,
                                                              int width,
                                                              int height,
                                                              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,
                                                              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,
                                                              Pointer scalars)

addWeighted32f

@Namespace(value="cv::hal")
public static void addWeighted32f(@Const
                                                              FloatPointer src1,
                                                              @Cast(value="size_t")
                                                              long step1,
                                                              @Const
                                                              FloatPointer src2,
                                                              @Cast(value="size_t")
                                                              long step2,
                                                              FloatPointer dst,
                                                              @Cast(value="size_t")
                                                              long step,
                                                              int width,
                                                              int height,
                                                              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,
                                                              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,
                                                              Pointer scalars)

addWeighted64f

@Namespace(value="cv::hal")
public static void addWeighted64f(@Const
                                                              DoublePointer src1,
                                                              @Cast(value="size_t")
                                                              long step1,
                                                              @Const
                                                              DoublePointer src2,
                                                              @Cast(value="size_t")
                                                              long step2,
                                                              DoublePointer dst,
                                                              @Cast(value="size_t")
                                                              long step,
                                                              int width,
                                                              int height,
                                                              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,
                                                              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,
                                                              Pointer scalars)

cvt16f32f

@Namespace(value="cv::hal")
public static void cvt16f32f(@Const
                                                         float16_t src,
                                                         FloatPointer dst,
                                                         int len)

cvt16f32f

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

cvt16f32f

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

cvt32f16f

@Namespace(value="cv::hal")
public static void cvt32f16f(@Const
                                                         FloatPointer src,
                                                         float16_t dst,
                                                         int len)

cvt32f16f

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

cvt32f16f

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

addRNGBias32f

@Namespace(value="cv::hal")
public static void addRNGBias32f(FloatPointer arr,
                                                             @Const
                                                             FloatPointer scaleBiasPairs,
                                                             int len)

addRNGBias32f

@Namespace(value="cv::hal")
public static void addRNGBias32f(FloatBuffer arr,
                                                             @Const
                                                             FloatBuffer scaleBiasPairs,
                                                             int len)

addRNGBias32f

@Namespace(value="cv::hal")
public static void addRNGBias32f(float[] arr,
                                                             @Const
                                                             float[] scaleBiasPairs,
                                                             int len)

addRNGBias64f

@Namespace(value="cv::hal")
public static void addRNGBias64f(DoublePointer arr,
                                                             @Const
                                                             DoublePointer scaleBiasPairs,
                                                             int len)

addRNGBias64f

@Namespace(value="cv::hal")
public static void addRNGBias64f(DoubleBuffer arr,
                                                             @Const
                                                             DoubleBuffer scaleBiasPairs,
                                                             int len)

addRNGBias64f

@Namespace(value="cv::hal")
public static void addRNGBias64f(double[] arr,
                                                             @Const
                                                             double[] scaleBiasPairs,
                                                             int len)

LU

@Namespace(value="cv::hal")
public static int LU(FloatPointer A,
                                                 @Cast(value="size_t")
                                                 long astep,
                                                 int m,
                                                 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(DoublePointer A,
                                                 @Cast(value="size_t")
                                                 long astep,
                                                 int m,
                                                 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(FloatPointer A,
                                                                                @Cast(value="size_t")
                                                                                long astep,
                                                                                int m,
                                                                                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(DoublePointer A,
                                                                                @Cast(value="size_t")
                                                                                long astep,
                                                                                int m,
                                                                                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
                                                   FloatPointer src,
                                                   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
                                                   DoublePointer src,
                                                   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
                                                   FloatPointer src,
                                                   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
                                                   DoublePointer src,
                                                   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
                                                         FloatPointer y,
                                                         @Const
                                                         FloatPointer x,
                                                         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
                                                         FloatPointer x,
                                                         @Const
                                                         FloatPointer y,
                                                         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
                                                         DoublePointer x,
                                                         @Const
                                                         DoublePointer y,
                                                         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
                                                    FloatPointer src,
                                                    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
                                                    DoublePointer src,
                                                    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
                                                       FloatPointer src,
                                                       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
                                                       DoublePointer src,
                                                       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:
```
 \[i \le \texttt{value} < i+1\]
```
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:
```
 \[i \le \texttt{value} < i+1\]
```
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).
Parameters:

v - Function parameter.

See Also:

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)

float16SaturateCast

@Namespace(value="cv")
 @ByVal
 @Name(value="saturate_cast<cv::float16_t>")
public static float16_t float16SaturateCast(@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)

float16SaturateCast

@Namespace(value="cv")
 @ByVal
 @Name(value="saturate_cast<cv::float16_t>")
public static float16_t float16SaturateCast(@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)

float16SaturateCast

@Namespace(value="cv")
 @ByVal
 @Name(value="saturate_cast<cv::float16_t>")
public static float16_t float16SaturateCast(@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)

float16SaturateCast

@Namespace(value="cv")
 @ByVal
 @Name(value="saturate_cast<cv::float16_t>")
public static float16_t float16SaturateCast(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)

float16SaturateCast

@Namespace(value="cv")
 @ByVal
 @Name(value="saturate_cast<cv::float16_t>")
public static float16_t float16SaturateCast(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)

float16SaturateCast

@Namespace(value="cv")
 @ByVal
 @Name(value="saturate_cast<cv::float16_t>")
public static float16_t float16SaturateCast(@Cast(value="int64")
                                                                                                                        long v)

ucharSaturateCast

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

\overload

scharSaturateCast

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

ushortSaturateCast

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

shortSaturateCast

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

intSaturate

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

unsignedSaturateCast

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

uint64SaturateCast

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

int64SaturateCast

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

float16SaturateCast

@Namespace(value="cv")
 @ByVal
 @Name(value="saturate_cast<cv::float16_t>")
public static float16_t float16SaturateCast(@ByVal
                                                                                                                        float16_t v)

CV_VERSION

@MemberGetter
public static String CV_VERSION()

error

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

\} core_array

\addtogroup core_utils \{

/** \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)

cv_abs

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

replaced with CV_Assert(expr) in Debug configuration

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 \sqrt[3]{\texttt{val}}. 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.

cubeRoot
```
@Namespace(value="cv")
public static double cubeRoot(double val)
```
\overload
cubeRoot with argument of double type calls std::cbrt(double)

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()

\cond IGNORED

setIppStatus

@Namespace(value="cv::ipp")
public static void setIppStatus(int status,
                                                            @Cast(value="const char*")
                                                            BytePointer funcname,
                                                            @Cast(value="const char*")
                                                            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 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 BytePointer getIppVersion()

useIPP_NotExact

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

setUseIPP_NotExact

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

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 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(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.

char_tolower

@Namespace(value="cv::details")
 @Cast(value="char")
public static byte char_tolower(@Cast(value="char")
                                                                                     byte ch)

\cond IGNORED

char_toupper

@Namespace(value="cv::details")
 @Cast(value="char")
public static byte char_toupper(@Cast(value="char")
                                                                                     byte ch)

toLowerCase

@Namespace(value="cv")
 @StdString
public static BytePointer toLowerCase(@StdString
                                                                         BytePointer str)

\endcond

toLowerCase

@Namespace(value="cv")
 @StdString
public static String toLowerCase(@StdString
                                                                    String str)

toUpperCase

@Namespace(value="cv")
 @StdString
public static BytePointer toUpperCase(@StdString
                                                                         BytePointer str)

toUpperCase

@Namespace(value="cv")
 @StdString
public static String toUpperCase(@StdString
                                                                    String str)

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 ErrorCallback redirectError(ErrorCallback errCallback,
                                                                 Pointer userdata,
                                                                 @Cast(value="void**")
                                                                 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 ErrorCallback redirectError(ErrorCallback errCallback)

redirectError

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

tempfile

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

tempfile

@Namespace(value="cv")
 @opencv_core.Str
public static 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
                                               BytePointer pattern,
                                               @ByRef
                                               StringVector result,
                                               @Cast(value="bool")
                                               boolean recursive)

glob

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

glob

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

glob

@Namespace(value="cv")
public static void glob(@opencv_core.Str
                                               String pattern,
                                               @ByRef
                                               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.

See Also:

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.

See Also:

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.

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

See Also:

setNumThreads, getNumThreads

getBuildInformation
```
@Namespace(value="cv")
 @opencv_core.Str
public static 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 BytePointer getVersionString()
```
\brief Returns library version string
For example "3.4.1-dev".

See Also:

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.

See Also:

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();
```
See Also:

getTickCount, TickMeter

shiftLeft

@Namespace(value="cv")
 @Cast(value="std::ostream*")
 @ByRef
 @Name(value="operator <<")
public static Pointer shiftLeft(@Cast(value="std::ostream*") @ByRef
                                                                                                                         Pointer out,
                                                                                                                         @Const @ByRef
                                                                                                                         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 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 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 :

 \[\texttt{(sz + n-1) & -n}\]

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.

See Also:: 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

roundUp

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

\brief Round first value up to the nearest multiple of second value.

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

See Also:: divUp

roundUp

@Namespace(value="cv")
 @Cast(value="size_t")
public static long roundUp(@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 dispatched code (code that uses SSE4.2, AVX/AVX2, 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
                                                        Range range,
                                                        @Const @ByRef
                                                        ParallelLoopBody body,
                                                        double nstripes)

\brief Parallel data processor

\ingroup core_parallel

parallel_for_

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

parallel_for_

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

\ingroup core_parallel

parallel_for_

@Namespace(value="cv")
public static void parallel_for_(@Const @ByRef
                                                        Range range,
                                                        @ByVal
                                                        opencv_core.Functor functor)

findFile
```
@Namespace(value="cv::samples")
 @opencv_core.Str
public static BytePointer findFile(@opencv_core.Str
                                                                                     BytePointer relative_path,
                                                                                     @Cast(value="bool")
                                                                                     boolean required,
                                                                                     @Cast(value="bool")
                                                                                     boolean silentMode)
```
\{
/** \brief Try to find requested data file
Search directories:
1. Directories passed via addSamplesDataSearchPath() 2. OPENCV_SAMPLES_DATA_PATH_HINT environment variable 3. OPENCV_SAMPLES_DATA_PATH environment variable If parameter value is not empty and nothing is found then stop searching. 4. Detects build/install path based on: a. current working directory (CWD) b. and/or binary module location (opencv_core/opencv_world, doesn't work with static linkage) 5. Scan <source>/{,data,samples/data} directories if build directory is detected or the current directory is in source tree. 6. Scan <install>/share/OpenCV directory if install directory is detected.

Parameters:

relative_path - Relative path to data file

required - Specify "file not found" handling. If true, function prints information message and raises cv::Exception. If false, function returns empty result

silentMode - Disables messages

Returns:

Returns path (absolute or relative to the current directory) or empty string if file is not found

See Also:

findFile

@Namespace(value="cv::samples")
 @opencv_core.Str
public static BytePointer findFile(@opencv_core.Str
                                                                                     BytePointer relative_path)

findFile

@Namespace(value="cv::samples")
 @opencv_core.Str
public static String findFile(@opencv_core.Str
                                                                                String relative_path,
                                                                                @Cast(value="bool")
                                                                                boolean required,
                                                                                @Cast(value="bool")
                                                                                boolean silentMode)

findFile

@Namespace(value="cv::samples")
 @opencv_core.Str
public static String findFile(@opencv_core.Str
                                                                                String relative_path)

findFileOrKeep

@Namespace(value="cv::samples")
 @opencv_core.Str
public static BytePointer findFileOrKeep(@opencv_core.Str
                                                                                           BytePointer relative_path,
                                                                                           @Cast(value="bool")
                                                                                           boolean silentMode)

findFileOrKeep

@Namespace(value="cv::samples")
 @opencv_core.Str
public static BytePointer findFileOrKeep(@opencv_core.Str
                                                                                           BytePointer relative_path)

findFileOrKeep

@Namespace(value="cv::samples")
 @opencv_core.Str
public static String findFileOrKeep(@opencv_core.Str
                                                                                      String relative_path,
                                                                                      @Cast(value="bool")
                                                                                      boolean silentMode)

findFileOrKeep

@Namespace(value="cv::samples")
 @opencv_core.Str
public static String findFileOrKeep(@opencv_core.Str
                                                                                      String relative_path)

addSamplesDataSearchPath

@Namespace(value="cv::samples")
public static void addSamplesDataSearchPath(@opencv_core.Str
                                                                            BytePointer path)

\brief Override search data path by adding new search location

Use this only to override default behavior Passed paths are used in LIFO order.

Parameters:: path - Path to used samples data

addSamplesDataSearchPath

@Namespace(value="cv::samples")
public static void addSamplesDataSearchPath(@opencv_core.Str
                                                                            String path)

addSamplesDataSearchSubDirectory
```
@Namespace(value="cv::samples")
public static void addSamplesDataSearchSubDirectory(@opencv_core.Str
                                                                                    BytePointer subdir)
```
\brief Append samples search data sub directory
General usage is to add OpenCV modules name (<opencv_contrib>/modules/<name>/samples/data -> <name>/samples/data + modules/<name>/samples/data). Passed subdirectories are used in LIFO order.

Parameters:

subdir - samples data sub directory

addSamplesDataSearchSubDirectory

@Namespace(value="cv::samples")
public static void addSamplesDataSearchSubDirectory(@opencv_core.Str
                                                                                    String subdir)

getThreadID

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

equals

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

getTrace

@Namespace(value="cv::instr")
public static 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()

CV_STRUCT_INITIALIZER

@MemberGetter
public static int CV_STRUCT_INITIALIZER()

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

See Also:

C++ class RNG replaced CvRNG.

cvRNG

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

cvRandInt
```
@Cast(value="unsigned")
public static int cvRandInt(@Cast(value="CvRNG*")
                                                    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*")
                                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)

cvIplImage

@ByVal
public static IplImage cvIplImage(@Const @ByRef
                                         Mat m)

cvIplImage

@ByVal
public static IplImage cvIplImage()

IPL_IMAGE_MAGIC_VAL

@MemberGetter
public static int IPL_IMAGE_MAGIC_VAL()

cvMat

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

cvMat

@ByVal
public static CvMat cvMat(int rows,
                                 int cols,
                                 int type,
                                 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 CvMat cvMat(int rows,
                                 int cols,
                                 int type)

cvMat
```
@ByVal
public static CvMat cvMat()
```

cvMat

@ByVal
public static CvMat cvMat(@Const @ByRef
                                 CvMat m)

cvmGet
```
public static double cvmGet(@Const
                            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(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)

cvMatND

@ByVal
public static CvMatND cvMatND(@Const @ByRef
                                     Mat m)

cvMatND

@ByVal
public static CvMatND cvMatND()

cvCreateSparseMat

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

cvRect

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

constructs CvRect structure.

cvRect

@ByVal
public static CvRect cvRect(@Const @ByRef
                                   Rect rc)

cvRectToROI

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

cvROIToRect

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

cvTermCriteria

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

cvTermCriteria

@ByVal
public static CvTermCriteria cvTermCriteria(@Const @ByRef
                                                   TermCriteria t)

cvPoint

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

constructs CvPoint structure.

cvPoint

@ByVal
public static CvPoint cvPoint(@Const @ByRef
                                     Point pt)

cvPoint2D32f

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

constructs CvPoint2D32f structure.

cvPointTo32f

@ByVal
public static CvPoint2D32f cvPointTo32f(@ByVal
                                               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 CvPoint cvPointFrom32f(@ByVal
                                            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 CvPoint3D32f cvPoint3D32f(double x,
                                               double y,
                                               double z)

constructs CvPoint3D32f structure.

cvPoint2D64f

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

constructs CvPoint2D64f structure.

cvPoint3D64f

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

constructs CvPoint3D64f structure.

cvSize

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

constructs CvSize structure.

cvSize

@ByVal
public static CvSize cvSize(@Const @ByRef
                                   Size sz)

cvSize2D32f

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

constructs CvSize2D32f structure.

cvBox2D

@ByVal
public static CvBox2D cvBox2D(@ByVal(nullValue="CvPoint2D32f()")
                                     CvPoint2D32f c,
                                     @ByVal(nullValue="CvSize2D32f()")
                                     CvSize2D32f s,
                                     float a)

cvBox2D

@ByVal
public static CvBox2D cvBox2D()

cvBox2D

@ByVal
public static CvBox2D cvBox2D(@ByVal(nullValue="CvPoint2D32f()") @Cast(value="CvPoint2D32f*")
                                     FloatBuffer c,
                                     @ByVal(nullValue="CvSize2D32f()")
                                     CvSize2D32f s,
                                     float a)

cvBox2D

@ByVal
public static CvBox2D cvBox2D(@ByVal(nullValue="CvPoint2D32f()") @Cast(value="CvPoint2D32f*")
                                     float[] c,
                                     @ByVal(nullValue="CvSize2D32f()")
                                     CvSize2D32f s,
                                     float a)

cvBox2D

@ByVal
public static CvBox2D cvBox2D(@Const @ByRef
                                     RotatedRect rr)

cvSlice

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

cvSlice

@ByVal
public static CvSlice cvSlice(@Const @ByRef
                                     Range r)

cvScalar

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

cvScalar

@ByVal
public static CvScalar cvScalar(double val0)

cvScalar

@ByVal
public static CvScalar cvScalar()

cvScalar

@ByVal
public static CvScalar cvScalar(@Const @ByRef
                                       Scalar s)

cvRealScalar

@ByVal
public static CvScalar cvRealScalar(double val0)

cvScalarAll

@ByVal
public static CvScalar cvScalarAll(double val0123)

CV_SET_ELEM_FREE_FLAG

@MemberGetter
public static int CV_SET_ELEM_FREE_FLAG()

CV_SEQ_ELTYPE_PTR

@MemberGetter
public static int CV_SEQ_ELTYPE_PTR()

CV_SEQ_ELTYPE_PPOINT

@MemberGetter
public static int CV_SEQ_ELTYPE_PPOINT()

&(x,y)

cvAlloc
```
public static 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_(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 IplImage cvCreateImageHeader(@ByVal
                                           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 IplImage cvInitImageHeader(IplImage image,
                                         @ByVal
                                         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 IplImage cvInitImageHeader(IplImage image,
                                         @ByVal
                                         CvSize size,
                                         int depth,
                                         int channels)

cvCreateImage
```
public static IplImage cvCreateImage(@ByVal
                                     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**")
                                        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
                                        IplImage image)

cvReleaseImage

public static void cvReleaseImage(@Cast(value="IplImage**")
                                  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
                                  IplImage image)

cvCloneImage

public static IplImage cvCloneImage(@Const
                                    IplImage image)

Creates a copy of IPL image (widthStep may differ)

cvSetImageCOI
```
public static void cvSetImageCOI(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
                                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(IplImage image,
                                 @ByVal
                                 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(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 CvRect cvGetImageROI(@Const
                                          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 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 CvMat cvInitMatHeader(CvMat mat,
                                    int rows,
                                    int cols,
                                    int type,
                                    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 CvMat cvInitMatHeader(CvMat mat,
                                    int rows,
                                    int cols,
                                    int type)

cvCreateMat
```
public static 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**")
                                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
                                CvMat mat)

cvDecRefData
```
public static void cvDecRefData(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(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 CvMat cvCloneMat(@Const
                               CvMat mat)

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

cvGetSubRect
```
public static CvMat cvGetSubRect(@Const
                                 CvArr arr,
                                 CvMat submat,
                                 @ByVal
                                 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 CvMat cvGetSubArr(CvArr arg1,
                                CvMat arg2,
                                @ByVal
                                CvRect arg3)

cvGetRows
```
public static CvMat cvGetRows(@Const
                              CvArr arr,
                              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 CvMat cvGetRows(@Const
                              CvArr arr,
                              CvMat submat,
                              int start_row,
                              int end_row)

cvGetRow

public static CvMat cvGetRow(@Const
                             CvArr arr,
                             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 CvMat cvGetCols(@Const
                              CvArr arr,
                              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 CvMat cvGetCol(@Const
                             CvArr arr,
                             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 CvMat cvGetDiag(@Const
                              CvArr arr,
                              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 CvMat cvGetDiag(@Const
                              CvArr arr,
                              CvMat submat)

cvScalarToRawData

public static void cvScalarToRawData(@Const
                                     CvScalar scalar,
                                     Pointer data,
                                     int type,
                                     int extend_to_12)

low-level scalar <-> raw data conversion functions

cvScalarToRawData

public static void cvScalarToRawData(@Const
                                     CvScalar scalar,
                                     Pointer data,
                                     int type)

cvRawDataToScalar

public static void cvRawDataToScalar(@Const
                                     Pointer data,
                                     int type,
                                     CvScalar scalar)

cvCreateMatNDHeader
```
public static CvMatND cvCreateMatNDHeader(int dims,
                                          @Const
                                          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 CvMatND cvCreateMatNDHeader(int dims,
                                          @Const
                                          IntBuffer sizes,
                                          int type)

cvCreateMatNDHeader

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

cvCreateMatND

public static CvMatND cvCreateMatND(int dims,
                                    @Const
                                    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 CvMatND cvCreateMatND(int dims,
                                    @Const
                                    IntBuffer sizes,
                                    int type)

cvCreateMatND

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

cvInitMatNDHeader

public static CvMatND cvInitMatNDHeader(CvMatND mat,
                                        int dims,
                                        @Const
                                        IntPointer sizes,
                                        int type,
                                        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 CvMatND cvInitMatNDHeader(CvMatND mat,
                                        int dims,
                                        @Const
                                        IntPointer sizes,
                                        int type)

cvInitMatNDHeader

public static CvMatND cvInitMatNDHeader(CvMatND mat,
                                        int dims,
                                        @Const
                                        IntBuffer sizes,
                                        int type,
                                        Pointer data)

cvInitMatNDHeader

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

cvInitMatNDHeader

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

cvInitMatNDHeader

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

cvReleaseMatND
```
public static void cvReleaseMatND(@Cast(value="CvMatND**")
                                  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
                                  CvMatND mat)

cvCloneMatND

public static CvMatND cvCloneMatND(@Const
                                   CvMatND mat)

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

cvCreateSparseMat
```
public static CvSparseMat cvCreateSparseMat(int dims,
                                            @Const
                                            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 2^{16} ).

sizes - Array of dimension sizes

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

cvCreateSparseMat

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

cvCreateSparseMat

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

cvReleaseSparseMat
```
public static void cvReleaseSparseMat(@Cast(value="CvSparseMat**")
                                      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
                                      CvSparseMat mat)

cvCloneSparseMat

public static CvSparseMat cvCloneSparseMat(@Const
                                           CvSparseMat mat)

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

cvInitSparseMatIterator

public static CvSparseNode cvInitSparseMatIterator(@Const
                                                   CvSparseMat mat,
                                                   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 CvSparseNode cvGetNextSparseNode(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**")
                                       PointerPointer arrs,
                                       @Const
                                       CvArr mask,
                                       CvMatND stubs,
                                       CvNArrayIterator array_iterator,
                                       int flags)

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

cvInitNArrayIterator

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

cvInitNArrayIterator

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

cvNextNArraySlice
```
public static int cvNextNArraySlice(CvNArrayIterator array_iterator)
```
returns zero value if iteration is finished, non-zero (slice length) otherwise

cvGetElemType
```
public static int cvGetElemType(@Const
                                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
                            CvArr arr,
                            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
                            CvArr arr)

cvGetDims

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

cvGetDims

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

cvGetDimSize
```
public static int cvGetDimSize(@Const
                               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 BytePointer cvPtr1D(@Const
                                                        CvArr arr,
                                                        int idx0,
                                                        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 BytePointer cvPtr1D(@Const
                                                        CvArr arr,
                                                        int idx0)

cvPtr1D

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

cvPtr1D

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

cvPtr2D

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

\overload

cvPtr2D

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

cvPtr2D

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

cvPtr2D

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

cvPtr3D

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

\overload

cvPtr3D

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

cvPtr3D

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

cvPtr3D

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

cvPtrND

@Cast(value="uchar*")
public static BytePointer cvPtrND(@Const
                                                        CvArr arr,
                                                        @Const
                                                        IntPointer idx,
                                                        IntPointer type,
                                                        int create_node,
                                                        @Cast(value="unsigned*")
                                                        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 BytePointer cvPtrND(@Const
                                                        CvArr arr,
                                                        @Const
                                                        IntPointer idx)

cvPtrND

@Cast(value="uchar*")
public static ByteBuffer cvPtrND(@Const
                                                       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
                                                       CvArr arr,
                                                       @Const
                                                       IntBuffer idx)

cvPtrND

@Cast(value="uchar*")
public static byte[] cvPtrND(@Const
                                                   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
                                                   CvArr arr,
                                                   @Const
                                                   int[] idx)

cvGet1D
```
@ByVal
public static CvScalar cvGet1D(@Const
                                      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 CvScalar cvGet2D(@Const
                                      CvArr arr,
                                      int idx0,
                                      int idx1)

\overload

cvGet3D

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

\overload

cvGetND

@ByVal
public static CvScalar cvGetND(@Const
                                      CvArr arr,
                                      @Const
                                      IntPointer idx)

\overload

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

cvGetND

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

cvGetND

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

cvGetReal1D
```
public static double cvGetReal1D(@Const
                                 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
                                 CvArr arr,
                                 int idx0,
                                 int idx1)

\overload

cvGetReal3D

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

\overload

cvGetRealND

public static double cvGetRealND(@Const
                                 CvArr arr,
                                 @Const
                                 IntPointer idx)

\overload

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

cvGetRealND

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

cvGetRealND

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

cvSet1D
```
public static void cvSet1D(CvArr arr,
                           int idx0,
                           @ByVal
                           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(CvArr arr,
                           int idx0,
                           int idx1,
                           @ByVal
                           CvScalar value)

\overload

cvSet3D

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

\overload

cvSetND

public static void cvSetND(CvArr arr,
                           @Const
                           IntPointer idx,
                           @ByVal
                           CvScalar value)

\overload

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

cvSetND

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

cvSetND

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

cvSetReal1D
```
public static void cvSetReal1D(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(CvArr arr,
                               int idx0,
                               int idx1,
                               double value)

\overload

cvSetReal3D

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

\overload

cvSetRealND

public static void cvSetRealND(CvArr arr,
                               @Const
                               IntPointer idx,
                               double value)

\overload

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

cvSetRealND

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

cvSetRealND

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

cvClearND

public static void cvClearND(CvArr arr,
                             @Const
                             IntPointer idx)

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

cvClearND

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

cvClearND

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

cvGetMat
```
public static CvMat cvGetMat(@Const
                             CvArr arr,
                             CvMat header,
                             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.

See Also:

cvGetImage, cvarrToMat.

cvGetMat

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

cvGetMat

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

cvGetMat

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

cvGetImage
```
public static IplImage cvGetImage(@Const
                                  CvArr arr,
                                  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 CvArr cvReshapeMatND(@Const
                                   CvArr arr,
                                   int sizeof_header,
                                   CvArr header,
                                   int new_cn,
                                   int new_dims,
                                   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 CvArr cvReshapeMatND(@Const
                                   CvArr arr,
                                   int sizeof_header,
                                   CvArr header,
                                   int new_cn,
                                   int new_dims,
                                   IntBuffer new_sizes)

cvReshapeMatND

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

cvReshape
```
public static CvMat cvReshape(@Const
                              CvArr arr,
                              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 CvMat cvReshape(@Const
                              CvArr arr,
                              CvMat header,
                              int new_cn)

cvRepeat

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

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

cvCreateData
```
public static void cvCreateData(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(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(CvArr arr,
                             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
                                CvArr arr,
                                @Cast(value="uchar**")
                                PointerPointer data,
                                IntPointer step,
                                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
                                CvArr arr,
                                @Cast(value="uchar**") @ByPtrPtr
                                BytePointer data)

cvGetRawData

public static void cvGetRawData(@Const
                                CvArr arr,
                                @Cast(value="uchar**") @ByPtrPtr
                                BytePointer data,
                                IntPointer step,
                                CvSize roi_size)

cvGetRawData

public static void cvGetRawData(@Const
                                CvArr arr,
                                @Cast(value="uchar**") @ByPtrPtr
                                ByteBuffer data,
                                IntBuffer step,
                                CvSize roi_size)

cvGetRawData

public static void cvGetRawData(@Const
                                CvArr arr,
                                @Cast(value="uchar**") @ByPtrPtr
                                ByteBuffer data)

cvGetRawData

public static void cvGetRawData(@Const
                                CvArr arr,
                                @Cast(value="uchar**") @ByPtrPtr
                                byte[] data,
                                int[] step,
                                CvSize roi_size)

cvGetRawData

public static void cvGetRawData(@Const
                                CvArr arr,
                                @Cast(value="uchar**") @ByPtrPtr
                                byte[] data)

cvGetSize
```
@ByVal
public static CvSize cvGetSize(@Const
                                      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
                          CvArr src,
                          CvArr dst,
                          @Const
                          CvArr mask)
```
\brief Copies one array to another.
The function copies selected elements from an input array to an output array:
```
 \[\texttt{dst} (I)= \texttt{src} (I)  \quad \text{if} \quad \texttt{mask} (I)  \ne 0.\]
```
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
                          CvArr src,
                          CvArr dst)

cvSet
```
public static void cvSet(CvArr arr,
                         @ByVal
                         CvScalar value,
                         @Const
                         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:
```
 \[\texttt{arr} (I)= \texttt{value} \quad \text{if} \quad \texttt{mask} (I)  \ne 0\]
```
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(CvArr arr,
                         @ByVal
                         CvScalar value)

cvSetZero
```
public static void cvSetZero(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(CvArr arg1)

cvSplit

public static void cvSplit(@Const
                           CvArr src,
                           CvArr dst0,
                           CvArr dst1,
                           CvArr dst2,
                           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
                           CvArr src0,
                           @Const
                           CvArr src1,
                           @Const
                           CvArr src2,
                           @Const
                           CvArr src3,
                           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**")
                                 PointerPointer src,
                                 int src_count,
                                 @Cast(value="CvArr**")
                                 PointerPointer dst,
                                 int dst_count,
                                 @Const
                                 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
                                 CvArr src,
                                 int src_count,
                                 @ByPtrPtr
                                 CvArr dst,
                                 int dst_count,
                                 @Const
                                 IntPointer from_to,
                                 int pair_count)

cvMixChannels

public static void cvMixChannels(@Const @ByPtrPtr
                                 CvArr src,
                                 int src_count,
                                 @ByPtrPtr
                                 CvArr dst,
                                 int dst_count,
                                 @Const
                                 IntBuffer from_to,
                                 int pair_count)

cvMixChannels

public static void cvMixChannels(@Const @ByPtrPtr
                                 CvArr src,
                                 int src_count,
                                 @ByPtrPtr
                                 CvArr dst,
                                 int dst_count,
                                 @Const
                                 int[] from_to,
                                 int pair_count)

cvConvertScale
```
public static void cvConvertScale(@Const
                                  CvArr src,
                                  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:
```
 \[\texttt{dst} (I) =  \texttt{scale} \texttt{src} (I) + ( \texttt{shift} _0, \texttt{shift} _1,...)\]
```
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
                                  CvArr src,
                                  CvArr dst)

cvCvtScale

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

cvScale

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

cvConvert

public static void cvConvert(CvArr src,
                             CvArr dst)

cvConvertScaleAbs

public static void cvConvertScaleAbs(@Const
                                     CvArr src,
                                     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
                                     CvArr src,
                                     CvArr dst)

cvCvtScaleAbs

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

cvCheckTermCriteria

@ByVal
public static CvTermCriteria cvCheckTermCriteria(@ByVal
                                                        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
                         CvArr src1,
                         @Const
                         CvArr src2,
                         CvArr dst,
                         @Const
                         CvArr mask)

dst(mask) = src1(mask) + src2(mask)

cvAdd

public static void cvAdd(@Const
                         CvArr src1,
                         @Const
                         CvArr src2,
                         CvArr dst)

cvAddS

public static void cvAddS(@Const
                          CvArr src,
                          @ByVal
                          CvScalar value,
                          CvArr dst,
                          @Const
                          CvArr mask)

dst(mask) = src(mask) + value

cvAddS

public static void cvAddS(@Const
                          CvArr src,
                          @ByVal
                          CvScalar value,
                          CvArr dst)

cvSub

public static void cvSub(@Const
                         CvArr src1,
                         @Const
                         CvArr src2,
                         CvArr dst,
                         @Const
                         CvArr mask)

dst(mask) = src1(mask) - src2(mask)

cvSub

public static void cvSub(@Const
                         CvArr src1,
                         @Const
                         CvArr src2,
                         CvArr dst)

cvSubS

public static void cvSubS(@Const
                          CvArr src,
                          @ByVal
                          CvScalar value,
                          CvArr dst,
                          @Const
                          CvArr mask)

dst(mask) = src(mask) - value = src(mask) + (-value)

cvSubS

public static void cvSubS(@Const
                          CvArr src,
                          @ByVal
                          CvScalar value,
                          CvArr dst)

cvSubRS

public static void cvSubRS(@Const
                           CvArr src,
                           @ByVal
                           CvScalar value,
                           CvArr dst,
                           @Const
                           CvArr mask)

dst(mask) = value - src(mask)

cvSubRS

public static void cvSubRS(@Const
                           CvArr src,
                           @ByVal
                           CvScalar value,
                           CvArr dst)

cvMul

public static void cvMul(@Const
                         CvArr src1,
                         @Const
                         CvArr src2,
                         CvArr dst,
                         double scale)

dst(idx) = src1(idx) * src2(idx) * scale (scaled element-wise multiplication of 2 arrays)

cvMul

public static void cvMul(@Const
                         CvArr src1,
                         @Const
                         CvArr src2,
                         CvArr dst)

cvDiv

public static void cvDiv(@Const
                         CvArr src1,
                         @Const
                         CvArr src2,
                         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
                         CvArr src1,
                         @Const
                         CvArr src2,
                         CvArr dst)

cvScaleAdd

public static void cvScaleAdd(@Const
                              CvArr src1,
                              @ByVal
                              CvScalar scale,
                              @Const
                              CvArr src2,
                              CvArr dst)

dst = src1 * scale + src2

cvAddWeighted

public static void cvAddWeighted(@Const
                                 CvArr src1,
                                 double alpha,
                                 @Const
                                 CvArr src2,
                                 double beta,
                                 double gamma,
                                 CvArr dst)

dst = src1 * alpha + src2 * beta + gamma

cvDotProduct
```
public static double cvDotProduct(@Const
                                  CvArr src1,
                                  @Const
                                  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.
```
 \[src1  \bullet src2 =  \sum _I ( \texttt{src1} (I)  \texttt{src2} (I))\]
```
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 ||\texttt{a}||^2. 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
                         CvArr src1,
                         @Const
                         CvArr src2,
                         CvArr dst,
                         @Const
                         CvArr mask)

dst(idx) = src1(idx) & src2(idx)

cvAnd

public static void cvAnd(@Const
                         CvArr src1,
                         @Const
                         CvArr src2,
                         CvArr dst)

cvAndS

public static void cvAndS(@Const
                          CvArr src,
                          @ByVal
                          CvScalar value,
                          CvArr dst,
                          @Const
                          CvArr mask)

dst(idx) = src(idx) & value

cvAndS

public static void cvAndS(@Const
                          CvArr src,
                          @ByVal
                          CvScalar value,
                          CvArr dst)

cvOr

public static void cvOr(@Const
                        CvArr src1,
                        @Const
                        CvArr src2,
                        CvArr dst,
                        @Const
                        CvArr mask)

dst(idx) = src1(idx) | src2(idx)

cvOr

public static void cvOr(@Const
                        CvArr src1,
                        @Const
                        CvArr src2,
                        CvArr dst)

cvOrS

public static void cvOrS(@Const
                         CvArr src,
                         @ByVal
                         CvScalar value,
                         CvArr dst,
                         @Const
                         CvArr mask)

dst(idx) = src(idx) | value

cvOrS

public static void cvOrS(@Const
                         CvArr src,
                         @ByVal
                         CvScalar value,
                         CvArr dst)

cvXor

public static void cvXor(@Const
                         CvArr src1,
                         @Const
                         CvArr src2,
                         CvArr dst,
                         @Const
                         CvArr mask)

dst(idx) = src1(idx) ^ src2(idx)

cvXor

public static void cvXor(@Const
                         CvArr src1,
                         @Const
                         CvArr src2,
                         CvArr dst)

cvXorS

public static void cvXorS(@Const
                          CvArr src,
                          @ByVal
                          CvScalar value,
                          CvArr dst,
                          @Const
                          CvArr mask)

dst(idx) = src(idx) ^ value

cvXorS

public static void cvXorS(@Const
                          CvArr src,
                          @ByVal
                          CvScalar value,
                          CvArr dst)

cvNot

public static void cvNot(@Const
                         CvArr src,
                         CvArr dst)

dst(idx) = ~src(idx)

cvInRange

public static void cvInRange(@Const
                             CvArr src,
                             @Const
                             CvArr lower,
                             @Const
                             CvArr upper,
                             CvArr dst)

dst(idx) = lower(idx) <= src(idx) < upper(idx)

cvInRangeS

public static void cvInRangeS(@Const
                              CvArr src,
                              @ByVal
                              CvScalar lower,
                              @ByVal
                              CvScalar upper,
                              CvArr dst)

dst(idx) = lower <= src(idx) < upper

cvCmp

public static void cvCmp(@Const
                         CvArr src1,
                         @Const
                         CvArr src2,
                         CvArr dst,
                         int cmp_op)

dst(idx) = src1(idx) _cmp_op_ src2(idx)

cvCmpS

public static void cvCmpS(@Const
                          CvArr src,
                          double value,
                          CvArr dst,
                          int cmp_op)

dst(idx) = src1(idx) _cmp_op_ value

cvMin

public static void cvMin(@Const
                         CvArr src1,
                         @Const
                         CvArr src2,
                         CvArr dst)

dst(idx) = min(src1(idx),src2(idx))

cvMax

public static void cvMax(@Const
                         CvArr src1,
                         @Const
                         CvArr src2,
                         CvArr dst)

dst(idx) = max(src1(idx),src2(idx))

cvMinS

public static void cvMinS(@Const
                          CvArr src,
                          double value,
                          CvArr dst)

dst(idx) = min(src(idx),value)

cvMaxS

public static void cvMaxS(@Const
                          CvArr src,
                          double value,
                          CvArr dst)

dst(idx) = max(src(idx),value)

cvAbsDiff

public static void cvAbsDiff(@Const
                             CvArr src1,
                             @Const
                             CvArr src2,
                             CvArr dst)

dst(x,y,c) = abs(src1(x,y,c) - src2(x,y,c))

cvAbsDiffS

public static void cvAbsDiffS(@Const
                              CvArr src,
                              CvArr dst,
                              @ByVal
                              CvScalar value)

dst(x,y,c) = abs(src(x,y,c) - value(c))

cvCartToPolar

public static void cvCartToPolar(@Const
                                 CvArr x,
                                 @Const
                                 CvArr y,
                                 CvArr magnitude,
                                 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
                                 CvArr x,
                                 @Const
                                 CvArr y,
                                 CvArr magnitude)

cvPolarToCart

public static void cvPolarToCart(@Const
                                 CvArr magnitude,
                                 @Const
                                 CvArr angle,
                                 CvArr x,
                                 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
                                 CvArr magnitude,
                                 @Const
                                 CvArr angle,
                                 CvArr x,
                                 CvArr y)

cvPow

public static void cvPow(@Const
                         CvArr src,
                         CvArr dst,
                         double power)

Does powering: dst(idx) = src(idx)^power

cvExp
```
public static void cvExp(@Const
                         CvArr src,
                         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
                         CvArr src,
                         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
                             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
                             CvArr arr)

cvCheckArray

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

cvRandArr
```
public static void cvRandArr(@Cast(value="CvRNG*")
                             LongPointer rng,
                             CvArr arr,
                             int dist_type,
                             @ByVal
                             CvScalar param1,
                             @ByVal
                             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.

See Also:

randu, randn, RNG::fill.

cvRandArr

public static void cvRandArr(@Cast(value="CvRNG*")
                             LongBuffer rng,
                             CvArr arr,
                             int dist_type,
                             @ByVal
                             CvScalar param1,
                             @ByVal
                             CvScalar param2)

cvRandArr

public static void cvRandArr(@Cast(value="CvRNG*")
                             long[] rng,
                             CvArr arr,
                             int dist_type,
                             @ByVal
                             CvScalar param1,
                             @ByVal
                             CvScalar param2)

cvRandShuffle

public static void cvRandShuffle(CvArr mat,
                                 @Cast(value="CvRNG*")
                                 LongPointer rng,
                                 double iter_factor)

cvRandShuffle

public static void cvRandShuffle(CvArr mat,
                                 @Cast(value="CvRNG*")
                                 LongPointer rng)

cvRandShuffle

public static void cvRandShuffle(CvArr mat,
                                 @Cast(value="CvRNG*")
                                 LongBuffer rng,
                                 double iter_factor)

cvRandShuffle

public static void cvRandShuffle(CvArr mat,
                                 @Cast(value="CvRNG*")
                                 LongBuffer rng)

cvRandShuffle

public static void cvRandShuffle(CvArr mat,
                                 @Cast(value="CvRNG*")
                                 long[] rng,
                                 double iter_factor)

cvRandShuffle

public static void cvRandShuffle(CvArr mat,
                                 @Cast(value="CvRNG*")
                                 long[] rng)

cvSort

public static void cvSort(@Const
                          CvArr src,
                          CvArr dst,
                          CvArr idxmat,
                          int flags)

cvSort

public static void cvSort(@Const
                          CvArr src)

cvSolveCubic

public static int cvSolveCubic(@Const
                               CvMat coeffs,
                               CvMat roots)

Finds real roots of a cubic equation

cvSolvePoly

public static void cvSolvePoly(@Const
                               CvMat coeffs,
                               CvMat roots2,
                               int maxiter,
                               int fig)

Finds all real and complex roots of a polynomial equation

cvSolvePoly

public static void cvSolvePoly(@Const
                               CvMat coeffs,
                               CvMat roots2)

cvCrossProduct

public static void cvCrossProduct(@Const
                                  CvArr src1,
                                  @Const
                                  CvArr src2,
                                  CvArr dst)

\brief Calculates the cross product of two 3D vectors.

The function calculates the cross product of two 3D vectors:

 \[\texttt{dst} =  \texttt{src1} \times \texttt{src2}\]

or:

 \[\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}\]

Parameters:: src1 - The first source vector; src2 - The second source vector; dst - The destination vector

cvMatMulAdd

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

Matrix transform: dst = A*B + C, C is optional

cvMatMul

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

cvGEMM

public static void cvGEMM(@Const
                          CvArr src1,
                          @Const
                          CvArr src2,
                          double alpha,
                          @Const
                          CvArr src3,
                          double beta,
                          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
                          CvArr src1,
                          @Const
                          CvArr src2,
                          double alpha,
                          @Const
                          CvArr src3,
                          double beta,
                          CvArr dst)

cvMatMulAddEx

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

cvTransform

public static void cvTransform(@Const
                               CvArr src,
                               CvArr dst,
                               @Const
                               CvMat transmat,
                               @Const
                               CvMat shiftvec)

Transforms each element of source array and stores resultant vectors in destination array

cvTransform

public static void cvTransform(@Const
                               CvArr src,
                               CvArr dst,
                               @Const
                               CvMat transmat)

cvMatMulAddS

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

cvPerspectiveTransform

public static void cvPerspectiveTransform(@Const
                                          CvArr src,
                                          CvArr dst,
                                          @Const
                                          CvMat mat)

Does perspective transform on every element of input array

cvMulTransposed

public static void cvMulTransposed(@Const
                                   CvArr src,
                                   CvArr dst,
                                   int order,
                                   @Const
                                   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
                                   CvArr src,
                                   CvArr dst,
                                   int order)

cvTranspose

public static void cvTranspose(@Const
                               CvArr src,
                               CvArr dst)

Transposes matrix. Square matrices can be transposed in-place

cvT

public static void cvT(CvArr arg1,
                       CvArr arg2)

cvCompleteSymm
```
public static void cvCompleteSymm(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(CvMat matrix)

cvFlip

public static void cvFlip(@Const
                          CvArr src,
                          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
                          CvArr src)

cvMirror

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

cvSVD

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

Performs Singular Value Decomposition of a matrix

cvSVD

public static void cvSVD(CvArr A,
                         CvArr W)

cvSVBkSb

public static void cvSVBkSb(@Const
                            CvArr W,
                            @Const
                            CvArr U,
                            @Const
                            CvArr V,
                            @Const
                            CvArr B,
                            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
                              CvArr src,
                              CvArr dst,
                              int method)

Inverts matrix

cvInvert

public static double cvInvert(@Const
                              CvArr src,
                              CvArr dst)

cvInv

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

cvSolve

public static int cvSolve(@Const
                          CvArr src1,
                          @Const
                          CvArr src2,
                          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
                          CvArr src1,
                          @Const
                          CvArr src2,
                          CvArr dst)

cvDet

public static double cvDet(@Const
                           CvArr mat)

Calculates determinant of input matrix

cvTrace

@ByVal
public static CvScalar cvTrace(@Const
                                      CvArr mat)

Calculates trace of the matrix (sum of elements on the main diagonal)

cvEigenVV

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

Finds eigen values and vectors of a symmetric matrix

cvEigenVV

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

cvSetIdentity

public static void cvSetIdentity(CvArr mat,
                                 @ByVal(nullValue="CvScalar(cvRealScalar(1))")
                                 CvScalar value)

Makes an identity matrix (mat_ij = i == j)

cvSetIdentity

public static void cvSetIdentity(CvArr mat)

cvRange

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

Fills matrix with given range of numbers

cvCalcCovarMatrix

public static void cvCalcCovarMatrix(@Cast(value="const CvArr**")
                                     PointerPointer vects,
                                     int count,
                                     CvArr cov_mat,
                                     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
                                     CvArr vects,
                                     int count,
                                     CvArr cov_mat,
                                     CvArr avg,
                                     int flags)

cvCalcPCA

public static void cvCalcPCA(@Const
                             CvArr data,
                             CvArr mean,
                             CvArr eigenvals,
                             CvArr eigenvects,
                             int flags)

cvProjectPCA

public static void cvProjectPCA(@Const
                                CvArr data,
                                @Const
                                CvArr mean,
                                @Const
                                CvArr eigenvects,
                                CvArr result)

cvBackProjectPCA

public static void cvBackProjectPCA(@Const
                                    CvArr proj,
                                    @Const
                                    CvArr mean,
                                    @Const
                                    CvArr eigenvects,
                                    CvArr result)

cvMahalanobis

public static double cvMahalanobis(@Const
                                   CvArr vec1,
                                   @Const
                                   CvArr vec2,
                                   @Const
                                   CvArr mat)

Calculates Mahalanobis(weighted) distance

cvMahalonobis

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

cvSum

@ByVal
public static CvScalar cvSum(@Const
                                    CvArr arr)

Finds sum of array elements

cvCountNonZero

public static int cvCountNonZero(@Const
                                 CvArr arr)

Calculates number of non-zero pixels

cvAvg

@ByVal
public static CvScalar cvAvg(@Const
                                    CvArr arr,
                                    @Const
                                    CvArr mask)

Calculates mean value of array elements

cvAvg

@ByVal
public static CvScalar cvAvg(@Const
                                    CvArr arr)

cvAvgSdv

public static void cvAvgSdv(@Const
                            CvArr arr,
                            CvScalar mean,
                            CvScalar std_dev,
                            @Const
                            CvArr mask)

Calculates mean and standard deviation of pixel values

cvAvgSdv

public static void cvAvgSdv(@Const
                            CvArr arr,
                            CvScalar mean,
                            CvScalar std_dev)

cvMinMaxLoc

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

Finds global minimum, maximum and their positions

cvMinMaxLoc

public static void cvMinMaxLoc(@Const
                               CvArr arr,
                               DoublePointer min_val,
                               DoublePointer max_val)

cvMinMaxLoc

public static void cvMinMaxLoc(@Const
                               CvArr arr,
                               DoubleBuffer min_val,
                               DoubleBuffer max_val,
                               @Cast(value="CvPoint*")
                               IntBuffer min_loc,
                               @Cast(value="CvPoint*")
                               IntBuffer max_loc,
                               @Const
                               CvArr mask)

cvMinMaxLoc

public static void cvMinMaxLoc(@Const
                               CvArr arr,
                               DoubleBuffer min_val,
                               DoubleBuffer max_val)

cvMinMaxLoc

public static void cvMinMaxLoc(@Const
                               CvArr arr,
                               double[] min_val,
                               double[] max_val,
                               @Cast(value="CvPoint*")
                               int[] min_loc,
                               @Cast(value="CvPoint*")
                               int[] max_loc,
                               @Const
                               CvArr mask)

cvMinMaxLoc

public static void cvMinMaxLoc(@Const
                               CvArr arr,
                               double[] min_val,
                               double[] max_val)

cvNorm

public static double cvNorm(@Const
                            CvArr arr1,
                            @Const
                            CvArr arr2,
                            int norm_type,
                            @Const
                            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
                            CvArr arr1)

cvNormalize

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

See Also:: core_c_NormFlags "flags"

cvNormalize

public static void cvNormalize(@Const
                               CvArr src,
                               CvArr dst)

cvReduce

public static void cvReduce(@Const
                            CvArr src,
                            CvArr dst,
                            int dim,
                            int op)

See Also:: core_c_ReduceFlags "flags"

cvReduce

public static void cvReduce(@Const
                            CvArr src,
                            CvArr dst)

cvDFT

public static void cvDFT(@Const
                         CvArr src,
                         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
                         CvArr src,
                         CvArr dst,
                         int flags)

cvFFT

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

cvMulSpectrums

public static void cvMulSpectrums(@Const
                                  CvArr src1,
                                  @Const
                                  CvArr src2,
                                  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
                         CvArr src,
                         CvArr dst,
                         int flags)

Discrete Cosine Transform

See Also:: "flags"

cvSliceLength

public static int cvSliceLength(@ByVal
                                CvSlice slice,
                                @Const
                                CvSeq seq)

Calculates length of sequence slice (with support of negative indices).

cvCreateMemStorage
```
public static 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 CvMemStorage cvCreateMemStorage()

cvCreateChildMemStorage
```
public static CvMemStorage cvCreateChildMemStorage(CvMemStorage parent)
```
Creates a memory storage that will borrow memory blocks from parent storage

cvReleaseMemStorage
```
public static void cvReleaseMemStorage(@Cast(value="CvMemStorage**")
                                       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
                                       CvMemStorage storage)

cvClearMemStorage
```
public static void cvClearMemStorage(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
                                       CvMemStorage storage,
                                       CvMemStoragePos pos)

Remember a storage "free memory" position

cvRestoreMemStoragePos

public static void cvRestoreMemStoragePos(CvMemStorage storage,
                                          CvMemStoragePos pos)

Restore a storage "free memory" position

cvMemStorageAlloc

public static Pointer cvMemStorageAlloc(CvMemStorage storage,
                                        @Cast(value="size_t")
                                        long size)

Allocates continuous buffer of the specified size in the storage

cvCreateSeq

public static CvSeq cvCreateSeq(int seq_flags,
                                @Cast(value="size_t")
                                long header_size,
                                @Cast(value="size_t")
                                long elem_size,
                                CvMemStorage storage)

Creates new empty sequence that will reside in the specified storage

cvSetSeqBlockSize

public static void cvSetSeqBlockSize(CvSeq seq,
                                     int delta_elems)

Changes default size (granularity) of sequence blocks. The default size is ~1Kbyte

cvSeqPush

@Cast(value="schar*")
public static BytePointer cvSeqPush(CvSeq seq,
                                                          @Const
                                                          Pointer element)

Adds new element to the end of sequence. Returns pointer to the element

cvSeqPush

@Cast(value="schar*")
public static BytePointer cvSeqPush(CvSeq seq)

cvSeqPushFront

@Cast(value="schar*")
public static BytePointer cvSeqPushFront(CvSeq seq,
                                                               @Const
                                                               Pointer element)

Adds new element to the beginning of sequence. Returns pointer to it

cvSeqPushFront

@Cast(value="schar*")
public static BytePointer cvSeqPushFront(CvSeq seq)

cvSeqPop

public static void cvSeqPop(CvSeq seq,
                            Pointer element)

Removes the last element from sequence and optionally saves it

cvSeqPop

public static void cvSeqPop(CvSeq seq)

cvSeqPopFront

public static void cvSeqPopFront(CvSeq seq,
                                 Pointer element)

Removes the first element from sequence and optioanally saves it

cvSeqPopFront

public static void cvSeqPopFront(CvSeq seq)

cvSeqPushMulti

public static void cvSeqPushMulti(CvSeq seq,
                                  @Const
                                  Pointer elements,
                                  int count,
                                  int in_front)

Adds several new elements to the end of sequence

cvSeqPushMulti

public static void cvSeqPushMulti(CvSeq seq,
                                  @Const
                                  Pointer elements,
                                  int count)

cvSeqPopMulti

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

Removes several elements from the end of sequence and optionally saves them

cvSeqPopMulti

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

cvSeqInsert

@Cast(value="schar*")
public static BytePointer cvSeqInsert(CvSeq seq,
                                                            int before_index,
                                                            @Const
                                                            Pointer element)

Inserts a new element in the middle of sequence. cvSeqInsert(seq,0,elem) == cvSeqPushFront(seq,elem)

cvSeqInsert

@Cast(value="schar*")
public static BytePointer cvSeqInsert(CvSeq seq,
                                                            int before_index)

cvSeqRemove

public static void cvSeqRemove(CvSeq seq,
                               int index)

Removes specified sequence element

cvClearSeq
```
public static void cvClearSeq(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 BytePointer cvGetSeqElem(@Const
                                                             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
                               CvSeq seq,
                               @Const
                               Pointer element,
                               @Cast(value="CvSeqBlock**")
                               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
                               CvSeq seq,
                               @Const
                               Pointer element)

cvSeqElemIdx

public static int cvSeqElemIdx(@Const
                               CvSeq seq,
                               @Const
                               Pointer element,
                               @ByPtrPtr
                               CvSeqBlock block)

cvStartAppendToSeq

public static void cvStartAppendToSeq(CvSeq seq,
                                      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,
                                   CvMemStorage storage,
                                   CvSeqWriter writer)

Combination of cvCreateSeq and cvStartAppendToSeq

cvEndWriteSeq
```
public static CvSeq cvEndWriteSeq(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(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
                                  CvSeq seq,
                                  CvSeqReader reader,
                                  int reverse)

Initializes sequence reader. The sequence can be read in forward or backward direction

cvStartReadSeq

public static void cvStartReadSeq(@Const
                                  CvSeq seq,
                                  CvSeqReader reader)

cvGetSeqReaderPos
```
public static int cvGetSeqReaderPos(CvSeqReader reader)
```
Returns current sequence reader position (currently observed sequence element)

cvSetSeqReaderPos

public static void cvSetSeqReaderPos(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(CvSeqReader reader,
                                     int index)

cvCvtSeqToArray

public static Pointer cvCvtSeqToArray(@Const
                                      CvSeq seq,
                                      Pointer elements,
                                      @ByVal(nullValue="CvSlice(CV_WHOLE_SEQ)")
                                      CvSlice slice)

Copies sequence content to a continuous piece of memory

cvCvtSeqToArray

public static Pointer cvCvtSeqToArray(@Const
                                      CvSeq seq,
                                      Pointer elements)

cvMakeSeqHeaderForArray

public static CvSeq cvMakeSeqHeaderForArray(int seq_type,
                                            int header_size,
                                            int elem_size,
                                            Pointer elements,
                                            int total,
                                            CvSeq seq,
                                            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 CvSeq cvSeqSlice(@Const
                               CvSeq seq,
                               @ByVal
                               CvSlice slice,
                               CvMemStorage storage,
                               int copy_data)

Extracts sequence slice (with or without copying sequence elements)

cvSeqSlice

public static CvSeq cvSeqSlice(@Const
                               CvSeq seq,
                               @ByVal
                               CvSlice slice)

cvCloneSeq

public static CvSeq cvCloneSeq(@Const
                               CvSeq seq,
                               CvMemStorage storage)

cvCloneSeq

public static CvSeq cvCloneSeq(@Const
                               CvSeq seq)

cvSeqRemoveSlice

public static void cvSeqRemoveSlice(CvSeq seq,
                                    @ByVal
                                    CvSlice slice)

Removes sequence slice

cvSeqInsertSlice

public static void cvSeqInsertSlice(CvSeq seq,
                                    int before_index,
                                    @Const
                                    CvArr from_arr)

Inserts a sequence or array into another sequence

cvSeqSort

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

Sorts sequence in-place given element comparison function

cvSeqSort

public static void cvSeqSort(CvSeq seq,
                             CvCmpFunc func)

cvSeqSearch

@Cast(value="schar*")
public static BytePointer cvSeqSearch(CvSeq seq,
                                                            @Const
                                                            Pointer elem,
                                                            CvCmpFunc func,
                                                            int is_sorted,
                                                            IntPointer elem_idx,
                                                            Pointer userdata)

Finds element in a [sorted] sequence

cvSeqSearch

@Cast(value="schar*")
public static BytePointer cvSeqSearch(CvSeq seq,
                                                            @Const
                                                            Pointer elem,
                                                            CvCmpFunc func,
                                                            int is_sorted,
                                                            IntPointer elem_idx)

cvSeqSearch

@Cast(value="schar*")
public static ByteBuffer cvSeqSearch(CvSeq seq,
                                                           @Const
                                                           Pointer elem,
                                                           CvCmpFunc func,
                                                           int is_sorted,
                                                           IntBuffer elem_idx,
                                                           Pointer userdata)

cvSeqSearch

@Cast(value="schar*")
public static ByteBuffer cvSeqSearch(CvSeq seq,
                                                           @Const
                                                           Pointer elem,
                                                           CvCmpFunc func,
                                                           int is_sorted,
                                                           IntBuffer elem_idx)

cvSeqSearch

@Cast(value="schar*")
public static byte[] cvSeqSearch(CvSeq seq,
                                                       @Const
                                                       Pointer elem,
                                                       CvCmpFunc func,
                                                       int is_sorted,
                                                       int[] elem_idx,
                                                       Pointer userdata)

cvSeqSearch

@Cast(value="schar*")
public static byte[] cvSeqSearch(CvSeq seq,
                                                       @Const
                                                       Pointer elem,
                                                       CvCmpFunc func,
                                                       int is_sorted,
                                                       int[] elem_idx)

cvSeqInvert
```
public static void cvSeqInvert(CvSeq seq)
```
Reverses order of sequence elements in-place

cvSeqPartition

public static int cvSeqPartition(@Const
                                 CvSeq seq,
                                 CvMemStorage storage,
                                 @Cast(value="CvSeq**")
                                 PointerPointer labels,
                                 CvCmpFunc is_equal,
                                 Pointer userdata)

Splits sequence into one or more equivalence classes using the specified criteria

cvSeqPartition

public static int cvSeqPartition(@Const
                                 CvSeq seq,
                                 CvMemStorage storage,
                                 @ByPtrPtr
                                 CvSeq labels,
                                 CvCmpFunc is_equal,
                                 Pointer userdata)

cvChangeSeqBlock

public static void cvChangeSeqBlock(Pointer reader,
                                    int direction)

Internal sequence functions

cvCreateSeqBlock

public static void cvCreateSeqBlock(CvSeqWriter writer)

cvCreateSet

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

Creates a new set

cvSetAdd

public static int cvSetAdd(CvSet set_header,
                           CvSetElem elem,
                           @Cast(value="CvSetElem**")
                           PointerPointer inserted_elem)

Adds new element to the set and returns pointer to it

cvSetAdd

public static int cvSetAdd(CvSet set_header)

cvSetAdd

public static int cvSetAdd(CvSet set_header,
                           CvSetElem elem,
                           @ByPtrPtr
                           CvSetElem inserted_elem)

cvSetNew

public static CvSetElem cvSetNew(CvSet set_header)

Fast variant of cvSetAdd

cvSetRemoveByPtr

public static void cvSetRemoveByPtr(CvSet set_header,
                                    Pointer elem)

Removes set element given its pointer

cvSetRemove

public static void cvSetRemove(CvSet set_header,
                               int index)

Removes element from the set by its index

cvGetSetElem

public static CvSetElem cvGetSetElem(@Const
                                     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(CvSet set_header)

Removes all the elements from the set

cvCreateGraph

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

Creates new graph

cvGraphAddVtx

public static int cvGraphAddVtx(CvGraph graph,
                                @Const
                                CvGraphVtx vtx,
                                @Cast(value="CvGraphVtx**")
                                PointerPointer inserted_vtx)

Adds new vertex to the graph

cvGraphAddVtx

public static int cvGraphAddVtx(CvGraph graph)

cvGraphAddVtx

public static int cvGraphAddVtx(CvGraph graph,
                                @Const
                                CvGraphVtx vtx,
                                @ByPtrPtr
                                CvGraphVtx inserted_vtx)

cvGraphRemoveVtx

public static int cvGraphRemoveVtx(CvGraph graph,
                                   int index)

Removes vertex from the graph together with all incident edges

cvGraphRemoveVtxByPtr

public static int cvGraphRemoveVtxByPtr(CvGraph graph,
                                        CvGraphVtx vtx)

cvGraphAddEdge

public static int cvGraphAddEdge(CvGraph graph,
                                 int start_idx,
                                 int end_idx,
                                 @Const
                                 CvGraphEdge edge,
                                 @Cast(value="CvGraphEdge**")
                                 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(CvGraph graph,
                                 int start_idx,
                                 int end_idx)

cvGraphAddEdge

public static int cvGraphAddEdge(CvGraph graph,
                                 int start_idx,
                                 int end_idx,
                                 @Const
                                 CvGraphEdge edge,
                                 @ByPtrPtr
                                 CvGraphEdge inserted_edge)

cvGraphAddEdgeByPtr

public static int cvGraphAddEdgeByPtr(CvGraph graph,
                                      CvGraphVtx start_vtx,
                                      CvGraphVtx end_vtx,
                                      @Const
                                      CvGraphEdge edge,
                                      @Cast(value="CvGraphEdge**")
                                      PointerPointer inserted_edge)

cvGraphAddEdgeByPtr

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

cvGraphAddEdgeByPtr

public static int cvGraphAddEdgeByPtr(CvGraph graph,
                                      CvGraphVtx start_vtx,
                                      CvGraphVtx end_vtx,
                                      @Const
                                      CvGraphEdge edge,
                                      @ByPtrPtr
                                      CvGraphEdge inserted_edge)

cvGraphRemoveEdge

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

Remove edge connecting two vertices

cvGraphRemoveEdgeByPtr

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

cvFindGraphEdge

public static CvGraphEdge cvFindGraphEdge(@Const
                                          CvGraph graph,
                                          int start_idx,
                                          int end_idx)

Find edge connecting two vertices

cvFindGraphEdgeByPtr

public static CvGraphEdge cvFindGraphEdgeByPtr(@Const
                                               CvGraph graph,
                                               @Const
                                               CvGraphVtx start_vtx,
                                               @Const
                                               CvGraphVtx end_vtx)

cvGraphFindEdge

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

cvGraphFindEdgeByPtr

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

cvClearGraph
```
public static void cvClearGraph(CvGraph graph)
```
Remove all vertices and edges from the graph

cvGraphVtxDegree

public static int cvGraphVtxDegree(@Const
                                   CvGraph graph,
                                   int vtx_idx)

Count number of edges incident to the vertex

cvGraphVtxDegreeByPtr

public static int cvGraphVtxDegreeByPtr(@Const
                                        CvGraph graph,
                                        @Const
                                        CvGraphVtx vtx)

cvCreateGraphScanner

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

Creates new graph scanner.

cvCreateGraphScanner

public static CvGraphScanner cvCreateGraphScanner(CvGraph graph)

cvReleaseGraphScanner

public static void cvReleaseGraphScanner(@Cast(value="CvGraphScanner**")
                                         PointerPointer scanner)

Releases graph scanner.

cvReleaseGraphScanner

public static void cvReleaseGraphScanner(@ByPtrPtr
                                         CvGraphScanner scanner)

cvNextGraphItem

public static int cvNextGraphItem(CvGraphScanner scanner)

Get next graph element

cvCloneGraph

public static CvGraph cvCloneGraph(@Const
                                   CvGraph graph,
                                   CvMemStorage storage)

Creates a copy of graph

cvLUT

public static void cvLUT(@Const
                         CvArr src,
                         CvArr dst,
                         @Const
                         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(CvTreeNodeIterator tree_iterator,
                                          @Const
                                          Pointer first,
                                          int max_level)

cvNextTreeNode

public static Pointer cvNextTreeNode(CvTreeNodeIterator tree_iterator)

cvPrevTreeNode

public static Pointer cvPrevTreeNode(CvTreeNodeIterator tree_iterator)

cvInsertNodeIntoTree

public static void cvInsertNodeIntoTree(Pointer node,
                                        Pointer parent,
                                        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(Pointer node,
                                        Pointer frame)

Removes contour from tree (together with the contour children).

cvTreeToNodeSeq

public static CvSeq cvTreeToNodeSeq(@Const
                                    Pointer first,
                                    int header_size,
                                    CvMemStorage storage)

Gathers pointers to all the sequences, accessible from the first, to the single sequence

cvKMeans2

public static int cvKMeans2(@Const
                            CvArr samples,
                            int cluster_count,
                            CvArr labels,
                            @ByVal
                            CvTermCriteria termcrit,
                            int attempts,
                            @Cast(value="CvRNG*")
                            LongPointer rng,
                            int flags,
                            CvArr _centers,
                            DoublePointer compactness)

cvKMeans2

public static int cvKMeans2(@Const
                            CvArr samples,
                            int cluster_count,
                            CvArr labels,
                            @ByVal
                            CvTermCriteria termcrit)

cvKMeans2

public static int cvKMeans2(@Const
                            CvArr samples,
                            int cluster_count,
                            CvArr labels,
                            @ByVal
                            CvTermCriteria termcrit,
                            int attempts,
                            @Cast(value="CvRNG*")
                            LongBuffer rng,
                            int flags,
                            CvArr _centers,
                            DoubleBuffer compactness)

cvKMeans2

public static int cvKMeans2(@Const
                            CvArr samples,
                            int cluster_count,
                            CvArr labels,
                            @ByVal
                            CvTermCriteria termcrit,
                            int attempts,
                            @Cast(value="CvRNG*")
                            long[] rng,
                            int flags,
                            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(Cv_iplCreateImageHeader create_header,
                                      Cv_iplAllocateImageData allocate_data,
                                      Cv_iplDeallocate _deallocate,
                                      Cv_iplCreateROI create_roi,
                                      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.

cvRelease
```
public static void cvRelease(@Cast(value="void**")
                             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
                             Pointer struct_ptr)

cvClone
```
public static Pointer cvClone(@Const
                              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

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*")
                           BytePointer func_name,
                           @Cast(value="const char*")
                           BytePointer err_msg,
                           @Cast(value="const char*")
                           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 BytePointer cvErrorStr(int status)

Retrieves textual description of the error given its code

cvGetErrInfo

public static int cvGetErrInfo(@Cast(value="const char**")
                               PointerPointer errcode_desc,
                               @Cast(value="const char**")
                               PointerPointer description,
                               @Cast(value="const char**")
                               PointerPointer filename,
                               IntPointer line)

Retrieves detailed information about the last error occurred

cvGetErrInfo

public static int cvGetErrInfo(@Cast(value="const char**") @ByPtrPtr
                               BytePointer errcode_desc,
                               @Cast(value="const char**") @ByPtrPtr
                               BytePointer description,
                               @Cast(value="const char**") @ByPtrPtr
                               BytePointer filename,
                               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 CvErrorCallback cvRedirectError(CvErrorCallback error_handler,
                                              Pointer userdata,
                                              @Cast(value="void**")
                                              PointerPointer prev_userdata)

Assigns a new error-handling function

cvRedirectError

public static CvErrorCallback cvRedirectError(CvErrorCallback error_handler)

cvRedirectError

public static CvErrorCallback cvRedirectError(CvErrorCallback error_handler,
                                              Pointer userdata,
                                              @Cast(value="void**") @ByPtrPtr
                                              Pointer prev_userdata)

cvNulDevReport

public static int cvNulDevReport(int status,
                                 @Cast(value="const char*")
                                 BytePointer func_name,
                                 @Cast(value="const char*")
                                 BytePointer err_msg,
                                 @Cast(value="const char*")
                                 BytePointer file_name,
                                 int line,
                                 Pointer userdata)

Output nothing

cvNulDevReport

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

cvStdErrReport

public static int cvStdErrReport(int status,
                                 @Cast(value="const char*")
                                 BytePointer func_name,
                                 @Cast(value="const char*")
                                 BytePointer err_msg,
                                 @Cast(value="const char*")
                                 BytePointer file_name,
                                 int line,
                                 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,
                                 Pointer userdata)

cvGuiBoxReport

public static int cvGuiBoxReport(int status,
                                 @Cast(value="const char*")
                                 BytePointer func_name,
                                 @Cast(value="const char*")
                                 BytePointer err_msg,
                                 @Cast(value="const char*")
                                 BytePointer file_name,
                                 int line,
                                 Pointer userdata)

Output to MessageBox(WIN32)

cvGuiBoxReport

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

cvarrToMat

@Namespace(value="cv")
 @ByVal
public static Mat cvarrToMat(@Const
                                                            CvArr arr,
                                                            @Cast(value="bool")
                                                            boolean copyData,
                                                            @Cast(value="bool")
                                                            boolean allowND,
                                                            int coiMode,
                                                            @Cast(value="cv::AutoBuffer<double>*")
                                                            Pointer buf)

\addtogroup core_c_glue \{

/////////////////////////////////////////// glue ///////////////////////////////////////////

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

cvarrToMat

@Namespace(value="cv")
 @ByVal
public static Mat cvarrToMat(@Const
                                                            CvArr arr)

cvarrToMatND

@Namespace(value="cv")
 @ByVal
public static Mat cvarrToMatND(@Const
                                                              CvArr arr,
                                                              @Cast(value="bool")
                                                              boolean copyData,
                                                              int coiMode)

cvarrToMatND

@Namespace(value="cv")
 @ByVal
public static Mat cvarrToMatND(@Const
                                                              CvArr arr)

extractImageCOI

@Namespace(value="cv")
public static void extractImageCOI(@Const
                                                          CvArr arr,
                                                          @ByVal
                                                          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
                                                          CvArr arr,
                                                          @ByVal
                                                          Mat coiimg)

extractImageCOI

@Namespace(value="cv")
public static void extractImageCOI(@Const
                                                          CvArr arr,
                                                          @ByVal
                                                          UMat coiimg,
                                                          int coi)

extractImageCOI

@Namespace(value="cv")
public static void extractImageCOI(@Const
                                                          CvArr arr,
                                                          @ByVal
                                                          UMat coiimg)

extractImageCOI

@Namespace(value="cv")
public static void extractImageCOI(@Const
                                                          CvArr arr,
                                                          @ByVal
                                                          GpuMat coiimg,
                                                          int coi)

extractImageCOI

@Namespace(value="cv")
public static void extractImageCOI(@Const
                                                          CvArr arr,
                                                          @ByVal
                                                          GpuMat coiimg)

insertImageCOI

@Namespace(value="cv")
public static void insertImageCOI(@ByVal
                                                         Mat coiimg,
                                                         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
                                                         Mat coiimg,
                                                         CvArr arr)

insertImageCOI

@Namespace(value="cv")
public static void insertImageCOI(@ByVal
                                                         UMat coiimg,
                                                         CvArr arr,
                                                         int coi)

insertImageCOI

@Namespace(value="cv")
public static void insertImageCOI(@ByVal
                                                         UMat coiimg,
                                                         CvArr arr)

insertImageCOI

@Namespace(value="cv")
public static void insertImageCOI(@ByVal
                                                         GpuMat coiimg,
                                                         CvArr arr,
                                                         int coi)

insertImageCOI

@Namespace(value="cv")
public static void insertImageCOI(@ByVal
                                                         GpuMat coiimg,
                                                         CvArr arr)

seqPush

@Namespace(value="cv")
 @Cast(value="schar*")
public static BytePointer seqPush(CvSeq seq,
                                                                                @Const
                                                                                Pointer element)

STL-style Sequence Iterator inherited from the CvSeqReader structure

seqPush

@Namespace(value="cv")
 @Cast(value="schar*")
public static BytePointer seqPush(CvSeq seq)

seqPushFront

@Namespace(value="cv")
 @Cast(value="schar*")
public static BytePointer seqPushFront(CvSeq seq,
                                                                                     @Const
                                                                                     Pointer element)

seqPushFront

@Namespace(value="cv")
 @Cast(value="schar*")
public static BytePointer seqPushFront(CvSeq seq)

seqPop

@Namespace(value="cv")
public static void seqPop(CvSeq seq,
                                                 Pointer element)

seqPop

@Namespace(value="cv")
public static void seqPop(CvSeq seq)

seqPopFront

@Namespace(value="cv")
public static void seqPopFront(CvSeq seq,
                                                      Pointer element)

seqPopFront

@Namespace(value="cv")
public static void seqPopFront(CvSeq seq)

seqRemove

@Namespace(value="cv")
public static void seqRemove(CvSeq seq,
                                                    int index)

clearSeq

@Namespace(value="cv")
public static void clearSeq(CvSeq seq)

getSeqElem

@Namespace(value="cv")
 @Cast(value="schar*")
public static BytePointer getSeqElem(@Const
                                                                                   CvSeq seq,
                                                                                   int index)

seqRemoveSlice

@Namespace(value="cv")
public static void seqRemoveSlice(CvSeq seq,
                                                         @ByVal
                                                         CvSlice slice)

seqInsertSlice

@Namespace(value="cv")
public static void seqInsertSlice(CvSeq seq,
                                                         int before_index,
                                                         @Const
                                                         CvArr from_arr)

equals

@Namespace(value="cv")
 @Cast(value="bool")
 @Name(value="operator ==")
public static boolean equals(@Const @ByRef
                                                                                                     Range r1,
                                                                                                     @Const @ByRef
                                                                                                     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
                                                                                                        Range r1,
                                                                                                        @Const @ByRef
                                                                                                        Range r2)

not

@Namespace(value="cv")
 @Cast(value="bool")
 @Name(value="operator !")
public static boolean not(@Const @ByRef
                                                                                                 Range r)

and

@Namespace(value="cv")
 @ByVal
 @Name(value="operator &")
public static Range and(@Const @ByRef
                                                                                  Range r1,
                                                                                  @Const @ByRef
                                                                                  Range r2)

andPut

@Namespace(value="cv")
 @ByRef
 @Name(value="operator &=")
public static Range andPut(@ByRef
                                                                                      Range r1,
                                                                                      @Const @ByRef
                                                                                      Range r2)

add

@Namespace(value="cv")
 @ByVal
 @Name(value="operator +")
public static Range add(@Const @ByRef
                                                                                  Range r1,
                                                                                  int delta)

add

@Namespace(value="cv")
 @ByVal
 @Name(value="operator +")
public static Range add(int delta,
                                                                                  @Const @ByRef
                                                                                  Range r1)

subtract

@Namespace(value="cv")
 @ByVal
 @Name(value="operator -")
public static Range subtract(@Const @ByRef
                                                                                       Range r1,
                                                                                       int delta)

swap

@Namespace(value="cv")
public static void swap(@ByRef
                                               Mat a,
                                               @ByRef
                                               Mat b)

\} core_array

/** \brief Swaps two matrices

swap

@Namespace(value="cv")
public static void swap(@ByRef
                                               UMat a,
                                               @ByRef
                                               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.

See Also:

copyMakeBorder

copyMakeBorder

@Namespace(value="cv")
public static void copyMakeBorder(@ByVal
                                                         Mat src,
                                                         @ByVal
                                                         Mat dst,
                                                         int top,
                                                         int bottom,
                                                         int left,
                                                         int right,
                                                         int borderType,
                                                         @Const @ByRef(nullValue="cv::Scalar()")
                                                         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 - the top pixels; bottom - the bottom pixels; left - the left pixels; 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 .
See Also:: borderInterpolate

copyMakeBorder

@Namespace(value="cv")
public static void copyMakeBorder(@ByVal
                                                         Mat src,
                                                         @ByVal
                                                         Mat dst,
                                                         int top,
                                                         int bottom,
                                                         int left,
                                                         int right,
                                                         int borderType)

copyMakeBorder

@Namespace(value="cv")
public static void copyMakeBorder(@ByVal
                                                         UMat src,
                                                         @ByVal
                                                         UMat dst,
                                                         int top,
                                                         int bottom,
                                                         int left,
                                                         int right,
                                                         int borderType,
                                                         @Const @ByRef(nullValue="cv::Scalar()")
                                                         Scalar value)

copyMakeBorder

@Namespace(value="cv")
public static void copyMakeBorder(@ByVal
                                                         UMat src,
                                                         @ByVal
                                                         UMat dst,
                                                         int top,
                                                         int bottom,
                                                         int left,
                                                         int right,
                                                         int borderType)

copyMakeBorder

@Namespace(value="cv")
public static void copyMakeBorder(@ByVal
                                                         GpuMat src,
                                                         @ByVal
                                                         GpuMat dst,
                                                         int top,
                                                         int bottom,
                                                         int left,
                                                         int right,
                                                         int borderType,
                                                         @Const @ByRef(nullValue="cv::Scalar()")
                                                         Scalar value)

copyMakeBorder

@Namespace(value="cv")
public static void copyMakeBorder(@ByVal
                                                         GpuMat src,
                                                         @ByVal
                                                         GpuMat dst,
                                                         int top,
                                                         int bottom,
                                                         int left,
                                                         int right,
                                                         int borderType)

add
```
@Namespace(value="cv")
public static void add(@ByVal
                                              Mat src1,
                                              @ByVal
                                              Mat src2,
                                              @ByVal
                                              Mat dst,
                                              @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                              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:
```
 \[\texttt{dst}(I) =  \texttt{saturate} ( \texttt{src1}(I) +  \texttt{src2}(I)) \quad \texttt{if mask}(I) \ne0\]
```
- Sum of an array and a scalar when src2 is constructed from Scalar or has the same number of elements as src1.channels():
```
 \[\texttt{dst}(I) =  \texttt{saturate} ( \texttt{src1}(I) +  \texttt{src2} ) \quad \texttt{if mask}(I) \ne0\]
```
- Sum of a scalar and an array when src1 is constructed from Scalar or has the same number of elements as src2.channels():
```
 \[\texttt{dst}(I) =  \texttt{saturate} ( \texttt{src1} +  \texttt{src2}(I) ) \quad \texttt{if mask}(I) \ne0\]
```
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).

See Also:

subtract, addWeighted, scaleAdd, Mat::convertTo

add

@Namespace(value="cv")
public static void add(@ByVal
                                              Mat src1,
                                              @ByVal
                                              Mat src2,
                                              @ByVal
                                              Mat dst)

add

@Namespace(value="cv")
public static void add(@ByVal
                                              UMat src1,
                                              @ByVal
                                              UMat src2,
                                              @ByVal
                                              UMat dst,
                                              @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                              UMat mask,
                                              int dtype)

add

@Namespace(value="cv")
public static void add(@ByVal
                                              UMat src1,
                                              @ByVal
                                              UMat src2,
                                              @ByVal
                                              UMat dst)

add

@Namespace(value="cv")
public static void add(@ByVal
                                              GpuMat src1,
                                              @ByVal
                                              GpuMat src2,
                                              @ByVal
                                              GpuMat dst,
                                              @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                              GpuMat mask,
                                              int dtype)

add

@Namespace(value="cv")
public static void add(@ByVal
                                              GpuMat src1,
                                              @ByVal
                                              GpuMat src2,
                                              @ByVal
                                              GpuMat dst)

subtract
```
@Namespace(value="cv")
public static void subtract(@ByVal
                                                   Mat src1,
                                                   @ByVal
                                                   Mat src2,
                                                   @ByVal
                                                   Mat dst,
                                                   @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                   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:
```
 \[\texttt{dst}(I) =  \texttt{saturate} ( \texttt{src1}(I) -  \texttt{src2}(I)) \quad \texttt{if mask}(I) \ne0\]
```
- Difference between an array and a scalar, when src2 is constructed from Scalar or has the same number of elements as src1.channels():
```
 \[\texttt{dst}(I) =  \texttt{saturate} ( \texttt{src1}(I) -  \texttt{src2} ) \quad \texttt{if mask}(I) \ne0\]
```
- Difference between a scalar and an array, when src1 is constructed from Scalar or has the same number of elements as src2.channels():
```
 \[\texttt{dst}(I) =  \texttt{saturate} ( \texttt{src1} -  \texttt{src2}(I) ) \quad \texttt{if mask}(I) \ne0\]
```
- The reverse difference between a scalar and an array in the case of SubRS:
```
 \[\texttt{dst}(I) =  \texttt{saturate} ( \texttt{src2} -  \texttt{src1}(I) ) \quad \texttt{if mask}(I) \ne0\]
```
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

See Also:

add, addWeighted, scaleAdd, Mat::convertTo

subtract

@Namespace(value="cv")
public static void subtract(@ByVal
                                                   Mat src1,
                                                   @ByVal
                                                   Mat src2,
                                                   @ByVal
                                                   Mat dst)

subtract

@Namespace(value="cv")
public static void subtract(@ByVal
                                                   UMat src1,
                                                   @ByVal
                                                   UMat src2,
                                                   @ByVal
                                                   UMat dst,
                                                   @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                   UMat mask,
                                                   int dtype)

subtract

@Namespace(value="cv")
public static void subtract(@ByVal
                                                   UMat src1,
                                                   @ByVal
                                                   UMat src2,
                                                   @ByVal
                                                   UMat dst)

subtract

@Namespace(value="cv")
public static void subtract(@ByVal
                                                   GpuMat src1,
                                                   @ByVal
                                                   GpuMat src2,
                                                   @ByVal
                                                   GpuMat dst,
                                                   @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                   GpuMat mask,
                                                   int dtype)

subtract

@Namespace(value="cv")
public static void subtract(@ByVal
                                                   GpuMat src1,
                                                   @ByVal
                                                   GpuMat src2,
                                                   @ByVal
                                                   GpuMat dst)

multiply

@Namespace(value="cv")
public static void multiply(@ByVal
                                                   Mat src1,
                                                   @ByVal
                                                   Mat src2,
                                                   @ByVal
                                                   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:

 \[\texttt{dst} (I)= \texttt{saturate} ( \texttt{scale} \cdot \texttt{src1} (I)  \cdot \texttt{src2} (I))\]

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
See Also:: add, subtract, divide, scaleAdd, addWeighted, accumulate, accumulateProduct, accumulateSquare, Mat::convertTo

multiply

@Namespace(value="cv")
public static void multiply(@ByVal
                                                   Mat src1,
                                                   @ByVal
                                                   Mat src2,
                                                   @ByVal
                                                   Mat dst)

multiply

@Namespace(value="cv")
public static void multiply(@ByVal
                                                   UMat src1,
                                                   @ByVal
                                                   UMat src2,
                                                   @ByVal
                                                   UMat dst,
                                                   double scale,
                                                   int dtype)

multiply

@Namespace(value="cv")
public static void multiply(@ByVal
                                                   UMat src1,
                                                   @ByVal
                                                   UMat src2,
                                                   @ByVal
                                                   UMat dst)

multiply

@Namespace(value="cv")
public static void multiply(@ByVal
                                                   GpuMat src1,
                                                   @ByVal
                                                   GpuMat src2,
                                                   @ByVal
                                                   GpuMat dst,
                                                   double scale,
                                                   int dtype)

multiply

@Namespace(value="cv")
public static void multiply(@ByVal
                                                   GpuMat src1,
                                                   @ByVal
                                                   GpuMat src2,
                                                   @ByVal
                                                   GpuMat dst)

divide
```
@Namespace(value="cv")
public static void divide(@ByVal
                                                 Mat src1,
                                                 @ByVal
                                                 Mat src2,
                                                 @ByVal
                                                 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:
```
 \[\texttt{dst(I) = saturate(src1(I)*scale/src2(I))}\]
```
or a scalar by an array when there is no src1 :
```
 \[\texttt{dst(I) = saturate(scale/src2(I))}\]
```
Different channels of multi-channel arrays are processed independently.
For integer types when src2(I) is zero, dst(I) will also be zero.
\note In case of floating point data there is no special defined behavior for zero src2(I) values. Regular floating-point division is used. Expect correct IEEE-754 behaviour for floating-point data (with NaN, Inf result values).
\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().

See Also:

multiply, add, subtract

divide

@Namespace(value="cv")
public static void divide(@ByVal
                                                 Mat src1,
                                                 @ByVal
                                                 Mat src2,
                                                 @ByVal
                                                 Mat dst)

divide

@Namespace(value="cv")
public static void divide(@ByVal
                                                 UMat src1,
                                                 @ByVal
                                                 UMat src2,
                                                 @ByVal
                                                 UMat dst,
                                                 double scale,
                                                 int dtype)

divide

@Namespace(value="cv")
public static void divide(@ByVal
                                                 UMat src1,
                                                 @ByVal
                                                 UMat src2,
                                                 @ByVal
                                                 UMat dst)

divide

@Namespace(value="cv")
public static void divide(@ByVal
                                                 GpuMat src1,
                                                 @ByVal
                                                 GpuMat src2,
                                                 @ByVal
                                                 GpuMat dst,
                                                 double scale,
                                                 int dtype)

divide

@Namespace(value="cv")
public static void divide(@ByVal
                                                 GpuMat src1,
                                                 @ByVal
                                                 GpuMat src2,
                                                 @ByVal
                                                 GpuMat dst)

divide

@Namespace(value="cv")
public static void divide(double scale,
                                                 @ByVal
                                                 Mat src2,
                                                 @ByVal
                                                 Mat dst,
                                                 int dtype)

\overload

divide

@Namespace(value="cv")
public static void divide(double scale,
                                                 @ByVal
                                                 Mat src2,
                                                 @ByVal
                                                 Mat dst)

divide

@Namespace(value="cv")
public static void divide(double scale,
                                                 @ByVal
                                                 UMat src2,
                                                 @ByVal
                                                 UMat dst,
                                                 int dtype)

divide

@Namespace(value="cv")
public static void divide(double scale,
                                                 @ByVal
                                                 UMat src2,
                                                 @ByVal
                                                 UMat dst)

divide

@Namespace(value="cv")
public static void divide(double scale,
                                                 @ByVal
                                                 GpuMat src2,
                                                 @ByVal
                                                 GpuMat dst,
                                                 int dtype)

divide

@Namespace(value="cv")
public static void divide(double scale,
                                                 @ByVal
                                                 GpuMat src2,
                                                 @ByVal
                                                 GpuMat dst)

scaleAdd

@Namespace(value="cv")
public static void scaleAdd(@ByVal
                                                   Mat src1,
                                                   double alpha,
                                                   @ByVal
                                                   Mat src2,
                                                   @ByVal
                                                   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:

 \[\texttt{dst} (I)= \texttt{scale} \cdot \texttt{src1} (I) +  \texttt{src2} (I)\]

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.
See Also:: add, addWeighted, subtract, Mat::dot, Mat::convertTo

scaleAdd

@Namespace(value="cv")
public static void scaleAdd(@ByVal
                                                   UMat src1,
                                                   double alpha,
                                                   @ByVal
                                                   UMat src2,
                                                   @ByVal
                                                   UMat dst)

scaleAdd

@Namespace(value="cv")
public static void scaleAdd(@ByVal
                                                   GpuMat src1,
                                                   double alpha,
                                                   @ByVal
                                                   GpuMat src2,
                                                   @ByVal
                                                   GpuMat dst)

addWeighted

@Namespace(value="cv")
public static void addWeighted(@ByVal
                                                      Mat src1,
                                                      double alpha,
                                                      @ByVal
                                                      Mat src2,
                                                      double beta,
                                                      double gamma,
                                                      @ByVal
                                                      Mat dst,
                                                      int dtype)

\brief Calculates the weighted sum of two arrays.

The function addWeighted calculates the weighted sum of two arrays as follows:

 \[\texttt{dst} (I)= \texttt{saturate} ( \texttt{src1} (I)* \texttt{alpha} +  \texttt{src2} (I)* \texttt{beta} +  \texttt{gamma} )\]

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().
See Also:: add, subtract, scaleAdd, Mat::convertTo

addWeighted

@Namespace(value="cv")
public static void addWeighted(@ByVal
                                                      Mat src1,
                                                      double alpha,
                                                      @ByVal
                                                      Mat src2,
                                                      double beta,
                                                      double gamma,
                                                      @ByVal
                                                      Mat dst)

addWeighted

@Namespace(value="cv")
public static void addWeighted(@ByVal
                                                      UMat src1,
                                                      double alpha,
                                                      @ByVal
                                                      UMat src2,
                                                      double beta,
                                                      double gamma,
                                                      @ByVal
                                                      UMat dst,
                                                      int dtype)

addWeighted

@Namespace(value="cv")
public static void addWeighted(@ByVal
                                                      UMat src1,
                                                      double alpha,
                                                      @ByVal
                                                      UMat src2,
                                                      double beta,
                                                      double gamma,
                                                      @ByVal
                                                      UMat dst)

addWeighted

@Namespace(value="cv")
public static void addWeighted(@ByVal
                                                      GpuMat src1,
                                                      double alpha,
                                                      @ByVal
                                                      GpuMat src2,
                                                      double beta,
                                                      double gamma,
                                                      @ByVal
                                                      GpuMat dst,
                                                      int dtype)

addWeighted

@Namespace(value="cv")
public static void addWeighted(@ByVal
                                                      GpuMat src1,
                                                      double alpha,
                                                      @ByVal
                                                      GpuMat src2,
                                                      double beta,
                                                      double gamma,
                                                      @ByVal
                                                      GpuMat dst)

convertScaleAbs

@Namespace(value="cv")
public static void convertScaleAbs(@ByVal
                                                          Mat src,
                                                          @ByVal
                                                          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:

 \[\texttt{dst} (I)= \texttt{saturate\_cast<uchar>} (| \texttt{src} (I)* \texttt{alpha} +  \texttt{beta} |)\]

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.
See Also:: Mat::convertTo, cv::abs(const Mat&)

convertScaleAbs

@Namespace(value="cv")
public static void convertScaleAbs(@ByVal
                                                          Mat src,
                                                          @ByVal
                                                          Mat dst)

convertScaleAbs

@Namespace(value="cv")
public static void convertScaleAbs(@ByVal
                                                          UMat src,
                                                          @ByVal
                                                          UMat dst,
                                                          double alpha,
                                                          double beta)

convertScaleAbs

@Namespace(value="cv")
public static void convertScaleAbs(@ByVal
                                                          UMat src,
                                                          @ByVal
                                                          UMat dst)

convertScaleAbs

@Namespace(value="cv")
public static void convertScaleAbs(@ByVal
                                                          GpuMat src,
                                                          @ByVal
                                                          GpuMat dst,
                                                          double alpha,
                                                          double beta)

convertScaleAbs

@Namespace(value="cv")
public static void convertScaleAbs(@ByVal
                                                          GpuMat src,
                                                          @ByVal
                                                          GpuMat dst)

convertFp16
```
@Namespace(value="cv")
public static void convertFp16(@ByVal
                                                      Mat src,
                                                      @ByVal
                                                      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
                                                      UMat src,
                                                      @ByVal
                                                      UMat dst)

convertFp16

@Namespace(value="cv")
public static void convertFp16(@ByVal
                                                      GpuMat src,
                                                      @ByVal
                                                      GpuMat dst)

LUT

@Namespace(value="cv")
public static void LUT(@ByVal
                                              Mat src,
                                              @ByVal
                                              Mat lut,
                                              @ByVal
                                              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:

 \[\texttt{dst} (I)  \leftarrow \texttt{lut(src(I) + d)}\]

where

 \[d =  \fork{0}{if \(\texttt{src}\) has depth \(\texttt{CV_8U}\)}{128}{if \(\texttt{src}\) has depth \(\texttt{CV_8S}\)}\]

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.
See Also:: convertScaleAbs, Mat::convertTo

LUT

@Namespace(value="cv")
public static void LUT(@ByVal
                                              UMat src,
                                              @ByVal
                                              UMat lut,
                                              @ByVal
                                              UMat dst)

LUT

@Namespace(value="cv")
public static void LUT(@ByVal
                                              GpuMat src,
                                              @ByVal
                                              GpuMat lut,
                                              @ByVal
                                              GpuMat dst)

sumElems
```
@Namespace(value="cv")
 @ByVal
 @Name(value="sum")
public static Scalar sumElems(@ByVal
                                                                                 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.

See Also:

countNonZero, mean, meanStdDev, norm, minMaxLoc, reduce

sumElems

@Namespace(value="cv")
 @ByVal
 @Name(value="sum")
public static Scalar sumElems(@ByVal
                                                                                 UMat src)

sumElems

@Namespace(value="cv")
 @ByVal
 @Name(value="sum")
public static Scalar sumElems(@ByVal
                                                                                 GpuMat src)

countNonZero

@Namespace(value="cv")
public static int countNonZero(@ByVal
                                                      Mat src)

\brief Counts non-zero array elements.

The function returns the number of non-zero elements in src :

 \[\sum _{I: \; \texttt{src} (I) \ne0 } 1\]

Parameters:: src - single-channel array.
See Also:: mean, meanStdDev, norm, minMaxLoc, calcCovarMatrix

countNonZero

@Namespace(value="cv")
public static int countNonZero(@ByVal
                                                      UMat src)

countNonZero

@Namespace(value="cv")
public static int countNonZero(@ByVal
                                                      GpuMat src)

findNonZero

@Namespace(value="cv")
public static void findNonZero(@ByVal
                                                      Mat src,
                                                      @ByVal
                                                      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; 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
                                                      UMat src,
                                                      @ByVal
                                                      UMat idx)

findNonZero

@Namespace(value="cv")
public static void findNonZero(@ByVal
                                                      GpuMat src,
                                                      @ByVal
                                                      GpuMat idx)

mean

@Namespace(value="cv")
 @ByVal
public static Scalar mean(@ByVal
                                                         Mat src,
                                                         @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                         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:

 \[\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}\]

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.
See Also:: countNonZero, meanStdDev, norm, minMaxLoc

mean

@Namespace(value="cv")
 @ByVal
public static Scalar mean(@ByVal
                                                         Mat src)

mean

@Namespace(value="cv")
 @ByVal
public static Scalar mean(@ByVal
                                                         UMat src,
                                                         @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                         UMat mask)

mean

@Namespace(value="cv")
 @ByVal
public static Scalar mean(@ByVal
                                                         UMat src)

mean

@Namespace(value="cv")
 @ByVal
public static Scalar mean(@ByVal
                                                         GpuMat src,
                                                         @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                         GpuMat mask)

mean

@Namespace(value="cv")
 @ByVal
public static Scalar mean(@ByVal
                                                         GpuMat src)

meanStdDev

@Namespace(value="cv")
public static void meanStdDev(@ByVal
                                                     Mat src,
                                                     @ByVal
                                                     Mat mean,
                                                     @ByVal
                                                     Mat stddev,
                                                     @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                     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:

 \[\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}\]

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.
See Also:: countNonZero, mean, norm, minMaxLoc, calcCovarMatrix

meanStdDev

@Namespace(value="cv")
public static void meanStdDev(@ByVal
                                                     Mat src,
                                                     @ByVal
                                                     Mat mean,
                                                     @ByVal
                                                     Mat stddev)

meanStdDev

@Namespace(value="cv")
public static void meanStdDev(@ByVal
                                                     UMat src,
                                                     @ByVal
                                                     UMat mean,
                                                     @ByVal
                                                     UMat stddev,
                                                     @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                     UMat mask)

meanStdDev

@Namespace(value="cv")
public static void meanStdDev(@ByVal
                                                     UMat src,
                                                     @ByVal
                                                     UMat mean,
                                                     @ByVal
                                                     UMat stddev)

meanStdDev

@Namespace(value="cv")
public static void meanStdDev(@ByVal
                                                     GpuMat src,
                                                     @ByVal
                                                     GpuMat mean,
                                                     @ByVal
                                                     GpuMat stddev,
                                                     @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                     GpuMat mask)

meanStdDev

@Namespace(value="cv")
public static void meanStdDev(@ByVal
                                                     GpuMat src,
                                                     @ByVal
                                                     GpuMat mean,
                                                     @ByVal
                                                     GpuMat stddev)

norm
```
@Namespace(value="cv")
public static double norm(@ByVal
                                                 Mat src1,
                                                 int normType,
                                                 @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                 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 r(x)= \begin{pmatrix} x \\ 1-x \end{pmatrix}, x \in [-1;1]. The L_{1}, L_{2} and L_{\infty} norm for the sample value r(-1) = \begin{pmatrix} -1 \\ 2 \end{pmatrix} 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 r(0.5) = \begin{pmatrix} 0.5 \\ 0.5 \end{pmatrix} 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 \| r(x) \|_{L_1}, \| r(x) \|_{L_2} and \| r(x) \|_{L_\infty}. It is notable that the L_{1} norm forms the upper and the L_{\infty} norm forms the lower border for the example function r(x) . ![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
                                                 Mat src1)

norm

@Namespace(value="cv")
public static double norm(@ByVal
                                                 UMat src1,
                                                 int normType,
                                                 @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                 UMat mask)

norm

@Namespace(value="cv")
public static double norm(@ByVal
                                                 UMat src1)

norm

@Namespace(value="cv")
public static double norm(@ByVal
                                                 GpuMat src1,
                                                 int normType,
                                                 @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                 GpuMat mask)

norm

@Namespace(value="cv")
public static double norm(@ByVal
                                                 GpuMat src1)

norm

@Namespace(value="cv")
public static double norm(@ByVal
                                                 Mat src1,
                                                 @ByVal
                                                 Mat src2,
                                                 int normType,
                                                 @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                 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
                                                 Mat src1,
                                                 @ByVal
                                                 Mat src2)

norm

@Namespace(value="cv")
public static double norm(@ByVal
                                                 UMat src1,
                                                 @ByVal
                                                 UMat src2,
                                                 int normType,
                                                 @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                 UMat mask)

norm

@Namespace(value="cv")
public static double norm(@ByVal
                                                 UMat src1,
                                                 @ByVal
                                                 UMat src2)

norm

@Namespace(value="cv")
public static double norm(@ByVal
                                                 GpuMat src1,
                                                 @ByVal
                                                 GpuMat src2,
                                                 int normType,
                                                 @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                 GpuMat mask)

norm

@Namespace(value="cv")
public static double norm(@ByVal
                                                 GpuMat src1,
                                                 @ByVal
                                                 GpuMat src2)

norm

@Namespace(value="cv")
public static double norm(@Const @ByRef
                                                 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
                                                 Mat src1,
                                                 @ByVal
                                                 Mat src2,
                                                 double R)
```
\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. The arrays must have the same type.
The PSNR is calculated as follows:
```
 \[
\texttt{PSNR} = 10 \cdot \log_{10}{\left( \frac{R^2}{MSE} \right) }
\]
```
where R is the maximum integer value of depth (e.g. 255 in the case of CV_8U data) 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.

R - the maximum pixel value (255 by default)

PSNR

@Namespace(value="cv")
public static double PSNR(@ByVal
                                                 Mat src1,
                                                 @ByVal
                                                 Mat src2)

PSNR

@Namespace(value="cv")
public static double PSNR(@ByVal
                                                 UMat src1,
                                                 @ByVal
                                                 UMat src2,
                                                 double R)

PSNR

@Namespace(value="cv")
public static double PSNR(@ByVal
                                                 UMat src1,
                                                 @ByVal
                                                 UMat src2)

PSNR

@Namespace(value="cv")
public static double PSNR(@ByVal
                                                 GpuMat src1,
                                                 @ByVal
                                                 GpuMat src2,
                                                 double R)

PSNR

@Namespace(value="cv")
public static double PSNR(@ByVal
                                                 GpuMat src1,
                                                 @ByVal
                                                 GpuMat src2)

batchDistance

@Namespace(value="cv")
public static void batchDistance(@ByVal
                                                        Mat src1,
                                                        @ByVal
                                                        Mat src2,
                                                        @ByVal
                                                        Mat dist,
                                                        int dtype,
                                                        @ByVal
                                                        Mat nidx,
                                                        int normType,
                                                        int K,
                                                        @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                        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
                                                        Mat src1,
                                                        @ByVal
                                                        Mat src2,
                                                        @ByVal
                                                        Mat dist,
                                                        int dtype,
                                                        @ByVal
                                                        Mat nidx)

batchDistance

@Namespace(value="cv")
public static void batchDistance(@ByVal
                                                        UMat src1,
                                                        @ByVal
                                                        UMat src2,
                                                        @ByVal
                                                        UMat dist,
                                                        int dtype,
                                                        @ByVal
                                                        UMat nidx,
                                                        int normType,
                                                        int K,
                                                        @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                        UMat mask,
                                                        int update,
                                                        @Cast(value="bool")
                                                        boolean crosscheck)

batchDistance

@Namespace(value="cv")
public static void batchDistance(@ByVal
                                                        UMat src1,
                                                        @ByVal
                                                        UMat src2,
                                                        @ByVal
                                                        UMat dist,
                                                        int dtype,
                                                        @ByVal
                                                        UMat nidx)

batchDistance

@Namespace(value="cv")
public static void batchDistance(@ByVal
                                                        GpuMat src1,
                                                        @ByVal
                                                        GpuMat src2,
                                                        @ByVal
                                                        GpuMat dist,
                                                        int dtype,
                                                        @ByVal
                                                        GpuMat nidx,
                                                        int normType,
                                                        int K,
                                                        @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                        GpuMat mask,
                                                        int update,
                                                        @Cast(value="bool")
                                                        boolean crosscheck)

batchDistance

@Namespace(value="cv")
public static void batchDistance(@ByVal
                                                        GpuMat src1,
                                                        @ByVal
                                                        GpuMat src2,
                                                        @ByVal
                                                        GpuMat dist,
                                                        int dtype,
                                                        @ByVal
                                                        GpuMat nidx)

normalize

@Namespace(value="cv")
public static void normalize(@ByVal
                                                    Mat src,
                                                    @ByVal
                                                    Mat dst,
                                                    double alpha,
                                                    double beta,
                                                    int norm_type,
                                                    int dtype,
                                                    @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                    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

 \[\| \texttt{dst} \| _{L_p}= \texttt{alpha}\]

(where p=Inf, 1 or 2) when normType=NORM_INF, NORM_L1, or NORM_L2, respectively; or so that

 \[\min _I  \texttt{dst} (I)= \texttt{alpha} , \, \, \max _I  \texttt{dst} (I)= \texttt{beta}\]

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.
See Also:: norm, Mat::convertTo, SparseMat::convertTo

normalize

@Namespace(value="cv")
public static void normalize(@ByVal
                                                    Mat src,
                                                    @ByVal
                                                    Mat dst)

normalize

@Namespace(value="cv")
public static void normalize(@ByVal
                                                    UMat src,
                                                    @ByVal
                                                    UMat dst,
                                                    double alpha,
                                                    double beta,
                                                    int norm_type,
                                                    int dtype,
                                                    @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                    UMat mask)

normalize

@Namespace(value="cv")
public static void normalize(@ByVal
                                                    UMat src,
                                                    @ByVal
                                                    UMat dst)

normalize

@Namespace(value="cv")
public static void normalize(@ByVal
                                                    GpuMat src,
                                                    @ByVal
                                                    GpuMat dst,
                                                    double alpha,
                                                    double beta,
                                                    int norm_type,
                                                    int dtype,
                                                    @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                    GpuMat mask)

normalize

@Namespace(value="cv")
public static void normalize(@ByVal
                                                    GpuMat src,
                                                    @ByVal
                                                    GpuMat dst)

normalize

@Namespace(value="cv")
public static void normalize(@Const @ByRef
                                                    SparseMat src,
                                                    @ByRef
                                                    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
                                                    Mat src,
                                                    DoublePointer minVal,
                                                    DoublePointer maxVal,
                                                    Point minLoc,
                                                    Point maxLoc,
                                                    @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                    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.

See Also:

max, min, reduceArgMin, reduceArgMax, compare, inRange, extractImageCOI, mixChannels, split, Mat::reshape

minMaxLoc

@Namespace(value="cv")
public static void minMaxLoc(@ByVal
                                                    Mat src,
                                                    DoublePointer minVal)

minMaxLoc

@Namespace(value="cv")
public static void minMaxLoc(@ByVal
                                                    Mat src,
                                                    DoubleBuffer minVal,
                                                    DoubleBuffer maxVal,
                                                    Point minLoc,
                                                    Point maxLoc,
                                                    @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                    Mat mask)

minMaxLoc

@Namespace(value="cv")
public static void minMaxLoc(@ByVal
                                                    Mat src,
                                                    DoubleBuffer minVal)

minMaxLoc

@Namespace(value="cv")
public static void minMaxLoc(@ByVal
                                                    Mat src,
                                                    double[] minVal,
                                                    double[] maxVal,
                                                    Point minLoc,
                                                    Point maxLoc,
                                                    @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                    Mat mask)

minMaxLoc

@Namespace(value="cv")
public static void minMaxLoc(@ByVal
                                                    Mat src,
                                                    double[] minVal)

minMaxLoc

@Namespace(value="cv")
public static void minMaxLoc(@ByVal
                                                    UMat src,
                                                    DoublePointer minVal,
                                                    DoublePointer maxVal,
                                                    Point minLoc,
                                                    Point maxLoc,
                                                    @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                    UMat mask)

minMaxLoc

@Namespace(value="cv")
public static void minMaxLoc(@ByVal
                                                    UMat src,
                                                    DoublePointer minVal)

minMaxLoc

@Namespace(value="cv")
public static void minMaxLoc(@ByVal
                                                    UMat src,
                                                    DoubleBuffer minVal,
                                                    DoubleBuffer maxVal,
                                                    Point minLoc,
                                                    Point maxLoc,
                                                    @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                    UMat mask)

minMaxLoc

@Namespace(value="cv")
public static void minMaxLoc(@ByVal
                                                    UMat src,
                                                    DoubleBuffer minVal)

minMaxLoc

@Namespace(value="cv")
public static void minMaxLoc(@ByVal
                                                    UMat src,
                                                    double[] minVal,
                                                    double[] maxVal,
                                                    Point minLoc,
                                                    Point maxLoc,
                                                    @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                    UMat mask)

minMaxLoc

@Namespace(value="cv")
public static void minMaxLoc(@ByVal
                                                    UMat src,
                                                    double[] minVal)

minMaxLoc

@Namespace(value="cv")
public static void minMaxLoc(@ByVal
                                                    GpuMat src,
                                                    DoublePointer minVal,
                                                    DoublePointer maxVal,
                                                    Point minLoc,
                                                    Point maxLoc,
                                                    @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                    GpuMat mask)

minMaxLoc

@Namespace(value="cv")
public static void minMaxLoc(@ByVal
                                                    GpuMat src,
                                                    DoublePointer minVal)

minMaxLoc

@Namespace(value="cv")
public static void minMaxLoc(@ByVal
                                                    GpuMat src,
                                                    DoubleBuffer minVal,
                                                    DoubleBuffer maxVal,
                                                    Point minLoc,
                                                    Point maxLoc,
                                                    @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                    GpuMat mask)

minMaxLoc

@Namespace(value="cv")
public static void minMaxLoc(@ByVal
                                                    GpuMat src,
                                                    DoubleBuffer minVal)

minMaxLoc

@Namespace(value="cv")
public static void minMaxLoc(@ByVal
                                                    GpuMat src,
                                                    double[] minVal,
                                                    double[] maxVal,
                                                    Point minLoc,
                                                    Point maxLoc,
                                                    @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                    GpuMat mask)

minMaxLoc

@Namespace(value="cv")
public static void minMaxLoc(@ByVal
                                                    GpuMat src,
                                                    double[] minVal)

reduceArgMin

@Namespace(value="cv")
public static void reduceArgMin(@ByVal
                                                       Mat src,
                                                       @ByVal
                                                       Mat dst,
                                                       int axis,
                                                       @Cast(value="bool")
                                                       boolean lastIndex)

\brief Finds indices of min elements along provided axis \note - If input or output array is not continuous, this function will create an internal copy. - NaN handling is left unspecified, see patchNaNs(). - The returned index is always in bounds of input matrix.

Parameters:: src - input single-channel array.; dst - output array of type CV_32SC1 with the same dimensionality as src, except for axis being reduced - it should be set to 1.; lastIndex - whether to get the index of first or last occurrence of min.; axis - axis to reduce along.
See Also:: reduceArgMax, minMaxLoc, min, max, compare, reduce

reduceArgMin

@Namespace(value="cv")
public static void reduceArgMin(@ByVal
                                                       Mat src,
                                                       @ByVal
                                                       Mat dst,
                                                       int axis)

reduceArgMin

@Namespace(value="cv")
public static void reduceArgMin(@ByVal
                                                       UMat src,
                                                       @ByVal
                                                       UMat dst,
                                                       int axis,
                                                       @Cast(value="bool")
                                                       boolean lastIndex)

reduceArgMin

@Namespace(value="cv")
public static void reduceArgMin(@ByVal
                                                       UMat src,
                                                       @ByVal
                                                       UMat dst,
                                                       int axis)

reduceArgMin

@Namespace(value="cv")
public static void reduceArgMin(@ByVal
                                                       GpuMat src,
                                                       @ByVal
                                                       GpuMat dst,
                                                       int axis,
                                                       @Cast(value="bool")
                                                       boolean lastIndex)

reduceArgMin

@Namespace(value="cv")
public static void reduceArgMin(@ByVal
                                                       GpuMat src,
                                                       @ByVal
                                                       GpuMat dst,
                                                       int axis)

reduceArgMax

@Namespace(value="cv")
public static void reduceArgMax(@ByVal
                                                       Mat src,
                                                       @ByVal
                                                       Mat dst,
                                                       int axis,
                                                       @Cast(value="bool")
                                                       boolean lastIndex)

\brief Finds indices of max elements along provided axis \note - If input or output array is not continuous, this function will create an internal copy. - NaN handling is left unspecified, see patchNaNs(). - The returned index is always in bounds of input matrix.

Parameters:: src - input single-channel array.; dst - output array of type CV_32SC1 with the same dimensionality as src, except for axis being reduced - it should be set to 1.; lastIndex - whether to get the index of first or last occurrence of max.; axis - axis to reduce along.
See Also:: reduceArgMin, minMaxLoc, min, max, compare, reduce

reduceArgMax

@Namespace(value="cv")
public static void reduceArgMax(@ByVal
                                                       Mat src,
                                                       @ByVal
                                                       Mat dst,
                                                       int axis)

reduceArgMax

@Namespace(value="cv")
public static void reduceArgMax(@ByVal
                                                       UMat src,
                                                       @ByVal
                                                       UMat dst,
                                                       int axis,
                                                       @Cast(value="bool")
                                                       boolean lastIndex)

reduceArgMax

@Namespace(value="cv")
public static void reduceArgMax(@ByVal
                                                       UMat src,
                                                       @ByVal
                                                       UMat dst,
                                                       int axis)

reduceArgMax

@Namespace(value="cv")
public static void reduceArgMax(@ByVal
                                                       GpuMat src,
                                                       @ByVal
                                                       GpuMat dst,
                                                       int axis,
                                                       @Cast(value="bool")
                                                       boolean lastIndex)

reduceArgMax

@Namespace(value="cv")
public static void reduceArgMax(@ByVal
                                                       GpuMat src,
                                                       @ByVal
                                                       GpuMat dst,
                                                       int axis)

minMaxIdx
```
@Namespace(value="cv")
public static void minMaxIdx(@ByVal
                                                    Mat src,
                                                    DoublePointer minVal,
                                                    DoublePointer maxVal,
                                                    IntPointer minIdx,
                                                    IntPointer maxIdx,
                                                    @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                    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
                                                    Mat src,
                                                    DoublePointer minVal)

minMaxIdx

@Namespace(value="cv")
public static void minMaxIdx(@ByVal
                                                    Mat src,
                                                    DoubleBuffer minVal,
                                                    DoubleBuffer maxVal,
                                                    IntBuffer minIdx,
                                                    IntBuffer maxIdx,
                                                    @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                    Mat mask)

minMaxIdx

@Namespace(value="cv")
public static void minMaxIdx(@ByVal
                                                    Mat src,
                                                    DoubleBuffer minVal)

minMaxIdx

@Namespace(value="cv")
public static void minMaxIdx(@ByVal
                                                    Mat src,
                                                    double[] minVal,
                                                    double[] maxVal,
                                                    int[] minIdx,
                                                    int[] maxIdx,
                                                    @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                    Mat mask)

minMaxIdx

@Namespace(value="cv")
public static void minMaxIdx(@ByVal
                                                    Mat src,
                                                    double[] minVal)

minMaxIdx

@Namespace(value="cv")
public static void minMaxIdx(@ByVal
                                                    UMat src,
                                                    DoublePointer minVal,
                                                    DoublePointer maxVal,
                                                    IntPointer minIdx,
                                                    IntPointer maxIdx,
                                                    @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                    UMat mask)

minMaxIdx

@Namespace(value="cv")
public static void minMaxIdx(@ByVal
                                                    UMat src,
                                                    DoublePointer minVal)

minMaxIdx

@Namespace(value="cv")
public static void minMaxIdx(@ByVal
                                                    UMat src,
                                                    DoubleBuffer minVal,
                                                    DoubleBuffer maxVal,
                                                    IntBuffer minIdx,
                                                    IntBuffer maxIdx,
                                                    @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                    UMat mask)

minMaxIdx

@Namespace(value="cv")
public static void minMaxIdx(@ByVal
                                                    UMat src,
                                                    DoubleBuffer minVal)

minMaxIdx

@Namespace(value="cv")
public static void minMaxIdx(@ByVal
                                                    UMat src,
                                                    double[] minVal,
                                                    double[] maxVal,
                                                    int[] minIdx,
                                                    int[] maxIdx,
                                                    @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                    UMat mask)

minMaxIdx

@Namespace(value="cv")
public static void minMaxIdx(@ByVal
                                                    UMat src,
                                                    double[] minVal)

minMaxIdx

@Namespace(value="cv")
public static void minMaxIdx(@ByVal
                                                    GpuMat src,
                                                    DoublePointer minVal,
                                                    DoublePointer maxVal,
                                                    IntPointer minIdx,
                                                    IntPointer maxIdx,
                                                    @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                    GpuMat mask)

minMaxIdx

@Namespace(value="cv")
public static void minMaxIdx(@ByVal
                                                    GpuMat src,
                                                    DoublePointer minVal)

minMaxIdx

@Namespace(value="cv")
public static void minMaxIdx(@ByVal
                                                    GpuMat src,
                                                    DoubleBuffer minVal,
                                                    DoubleBuffer maxVal,
                                                    IntBuffer minIdx,
                                                    IntBuffer maxIdx,
                                                    @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                    GpuMat mask)

minMaxIdx

@Namespace(value="cv")
public static void minMaxIdx(@ByVal
                                                    GpuMat src,
                                                    DoubleBuffer minVal)

minMaxIdx

@Namespace(value="cv")
public static void minMaxIdx(@ByVal
                                                    GpuMat src,
                                                    double[] minVal,
                                                    double[] maxVal,
                                                    int[] minIdx,
                                                    int[] maxIdx,
                                                    @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                    GpuMat mask)

minMaxIdx

@Namespace(value="cv")
public static void minMaxIdx(@ByVal
                                                    GpuMat src,
                                                    double[] minVal)

minMaxLoc

@Namespace(value="cv")
public static void minMaxLoc(@Const @ByRef
                                                    SparseMat a,
                                                    DoublePointer minVal,
                                                    DoublePointer maxVal,
                                                    IntPointer minIdx,
                                                    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
                                                    SparseMat a,
                                                    DoublePointer minVal,
                                                    DoublePointer maxVal)

minMaxLoc

@Namespace(value="cv")
public static void minMaxLoc(@Const @ByRef
                                                    SparseMat a,
                                                    DoubleBuffer minVal,
                                                    DoubleBuffer maxVal,
                                                    IntBuffer minIdx,
                                                    IntBuffer maxIdx)

minMaxLoc

@Namespace(value="cv")
public static void minMaxLoc(@Const @ByRef
                                                    SparseMat a,
                                                    DoubleBuffer minVal,
                                                    DoubleBuffer maxVal)

minMaxLoc

@Namespace(value="cv")
public static void minMaxLoc(@Const @ByRef
                                                    SparseMat a,
                                                    double[] minVal,
                                                    double[] maxVal,
                                                    int[] minIdx,
                                                    int[] maxIdx)

minMaxLoc

@Namespace(value="cv")
public static void minMaxLoc(@Const @ByRef
                                                    SparseMat a,
                                                    double[] minVal,
                                                    double[] maxVal)

reduce
```
@Namespace(value="cv")
public static void reduce(@ByVal
                                                 Mat src,
                                                 @ByVal
                                                 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()).

See Also:

repeat, reduceArgMin, reduceArgMax

reduce

@Namespace(value="cv")
public static void reduce(@ByVal
                                                 Mat src,
                                                 @ByVal
                                                 Mat dst,
                                                 int dim,
                                                 int rtype)

reduce

@Namespace(value="cv")
public static void reduce(@ByVal
                                                 UMat src,
                                                 @ByVal
                                                 UMat dst,
                                                 int dim,
                                                 int rtype,
                                                 int dtype)

reduce

@Namespace(value="cv")
public static void reduce(@ByVal
                                                 UMat src,
                                                 @ByVal
                                                 UMat dst,
                                                 int dim,
                                                 int rtype)

reduce

@Namespace(value="cv")
public static void reduce(@ByVal
                                                 GpuMat src,
                                                 @ByVal
                                                 GpuMat dst,
                                                 int dim,
                                                 int rtype,
                                                 int dtype)

reduce

@Namespace(value="cv")
public static void reduce(@ByVal
                                                 GpuMat src,
                                                 @ByVal
                                                 GpuMat dst,
                                                 int dim,
                                                 int rtype)

merge
```
@Namespace(value="cv")
public static void merge(@Const
                                                Mat mv,
                                                @Cast(value="size_t")
                                                long count,
                                                @ByVal
                                                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.

See Also:

mixChannels, split, Mat::reshape

merge

@Namespace(value="cv")
public static void merge(@Const
                                                Mat mv,
                                                @Cast(value="size_t")
                                                long count,
                                                @ByVal
                                                UMat dst)

merge

@Namespace(value="cv")
public static void merge(@Const
                                                Mat mv,
                                                @Cast(value="size_t")
                                                long count,
                                                @ByVal
                                                GpuMat dst)

merge

@Namespace(value="cv")
public static void merge(@ByVal
                                                MatVector mv,
                                                @ByVal
                                                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
                                                UMatVector mv,
                                                @ByVal
                                                Mat dst)

merge

@Namespace(value="cv")
public static void merge(@ByVal
                                                GpuMatVector mv,
                                                @ByVal
                                                Mat dst)

merge

@Namespace(value="cv")
public static void merge(@ByVal
                                                MatVector mv,
                                                @ByVal
                                                UMat dst)

merge

@Namespace(value="cv")
public static void merge(@ByVal
                                                UMatVector mv,
                                                @ByVal
                                                UMat dst)

merge

@Namespace(value="cv")
public static void merge(@ByVal
                                                GpuMatVector mv,
                                                @ByVal
                                                UMat dst)

merge

@Namespace(value="cv")
public static void merge(@ByVal
                                                MatVector mv,
                                                @ByVal
                                                GpuMat dst)

merge

@Namespace(value="cv")
public static void merge(@ByVal
                                                UMatVector mv,
                                                @ByVal
                                                GpuMat dst)

merge

@Namespace(value="cv")
public static void merge(@ByVal
                                                GpuMatVector mv,
                                                @ByVal
                                                GpuMat dst)

split
```
@Namespace(value="cv")
public static void split(@Const @ByRef
                                                Mat src,
                                                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:
```
 \[\texttt{mv} [c](I) =  \texttt{src} (I)_c\]
```
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.

See Also:

merge, mixChannels, cvtColor

split

@Namespace(value="cv")
public static void split(@ByVal
                                                Mat m,
                                                @ByVal
                                                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
                                                Mat m,
                                                @ByVal
                                                UMatVector mv)

split

@Namespace(value="cv")
public static void split(@ByVal
                                                Mat m,
                                                @ByVal
                                                GpuMatVector mv)

split

@Namespace(value="cv")
public static void split(@ByVal
                                                UMat m,
                                                @ByVal
                                                MatVector mv)

split

@Namespace(value="cv")
public static void split(@ByVal
                                                UMat m,
                                                @ByVal
                                                UMatVector mv)

split

@Namespace(value="cv")
public static void split(@ByVal
                                                UMat m,
                                                @ByVal
                                                GpuMatVector mv)

split

@Namespace(value="cv")
public static void split(@ByVal
                                                GpuMat m,
                                                @ByVal
                                                MatVector mv)

split

@Namespace(value="cv")
public static void split(@ByVal
                                                GpuMat m,
                                                @ByVal
                                                UMatVector mv)

split

@Namespace(value="cv")
public static void split(@ByVal
                                                GpuMat m,
                                                @ByVal
                                                GpuMatVector mv)

mixChannels
```
@Namespace(value="cv")
public static void mixChannels(@Const
                                                      Mat src,
                                                      @Cast(value="size_t")
                                                      long nsrcs,
                                                      Mat dst,
                                                      @Cast(value="size_t")
                                                      long ndsts,
                                                      @Const
                                                      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.

See Also:

split, merge, extractChannel, insertChannel, cvtColor

mixChannels

@Namespace(value="cv")
public static void mixChannels(@Const
                                                      Mat src,
                                                      @Cast(value="size_t")
                                                      long nsrcs,
                                                      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
                                                      Mat src,
                                                      @Cast(value="size_t")
                                                      long nsrcs,
                                                      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
                                                      MatVector src,
                                                      @ByVal
                                                      MatVector dst,
                                                      @Const
                                                      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
                                                      UMatVector src,
                                                      @ByVal
                                                      UMatVector dst,
                                                      @Const
                                                      IntBuffer fromTo,
                                                      @Cast(value="size_t")
                                                      long npairs)

mixChannels

@Namespace(value="cv")
public static void mixChannels(@ByVal
                                                      GpuMatVector src,
                                                      @ByVal
                                                      GpuMatVector dst,
                                                      @Const
                                                      int[] fromTo,
                                                      @Cast(value="size_t")
                                                      long npairs)

mixChannels
```
@Namespace(value="cv")
public static void mixChannels(@ByVal
                                                      MatVector src,
                                                      @ByVal
                                                      MatVector dst,
                                                      @StdVector
                                                      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
                                                      UMatVector src,
                                                      @ByVal
                                                      UMatVector dst,
                                                      @StdVector
                                                      IntBuffer fromTo)

mixChannels

@Namespace(value="cv")
public static void mixChannels(@ByVal
                                                      GpuMatVector src,
                                                      @ByVal
                                                      GpuMatVector dst,
                                                      @StdVector
                                                      int[] fromTo)

extractChannel

@Namespace(value="cv")
public static void extractChannel(@ByVal
                                                         Mat src,
                                                         @ByVal
                                                         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
See Also:: mixChannels, split

extractChannel

@Namespace(value="cv")
public static void extractChannel(@ByVal
                                                         UMat src,
                                                         @ByVal
                                                         UMat dst,
                                                         int coi)

extractChannel

@Namespace(value="cv")
public static void extractChannel(@ByVal
                                                         GpuMat src,
                                                         @ByVal
                                                         GpuMat dst,
                                                         int coi)

insertChannel

@Namespace(value="cv")
public static void insertChannel(@ByVal
                                                        Mat src,
                                                        @ByVal
                                                        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
See Also:: mixChannels, merge

insertChannel

@Namespace(value="cv")
public static void insertChannel(@ByVal
                                                        UMat src,
                                                        @ByVal
                                                        UMat dst,
                                                        int coi)

insertChannel

@Namespace(value="cv")
public static void insertChannel(@ByVal
                                                        GpuMat src,
                                                        @ByVal
                                                        GpuMat dst,
                                                        int coi)

flip
```
@Namespace(value="cv")
public static void flip(@ByVal
                                               Mat src,
                                               @ByVal
                                               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):
```
 \[\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.\]}
```
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.

See Also:

, repeat , completeSymm

flip

@Namespace(value="cv")
public static void flip(@ByVal
                                               UMat src,
                                               @ByVal
                                               UMat dst,
                                               int flipCode)

flip

@Namespace(value="cv")
public static void flip(@ByVal
                                               GpuMat src,
                                               @ByVal
                                               GpuMat dst,
                                               int flipCode)

rotate
```
@Namespace(value="cv")
public static void rotate(@ByVal
                                                 Mat src,
                                                 @ByVal
                                                 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

See Also:

, repeat , completeSymm, flip, RotateFlags

rotate

@Namespace(value="cv")
public static void rotate(@ByVal
                                                 UMat src,
                                                 @ByVal
                                                 UMat dst,
                                                 int rotateCode)

rotate

@Namespace(value="cv")
public static void rotate(@ByVal
                                                 GpuMat src,
                                                 @ByVal
                                                 GpuMat dst,
                                                 int rotateCode)

repeat

@Namespace(value="cv")
public static void repeat(@ByVal
                                                 Mat src,
                                                 int ny,
                                                 int nx,
                                                 @ByVal
                                                 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:

 \[\texttt{dst} _{ij}= \texttt{src} _{i\mod src.rows, \; j\mod src.cols }\]

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.
See Also:: cv::reduce

repeat

@Namespace(value="cv")
public static void repeat(@ByVal
                                                 UMat src,
                                                 int ny,
                                                 int nx,
                                                 @ByVal
                                                 UMat dst)

repeat

@Namespace(value="cv")
public static void repeat(@ByVal
                                                 GpuMat src,
                                                 int ny,
                                                 int nx,
                                                 @ByVal
                                                 GpuMat dst)

repeat

@Namespace(value="cv")
 @ByVal
public static Mat repeat(@Const @ByRef
                                                        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
                                                  Mat src,
                                                  @Cast(value="size_t")
                                                  long nsrc,
                                                  @ByVal
                                                  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.
See Also:: cv::vconcat(const Mat*, size_t, OutputArray), @see cv::vconcat(InputArrayOfArrays, OutputArray) and @see cv::vconcat(InputArray, InputArray, OutputArray)

hconcat

@Namespace(value="cv")
public static void hconcat(@Const
                                                  Mat src,
                                                  @Cast(value="size_t")
                                                  long nsrc,
                                                  @ByVal
                                                  UMat dst)

hconcat

@Namespace(value="cv")
public static void hconcat(@Const
                                                  Mat src,
                                                  @Cast(value="size_t")
                                                  long nsrc,
                                                  @ByVal
                                                  GpuMat dst)

hconcat

@Namespace(value="cv")
public static void hconcat(@ByVal
                                                  Mat src1,
                                                  @ByVal
                                                  Mat src2,
                                                  @ByVal
                                                  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
                                                  UMat src1,
                                                  @ByVal
                                                  UMat src2,
                                                  @ByVal
                                                  UMat dst)

hconcat

@Namespace(value="cv")
public static void hconcat(@ByVal
                                                  GpuMat src1,
                                                  @ByVal
                                                  GpuMat src2,
                                                  @ByVal
                                                  GpuMat dst)

hconcat

@Namespace(value="cv")
public static void hconcat(@ByVal
                                                  MatVector src,
                                                  @ByVal
                                                  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
                                                  UMatVector src,
                                                  @ByVal
                                                  Mat dst)

hconcat

@Namespace(value="cv")
public static void hconcat(@ByVal
                                                  GpuMatVector src,
                                                  @ByVal
                                                  Mat dst)

hconcat

@Namespace(value="cv")
public static void hconcat(@ByVal
                                                  MatVector src,
                                                  @ByVal
                                                  UMat dst)

hconcat

@Namespace(value="cv")
public static void hconcat(@ByVal
                                                  UMatVector src,
                                                  @ByVal
                                                  UMat dst)

hconcat

@Namespace(value="cv")
public static void hconcat(@ByVal
                                                  GpuMatVector src,
                                                  @ByVal
                                                  UMat dst)

hconcat

@Namespace(value="cv")
public static void hconcat(@ByVal
                                                  MatVector src,
                                                  @ByVal
                                                  GpuMat dst)

hconcat

@Namespace(value="cv")
public static void hconcat(@ByVal
                                                  UMatVector src,
                                                  @ByVal
                                                  GpuMat dst)

hconcat

@Namespace(value="cv")
public static void hconcat(@ByVal
                                                  GpuMatVector src,
                                                  @ByVal
                                                  GpuMat dst)

vconcat

@Namespace(value="cv")
public static void vconcat(@Const
                                                  Mat src,
                                                  @Cast(value="size_t")
                                                  long nsrc,
                                                  @ByVal
                                                  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.
See Also:: cv::hconcat(const Mat*, size_t, OutputArray), @see cv::hconcat(InputArrayOfArrays, OutputArray) and @see cv::hconcat(InputArray, InputArray, OutputArray)

vconcat

@Namespace(value="cv")
public static void vconcat(@Const
                                                  Mat src,
                                                  @Cast(value="size_t")
                                                  long nsrc,
                                                  @ByVal
                                                  UMat dst)

vconcat

@Namespace(value="cv")
public static void vconcat(@Const
                                                  Mat src,
                                                  @Cast(value="size_t")
                                                  long nsrc,
                                                  @ByVal
                                                  GpuMat dst)

vconcat

@Namespace(value="cv")
public static void vconcat(@ByVal
                                                  Mat src1,
                                                  @ByVal
                                                  Mat src2,
                                                  @ByVal
                                                  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
                                                  UMat src1,
                                                  @ByVal
                                                  UMat src2,
                                                  @ByVal
                                                  UMat dst)

vconcat

@Namespace(value="cv")
public static void vconcat(@ByVal
                                                  GpuMat src1,
                                                  @ByVal
                                                  GpuMat src2,
                                                  @ByVal
                                                  GpuMat dst)

vconcat

@Namespace(value="cv")
public static void vconcat(@ByVal
                                                  MatVector src,
                                                  @ByVal
                                                  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
                                                  UMatVector src,
                                                  @ByVal
                                                  Mat dst)

vconcat

@Namespace(value="cv")
public static void vconcat(@ByVal
                                                  GpuMatVector src,
                                                  @ByVal
                                                  Mat dst)

vconcat

@Namespace(value="cv")
public static void vconcat(@ByVal
                                                  MatVector src,
                                                  @ByVal
                                                  UMat dst)

vconcat

@Namespace(value="cv")
public static void vconcat(@ByVal
                                                  UMatVector src,
                                                  @ByVal
                                                  UMat dst)

vconcat

@Namespace(value="cv")
public static void vconcat(@ByVal
                                                  GpuMatVector src,
                                                  @ByVal
                                                  UMat dst)

vconcat

@Namespace(value="cv")
public static void vconcat(@ByVal
                                                  MatVector src,
                                                  @ByVal
                                                  GpuMat dst)

vconcat

@Namespace(value="cv")
public static void vconcat(@ByVal
                                                  UMatVector src,
                                                  @ByVal
                                                  GpuMat dst)

vconcat

@Namespace(value="cv")
public static void vconcat(@ByVal
                                                  GpuMatVector src,
                                                  @ByVal
                                                  GpuMat dst)

bitwise_and

@Namespace(value="cv")
public static void bitwise_and(@ByVal
                                                      Mat src1,
                                                      @ByVal
                                                      Mat src2,
                                                      @ByVal
                                                      Mat dst,
                                                      @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                      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:

 \[\texttt{dst} (I) =  \texttt{src1} (I)  \wedge \texttt{src2} (I) \quad \texttt{if mask} (I) \ne0\]

An array and a scalar when src2 is constructed from Scalar or has the same number of elements as src1.channels():

 \[\texttt{dst} (I) =  \texttt{src1} (I)  \wedge \texttt{src2} \quad \texttt{if mask} (I) \ne0\]

A scalar and an array when src1 is constructed from Scalar or has the same number of elements as src2.channels():

 \[\texttt{dst} (I) =  \texttt{src1}  \wedge \texttt{src2} (I) \quad \texttt{if mask} (I) \ne0\]

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
                                                      Mat src1,
                                                      @ByVal
                                                      Mat src2,
                                                      @ByVal
                                                      Mat dst)

bitwise_and

@Namespace(value="cv")
public static void bitwise_and(@ByVal
                                                      UMat src1,
                                                      @ByVal
                                                      UMat src2,
                                                      @ByVal
                                                      UMat dst,
                                                      @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                      UMat mask)

bitwise_and

@Namespace(value="cv")
public static void bitwise_and(@ByVal
                                                      UMat src1,
                                                      @ByVal
                                                      UMat src2,
                                                      @ByVal
                                                      UMat dst)

bitwise_and

@Namespace(value="cv")
public static void bitwise_and(@ByVal
                                                      GpuMat src1,
                                                      @ByVal
                                                      GpuMat src2,
                                                      @ByVal
                                                      GpuMat dst,
                                                      @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                      GpuMat mask)

bitwise_and

@Namespace(value="cv")
public static void bitwise_and(@ByVal
                                                      GpuMat src1,
                                                      @ByVal
                                                      GpuMat src2,
                                                      @ByVal
                                                      GpuMat dst)

bitwise_or

@Namespace(value="cv")
public static void bitwise_or(@ByVal
                                                     Mat src1,
                                                     @ByVal
                                                     Mat src2,
                                                     @ByVal
                                                     Mat dst,
                                                     @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                     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:

 \[\texttt{dst} (I) =  \texttt{src1} (I)  \vee \texttt{src2} (I) \quad \texttt{if mask} (I) \ne0\]

An array and a scalar when src2 is constructed from Scalar or has the same number of elements as src1.channels():

 \[\texttt{dst} (I) =  \texttt{src1} (I)  \vee \texttt{src2} \quad \texttt{if mask} (I) \ne0\]

A scalar and an array when src1 is constructed from Scalar or has the same number of elements as src2.channels():

 \[\texttt{dst} (I) =  \texttt{src1}  \vee \texttt{src2} (I) \quad \texttt{if mask} (I) \ne0\]

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
                                                     Mat src1,
                                                     @ByVal
                                                     Mat src2,
                                                     @ByVal
                                                     Mat dst)

bitwise_or

@Namespace(value="cv")
public static void bitwise_or(@ByVal
                                                     UMat src1,
                                                     @ByVal
                                                     UMat src2,
                                                     @ByVal
                                                     UMat dst,
                                                     @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                     UMat mask)

bitwise_or

@Namespace(value="cv")
public static void bitwise_or(@ByVal
                                                     UMat src1,
                                                     @ByVal
                                                     UMat src2,
                                                     @ByVal
                                                     UMat dst)

bitwise_or

@Namespace(value="cv")
public static void bitwise_or(@ByVal
                                                     GpuMat src1,
                                                     @ByVal
                                                     GpuMat src2,
                                                     @ByVal
                                                     GpuMat dst,
                                                     @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                     GpuMat mask)

bitwise_or

@Namespace(value="cv")
public static void bitwise_or(@ByVal
                                                     GpuMat src1,
                                                     @ByVal
                                                     GpuMat src2,
                                                     @ByVal
                                                     GpuMat dst)

bitwise_xor

@Namespace(value="cv")
public static void bitwise_xor(@ByVal
                                                      Mat src1,
                                                      @ByVal
                                                      Mat src2,
                                                      @ByVal
                                                      Mat dst,
                                                      @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                      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:

 \[\texttt{dst} (I) =  \texttt{src1} (I)  \oplus \texttt{src2} (I) \quad \texttt{if mask} (I) \ne0\]

An array and a scalar when src2 is constructed from Scalar or has the same number of elements as src1.channels():

 \[\texttt{dst} (I) =  \texttt{src1} (I)  \oplus \texttt{src2} \quad \texttt{if mask} (I) \ne0\]

A scalar and an array when src1 is constructed from Scalar or has the same number of elements as src2.channels():

 \[\texttt{dst} (I) =  \texttt{src1}  \oplus \texttt{src2} (I) \quad \texttt{if mask} (I) \ne0\]

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
                                                      Mat src1,
                                                      @ByVal
                                                      Mat src2,
                                                      @ByVal
                                                      Mat dst)

bitwise_xor

@Namespace(value="cv")
public static void bitwise_xor(@ByVal
                                                      UMat src1,
                                                      @ByVal
                                                      UMat src2,
                                                      @ByVal
                                                      UMat dst,
                                                      @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                      UMat mask)

bitwise_xor

@Namespace(value="cv")
public static void bitwise_xor(@ByVal
                                                      UMat src1,
                                                      @ByVal
                                                      UMat src2,
                                                      @ByVal
                                                      UMat dst)

bitwise_xor

@Namespace(value="cv")
public static void bitwise_xor(@ByVal
                                                      GpuMat src1,
                                                      @ByVal
                                                      GpuMat src2,
                                                      @ByVal
                                                      GpuMat dst,
                                                      @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                      GpuMat mask)

bitwise_xor

@Namespace(value="cv")
public static void bitwise_xor(@ByVal
                                                      GpuMat src1,
                                                      @ByVal
                                                      GpuMat src2,
                                                      @ByVal
                                                      GpuMat dst)

bitwise_not

@Namespace(value="cv")
public static void bitwise_not(@ByVal
                                                      Mat src,
                                                      @ByVal
                                                      Mat dst,
                                                      @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                      Mat mask)

\brief Inverts every bit of an array.

The function cv::bitwise_not calculates per-element bit-wise inversion of the input array:

 \[\texttt{dst} (I) =  \neg \texttt{src} (I)\]

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
                                                      Mat src,
                                                      @ByVal
                                                      Mat dst)

bitwise_not

@Namespace(value="cv")
public static void bitwise_not(@ByVal
                                                      UMat src,
                                                      @ByVal
                                                      UMat dst,
                                                      @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                      UMat mask)

bitwise_not

@Namespace(value="cv")
public static void bitwise_not(@ByVal
                                                      UMat src,
                                                      @ByVal
                                                      UMat dst)

bitwise_not

@Namespace(value="cv")
public static void bitwise_not(@ByVal
                                                      GpuMat src,
                                                      @ByVal
                                                      GpuMat dst,
                                                      @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                      GpuMat mask)

bitwise_not

@Namespace(value="cv")
public static void bitwise_not(@ByVal
                                                      GpuMat src,
                                                      @ByVal
                                                      GpuMat dst)

absdiff
```
@Namespace(value="cv")
public static void absdiff(@ByVal
                                                  Mat src1,
                                                  @ByVal
                                                  Mat src2,
                                                  @ByVal
                                                  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:
```
 \[\texttt{dst}(I) =  \texttt{saturate} (| \texttt{src1}(I) -  \texttt{src2}(I)|)\]
```
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:
```
 \[\texttt{dst}(I) =  \texttt{saturate} (| \texttt{src1}(I) -  \texttt{src2} |)\]
```
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:
```
 \[\texttt{dst}(I) =  \texttt{saturate} (| \texttt{src1} -  \texttt{src2}(I) |)\]
```
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.

See Also:

cv::abs(const Mat&)

absdiff

@Namespace(value="cv")
public static void absdiff(@ByVal
                                                  UMat src1,
                                                  @ByVal
                                                  UMat src2,
                                                  @ByVal
                                                  UMat dst)

absdiff

@Namespace(value="cv")
public static void absdiff(@ByVal
                                                  GpuMat src1,
                                                  @ByVal
                                                  GpuMat src2,
                                                  @ByVal
                                                  GpuMat dst)

copyTo
```
@Namespace(value="cv")
public static void copyTo(@ByVal
                                                 Mat src,
                                                 @ByVal
                                                 Mat dst,
                                                 @ByVal
                                                 Mat mask)
```
\brief This is an overloaded member function, provided for convenience (python) Copies the matrix to another one. When the operation mask is specified, if the Mat::create call shown above reallocates the matrix, the newly allocated matrix is initialized with all zeros before copying the data.

Parameters:

src - source matrix.

dst - Destination matrix. If it does not have a proper size or type before the operation, it is reallocated.

mask - Operation mask of the same size as \*this. Its non-zero elements indicate which matrix elements need to be copied. The mask has to be of type CV_8U and can have 1 or multiple channels.

copyTo

@Namespace(value="cv")
public static void copyTo(@ByVal
                                                 UMat src,
                                                 @ByVal
                                                 UMat dst,
                                                 @ByVal
                                                 UMat mask)

copyTo

@Namespace(value="cv")
public static void copyTo(@ByVal
                                                 GpuMat src,
                                                 @ByVal
                                                 GpuMat dst,
                                                 @ByVal
                                                 GpuMat mask)

inRange

@Namespace(value="cv")
public static void inRange(@ByVal
                                                  Mat src,
                                                  @ByVal
                                                  Mat lowerb,
                                                  @ByVal
                                                  Mat upperb,
                                                  @ByVal
                                                  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:

 \[\texttt{dst} (I)= \texttt{lowerb} (I)_0  \leq \texttt{src} (I)_0 \leq  \texttt{upperb} (I)_0\]

- For two-channel arrays:

 \[\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\]

- 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
                                                  UMat src,
                                                  @ByVal
                                                  UMat lowerb,
                                                  @ByVal
                                                  UMat upperb,
                                                  @ByVal
                                                  UMat dst)

inRange

@Namespace(value="cv")
public static void inRange(@ByVal
                                                  GpuMat src,
                                                  @ByVal
                                                  GpuMat lowerb,
                                                  @ByVal
                                                  GpuMat upperb,
                                                  @ByVal
                                                  GpuMat dst)

compare

@Namespace(value="cv")
public static void compare(@ByVal
                                                  Mat src1,
                                                  @ByVal
                                                  Mat src2,
                                                  @ByVal
                                                  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:

 \[\texttt{dst} (I) =  \texttt{src1} (I)  \,\texttt{cmpop}\, \texttt{src2} (I)\]

Elements of src1 with a scalar src2 when src2 is constructed from Scalar or has a single element:

 \[\texttt{dst} (I) =  \texttt{src1}(I) \,\texttt{cmpop}\,  \texttt{src2}\]

src1 with elements of src2 when src1 is constructed from Scalar or has a single element:

 \[\texttt{dst} (I) =  \texttt{src1}  \,\texttt{cmpop}\, \texttt{src2} (I)\]

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)
See Also:: checkRange, min, max, threshold

compare

@Namespace(value="cv")
public static void compare(@ByVal
                                                  UMat src1,
                                                  @ByVal
                                                  UMat src2,
                                                  @ByVal
                                                  UMat dst,
                                                  int cmpop)

compare

@Namespace(value="cv")
public static void compare(@ByVal
                                                  GpuMat src1,
                                                  @ByVal
                                                  GpuMat src2,
                                                  @ByVal
                                                  GpuMat dst,
                                                  int cmpop)

min

@Namespace(value="cv")
public static void min(@Const @ByRef
                                              Mat src1,
                                              @Const @ByRef
                                              Mat src2,
                                              @ByRef
                                              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
                                              UMat src1,
                                              @Const @ByRef
                                              UMat src2,
                                              @ByRef
                                              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
                                              Mat src1,
                                              @Const @ByRef
                                              Mat src2,
                                              @ByRef
                                              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
                                              UMat src1,
                                              @Const @ByRef
                                              UMat src2,
                                              @ByRef
                                              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
                                               Mat src,
                                               @ByVal
                                               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
                                               UMat src,
                                               @ByVal
                                               UMat dst)

sqrt

@Namespace(value="cv")
public static void sqrt(@ByVal
                                               GpuMat src,
                                               @ByVal
                                               GpuMat dst)

pow
```
@Namespace(value="cv")
public static void pow(@ByVal
                                              Mat src,
                                              double power,
                                              @ByVal
                                              Mat dst)
```
\brief Raises every array element to a power.
The function cv::pow raises every element of the input array to power :
```
 \[\texttt{dst} (I) =  \fork{\texttt{src}(I)^{power}}{if \(\texttt{power}\) is integer}{|\texttt{src}(I)|^{power}}{otherwise}\]
```
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.

See Also:

sqrt, exp, log, cartToPolar, polarToCart

pow

@Namespace(value="cv")
public static void pow(@ByVal
                                              UMat src,
                                              double power,
                                              @ByVal
                                              UMat dst)

pow

@Namespace(value="cv")
public static void pow(@ByVal
                                              GpuMat src,
                                              double power,
                                              @ByVal
                                              GpuMat dst)

exp
```
@Namespace(value="cv")
public static void exp(@ByVal
                                              Mat src,
                                              @ByVal
                                              Mat dst)
```
\brief Calculates the exponent of every array element.
The function cv::exp calculates the exponent of every element of the input array:
```
 \[\texttt{dst} [I] = e^{ src(I) }\]
```
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.

See Also:

, cartToPolar , polarToCart , phase , pow , sqrt , magnitude

exp

@Namespace(value="cv")
public static void exp(@ByVal
                                              UMat src,
                                              @ByVal
                                              UMat dst)

exp

@Namespace(value="cv")
public static void exp(@ByVal
                                              GpuMat src,
                                              @ByVal
                                              GpuMat dst)

log

@Namespace(value="cv")
public static void log(@ByVal
                                              Mat src,
                                              @ByVal
                                              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:

 \[\texttt{dst} (I) =  \log (\texttt{src}(I)) \]

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 .
See Also:: exp, cartToPolar, polarToCart, phase, pow, sqrt, magnitude

log

@Namespace(value="cv")
public static void log(@ByVal
                                              UMat src,
                                              @ByVal
                                              UMat dst)

log

@Namespace(value="cv")
public static void log(@ByVal
                                              GpuMat src,
                                              @ByVal
                                              GpuMat dst)

polarToCart

@Namespace(value="cv")
public static void polarToCart(@ByVal
                                                      Mat magnitude,
                                                      @ByVal
                                                      Mat angle,
                                                      @ByVal
                                                      Mat x,
                                                      @ByVal
                                                      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:

 \[\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}\]

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.
See Also:: cartToPolar, magnitude, phase, exp, log, pow, sqrt

polarToCart

@Namespace(value="cv")
public static void polarToCart(@ByVal
                                                      Mat magnitude,
                                                      @ByVal
                                                      Mat angle,
                                                      @ByVal
                                                      Mat x,
                                                      @ByVal
                                                      Mat y)

polarToCart

@Namespace(value="cv")
public static void polarToCart(@ByVal
                                                      UMat magnitude,
                                                      @ByVal
                                                      UMat angle,
                                                      @ByVal
                                                      UMat x,
                                                      @ByVal
                                                      UMat y,
                                                      @Cast(value="bool")
                                                      boolean angleInDegrees)

polarToCart

@Namespace(value="cv")
public static void polarToCart(@ByVal
                                                      UMat magnitude,
                                                      @ByVal
                                                      UMat angle,
                                                      @ByVal
                                                      UMat x,
                                                      @ByVal
                                                      UMat y)

polarToCart

@Namespace(value="cv")
public static void polarToCart(@ByVal
                                                      GpuMat magnitude,
                                                      @ByVal
                                                      GpuMat angle,
                                                      @ByVal
                                                      GpuMat x,
                                                      @ByVal
                                                      GpuMat y,
                                                      @Cast(value="bool")
                                                      boolean angleInDegrees)

polarToCart

@Namespace(value="cv")
public static void polarToCart(@ByVal
                                                      GpuMat magnitude,
                                                      @ByVal
                                                      GpuMat angle,
                                                      @ByVal
                                                      GpuMat x,
                                                      @ByVal
                                                      GpuMat y)

cartToPolar

@Namespace(value="cv")
public static void cartToPolar(@ByVal
                                                      Mat x,
                                                      @ByVal
                                                      Mat y,
                                                      @ByVal
                                                      Mat magnitude,
                                                      @ByVal
                                                      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)):

 \[\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}\]

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.
See Also:: Sobel, Scharr

cartToPolar

@Namespace(value="cv")
public static void cartToPolar(@ByVal
                                                      Mat x,
                                                      @ByVal
                                                      Mat y,
                                                      @ByVal
                                                      Mat magnitude,
                                                      @ByVal
                                                      Mat angle)

cartToPolar

@Namespace(value="cv")
public static void cartToPolar(@ByVal
                                                      UMat x,
                                                      @ByVal
                                                      UMat y,
                                                      @ByVal
                                                      UMat magnitude,
                                                      @ByVal
                                                      UMat angle,
                                                      @Cast(value="bool")
                                                      boolean angleInDegrees)

cartToPolar

@Namespace(value="cv")
public static void cartToPolar(@ByVal
                                                      UMat x,
                                                      @ByVal
                                                      UMat y,
                                                      @ByVal
                                                      UMat magnitude,
                                                      @ByVal
                                                      UMat angle)

cartToPolar

@Namespace(value="cv")
public static void cartToPolar(@ByVal
                                                      GpuMat x,
                                                      @ByVal
                                                      GpuMat y,
                                                      @ByVal
                                                      GpuMat magnitude,
                                                      @ByVal
                                                      GpuMat angle,
                                                      @Cast(value="bool")
                                                      boolean angleInDegrees)

cartToPolar

@Namespace(value="cv")
public static void cartToPolar(@ByVal
                                                      GpuMat x,
                                                      @ByVal
                                                      GpuMat y,
                                                      @ByVal
                                                      GpuMat magnitude,
                                                      @ByVal
                                                      GpuMat angle)

phase

@Namespace(value="cv")
public static void phase(@ByVal
                                                Mat x,
                                                @ByVal
                                                Mat y,
                                                @ByVal
                                                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 :

 \[\texttt{angle} (I) =  \texttt{atan2} ( \texttt{y} (I), \texttt{x} (I))\]

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
                                                Mat x,
                                                @ByVal
                                                Mat y,
                                                @ByVal
                                                Mat angle)

phase

@Namespace(value="cv")
public static void phase(@ByVal
                                                UMat x,
                                                @ByVal
                                                UMat y,
                                                @ByVal
                                                UMat angle,
                                                @Cast(value="bool")
                                                boolean angleInDegrees)

phase

@Namespace(value="cv")
public static void phase(@ByVal
                                                UMat x,
                                                @ByVal
                                                UMat y,
                                                @ByVal
                                                UMat angle)

phase

@Namespace(value="cv")
public static void phase(@ByVal
                                                GpuMat x,
                                                @ByVal
                                                GpuMat y,
                                                @ByVal
                                                GpuMat angle,
                                                @Cast(value="bool")
                                                boolean angleInDegrees)

phase

@Namespace(value="cv")
public static void phase(@ByVal
                                                GpuMat x,
                                                @ByVal
                                                GpuMat y,
                                                @ByVal
                                                GpuMat angle)

magnitude

@Namespace(value="cv")
public static void magnitude(@ByVal
                                                    Mat x,
                                                    @ByVal
                                                    Mat y,
                                                    @ByVal
                                                    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:

 \[\texttt{dst} (I) =  \sqrt{\texttt{x}(I)^2 + \texttt{y}(I)^2}\]

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.
See Also:: cartToPolar, polarToCart, phase, sqrt

magnitude

@Namespace(value="cv")
public static void magnitude(@ByVal
                                                    UMat x,
                                                    @ByVal
                                                    UMat y,
                                                    @ByVal
                                                    UMat magnitude)

magnitude

@Namespace(value="cv")
public static void magnitude(@ByVal
                                                    GpuMat x,
                                                    @ByVal
                                                    GpuMat y,
                                                    @ByVal
                                                    GpuMat magnitude)

checkRange
```
@Namespace(value="cv")
 @Cast(value="bool")
public static boolean checkRange(@ByVal
                                                                             Mat a,
                                                                             @Cast(value="bool")
                                                                             boolean quiet,
                                                                             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
                                                                             Mat a)

checkRange

@Namespace(value="cv")
 @Cast(value="bool")
public static boolean checkRange(@ByVal
                                                                             UMat a,
                                                                             @Cast(value="bool")
                                                                             boolean quiet,
                                                                             Point pos,
                                                                             double minVal,
                                                                             double maxVal)

checkRange

@Namespace(value="cv")
 @Cast(value="bool")
public static boolean checkRange(@ByVal
                                                                             UMat a)

checkRange

@Namespace(value="cv")
 @Cast(value="bool")
public static boolean checkRange(@ByVal
                                                                             GpuMat a,
                                                                             @Cast(value="bool")
                                                                             boolean quiet,
                                                                             Point pos,
                                                                             double minVal,
                                                                             double maxVal)

checkRange

@Namespace(value="cv")
 @Cast(value="bool")
public static boolean checkRange(@ByVal
                                                                             GpuMat a)

patchNaNs

@Namespace(value="cv")
public static void patchNaNs(@ByVal
                                                    Mat a,
                                                    double val)

\brief converts NaNs to the given number

Parameters:: a - input/output matrix (CV_32F type).; val - value to convert the NaNs

patchNaNs

@Namespace(value="cv")
public static void patchNaNs(@ByVal
                                                    Mat a)

patchNaNs

@Namespace(value="cv")
public static void patchNaNs(@ByVal
                                                    UMat a,
                                                    double val)

patchNaNs

@Namespace(value="cv")
public static void patchNaNs(@ByVal
                                                    UMat a)

patchNaNs

@Namespace(value="cv")
public static void patchNaNs(@ByVal
                                                    GpuMat a,
                                                    double val)

patchNaNs

@Namespace(value="cv")
public static void patchNaNs(@ByVal
                                                    GpuMat a)

gemm

@Namespace(value="cv")
public static void gemm(@ByVal
                                               Mat src1,
                                               @ByVal
                                               Mat src2,
                                               double alpha,
                                               @ByVal
                                               Mat src3,
                                               double beta,
                                               @ByVal
                                               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

 \[\texttt{dst} =  \texttt{alpha} \cdot \texttt{src1} ^T  \cdot \texttt{src2} +  \texttt{beta} \cdot \texttt{src3} ^T\]

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)
See Also:: , transform

gemm

@Namespace(value="cv")
public static void gemm(@ByVal
                                               Mat src1,
                                               @ByVal
                                               Mat src2,
                                               double alpha,
                                               @ByVal
                                               Mat src3,
                                               double beta,
                                               @ByVal
                                               Mat dst)

gemm

@Namespace(value="cv")
public static void gemm(@ByVal
                                               UMat src1,
                                               @ByVal
                                               UMat src2,
                                               double alpha,
                                               @ByVal
                                               UMat src3,
                                               double beta,
                                               @ByVal
                                               UMat dst,
                                               int flags)

gemm

@Namespace(value="cv")
public static void gemm(@ByVal
                                               UMat src1,
                                               @ByVal
                                               UMat src2,
                                               double alpha,
                                               @ByVal
                                               UMat src3,
                                               double beta,
                                               @ByVal
                                               UMat dst)

gemm

@Namespace(value="cv")
public static void gemm(@ByVal
                                               GpuMat src1,
                                               @ByVal
                                               GpuMat src2,
                                               double alpha,
                                               @ByVal
                                               GpuMat src3,
                                               double beta,
                                               @ByVal
                                               GpuMat dst,
                                               int flags)

gemm

@Namespace(value="cv")
public static void gemm(@ByVal
                                               GpuMat src1,
                                               @ByVal
                                               GpuMat src2,
                                               double alpha,
                                               @ByVal
                                               GpuMat src3,
                                               double beta,
                                               @ByVal
                                               GpuMat dst)

mulTransposed
```
@Namespace(value="cv")
public static void mulTransposed(@ByVal
                                                        Mat src,
                                                        @ByVal
                                                        Mat dst,
                                                        @Cast(value="bool")
                                                        boolean aTa,
                                                        @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                        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:
```
 \[\texttt{dst} = \texttt{scale} ( \texttt{src} - \texttt{delta} )^T ( \texttt{src} - \texttt{delta} )\]
```
if aTa=true , and
```
 \[\texttt{dst} = \texttt{scale} ( \texttt{src} - \texttt{delta} ) ( \texttt{src} - \texttt{delta} )^T\]
```
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 .

See Also:

calcCovarMatrix, gemm, repeat, reduce

mulTransposed

@Namespace(value="cv")
public static void mulTransposed(@ByVal
                                                        Mat src,
                                                        @ByVal
                                                        Mat dst,
                                                        @Cast(value="bool")
                                                        boolean aTa)

mulTransposed

@Namespace(value="cv")
public static void mulTransposed(@ByVal
                                                        UMat src,
                                                        @ByVal
                                                        UMat dst,
                                                        @Cast(value="bool")
                                                        boolean aTa,
                                                        @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                        UMat delta,
                                                        double scale,
                                                        int dtype)

mulTransposed

@Namespace(value="cv")
public static void mulTransposed(@ByVal
                                                        UMat src,
                                                        @ByVal
                                                        UMat dst,
                                                        @Cast(value="bool")
                                                        boolean aTa)

mulTransposed

@Namespace(value="cv")
public static void mulTransposed(@ByVal
                                                        GpuMat src,
                                                        @ByVal
                                                        GpuMat dst,
                                                        @Cast(value="bool")
                                                        boolean aTa,
                                                        @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                        GpuMat delta,
                                                        double scale,
                                                        int dtype)

mulTransposed

@Namespace(value="cv")
public static void mulTransposed(@ByVal
                                                        GpuMat src,
                                                        @ByVal
                                                        GpuMat dst,
                                                        @Cast(value="bool")
                                                        boolean aTa)

transpose

@Namespace(value="cv")
public static void transpose(@ByVal
                                                    Mat src,
                                                    @ByVal
                                                    Mat dst)

\brief Transposes a matrix.

The function cv::transpose transposes the matrix src :

 \[\texttt{dst} (i,j) =  \texttt{src} (j,i)\]

\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
                                                    UMat src,
                                                    @ByVal
                                                    UMat dst)

transpose

@Namespace(value="cv")
public static void transpose(@ByVal
                                                    GpuMat src,
                                                    @ByVal
                                                    GpuMat dst)

transform
```
@Namespace(value="cv")
public static void transform(@ByVal
                                                    Mat src,
                                                    @ByVal
                                                    Mat dst,
                                                    @ByVal
                                                    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 :
```
 \[\texttt{dst} (I) =  \texttt{m} \cdot \texttt{src} (I)\]
```
(when m.cols=src.channels() ), or
```
 \[\texttt{dst} (I) =  \texttt{m} \cdot [ \texttt{src} (I); 1]\]
```
(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.

See Also:

perspectiveTransform, getAffineTransform, estimateAffine2D, warpAffine, warpPerspective

transform

@Namespace(value="cv")
public static void transform(@ByVal
                                                    UMat src,
                                                    @ByVal
                                                    UMat dst,
                                                    @ByVal
                                                    UMat m)

transform

@Namespace(value="cv")
public static void transform(@ByVal
                                                    GpuMat src,
                                                    @ByVal
                                                    GpuMat dst,
                                                    @ByVal
                                                    GpuMat m)

perspectiveTransform
```
@Namespace(value="cv")
public static void perspectiveTransform(@ByVal
                                                               Mat src,
                                                               @ByVal
                                                               Mat dst,
                                                               @ByVal
                                                               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:
```
 \[(x, y, z)  \rightarrow (x'/w, y'/w, z'/w)\]
```
where
```
 \[(x', y', z', w') =  \texttt{mat} \cdot \begin{bmatrix} x & y & z & 1  \end{bmatrix}\]
```
and
```
 \[w =  \fork{w'}{if \(w' \ne 0\)}{\infty}{otherwise}\]
```
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.

See Also:

transform, warpPerspective, getPerspectiveTransform, findHomography

perspectiveTransform

@Namespace(value="cv")
public static void perspectiveTransform(@ByVal
                                                               UMat src,
                                                               @ByVal
                                                               UMat dst,
                                                               @ByVal
                                                               UMat m)

perspectiveTransform

@Namespace(value="cv")
public static void perspectiveTransform(@ByVal
                                                               GpuMat src,
                                                               @ByVal
                                                               GpuMat dst,
                                                               @ByVal
                                                               GpuMat m)

completeSymm
```
@Namespace(value="cv")
public static void completeSymm(@ByVal
                                                       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: - \texttt{m}_{ij}=\texttt{m}_{ji} for i > j if lowerToUpper=false - \texttt{m}_{ij}=\texttt{m}_{ji} for i < j 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.

See Also:

flip, transpose

completeSymm

@Namespace(value="cv")
public static void completeSymm(@ByVal
                                                       Mat m)

completeSymm

@Namespace(value="cv")
public static void completeSymm(@ByVal
                                                       UMat m,
                                                       @Cast(value="bool")
                                                       boolean lowerToUpper)

completeSymm

@Namespace(value="cv")
public static void completeSymm(@ByVal
                                                       UMat m)

completeSymm

@Namespace(value="cv")
public static void completeSymm(@ByVal
                                                       GpuMat m,
                                                       @Cast(value="bool")
                                                       boolean lowerToUpper)

completeSymm

@Namespace(value="cv")
public static void completeSymm(@ByVal
                                                       GpuMat m)

setIdentity

@Namespace(value="cv")
public static void setIdentity(@ByVal
                                                      Mat mtx,
                                                      @Const @ByRef(nullValue="cv::Scalar(1)")
                                                      Scalar s)

\brief Initializes a scaled identity matrix.

The function cv::setIdentity initializes a scaled identity matrix:

 \[\texttt{mtx} (i,j)= \fork{\texttt{value}}{ if \(i=j\)}{0}{otherwise}\]

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.
See Also:: Mat::zeros, Mat::ones, Mat::setTo, Mat::operator=

setIdentity

@Namespace(value="cv")
public static void setIdentity(@ByVal
                                                      Mat mtx)

setIdentity

@Namespace(value="cv")
public static void setIdentity(@ByVal
                                                      UMat mtx,
                                                      @Const @ByRef(nullValue="cv::Scalar(1)")
                                                      Scalar s)

setIdentity

@Namespace(value="cv")
public static void setIdentity(@ByVal
                                                      UMat mtx)

setIdentity

@Namespace(value="cv")
public static void setIdentity(@ByVal
                                                      GpuMat mtx,
                                                      @Const @ByRef(nullValue="cv::Scalar(1)")
                                                      Scalar s)

setIdentity

@Namespace(value="cv")
public static void setIdentity(@ByVal
                                                      GpuMat mtx)

determinant
```
@Namespace(value="cv")
public static double determinant(@ByVal
                                                        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.

See Also:

trace, invert, solve, eigen, \ref MatrixExpressions

determinant

@Namespace(value="cv")
public static double determinant(@ByVal
                                                        UMat mtx)

determinant

@Namespace(value="cv")
public static double determinant(@ByVal
                                                        GpuMat mtx)

trace

@Namespace(value="cv")
 @ByVal
public static Scalar trace(@ByVal
                                                          Mat mtx)

\brief Returns the trace of a matrix.

The function cv::trace returns the sum of the diagonal elements of the matrix mtx .

 \[\mathrm{tr} ( \texttt{mtx} ) =  \sum _i  \texttt{mtx} (i,i)\]

Parameters:: mtx - input matrix.

trace

@Namespace(value="cv")
 @ByVal
public static Scalar trace(@ByVal
                                                          UMat mtx)

trace

@Namespace(value="cv")
 @ByVal
public static Scalar trace(@ByVal
                                                          GpuMat mtx)

invert
```
@Namespace(value="cv")
public static double invert(@ByVal
                                                   Mat src,
                                                   @ByVal
                                                   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)

See Also:

solve, SVD

invert

@Namespace(value="cv")
public static double invert(@ByVal
                                                   Mat src,
                                                   @ByVal
                                                   Mat dst)

invert

@Namespace(value="cv")
public static double invert(@ByVal
                                                   UMat src,
                                                   @ByVal
                                                   UMat dst,
                                                   int flags)

invert

@Namespace(value="cv")
public static double invert(@ByVal
                                                   UMat src,
                                                   @ByVal
                                                   UMat dst)

invert

@Namespace(value="cv")
public static double invert(@ByVal
                                                   GpuMat src,
                                                   @ByVal
                                                   GpuMat dst,
                                                   int flags)

invert

@Namespace(value="cv")
public static double invert(@ByVal
                                                   GpuMat src,
                                                   @ByVal
                                                   GpuMat dst)

solve

@Namespace(value="cv")
 @Cast(value="bool")
public static boolean solve(@ByVal
                                                                        Mat src1,
                                                                        @ByVal
                                                                        Mat src2,
                                                                        @ByVal
                                                                        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 ):

 \[\texttt{dst} =  \arg \min _X \| \texttt{src1} \cdot \texttt{X} -  \texttt{src2} \|\]

If #DECOMP_LU or #DECOMP_CHOLESKY method is used, the function returns 1 if src1 (or \texttt{src1}^T\texttt{src1} ) 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 \texttt{src1}\cdot\texttt{dst}=0 , 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)
See Also:: invert, SVD, eigen

solve

@Namespace(value="cv")
 @Cast(value="bool")
public static boolean solve(@ByVal
                                                                        Mat src1,
                                                                        @ByVal
                                                                        Mat src2,
                                                                        @ByVal
                                                                        Mat dst)

solve

@Namespace(value="cv")
 @Cast(value="bool")
public static boolean solve(@ByVal
                                                                        UMat src1,
                                                                        @ByVal
                                                                        UMat src2,
                                                                        @ByVal
                                                                        UMat dst,
                                                                        int flags)

solve

@Namespace(value="cv")
 @Cast(value="bool")
public static boolean solve(@ByVal
                                                                        UMat src1,
                                                                        @ByVal
                                                                        UMat src2,
                                                                        @ByVal
                                                                        UMat dst)

solve

@Namespace(value="cv")
 @Cast(value="bool")
public static boolean solve(@ByVal
                                                                        GpuMat src1,
                                                                        @ByVal
                                                                        GpuMat src2,
                                                                        @ByVal
                                                                        GpuMat dst,
                                                                        int flags)

solve

@Namespace(value="cv")
 @Cast(value="bool")
public static boolean solve(@ByVal
                                                                        GpuMat src1,
                                                                        @ByVal
                                                                        GpuMat src2,
                                                                        @ByVal
                                                                        GpuMat dst)

sort
```
@Namespace(value="cv")
public static void sort(@ByVal
                                               Mat src,
                                               @ByVal
                                               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

See Also:

sortIdx, randShuffle

sort

@Namespace(value="cv")
public static void sort(@ByVal
                                               UMat src,
                                               @ByVal
                                               UMat dst,
                                               int flags)

sort

@Namespace(value="cv")
public static void sort(@ByVal
                                               GpuMat src,
                                               @ByVal
                                               GpuMat dst,
                                               int flags)

sortIdx

@Namespace(value="cv")
public static void sortIdx(@ByVal
                                                  Mat src,
                                                  @ByVal
                                                  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
See Also:: sort, randShuffle

sortIdx

@Namespace(value="cv")
public static void sortIdx(@ByVal
                                                  UMat src,
                                                  @ByVal
                                                  UMat dst,
                                                  int flags)

sortIdx

@Namespace(value="cv")
public static void sortIdx(@ByVal
                                                  GpuMat src,
                                                  @ByVal
                                                  GpuMat dst,
                                                  int flags)

solveCubic

@Namespace(value="cv")
public static int solveCubic(@ByVal
                                                    Mat coeffs,
                                                    @ByVal
                                                    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:

 \[\texttt{coeffs} [0] x^3 +  \texttt{coeffs} [1] x^2 +  \texttt{coeffs} [2] x +  \texttt{coeffs} [3] = 0\]

- if coeffs is a 3-element vector:

 \[x^3 +  \texttt{coeffs} [0] x^2 +  \texttt{coeffs} [1] x +  \texttt{coeffs} [2] = 0\]

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
                                                    UMat coeffs,
                                                    @ByVal
                                                    UMat roots)

solveCubic

@Namespace(value="cv")
public static int solveCubic(@ByVal
                                                    GpuMat coeffs,
                                                    @ByVal
                                                    GpuMat roots)

solvePoly

@Namespace(value="cv")
public static double solvePoly(@ByVal
                                                      Mat coeffs,
                                                      @ByVal
                                                      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:

 \[\texttt{coeffs} [n] x^{n} +  \texttt{coeffs} [n-1] x^{n-1} + ... +  \texttt{coeffs} [1] x +  \texttt{coeffs} [0] = 0\]

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
                                                      Mat coeffs,
                                                      @ByVal
                                                      Mat roots)

solvePoly

@Namespace(value="cv")
public static double solvePoly(@ByVal
                                                      UMat coeffs,
                                                      @ByVal
                                                      UMat roots,
                                                      int maxIters)

solvePoly

@Namespace(value="cv")
public static double solvePoly(@ByVal
                                                      UMat coeffs,
                                                      @ByVal
                                                      UMat roots)

solvePoly

@Namespace(value="cv")
public static double solvePoly(@ByVal
                                                      GpuMat coeffs,
                                                      @ByVal
                                                      GpuMat roots,
                                                      int maxIters)

solvePoly

@Namespace(value="cv")
public static double solvePoly(@ByVal
                                                      GpuMat coeffs,
                                                      @ByVal
                                                      GpuMat roots)

eigen

@Namespace(value="cv")
 @Cast(value="bool")
public static boolean eigen(@ByVal
                                                                        Mat src,
                                                                        @ByVal
                                                                        Mat eigenvalues,
                                                                        @ByVal(nullValue="cv::OutputArray(cv::noArray())")
                                                                        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.
See Also:: eigenNonSymmetric, completeSymm , PCA

eigen

@Namespace(value="cv")
 @Cast(value="bool")
public static boolean eigen(@ByVal
                                                                        Mat src,
                                                                        @ByVal
                                                                        Mat eigenvalues)

eigen

@Namespace(value="cv")
 @Cast(value="bool")
public static boolean eigen(@ByVal
                                                                        UMat src,
                                                                        @ByVal
                                                                        UMat eigenvalues,
                                                                        @ByVal(nullValue="cv::OutputArray(cv::noArray())")
                                                                        UMat eigenvectors)

eigen

@Namespace(value="cv")
 @Cast(value="bool")
public static boolean eigen(@ByVal
                                                                        UMat src,
                                                                        @ByVal
                                                                        UMat eigenvalues)

eigen

@Namespace(value="cv")
 @Cast(value="bool")
public static boolean eigen(@ByVal
                                                                        GpuMat src,
                                                                        @ByVal
                                                                        GpuMat eigenvalues,
                                                                        @ByVal(nullValue="cv::OutputArray(cv::noArray())")
                                                                        GpuMat eigenvectors)

eigen

@Namespace(value="cv")
 @Cast(value="bool")
public static boolean eigen(@ByVal
                                                                        GpuMat src,
                                                                        @ByVal
                                                                        GpuMat eigenvalues)

eigenNonSymmetric

@Namespace(value="cv")
public static void eigenNonSymmetric(@ByVal
                                                            Mat src,
                                                            @ByVal
                                                            Mat eigenvalues,
                                                            @ByVal
                                                            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.
See Also:: eigen

eigenNonSymmetric

@Namespace(value="cv")
public static void eigenNonSymmetric(@ByVal
                                                            UMat src,
                                                            @ByVal
                                                            UMat eigenvalues,
                                                            @ByVal
                                                            UMat eigenvectors)

eigenNonSymmetric

@Namespace(value="cv")
public static void eigenNonSymmetric(@ByVal
                                                            GpuMat src,
                                                            @ByVal
                                                            GpuMat eigenvalues,
                                                            @ByVal
                                                            GpuMat eigenvectors)

calcCovarMatrix

@Namespace(value="cv")
public static void calcCovarMatrix(@Const
                                                          Mat samples,
                                                          int nsamples,
                                                          @ByRef
                                                          Mat covar,
                                                          @ByRef
                                                          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.
See Also:: PCA, mulTransposed, Mahalanobis \todo InputArrayOfArrays

calcCovarMatrix

@Namespace(value="cv")
public static void calcCovarMatrix(@Const
                                                          Mat samples,
                                                          int nsamples,
                                                          @ByRef
                                                          Mat covar,
                                                          @ByRef
                                                          Mat mean,
                                                          int flags)

calcCovarMatrix

@Namespace(value="cv")
public static void calcCovarMatrix(@ByVal
                                                          Mat samples,
                                                          @ByVal
                                                          Mat covar,
                                                          @ByVal
                                                          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
                                                          Mat samples,
                                                          @ByVal
                                                          Mat covar,
                                                          @ByVal
                                                          Mat mean,
                                                          int flags)

calcCovarMatrix

@Namespace(value="cv")
public static void calcCovarMatrix(@ByVal
                                                          UMat samples,
                                                          @ByVal
                                                          UMat covar,
                                                          @ByVal
                                                          UMat mean,
                                                          int flags,
                                                          int ctype)

calcCovarMatrix

@Namespace(value="cv")
public static void calcCovarMatrix(@ByVal
                                                          UMat samples,
                                                          @ByVal
                                                          UMat covar,
                                                          @ByVal
                                                          UMat mean,
                                                          int flags)

calcCovarMatrix

@Namespace(value="cv")
public static void calcCovarMatrix(@ByVal
                                                          GpuMat samples,
                                                          @ByVal
                                                          GpuMat covar,
                                                          @ByVal
                                                          GpuMat mean,
                                                          int flags,
                                                          int ctype)

calcCovarMatrix

@Namespace(value="cv")
public static void calcCovarMatrix(@ByVal
                                                          GpuMat samples,
                                                          @ByVal
                                                          GpuMat covar,
                                                          @ByVal
                                                          GpuMat mean,
                                                          int flags)

PCACompute

@Namespace(value="cv")
public static void PCACompute(@ByVal
                                                     Mat data,
                                                     @ByVal
                                                     Mat mean,
                                                     @ByVal
                                                     Mat eigenvectors,
                                                     int maxComponents)

wrap PCA::operator()

PCACompute

@Namespace(value="cv")
public static void PCACompute(@ByVal
                                                     Mat data,
                                                     @ByVal
                                                     Mat mean,
                                                     @ByVal
                                                     Mat eigenvectors)

PCACompute

@Namespace(value="cv")
public static void PCACompute(@ByVal
                                                     UMat data,
                                                     @ByVal
                                                     UMat mean,
                                                     @ByVal
                                                     UMat eigenvectors,
                                                     int maxComponents)

PCACompute

@Namespace(value="cv")
public static void PCACompute(@ByVal
                                                     UMat data,
                                                     @ByVal
                                                     UMat mean,
                                                     @ByVal
                                                     UMat eigenvectors)

PCACompute

@Namespace(value="cv")
public static void PCACompute(@ByVal
                                                     GpuMat data,
                                                     @ByVal
                                                     GpuMat mean,
                                                     @ByVal
                                                     GpuMat eigenvectors,
                                                     int maxComponents)

PCACompute

@Namespace(value="cv")
public static void PCACompute(@ByVal
                                                     GpuMat data,
                                                     @ByVal
                                                     GpuMat mean,
                                                     @ByVal
                                                     GpuMat eigenvectors)

PCACompute2

@Namespace(value="cv")
 @Name(value="PCACompute")
public static void PCACompute2(@ByVal
                                                                                 Mat data,
                                                                                 @ByVal
                                                                                 Mat mean,
                                                                                 @ByVal
                                                                                 Mat eigenvectors,
                                                                                 @ByVal
                                                                                 Mat eigenvalues,
                                                                                 int maxComponents)

wrap PCA::operator() and add eigenvalues output parameter

PCACompute2

@Namespace(value="cv")
 @Name(value="PCACompute")
public static void PCACompute2(@ByVal
                                                                                 Mat data,
                                                                                 @ByVal
                                                                                 Mat mean,
                                                                                 @ByVal
                                                                                 Mat eigenvectors,
                                                                                 @ByVal
                                                                                 Mat eigenvalues)

PCACompute2

@Namespace(value="cv")
 @Name(value="PCACompute")
public static void PCACompute2(@ByVal
                                                                                 UMat data,
                                                                                 @ByVal
                                                                                 UMat mean,
                                                                                 @ByVal
                                                                                 UMat eigenvectors,
                                                                                 @ByVal
                                                                                 UMat eigenvalues,
                                                                                 int maxComponents)

PCACompute2

@Namespace(value="cv")
 @Name(value="PCACompute")
public static void PCACompute2(@ByVal
                                                                                 UMat data,
                                                                                 @ByVal
                                                                                 UMat mean,
                                                                                 @ByVal
                                                                                 UMat eigenvectors,
                                                                                 @ByVal
                                                                                 UMat eigenvalues)

PCACompute2

@Namespace(value="cv")
 @Name(value="PCACompute")
public static void PCACompute2(@ByVal
                                                                                 GpuMat data,
                                                                                 @ByVal
                                                                                 GpuMat mean,
                                                                                 @ByVal
                                                                                 GpuMat eigenvectors,
                                                                                 @ByVal
                                                                                 GpuMat eigenvalues,
                                                                                 int maxComponents)

PCACompute2

@Namespace(value="cv")
 @Name(value="PCACompute")
public static void PCACompute2(@ByVal
                                                                                 GpuMat data,
                                                                                 @ByVal
                                                                                 GpuMat mean,
                                                                                 @ByVal
                                                                                 GpuMat eigenvectors,
                                                                                 @ByVal
                                                                                 GpuMat eigenvalues)

PCACompute

@Namespace(value="cv")
public static void PCACompute(@ByVal
                                                     Mat data,
                                                     @ByVal
                                                     Mat mean,
                                                     @ByVal
                                                     Mat eigenvectors,
                                                     double retainedVariance)

wrap PCA::operator()

PCACompute

@Namespace(value="cv")
public static void PCACompute(@ByVal
                                                     UMat data,
                                                     @ByVal
                                                     UMat mean,
                                                     @ByVal
                                                     UMat eigenvectors,
                                                     double retainedVariance)

PCACompute

@Namespace(value="cv")
public static void PCACompute(@ByVal
                                                     GpuMat data,
                                                     @ByVal
                                                     GpuMat mean,
                                                     @ByVal
                                                     GpuMat eigenvectors,
                                                     double retainedVariance)

PCACompute2

@Namespace(value="cv")
 @Name(value="PCACompute")
public static void PCACompute2(@ByVal
                                                                                 Mat data,
                                                                                 @ByVal
                                                                                 Mat mean,
                                                                                 @ByVal
                                                                                 Mat eigenvectors,
                                                                                 @ByVal
                                                                                 Mat eigenvalues,
                                                                                 double retainedVariance)

wrap PCA::operator() and add eigenvalues output parameter

PCACompute2

@Namespace(value="cv")
 @Name(value="PCACompute")
public static void PCACompute2(@ByVal
                                                                                 UMat data,
                                                                                 @ByVal
                                                                                 UMat mean,
                                                                                 @ByVal
                                                                                 UMat eigenvectors,
                                                                                 @ByVal
                                                                                 UMat eigenvalues,
                                                                                 double retainedVariance)

PCACompute2

@Namespace(value="cv")
 @Name(value="PCACompute")
public static void PCACompute2(@ByVal
                                                                                 GpuMat data,
                                                                                 @ByVal
                                                                                 GpuMat mean,
                                                                                 @ByVal
                                                                                 GpuMat eigenvectors,
                                                                                 @ByVal
                                                                                 GpuMat eigenvalues,
                                                                                 double retainedVariance)

PCAProject

@Namespace(value="cv")
public static void PCAProject(@ByVal
                                                     Mat data,
                                                     @ByVal
                                                     Mat mean,
                                                     @ByVal
                                                     Mat eigenvectors,
                                                     @ByVal
                                                     Mat result)

wrap PCA::project

PCAProject

@Namespace(value="cv")
public static void PCAProject(@ByVal
                                                     UMat data,
                                                     @ByVal
                                                     UMat mean,
                                                     @ByVal
                                                     UMat eigenvectors,
                                                     @ByVal
                                                     UMat result)

PCAProject

@Namespace(value="cv")
public static void PCAProject(@ByVal
                                                     GpuMat data,
                                                     @ByVal
                                                     GpuMat mean,
                                                     @ByVal
                                                     GpuMat eigenvectors,
                                                     @ByVal
                                                     GpuMat result)

PCABackProject

@Namespace(value="cv")
public static void PCABackProject(@ByVal
                                                         Mat data,
                                                         @ByVal
                                                         Mat mean,
                                                         @ByVal
                                                         Mat eigenvectors,
                                                         @ByVal
                                                         Mat result)

wrap PCA::backProject

PCABackProject

@Namespace(value="cv")
public static void PCABackProject(@ByVal
                                                         UMat data,
                                                         @ByVal
                                                         UMat mean,
                                                         @ByVal
                                                         UMat eigenvectors,
                                                         @ByVal
                                                         UMat result)

PCABackProject

@Namespace(value="cv")
public static void PCABackProject(@ByVal
                                                         GpuMat data,
                                                         @ByVal
                                                         GpuMat mean,
                                                         @ByVal
                                                         GpuMat eigenvectors,
                                                         @ByVal
                                                         GpuMat result)

SVDecomp

@Namespace(value="cv")
public static void SVDecomp(@ByVal
                                                   Mat src,
                                                   @ByVal
                                                   Mat w,
                                                   @ByVal
                                                   Mat u,
                                                   @ByVal
                                                   Mat vt,
                                                   int flags)

wrap SVD::compute

SVDecomp

@Namespace(value="cv")
public static void SVDecomp(@ByVal
                                                   Mat src,
                                                   @ByVal
                                                   Mat w,
                                                   @ByVal
                                                   Mat u,
                                                   @ByVal
                                                   Mat vt)

SVDecomp

@Namespace(value="cv")
public static void SVDecomp(@ByVal
                                                   UMat src,
                                                   @ByVal
                                                   UMat w,
                                                   @ByVal
                                                   UMat u,
                                                   @ByVal
                                                   UMat vt,
                                                   int flags)

SVDecomp

@Namespace(value="cv")
public static void SVDecomp(@ByVal
                                                   UMat src,
                                                   @ByVal
                                                   UMat w,
                                                   @ByVal
                                                   UMat u,
                                                   @ByVal
                                                   UMat vt)

SVDecomp

@Namespace(value="cv")
public static void SVDecomp(@ByVal
                                                   GpuMat src,
                                                   @ByVal
                                                   GpuMat w,
                                                   @ByVal
                                                   GpuMat u,
                                                   @ByVal
                                                   GpuMat vt,
                                                   int flags)

SVDecomp

@Namespace(value="cv")
public static void SVDecomp(@ByVal
                                                   GpuMat src,
                                                   @ByVal
                                                   GpuMat w,
                                                   @ByVal
                                                   GpuMat u,
                                                   @ByVal
                                                   GpuMat vt)

SVBackSubst

@Namespace(value="cv")
public static void SVBackSubst(@ByVal
                                                      Mat w,
                                                      @ByVal
                                                      Mat u,
                                                      @ByVal
                                                      Mat vt,
                                                      @ByVal
                                                      Mat rhs,
                                                      @ByVal
                                                      Mat dst)

wrap SVD::backSubst

SVBackSubst

@Namespace(value="cv")
public static void SVBackSubst(@ByVal
                                                      UMat w,
                                                      @ByVal
                                                      UMat u,
                                                      @ByVal
                                                      UMat vt,
                                                      @ByVal
                                                      UMat rhs,
                                                      @ByVal
                                                      UMat dst)

SVBackSubst

@Namespace(value="cv")
public static void SVBackSubst(@ByVal
                                                      GpuMat w,
                                                      @ByVal
                                                      GpuMat u,
                                                      @ByVal
                                                      GpuMat vt,
                                                      @ByVal
                                                      GpuMat rhs,
                                                      @ByVal
                                                      GpuMat dst)

Mahalanobis

@Namespace(value="cv")
public static double Mahalanobis(@ByVal
                                                        Mat v1,
                                                        @ByVal
                                                        Mat v2,
                                                        @ByVal
                                                        Mat icovar)

\brief Calculates the Mahalanobis distance between two vectors.

The function cv::Mahalanobis calculates and returns the weighted distance between two vectors:

 \[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)})} }\]

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
                                                        UMat v1,
                                                        @ByVal
                                                        UMat v2,
                                                        @ByVal
                                                        UMat icovar)

Mahalanobis

@Namespace(value="cv")
public static double Mahalanobis(@ByVal
                                                        GpuMat v1,
                                                        @ByVal
                                                        GpuMat v2,
                                                        @ByVal
                                                        GpuMat icovar)

dft
```
@Namespace(value="cv")
public static void dft(@ByVal
                                              Mat src,
                                              @ByVal
                                              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:
```
 \[Y = F^{(N)}  \cdot X,\]
```
where F^{(N)}_{jk}=\exp(-2\pi i j k/N) and i=\sqrt{-1} - Inverse the Fourier transform of a 1D vector of N elements:
```
 \[\begin{array}{l} X'=  \left (F^{(N)} \right )^{-1}  \cdot Y =  \left (F^{(N)} \right )^*  \cdot y  \\ X = (1/N)  \cdot X, \end{array}\]
```
where F^*=\left(\textrm{Re}(F^{(N)})-\textrm{Im}(F^{(N)})\right)^T - Forward the 2D Fourier transform of a M x N matrix:
```
 \[Y = F^{(M)}  \cdot X  \cdot F^{(N)}\]
```
- Inverse the 2D Fourier transform of a M x N matrix:
```
 \[\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}\]
```
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:
```
 \[\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}\]
```
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.

See Also:

, getOptimalDFTSize , mulSpectrums, filter2D , matchTemplate , flip , cartToPolar , magnitude , phase

dft

@Namespace(value="cv")
public static void dft(@ByVal
                                              Mat src,
                                              @ByVal
                                              Mat dst)

dft

@Namespace(value="cv")
public static void dft(@ByVal
                                              UMat src,
                                              @ByVal
                                              UMat dst,
                                              int flags,
                                              int nonzeroRows)

dft

@Namespace(value="cv")
public static void dft(@ByVal
                                              UMat src,
                                              @ByVal
                                              UMat dst)

dft

@Namespace(value="cv")
public static void dft(@ByVal
                                              GpuMat src,
                                              @ByVal
                                              GpuMat dst,
                                              int flags,
                                              int nonzeroRows)

dft

@Namespace(value="cv")
public static void dft(@ByVal
                                              GpuMat src,
                                              @ByVal
                                              GpuMat dst)

idft
```
@Namespace(value="cv")
public static void idft(@ByVal
                                               Mat src,
                                               @ByVal
                                               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.

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.

See Also:

dft, dct, idct, mulSpectrums, getOptimalDFTSize

idft

@Namespace(value="cv")
public static void idft(@ByVal
                                               Mat src,
                                               @ByVal
                                               Mat dst)

idft

@Namespace(value="cv")
public static void idft(@ByVal
                                               UMat src,
                                               @ByVal
                                               UMat dst,
                                               int flags,
                                               int nonzeroRows)

idft

@Namespace(value="cv")
public static void idft(@ByVal
                                               UMat src,
                                               @ByVal
                                               UMat dst)

idft

@Namespace(value="cv")
public static void idft(@ByVal
                                               GpuMat src,
                                               @ByVal
                                               GpuMat dst,
                                               int flags,
                                               int nonzeroRows)

idft

@Namespace(value="cv")
public static void idft(@ByVal
                                               GpuMat src,
                                               @ByVal
                                               GpuMat dst)

dct
```
@Namespace(value="cv")
public static void dct(@ByVal
                                              Mat src,
                                              @ByVal
                                              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:
```
 \[Y = C^{(N)}  \cdot X\]
```
where
```
 \[C^{(N)}_{jk}= \sqrt{\alpha_j/N} \cos \left ( \frac{\pi(2k+1)j}{2N} \right )\]
```
and \alpha_0=1, \alpha_j=2 for *j \> 0*. - Inverse Cosine transform of a 1D vector of N elements:
```
 \[X =  \left (C^{(N)} \right )^{-1}  \cdot Y =  \left (C^{(N)} \right )^T  \cdot Y\]
```
(since C^{(N)} is an orthogonal matrix, C^{(N)} \cdot \left(C^{(N)}\right)^T = I ) - Forward 2D Cosine transform of M x N matrix:
```
 \[Y = C^{(N)}  \cdot X  \cdot \left (C^{(N)} \right )^T\]
```
- Inverse 2D Cosine transform of M x N matrix:
```
 \[X =  \left (C^{(N)} \right )^T  \cdot X  \cdot C^{(N)}\]
```
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_*)

See Also:

, getOptimalDFTSize , idct

dct

@Namespace(value="cv")
public static void dct(@ByVal
                                              Mat src,
                                              @ByVal
                                              Mat dst)

dct

@Namespace(value="cv")
public static void dct(@ByVal
                                              UMat src,
                                              @ByVal
                                              UMat dst,
                                              int flags)

dct

@Namespace(value="cv")
public static void dct(@ByVal
                                              UMat src,
                                              @ByVal
                                              UMat dst)

dct

@Namespace(value="cv")
public static void dct(@ByVal
                                              GpuMat src,
                                              @ByVal
                                              GpuMat dst,
                                              int flags)

dct

@Namespace(value="cv")
public static void dct(@ByVal
                                              GpuMat src,
                                              @ByVal
                                              GpuMat dst)

idct

@Namespace(value="cv")
public static void idct(@ByVal
                                               Mat src,
                                               @ByVal
                                               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.
See Also:: dct, dft, idft, getOptimalDFTSize

idct

@Namespace(value="cv")
public static void idct(@ByVal
                                               Mat src,
                                               @ByVal
                                               Mat dst)

idct

@Namespace(value="cv")
public static void idct(@ByVal
                                               UMat src,
                                               @ByVal
                                               UMat dst,
                                               int flags)

idct

@Namespace(value="cv")
public static void idct(@ByVal
                                               UMat src,
                                               @ByVal
                                               UMat dst)

idct

@Namespace(value="cv")
public static void idct(@ByVal
                                               GpuMat src,
                                               @ByVal
                                               GpuMat dst,
                                               int flags)

idct

@Namespace(value="cv")
public static void idct(@ByVal
                                               GpuMat src,
                                               @ByVal
                                               GpuMat dst)

mulSpectrums
```
@Namespace(value="cv")
public static void mulSpectrums(@ByVal
                                                       Mat a,
                                                       @ByVal
                                                       Mat b,
                                                       @ByVal
                                                       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
                                                       Mat a,
                                                       @ByVal
                                                       Mat b,
                                                       @ByVal
                                                       Mat c,
                                                       int flags)

mulSpectrums

@Namespace(value="cv")
public static void mulSpectrums(@ByVal
                                                       UMat a,
                                                       @ByVal
                                                       UMat b,
                                                       @ByVal
                                                       UMat c,
                                                       int flags,
                                                       @Cast(value="bool")
                                                       boolean conjB)

mulSpectrums

@Namespace(value="cv")
public static void mulSpectrums(@ByVal
                                                       UMat a,
                                                       @ByVal
                                                       UMat b,
                                                       @ByVal
                                                       UMat c,
                                                       int flags)

mulSpectrums

@Namespace(value="cv")
public static void mulSpectrums(@ByVal
                                                       GpuMat a,
                                                       @ByVal
                                                       GpuMat b,
                                                       @ByVal
                                                       GpuMat c,
                                                       int flags,
                                                       @Cast(value="bool")
                                                       boolean conjB)

mulSpectrums

@Namespace(value="cv")
public static void mulSpectrums(@ByVal
                                                       GpuMat a,
                                                       @ByVal
                                                       GpuMat b,
                                                       @ByVal
                                                       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.

See Also:

, dct , idft , idct , mulSpectrums

theRNG
```
@Namespace(value="cv")
 @ByRef
public static 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() .

See Also:

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

See Also:

RNG, randu, randn

randu

@Namespace(value="cv")
public static void randu(@ByVal
                                                Mat dst,
                                                @ByVal
                                                Mat low,
                                                @ByVal
                                                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:

 \[\texttt{low} _c  \leq \texttt{dst} (I)_c <  \texttt{high} _c\]

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.
See Also:: RNG, randn, theRNG

randu

@Namespace(value="cv")
public static void randu(@ByVal
                                                UMat dst,
                                                @ByVal
                                                UMat low,
                                                @ByVal
                                                UMat high)

randu

@Namespace(value="cv")
public static void randu(@ByVal
                                                GpuMat dst,
                                                @ByVal
                                                GpuMat low,
                                                @ByVal
                                                GpuMat high)

randn
```
@Namespace(value="cv")
public static void randn(@ByVal
                                                Mat dst,
                                                @ByVal
                                                Mat mean,
                                                @ByVal
                                                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.

See Also:

RNG, randu

randn

@Namespace(value="cv")
public static void randn(@ByVal
                                                UMat dst,
                                                @ByVal
                                                UMat mean,
                                                @ByVal
                                                UMat stddev)

randn

@Namespace(value="cv")
public static void randn(@ByVal
                                                GpuMat dst,
                                                @ByVal
                                                GpuMat mean,
                                                @ByVal
                                                GpuMat stddev)

randShuffle
```
@Namespace(value="cv")
public static void randShuffle(@ByVal
                                                      Mat dst,
                                                      double iterFactor,
                                                      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.

See Also:

RNG, sort

randShuffle

@Namespace(value="cv")
public static void randShuffle(@ByVal
                                                      Mat dst)

randShuffle

@Namespace(value="cv")
public static void randShuffle(@ByVal
                                                      UMat dst,
                                                      double iterFactor,
                                                      RNG rng)

randShuffle

@Namespace(value="cv")
public static void randShuffle(@ByVal
                                                      UMat dst)

randShuffle

@Namespace(value="cv")
public static void randShuffle(@ByVal
                                                      GpuMat dst,
                                                      double iterFactor,
                                                      RNG rng)

randShuffle

@Namespace(value="cv")
public static void randShuffle(@ByVal
                                                      GpuMat dst)

kmeans
```
@Namespace(value="cv")
public static double kmeans(@ByVal
                                                   Mat data,
                                                   int K,
                                                   @ByVal
                                                   Mat bestLabels,
                                                   @ByVal
                                                   TermCriteria criteria,
                                                   int attempts,
                                                   int flags,
                                                   @ByVal(nullValue="cv::OutputArray(cv::noArray())")
                                                   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, \texttt{bestLabels}_i contains a 0-based cluster index for the sample stored in the i^{th} 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
```
 \[\sum _i  \| \texttt{samples} _i -  \texttt{centers} _{ \texttt{labels} _i} \| ^2\]
```
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
                                                   Mat data,
                                                   int K,
                                                   @ByVal
                                                   Mat bestLabels,
                                                   @ByVal
                                                   TermCriteria criteria,
                                                   int attempts,
                                                   int flags)

kmeans

@Namespace(value="cv")
public static double kmeans(@ByVal
                                                   UMat data,
                                                   int K,
                                                   @ByVal
                                                   UMat bestLabels,
                                                   @ByVal
                                                   TermCriteria criteria,
                                                   int attempts,
                                                   int flags,
                                                   @ByVal(nullValue="cv::OutputArray(cv::noArray())")
                                                   UMat centers)

kmeans

@Namespace(value="cv")
public static double kmeans(@ByVal
                                                   UMat data,
                                                   int K,
                                                   @ByVal
                                                   UMat bestLabels,
                                                   @ByVal
                                                   TermCriteria criteria,
                                                   int attempts,
                                                   int flags)

kmeans

@Namespace(value="cv")
public static double kmeans(@ByVal
                                                   GpuMat data,
                                                   int K,
                                                   @ByVal
                                                   GpuMat bestLabels,
                                                   @ByVal
                                                   TermCriteria criteria,
                                                   int attempts,
                                                   int flags,
                                                   @ByVal(nullValue="cv::OutputArray(cv::noArray())")
                                                   GpuMat centers)

kmeans

@Namespace(value="cv")
public static double kmeans(@ByVal
                                                   GpuMat data,
                                                   int K,
                                                   @ByVal
                                                   GpuMat bestLabels,
                                                   @ByVal
                                                   TermCriteria criteria,
                                                   int attempts,
                                                   int flags)

shiftLeft

@Namespace(value="cv")
 @opencv_core.Str
 @Name(value="operator <<")
public static BytePointer shiftLeft(@opencv_core.Str
                                                                                                         BytePointer out,
                                                                                                         @opencv_core.Ptr
                                                                                                         Formatted fmtd)

shiftLeft

@Namespace(value="cv")
 @opencv_core.Str
 @Name(value="operator <<")
public static String shiftLeft(@opencv_core.Str
                                                                                                    String out,
                                                                                                    @opencv_core.Ptr
                                                                                                    Formatted fmtd)

shiftLeft

@Namespace(value="cv")
 @opencv_core.Str
 @Name(value="operator <<")
public static BytePointer shiftLeft(@opencv_core.Str
                                                                                                         BytePointer out,
                                                                                                         @Const @ByRef
                                                                                                         Mat mtx)

shiftLeft

@Namespace(value="cv")
 @opencv_core.Str
 @Name(value="operator <<")
public static String shiftLeft(@opencv_core.Str
                                                                                                    String out,
                                                                                                    @Const @ByRef
                                                                                                    Mat mtx)

createContinuous

@Namespace(value="cv::cuda")
public static void createContinuous(int rows,
                                                                 int cols,
                                                                 int type,
                                                                 @ByVal
                                                                 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 ( \texttt{rows} \times \texttt{cols} ).
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
                                                                 UMat arr)

createContinuous

@Namespace(value="cv::cuda")
public static void createContinuous(int rows,
                                                                 int cols,
                                                                 int type,
                                                                 @ByVal
                                                                 GpuMat arr)

ensureSizeIsEnough

@Namespace(value="cv::cuda")
public static void ensureSizeIsEnough(int rows,
                                                                   int cols,
                                                                   int type,
                                                                   @ByVal
                                                                   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
                                                                   UMat arr)

ensureSizeIsEnough

@Namespace(value="cv::cuda")
public static void ensureSizeIsEnough(int rows,
                                                                   int cols,
                                                                   int type,
                                                                   @ByVal
                                                                   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
                                                                   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
                                                                     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
                                                             BytePointer platformName,
                                                             Pointer platformID,
                                                             Pointer context,
                                                             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,
                                                             Pointer platformID,
                                                             Pointer context,
                                                             Pointer deviceID)

convertFromBuffer

@Namespace(value="cv::ocl")
public static void convertFromBuffer(Pointer cl_mem_buffer,
                                                                 @Cast(value="size_t")
                                                                 long step,
                                                                 int rows,
                                                                 int cols,
                                                                 int type,
                                                                 @ByRef
                                                                 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(Pointer cl_mem_image,
                                                                @ByRef
                                                                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 BytePointer convertTypeStr(int sdepth,
                                                                                                 int ddepth,
                                                                                                 int cn,
                                                                                                 @Cast(value="char*")
                                                                                                 BytePointer buf)

Deprecated.

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 BytePointer convertTypeStr(int sdepth,
                                                                                                 int ddepth,
                                                                                                 int cn,
                                                                                                 @Cast(value="char*")
                                                                                                 byte[] buf)

typeToStr

@Namespace(value="cv::ocl")
 @Cast(value="const char*")
public static BytePointer typeToStr(int t)

memopTypeToStr

@Namespace(value="cv::ocl")
 @Cast(value="const char*")
public static BytePointer memopTypeToStr(int t)

vecopTypeToStr

@Namespace(value="cv::ocl")
 @Cast(value="const char*")
public static BytePointer vecopTypeToStr(int t)

getOpenCLErrorString

@Namespace(value="cv::ocl")
 @Cast(value="const char*")
public static BytePointer getOpenCLErrorString(int errorCode)

kernelToStr

@Namespace(value="cv::ocl")
 @opencv_core.Str
public static BytePointer kernelToStr(@ByVal
                                                                                    Mat _kernel,
                                                                                    int ddepth,
                                                                                    @Cast(value="const char*")
                                                                                    BytePointer name)

kernelToStr

@Namespace(value="cv::ocl")
 @opencv_core.Str
public static BytePointer kernelToStr(@ByVal
                                                                                    Mat _kernel)

kernelToStr

@Namespace(value="cv::ocl")
 @opencv_core.Str
public static String kernelToStr(@ByVal
                                                                               Mat _kernel,
                                                                               int ddepth,
                                                                               String name)

kernelToStr

@Namespace(value="cv::ocl")
 @opencv_core.Str
public static String kernelToStr(@ByVal
                                                                               UMat _kernel,
                                                                               int ddepth,
                                                                               String name)

kernelToStr

@Namespace(value="cv::ocl")
 @opencv_core.Str
public static String kernelToStr(@ByVal
                                                                               UMat _kernel)

kernelToStr

@Namespace(value="cv::ocl")
 @opencv_core.Str
public static BytePointer kernelToStr(@ByVal
                                                                                    UMat _kernel,
                                                                                    int ddepth,
                                                                                    @Cast(value="const char*")
                                                                                    BytePointer name)

kernelToStr

@Namespace(value="cv::ocl")
 @opencv_core.Str
public static BytePointer kernelToStr(@ByVal
                                                                                    GpuMat _kernel,
                                                                                    int ddepth,
                                                                                    @Cast(value="const char*")
                                                                                    BytePointer name)

kernelToStr

@Namespace(value="cv::ocl")
 @opencv_core.Str
public static BytePointer kernelToStr(@ByVal
                                                                                    GpuMat _kernel)

kernelToStr

@Namespace(value="cv::ocl")
 @opencv_core.Str
public static String kernelToStr(@ByVal
                                                                               GpuMat _kernel,
                                                                               int ddepth,
                                                                               String name)

getPlatfomsInfo

@Namespace(value="cv::ocl")
public static void getPlatfomsInfo(@StdVector
                                                               PlatformInfo platform_info)

predictOptimalVectorWidth

@Namespace(value="cv::ocl")
public static int predictOptimalVectorWidth(@ByVal
                                                                        Mat src1,
                                                                        @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                                        Mat src2,
                                                                        @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                                        Mat src3,
                                                                        @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                                        Mat src4,
                                                                        @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                                        Mat src5,
                                                                        @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                                        Mat src6,
                                                                        @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                                        Mat src7,
                                                                        @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                                        Mat src8,
                                                                        @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                                        Mat src9,
                                                                        @Cast(value="cv::ocl::OclVectorStrategy")
                                                                        int strat)

predictOptimalVectorWidth

@Namespace(value="cv::ocl")
public static int predictOptimalVectorWidth(@ByVal
                                                                        Mat src1)

predictOptimalVectorWidth

@Namespace(value="cv::ocl")
public static int predictOptimalVectorWidth(@ByVal
                                                                        UMat src1,
                                                                        @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                                        UMat src2,
                                                                        @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                                        UMat src3,
                                                                        @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                                        UMat src4,
                                                                        @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                                        UMat src5,
                                                                        @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                                        UMat src6,
                                                                        @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                                        UMat src7,
                                                                        @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                                        UMat src8,
                                                                        @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                                        UMat src9,
                                                                        @Cast(value="cv::ocl::OclVectorStrategy")
                                                                        int strat)

predictOptimalVectorWidth

@Namespace(value="cv::ocl")
public static int predictOptimalVectorWidth(@ByVal
                                                                        UMat src1)

predictOptimalVectorWidth

@Namespace(value="cv::ocl")
public static int predictOptimalVectorWidth(@ByVal
                                                                        GpuMat src1,
                                                                        @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                                        GpuMat src2,
                                                                        @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                                        GpuMat src3,
                                                                        @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                                        GpuMat src4,
                                                                        @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                                        GpuMat src5,
                                                                        @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                                        GpuMat src6,
                                                                        @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                                        GpuMat src7,
                                                                        @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                                        GpuMat src8,
                                                                        @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                                        GpuMat src9,
                                                                        @Cast(value="cv::ocl::OclVectorStrategy")
                                                                        int strat)

predictOptimalVectorWidth

@Namespace(value="cv::ocl")
public static int predictOptimalVectorWidth(@ByVal
                                                                        GpuMat src1)

checkOptimalVectorWidth

@Namespace(value="cv::ocl")
public static int checkOptimalVectorWidth(@Const
                                                                      IntPointer vectorWidths,
                                                                      @ByVal
                                                                      Mat src1,
                                                                      @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                                      Mat src2,
                                                                      @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                                      Mat src3,
                                                                      @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                                      Mat src4,
                                                                      @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                                      Mat src5,
                                                                      @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                                      Mat src6,
                                                                      @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                                      Mat src7,
                                                                      @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                                      Mat src8,
                                                                      @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                                      Mat src9,
                                                                      @Cast(value="cv::ocl::OclVectorStrategy")
                                                                      int strat)

checkOptimalVectorWidth

@Namespace(value="cv::ocl")
public static int checkOptimalVectorWidth(@Const
                                                                      IntPointer vectorWidths,
                                                                      @ByVal
                                                                      Mat src1)

checkOptimalVectorWidth

@Namespace(value="cv::ocl")
public static int checkOptimalVectorWidth(@Const
                                                                      IntBuffer vectorWidths,
                                                                      @ByVal
                                                                      Mat src1,
                                                                      @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                                      Mat src2,
                                                                      @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                                      Mat src3,
                                                                      @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                                      Mat src4,
                                                                      @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                                      Mat src5,
                                                                      @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                                      Mat src6,
                                                                      @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                                      Mat src7,
                                                                      @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                                      Mat src8,
                                                                      @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                                      Mat src9,
                                                                      @Cast(value="cv::ocl::OclVectorStrategy")
                                                                      int strat)

checkOptimalVectorWidth

@Namespace(value="cv::ocl")
public static int checkOptimalVectorWidth(@Const
                                                                      IntBuffer vectorWidths,
                                                                      @ByVal
                                                                      Mat src1)

checkOptimalVectorWidth

@Namespace(value="cv::ocl")
public static int checkOptimalVectorWidth(@Const
                                                                      int[] vectorWidths,
                                                                      @ByVal
                                                                      Mat src1,
                                                                      @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                                      Mat src2,
                                                                      @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                                      Mat src3,
                                                                      @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                                      Mat src4,
                                                                      @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                                      Mat src5,
                                                                      @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                                      Mat src6,
                                                                      @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                                      Mat src7,
                                                                      @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                                      Mat src8,
                                                                      @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                                      Mat src9,
                                                                      @Cast(value="cv::ocl::OclVectorStrategy")
                                                                      int strat)

checkOptimalVectorWidth

@Namespace(value="cv::ocl")
public static int checkOptimalVectorWidth(@Const
                                                                      int[] vectorWidths,
                                                                      @ByVal
                                                                      Mat src1)

checkOptimalVectorWidth

@Namespace(value="cv::ocl")
public static int checkOptimalVectorWidth(@Const
                                                                      IntPointer vectorWidths,
                                                                      @ByVal
                                                                      UMat src1,
                                                                      @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                                      UMat src2,
                                                                      @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                                      UMat src3,
                                                                      @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                                      UMat src4,
                                                                      @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                                      UMat src5,
                                                                      @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                                      UMat src6,
                                                                      @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                                      UMat src7,
                                                                      @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                                      UMat src8,
                                                                      @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                                      UMat src9,
                                                                      @Cast(value="cv::ocl::OclVectorStrategy")
                                                                      int strat)

checkOptimalVectorWidth

@Namespace(value="cv::ocl")
public static int checkOptimalVectorWidth(@Const
                                                                      IntPointer vectorWidths,
                                                                      @ByVal
                                                                      UMat src1)

checkOptimalVectorWidth

@Namespace(value="cv::ocl")
public static int checkOptimalVectorWidth(@Const
                                                                      IntBuffer vectorWidths,
                                                                      @ByVal
                                                                      UMat src1,
                                                                      @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                                      UMat src2,
                                                                      @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                                      UMat src3,
                                                                      @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                                      UMat src4,
                                                                      @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                                      UMat src5,
                                                                      @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                                      UMat src6,
                                                                      @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                                      UMat src7,
                                                                      @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                                      UMat src8,
                                                                      @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                                      UMat src9,
                                                                      @Cast(value="cv::ocl::OclVectorStrategy")
                                                                      int strat)

checkOptimalVectorWidth

@Namespace(value="cv::ocl")
public static int checkOptimalVectorWidth(@Const
                                                                      IntBuffer vectorWidths,
                                                                      @ByVal
                                                                      UMat src1)

checkOptimalVectorWidth

@Namespace(value="cv::ocl")
public static int checkOptimalVectorWidth(@Const
                                                                      int[] vectorWidths,
                                                                      @ByVal
                                                                      UMat src1,
                                                                      @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                                      UMat src2,
                                                                      @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                                      UMat src3,
                                                                      @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                                      UMat src4,
                                                                      @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                                      UMat src5,
                                                                      @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                                      UMat src6,
                                                                      @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                                      UMat src7,
                                                                      @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                                      UMat src8,
                                                                      @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                                      UMat src9,
                                                                      @Cast(value="cv::ocl::OclVectorStrategy")
                                                                      int strat)

checkOptimalVectorWidth

@Namespace(value="cv::ocl")
public static int checkOptimalVectorWidth(@Const
                                                                      int[] vectorWidths,
                                                                      @ByVal
                                                                      UMat src1)

checkOptimalVectorWidth

@Namespace(value="cv::ocl")
public static int checkOptimalVectorWidth(@Const
                                                                      IntPointer vectorWidths,
                                                                      @ByVal
                                                                      GpuMat src1,
                                                                      @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                                      GpuMat src2,
                                                                      @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                                      GpuMat src3,
                                                                      @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                                      GpuMat src4,
                                                                      @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                                      GpuMat src5,
                                                                      @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                                      GpuMat src6,
                                                                      @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                                      GpuMat src7,
                                                                      @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                                      GpuMat src8,
                                                                      @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                                      GpuMat src9,
                                                                      @Cast(value="cv::ocl::OclVectorStrategy")
                                                                      int strat)

checkOptimalVectorWidth

@Namespace(value="cv::ocl")
public static int checkOptimalVectorWidth(@Const
                                                                      IntPointer vectorWidths,
                                                                      @ByVal
                                                                      GpuMat src1)

checkOptimalVectorWidth

@Namespace(value="cv::ocl")
public static int checkOptimalVectorWidth(@Const
                                                                      IntBuffer vectorWidths,
                                                                      @ByVal
                                                                      GpuMat src1,
                                                                      @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                                      GpuMat src2,
                                                                      @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                                      GpuMat src3,
                                                                      @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                                      GpuMat src4,
                                                                      @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                                      GpuMat src5,
                                                                      @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                                      GpuMat src6,
                                                                      @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                                      GpuMat src7,
                                                                      @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                                      GpuMat src8,
                                                                      @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                                      GpuMat src9,
                                                                      @Cast(value="cv::ocl::OclVectorStrategy")
                                                                      int strat)

checkOptimalVectorWidth

@Namespace(value="cv::ocl")
public static int checkOptimalVectorWidth(@Const
                                                                      IntBuffer vectorWidths,
                                                                      @ByVal
                                                                      GpuMat src1)

checkOptimalVectorWidth

@Namespace(value="cv::ocl")
public static int checkOptimalVectorWidth(@Const
                                                                      int[] vectorWidths,
                                                                      @ByVal
                                                                      GpuMat src1,
                                                                      @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                                      GpuMat src2,
                                                                      @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                                      GpuMat src3,
                                                                      @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                                      GpuMat src4,
                                                                      @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                                      GpuMat src5,
                                                                      @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                                      GpuMat src6,
                                                                      @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                                      GpuMat src7,
                                                                      @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                                      GpuMat src8,
                                                                      @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                                      GpuMat src9,
                                                                      @Cast(value="cv::ocl::OclVectorStrategy")
                                                                      int strat)

checkOptimalVectorWidth

@Namespace(value="cv::ocl")
public static int checkOptimalVectorWidth(@Const
                                                                      int[] vectorWidths,
                                                                      @ByVal
                                                                      GpuMat src1)

predictOptimalVectorWidthMax

@Namespace(value="cv::ocl")
public static int predictOptimalVectorWidthMax(@ByVal
                                                                           Mat src1,
                                                                           @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                                           Mat src2,
                                                                           @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                                           Mat src3,
                                                                           @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                                           Mat src4,
                                                                           @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                                           Mat src5,
                                                                           @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                                           Mat src6,
                                                                           @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                                           Mat src7,
                                                                           @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                                           Mat src8,
                                                                           @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                                           Mat src9)

predictOptimalVectorWidthMax

@Namespace(value="cv::ocl")
public static int predictOptimalVectorWidthMax(@ByVal
                                                                           Mat src1)

predictOptimalVectorWidthMax

@Namespace(value="cv::ocl")
public static int predictOptimalVectorWidthMax(@ByVal
                                                                           UMat src1,
                                                                           @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                                           UMat src2,
                                                                           @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                                           UMat src3,
                                                                           @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                                           UMat src4,
                                                                           @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                                           UMat src5,
                                                                           @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                                           UMat src6,
                                                                           @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                                           UMat src7,
                                                                           @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                                           UMat src8,
                                                                           @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                                           UMat src9)

predictOptimalVectorWidthMax

@Namespace(value="cv::ocl")
public static int predictOptimalVectorWidthMax(@ByVal
                                                                           UMat src1)

predictOptimalVectorWidthMax

@Namespace(value="cv::ocl")
public static int predictOptimalVectorWidthMax(@ByVal
                                                                           GpuMat src1,
                                                                           @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                                           GpuMat src2,
                                                                           @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                                           GpuMat src3,
                                                                           @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                                           GpuMat src4,
                                                                           @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                                           GpuMat src5,
                                                                           @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                                           GpuMat src6,
                                                                           @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                                           GpuMat src7,
                                                                           @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                                           GpuMat src8,
                                                                           @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                                           GpuMat src9)

predictOptimalVectorWidthMax

@Namespace(value="cv::ocl")
public static int predictOptimalVectorWidthMax(@ByVal
                                                                           GpuMat src1)

buildOptionsAddMatrixDescription

@Namespace(value="cv::ocl")
public static void buildOptionsAddMatrixDescription(@opencv_core.Str
                                                                                BytePointer buildOptions,
                                                                                @opencv_core.Str
                                                                                BytePointer name,
                                                                                @ByVal
                                                                                Mat _m)

buildOptionsAddMatrixDescription

@Namespace(value="cv::ocl")
public static void buildOptionsAddMatrixDescription(@opencv_core.Str
                                                                                String buildOptions,
                                                                                @opencv_core.Str
                                                                                String name,
                                                                                @ByVal
                                                                                Mat _m)

buildOptionsAddMatrixDescription

@Namespace(value="cv::ocl")
public static void buildOptionsAddMatrixDescription(@opencv_core.Str
                                                                                String buildOptions,
                                                                                @opencv_core.Str
                                                                                String name,
                                                                                @ByVal
                                                                                UMat _m)

buildOptionsAddMatrixDescription

@Namespace(value="cv::ocl")
public static void buildOptionsAddMatrixDescription(@opencv_core.Str
                                                                                BytePointer buildOptions,
                                                                                @opencv_core.Str
                                                                                BytePointer name,
                                                                                @ByVal
                                                                                UMat _m)

buildOptionsAddMatrixDescription

@Namespace(value="cv::ocl")
public static void buildOptionsAddMatrixDescription(@opencv_core.Str
                                                                                BytePointer buildOptions,
                                                                                @opencv_core.Str
                                                                                BytePointer name,
                                                                                @ByVal
                                                                                GpuMat _m)

buildOptionsAddMatrixDescription

@Namespace(value="cv::ocl")
public static void buildOptionsAddMatrixDescription(@opencv_core.Str
                                                                                String buildOptions,
                                                                                @opencv_core.Str
                                                                                String name,
                                                                                @ByVal
                                                                                GpuMat _m)

getOpenCLAllocator

@Namespace(value="cv::ocl")
public static MatAllocator getOpenCLAllocator()

addPut

@Namespace(value="cv")
 @ByRef
 @Name(value="operator +=")
public static Mat addPut(@ByRef
                                                                                    Mat a,
                                                                                    @Const @ByRef
                                                                                    Mat b)

\cond IGNORED

addPut

@Namespace(value="cv")
 @ByRef
 @Name(value="operator +=")
public static Mat addPut(@ByRef
                                                                                    Mat a,
                                                                                    @Const @ByRef
                                                                                    Scalar b)

subtractPut

@Namespace(value="cv")
 @ByRef
 @Name(value="operator -=")
public static Mat subtractPut(@ByRef
                                                                                         Mat a,
                                                                                         @Const @ByRef
                                                                                         Mat b)

subtractPut

@Namespace(value="cv")
 @ByRef
 @Name(value="operator -=")
public static Mat subtractPut(@ByRef
                                                                                         Mat a,
                                                                                         @Const @ByRef
                                                                                         Scalar b)

multiplyPut

@Namespace(value="cv")
 @ByRef
 @Name(value="operator *=")
public static Mat multiplyPut(@ByRef
                                                                                         Mat a,
                                                                                         @Const @ByRef
                                                                                         Mat b)

multiplyPut

@Namespace(value="cv")
 @ByRef
 @Name(value="operator *=")
public static Mat multiplyPut(@ByRef
                                                                                         Mat a,
                                                                                         double b)

dividePut

@Namespace(value="cv")
 @ByRef
 @Name(value="operator /=")
public static Mat dividePut(@ByRef
                                                                                       Mat a,
                                                                                       @Const @ByRef
                                                                                       Mat b)

dividePut

@Namespace(value="cv")
 @ByRef
 @Name(value="operator /=")
public static Mat dividePut(@ByRef
                                                                                       Mat a,
                                                                                       double b)

andPut

@Namespace(value="cv")
 @ByRef
 @Name(value="operator &=")
public static Mat andPut(@ByRef
                                                                                    Mat a,
                                                                                    @Const @ByRef
                                                                                    Mat b)

andPut

@Namespace(value="cv")
 @ByRef
 @Name(value="operator &=")
public static Mat andPut(@ByRef
                                                                                    Mat a,
                                                                                    @Const @ByRef
                                                                                    Scalar b)

orPut

@Namespace(value="cv")
 @ByRef
 @Name(value="operator |=")
public static Mat orPut(@ByRef
                                                                                   Mat a,
                                                                                   @Const @ByRef
                                                                                   Mat b)

orPut

@Namespace(value="cv")
 @ByRef
 @Name(value="operator |=")
public static Mat orPut(@ByRef
                                                                                   Mat a,
                                                                                   @Const @ByRef
                                                                                   Scalar b)

xorPut

@Namespace(value="cv")
 @ByRef
 @Name(value="operator ^=")
public static Mat xorPut(@ByRef
                                                                                    Mat a,
                                                                                    @Const @ByRef
                                                                                    Mat b)

xorPut

@Namespace(value="cv")
 @ByRef
 @Name(value="operator ^=")
public static Mat xorPut(@ByRef
                                                                                    Mat a,
                                                                                    @Const @ByRef
                                                                                    Scalar b)

intRand

@Namespace(value="cv")
 @Name(value="randu<int>")
public static int intRand()

returns the next uniformly-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 BytePointer format(@Cast(value="const char*")
                                                                          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.
Note**: |Type|Specifier| |-|-| |const char*|%s| |char|%c| |float / double|%f,%g| |int, long, long long|%d, %ld, %lld| |unsigned, unsigned long, unsigned long long|%u, %lu, %llu| |uint64-> uintmax_t, int64-> intmax_t|%ju, %jd| |size_t|%zu{@code |

format

@Namespace(value="cv")
 @opencv_core.Str
public static String format(String fmt)

format

@Namespace(value="cv")
 @opencv_core.Ptr
public static Formatted format(@ByVal
                                                                        Mat mtx,
                                                                        @Cast(value="cv::Formatter::FormatType")
                                                                        int fmt)

format

@Namespace(value="cv")
 @opencv_core.Ptr
public static Formatted format(@ByVal
                                                                        UMat mtx,
                                                                        @Cast(value="cv::Formatter::FormatType")
                                                                        int fmt)

format

@Namespace(value="cv")
 @opencv_core.Ptr
public static Formatted format(@ByVal
                                                                        GpuMat mtx,
                                                                        @Cast(value="cv::Formatter::FormatType")
                                                                        int fmt)

print

@Namespace(value="cv")
public static int print(@opencv_core.Ptr
                                               Formatted fmtd,
                                               @Cast(value="FILE*")
                                               Pointer stream)

print

@Namespace(value="cv")
public static int print(@opencv_core.Ptr
                                               Formatted fmtd)

print

@Namespace(value="cv")
public static int print(@Const @ByRef
                                               Mat mtx,
                                               @Cast(value="FILE*")
                                               Pointer stream)

print

@Namespace(value="cv")
public static int print(@Const @ByRef
                                               Mat mtx)

print

@Namespace(value="cv")
public static int print(@Const @ByRef
                                               UMat mtx,
                                               @Cast(value="FILE*")
                                               Pointer stream)

print

@Namespace(value="cv")
public static int print(@Const @ByRef
                                               UMat mtx)

not

@Namespace(value="cv")
 @Cast(value="bool")
 @Name(value="operator !")
public static boolean not(@Cast(value="const cv::AccessFlag")
                                                                                                 int val)

equals

@Namespace(value="cv")
 @Cast(value="bool")
 @Name(value="operator ==")
public static boolean equals(@Cast(value="const cv::AccessFlag")
                                                                                                     int a,
                                                                                                     int b)

notEquals

@Namespace(value="cv")
 @Cast(value="bool")
 @Name(value="operator !=")
public static boolean notEquals(@Cast(value="const cv::AccessFlag")
                                                                                                        int a,
                                                                                                        int b)

or

@Namespace(value="cv")
 @Cast(value="cv::AccessFlag")
 @Name(value="operator |")
public static int or(@Cast(value="const cv::AccessFlag")
                                                                                                      int a,
                                                                                                      @Cast(value="const cv::AccessFlag")
                                                                                                      int b)

and

@Namespace(value="cv")
 @Cast(value="cv::AccessFlag")
 @Name(value="operator &")
public static int and(@Cast(value="const cv::AccessFlag")
                                                                                                       int a,
                                                                                                       @Cast(value="const cv::AccessFlag")
                                                                                                       int b)

xor

@Namespace(value="cv")
 @Cast(value="cv::AccessFlag")
 @Name(value="operator ^")
public static int xor(@Cast(value="const cv::AccessFlag")
                                                                                                       int a,
                                                                                                       @Cast(value="const cv::AccessFlag")
                                                                                                       int b)

orPut

@Namespace(value="cv")
 @Cast(value="cv::AccessFlag*")
 @ByRef
 @Name(value="operator |=")
public static IntPointer orPut(@Cast(value="cv::AccessFlag*") @ByRef
                                                                                                                          IntPointer _this,
                                                                                                                          @Cast(value="const cv::AccessFlag")
                                                                                                                          int val)

orPut

@Namespace(value="cv")
 @Cast(value="cv::AccessFlag*")
 @ByRef
 @Name(value="operator |=")
public static IntBuffer orPut(@Cast(value="cv::AccessFlag*") @ByRef
                                                                                                                         IntBuffer _this,
                                                                                                                         @Cast(value="const cv::AccessFlag")
                                                                                                                         int val)

orPut

@Namespace(value="cv")
 @Cast(value="cv::AccessFlag*")
 @ByRef
 @Name(value="operator |=")
public static int[] orPut(@Cast(value="cv::AccessFlag*") @ByRef
                                                                                                                     int[] _this,
                                                                                                                     @Cast(value="const cv::AccessFlag")
                                                                                                                     int val)

andPut

@Namespace(value="cv")
 @Cast(value="cv::AccessFlag*")
 @ByRef
 @Name(value="operator &=")
public static IntPointer andPut(@Cast(value="cv::AccessFlag*") @ByRef
                                                                                                                           IntPointer _this,
                                                                                                                           @Cast(value="const cv::AccessFlag")
                                                                                                                           int val)

andPut

@Namespace(value="cv")
 @Cast(value="cv::AccessFlag*")
 @ByRef
 @Name(value="operator &=")
public static IntBuffer andPut(@Cast(value="cv::AccessFlag*") @ByRef
                                                                                                                          IntBuffer _this,
                                                                                                                          @Cast(value="const cv::AccessFlag")
                                                                                                                          int val)

andPut

@Namespace(value="cv")
 @Cast(value="cv::AccessFlag*")
 @ByRef
 @Name(value="operator &=")
public static int[] andPut(@Cast(value="cv::AccessFlag*") @ByRef
                                                                                                                      int[] _this,
                                                                                                                      @Cast(value="const cv::AccessFlag")
                                                                                                                      int val)

xorPut

@Namespace(value="cv")
 @Cast(value="cv::AccessFlag*")
 @ByRef
 @Name(value="operator ^=")
public static IntPointer xorPut(@Cast(value="cv::AccessFlag*") @ByRef
                                                                                                                           IntPointer _this,
                                                                                                                           @Cast(value="const cv::AccessFlag")
                                                                                                                           int val)

xorPut

@Namespace(value="cv")
 @Cast(value="cv::AccessFlag*")
 @ByRef
 @Name(value="operator ^=")
public static IntBuffer xorPut(@Cast(value="cv::AccessFlag*") @ByRef
                                                                                                                          IntBuffer _this,
                                                                                                                          @Cast(value="const cv::AccessFlag")
                                                                                                                          int val)

xorPut

@Namespace(value="cv")
 @Cast(value="cv::AccessFlag*")
 @ByRef
 @Name(value="operator ^=")
public static int[] xorPut(@Cast(value="cv::AccessFlag*") @ByRef
                                                                                                                      int[] _this,
                                                                                                                      @Cast(value="const cv::AccessFlag")
                                                                                                                      int val)

noArray
```
public static Mat noArray()
```
Helper to wrap custom types. @see InputArray

add

@Namespace(value="cv")
 @ByVal
 @Name(value="operator +")
public static MatExpr add(@Const @ByRef
                                                                                    Mat a,
                                                                                    @Const @ByRef
                                                                                    Mat b)

\} core_basic

\relates cv::MatExpr \{

add

@Namespace(value="cv")
 @ByVal
 @Name(value="operator +")
public static MatExpr add(@Const @ByRef
                                                                                    Mat a,
                                                                                    @Const @ByRef
                                                                                    Scalar s)

add

@Namespace(value="cv")
 @ByVal
 @Name(value="operator +")
public static MatExpr add(@Const @ByRef
                                                                                    Scalar s,
                                                                                    @Const @ByRef
                                                                                    Mat a)

add

@Namespace(value="cv")
 @ByVal
 @Name(value="operator +")
public static MatExpr add(@Const @ByRef
                                                                                    MatExpr e,
                                                                                    @Const @ByRef
                                                                                    Mat m)

add

@Namespace(value="cv")
 @ByVal
 @Name(value="operator +")
public static MatExpr add(@Const @ByRef
                                                                                    Mat m,
                                                                                    @Const @ByRef
                                                                                    MatExpr e)

add

@Namespace(value="cv")
 @ByVal
 @Name(value="operator +")
public static MatExpr add(@Const @ByRef
                                                                                    MatExpr e,
                                                                                    @Const @ByRef
                                                                                    Scalar s)

add

@Namespace(value="cv")
 @ByVal
 @Name(value="operator +")
public static MatExpr add(@Const @ByRef
                                                                                    Scalar s,
                                                                                    @Const @ByRef
                                                                                    MatExpr e)

add

@Namespace(value="cv")
 @ByVal
 @Name(value="operator +")
public static MatExpr add(@Const @ByRef
                                                                                    MatExpr e1,
                                                                                    @Const @ByRef
                                                                                    MatExpr e2)

subtract

@Namespace(value="cv")
 @ByVal
 @Name(value="operator -")
public static MatExpr subtract(@Const @ByRef
                                                                                         Mat a,
                                                                                         @Const @ByRef
                                                                                         Mat b)

subtract

@Namespace(value="cv")
 @ByVal
 @Name(value="operator -")
public static MatExpr subtract(@Const @ByRef
                                                                                         Mat a,
                                                                                         @Const @ByRef
                                                                                         Scalar s)

subtract

@Namespace(value="cv")
 @ByVal
 @Name(value="operator -")
public static MatExpr subtract(@Const @ByRef
                                                                                         Scalar s,
                                                                                         @Const @ByRef
                                                                                         Mat a)

subtract

@Namespace(value="cv")
 @ByVal
 @Name(value="operator -")
public static MatExpr subtract(@Const @ByRef
                                                                                         MatExpr e,
                                                                                         @Const @ByRef
                                                                                         Mat m)

subtract

@Namespace(value="cv")
 @ByVal
 @Name(value="operator -")
public static MatExpr subtract(@Const @ByRef
                                                                                         Mat m,
                                                                                         @Const @ByRef
                                                                                         MatExpr e)

subtract

@Namespace(value="cv")
 @ByVal
 @Name(value="operator -")
public static MatExpr subtract(@Const @ByRef
                                                                                         MatExpr e,
                                                                                         @Const @ByRef
                                                                                         Scalar s)

subtract

@Namespace(value="cv")
 @ByVal
 @Name(value="operator -")
public static MatExpr subtract(@Const @ByRef
                                                                                         Scalar s,
                                                                                         @Const @ByRef
                                                                                         MatExpr e)

subtract

@Namespace(value="cv")
 @ByVal
 @Name(value="operator -")
public static MatExpr subtract(@Const @ByRef
                                                                                         MatExpr e1,
                                                                                         @Const @ByRef
                                                                                         MatExpr e2)

subtract

@Namespace(value="cv")
 @ByVal
 @Name(value="operator -")
public static MatExpr subtract(@Const @ByRef
                                                                                         Mat m)

subtract

@Namespace(value="cv")
 @ByVal
 @Name(value="operator -")
public static MatExpr subtract(@Const @ByRef
                                                                                         MatExpr e)

multiply

@Namespace(value="cv")
 @ByVal
 @Name(value="operator *")
public static MatExpr multiply(@Const @ByRef
                                                                                         Mat a,
                                                                                         @Const @ByRef
                                                                                         Mat b)

multiply

@Namespace(value="cv")
 @ByVal
 @Name(value="operator *")
public static MatExpr multiply(@Const @ByRef
                                                                                         Mat a,
                                                                                         double s)

multiply

@Namespace(value="cv")
 @ByVal
 @Name(value="operator *")
public static MatExpr multiply(double s,
                                                                                         @Const @ByRef
                                                                                         Mat a)

multiply

@Namespace(value="cv")
 @ByVal
 @Name(value="operator *")
public static MatExpr multiply(@Const @ByRef
                                                                                         MatExpr e,
                                                                                         @Const @ByRef
                                                                                         Mat m)

multiply

@Namespace(value="cv")
 @ByVal
 @Name(value="operator *")
public static MatExpr multiply(@Const @ByRef
                                                                                         Mat m,
                                                                                         @Const @ByRef
                                                                                         MatExpr e)

multiply

@Namespace(value="cv")
 @ByVal
 @Name(value="operator *")
public static MatExpr multiply(@Const @ByRef
                                                                                         MatExpr e,
                                                                                         double s)

multiply

@Namespace(value="cv")
 @ByVal
 @Name(value="operator *")
public static MatExpr multiply(double s,
                                                                                         @Const @ByRef
                                                                                         MatExpr e)

multiply

@Namespace(value="cv")
 @ByVal
 @Name(value="operator *")
public static MatExpr multiply(@Const @ByRef
                                                                                         MatExpr e1,
                                                                                         @Const @ByRef
                                                                                         MatExpr e2)

divide

@Namespace(value="cv")
 @ByVal
 @Name(value="operator /")
public static MatExpr divide(@Const @ByRef
                                                                                       Mat a,
                                                                                       @Const @ByRef
                                                                                       Mat b)

divide

@Namespace(value="cv")
 @ByVal
 @Name(value="operator /")
public static MatExpr divide(@Const @ByRef
                                                                                       Mat a,
                                                                                       double s)

divide

@Namespace(value="cv")
 @ByVal
 @Name(value="operator /")
public static MatExpr divide(double s,
                                                                                       @Const @ByRef
                                                                                       Mat a)

divide

@Namespace(value="cv")
 @ByVal
 @Name(value="operator /")
public static MatExpr divide(@Const @ByRef
                                                                                       MatExpr e,
                                                                                       @Const @ByRef
                                                                                       Mat m)

divide

@Namespace(value="cv")
 @ByVal
 @Name(value="operator /")
public static MatExpr divide(@Const @ByRef
                                                                                       Mat m,
                                                                                       @Const @ByRef
                                                                                       MatExpr e)

divide

@Namespace(value="cv")
 @ByVal
 @Name(value="operator /")
public static MatExpr divide(@Const @ByRef
                                                                                       MatExpr e,
                                                                                       double s)

divide

@Namespace(value="cv")
 @ByVal
 @Name(value="operator /")
public static MatExpr divide(double s,
                                                                                       @Const @ByRef
                                                                                       MatExpr e)

divide

@Namespace(value="cv")
 @ByVal
 @Name(value="operator /")
public static MatExpr divide(@Const @ByRef
                                                                                       MatExpr e1,
                                                                                       @Const @ByRef
                                                                                       MatExpr e2)

lessThan

@Namespace(value="cv")
 @ByVal
 @Name(value="operator <")
public static MatExpr lessThan(@Const @ByRef
                                                                                         Mat a,
                                                                                         @Const @ByRef
                                                                                         Mat b)

lessThan

@Namespace(value="cv")
 @ByVal
 @Name(value="operator <")
public static MatExpr lessThan(@Const @ByRef
                                                                                         Mat a,
                                                                                         double s)

lessThan

@Namespace(value="cv")
 @ByVal
 @Name(value="operator <")
public static MatExpr lessThan(double s,
                                                                                         @Const @ByRef
                                                                                         Mat a)

lessThanEquals

@Namespace(value="cv")
 @ByVal
 @Name(value="operator <=")
public static MatExpr lessThanEquals(@Const @ByRef
                                                                                                Mat a,
                                                                                                @Const @ByRef
                                                                                                Mat b)

lessThanEquals

@Namespace(value="cv")
 @ByVal
 @Name(value="operator <=")
public static MatExpr lessThanEquals(@Const @ByRef
                                                                                                Mat a,
                                                                                                double s)

lessThanEquals

@Namespace(value="cv")
 @ByVal
 @Name(value="operator <=")
public static MatExpr lessThanEquals(double s,
                                                                                                @Const @ByRef
                                                                                                Mat a)

equals

@Namespace(value="cv")
 @ByVal
 @Name(value="operator ==")
public static MatExpr equals(@Const @ByRef
                                                                                        Mat a,
                                                                                        @Const @ByRef
                                                                                        Mat b)

equals

@Namespace(value="cv")
 @ByVal
 @Name(value="operator ==")
public static MatExpr equals(@Const @ByRef
                                                                                        Mat a,
                                                                                        double s)

equals

@Namespace(value="cv")
 @ByVal
 @Name(value="operator ==")
public static MatExpr equals(double s,
                                                                                        @Const @ByRef
                                                                                        Mat a)

notEquals

@Namespace(value="cv")
 @ByVal
 @Name(value="operator !=")
public static MatExpr notEquals(@Const @ByRef
                                                                                           Mat a,
                                                                                           @Const @ByRef
                                                                                           Mat b)

notEquals

@Namespace(value="cv")
 @ByVal
 @Name(value="operator !=")
public static MatExpr notEquals(@Const @ByRef
                                                                                           Mat a,
                                                                                           double s)

notEquals

@Namespace(value="cv")
 @ByVal
 @Name(value="operator !=")
public static MatExpr notEquals(double s,
                                                                                           @Const @ByRef
                                                                                           Mat a)

greaterThanEquals

@Namespace(value="cv")
 @ByVal
 @Name(value="operator >=")
public static MatExpr greaterThanEquals(@Const @ByRef
                                                                                                   Mat a,
                                                                                                   @Const @ByRef
                                                                                                   Mat b)

greaterThanEquals

@Namespace(value="cv")
 @ByVal
 @Name(value="operator >=")
public static MatExpr greaterThanEquals(@Const @ByRef
                                                                                                   Mat a,
                                                                                                   double s)

greaterThanEquals

@Namespace(value="cv")
 @ByVal
 @Name(value="operator >=")
public static MatExpr greaterThanEquals(double s,
                                                                                                   @Const @ByRef
                                                                                                   Mat a)

greaterThan

@Namespace(value="cv")
 @ByVal
 @Name(value="operator >")
public static MatExpr greaterThan(@Const @ByRef
                                                                                            Mat a,
                                                                                            @Const @ByRef
                                                                                            Mat b)

greaterThan

@Namespace(value="cv")
 @ByVal
 @Name(value="operator >")
public static MatExpr greaterThan(@Const @ByRef
                                                                                            Mat a,
                                                                                            double s)

greaterThan

@Namespace(value="cv")
 @ByVal
 @Name(value="operator >")
public static MatExpr greaterThan(double s,
                                                                                            @Const @ByRef
                                                                                            Mat a)

and

@Namespace(value="cv")
 @ByVal
 @Name(value="operator &")
public static MatExpr and(@Const @ByRef
                                                                                    Mat a,
                                                                                    @Const @ByRef
                                                                                    Mat b)

and

@Namespace(value="cv")
 @ByVal
 @Name(value="operator &")
public static MatExpr and(@Const @ByRef
                                                                                    Mat a,
                                                                                    @Const @ByRef
                                                                                    Scalar s)

and

@Namespace(value="cv")
 @ByVal
 @Name(value="operator &")
public static MatExpr and(@Const @ByRef
                                                                                    Scalar s,
                                                                                    @Const @ByRef
                                                                                    Mat a)

or

@Namespace(value="cv")
 @ByVal
 @Name(value="operator |")
public static MatExpr or(@Const @ByRef
                                                                                   Mat a,
                                                                                   @Const @ByRef
                                                                                   Mat b)

or

@Namespace(value="cv")
 @ByVal
 @Name(value="operator |")
public static MatExpr or(@Const @ByRef
                                                                                   Mat a,
                                                                                   @Const @ByRef
                                                                                   Scalar s)

or

@Namespace(value="cv")
 @ByVal
 @Name(value="operator |")
public static MatExpr or(@Const @ByRef
                                                                                   Scalar s,
                                                                                   @Const @ByRef
                                                                                   Mat a)

xor

@Namespace(value="cv")
 @ByVal
 @Name(value="operator ^")
public static MatExpr xor(@Const @ByRef
                                                                                    Mat a,
                                                                                    @Const @ByRef
                                                                                    Mat b)

xor

@Namespace(value="cv")
 @ByVal
 @Name(value="operator ^")
public static MatExpr xor(@Const @ByRef
                                                                                    Mat a,
                                                                                    @Const @ByRef
                                                                                    Scalar s)

xor

@Namespace(value="cv")
 @ByVal
 @Name(value="operator ^")
public static MatExpr xor(@Const @ByRef
                                                                                    Scalar s,
                                                                                    @Const @ByRef
                                                                                    Mat a)

not

@Namespace(value="cv")
 @ByVal
 @Name(value="operator ~")
public static MatExpr not(@Const @ByRef
                                                                                    Mat m)

min

@Namespace(value="cv")
 @ByVal
public static MatExpr min(@Const @ByRef
                                                         Mat a,
                                                         @Const @ByRef
                                                         Mat b)

min

@Namespace(value="cv")
 @ByVal
public static MatExpr min(@Const @ByRef
                                                         Mat a,
                                                         double s)

min

@Namespace(value="cv")
 @ByVal
public static MatExpr min(double s,
                                                         @Const @ByRef
                                                         Mat a)

max

@Namespace(value="cv")
 @ByVal
public static MatExpr max(@Const @ByRef
                                                         Mat a,
                                                         @Const @ByRef
                                                         Mat b)

max

@Namespace(value="cv")
 @ByVal
public static MatExpr max(@Const @ByRef
                                                         Mat a,
                                                         double s)

max

@Namespace(value="cv")
 @ByVal
public static MatExpr max(double s,
                                                         @Const @ByRef
                                                         Mat a)

abs
```
@Namespace(value="cv")
 @ByVal
public static MatExpr abs(@Const @ByRef
                                                         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.

See Also:

MatrixExpressions, absdiff, convertScaleAbs

abs

@Namespace(value="cv")
 @ByVal
public static MatExpr abs(@Const @ByRef
                                                         MatExpr e)

\overload

Parameters:: e - matrix expression.

write

@Namespace(value="cv")
public static void write(@ByRef
                                                FileStorage fs,
                                                @opencv_core.Str
                                                BytePointer name,
                                                int value)

\} core_xml

/////////////////// XML & YAML I/O implementation //////////////////

\relates cv::FileStorage \{

write

@Namespace(value="cv")
public static void write(@ByRef
                                                FileStorage fs,
                                                @opencv_core.Str
                                                String name,
                                                int value)

write

@Namespace(value="cv")
public static void write(@ByRef
                                                FileStorage fs,
                                                @opencv_core.Str
                                                BytePointer name,
                                                float value)

write

@Namespace(value="cv")
public static void write(@ByRef
                                                FileStorage fs,
                                                @opencv_core.Str
                                                String name,
                                                float value)

write

@Namespace(value="cv")
public static void write(@ByRef
                                                FileStorage fs,
                                                @opencv_core.Str
                                                BytePointer name,
                                                double value)

write

@Namespace(value="cv")
public static void write(@ByRef
                                                FileStorage fs,
                                                @opencv_core.Str
                                                String name,
                                                double value)

write

@Namespace(value="cv")
public static void write(@ByRef
                                                FileStorage fs,
                                                @opencv_core.Str
                                                BytePointer name,
                                                @opencv_core.Str
                                                BytePointer value)

write

@Namespace(value="cv")
public static void write(@ByRef
                                                FileStorage fs,
                                                @opencv_core.Str
                                                String name,
                                                @opencv_core.Str
                                                String value)

write

@Namespace(value="cv")
public static void write(@ByRef
                                                FileStorage fs,
                                                @opencv_core.Str
                                                BytePointer name,
                                                @Const @ByRef
                                                Mat value)

write

@Namespace(value="cv")
public static void write(@ByRef
                                                FileStorage fs,
                                                @opencv_core.Str
                                                String name,
                                                @Const @ByRef
                                                Mat value)

write

@Namespace(value="cv")
public static void write(@ByRef
                                                FileStorage fs,
                                                @opencv_core.Str
                                                BytePointer name,
                                                @Const @ByRef
                                                SparseMat value)

write

@Namespace(value="cv")
public static void write(@ByRef
                                                FileStorage fs,
                                                @opencv_core.Str
                                                String name,
                                                @Const @ByRef
                                                SparseMat value)

write

@Namespace(value="cv")
public static void write(@ByRef
                                                FileStorage fs,
                                                @opencv_core.Str
                                                BytePointer name,
                                                @Const @ByRef
                                                KeyPointVector value)

write

@Namespace(value="cv")
public static void write(@ByRef
                                                FileStorage fs,
                                                @opencv_core.Str
                                                String name,
                                                @Const @ByRef
                                                KeyPointVector value)

write

@Namespace(value="cv")
public static void write(@ByRef
                                                FileStorage fs,
                                                @opencv_core.Str
                                                BytePointer name,
                                                @Const @ByRef
                                                DMatchVector value)

write

@Namespace(value="cv")
public static void write(@ByRef
                                                FileStorage fs,
                                                @opencv_core.Str
                                                String name,
                                                @Const @ByRef
                                                DMatchVector value)

writeScalar

@Namespace(value="cv")
public static void writeScalar(@ByRef
                                                      FileStorage fs,
                                                      int value)

writeScalar

@Namespace(value="cv")
public static void writeScalar(@ByRef
                                                      FileStorage fs,
                                                      float value)

writeScalar

@Namespace(value="cv")
public static void writeScalar(@ByRef
                                                      FileStorage fs,
                                                      double value)

writeScalar

@Namespace(value="cv")
public static void writeScalar(@ByRef
                                                      FileStorage fs,
                                                      @opencv_core.Str
                                                      BytePointer value)

writeScalar

@Namespace(value="cv")
public static void writeScalar(@ByRef
                                                      FileStorage fs,
                                                      @opencv_core.Str
                                                      String value)

read

@Namespace(value="cv")
public static void read(@Const @ByRef
                                               FileNode node,
                                               @ByRef
                                               IntPointer value,
                                               int default_value)

\relates cv::FileNode \{

read

@Namespace(value="cv")
public static void read(@Const @ByRef
                                               FileNode node,
                                               @ByRef
                                               IntBuffer value,
                                               int default_value)

read

@Namespace(value="cv")
public static void read(@Const @ByRef
                                               FileNode node,
                                               @ByRef
                                               int[] value,
                                               int default_value)

read

@Namespace(value="cv")
public static void read(@Const @ByRef
                                               FileNode node,
                                               @ByRef
                                               FloatPointer value,
                                               float default_value)

read

@Namespace(value="cv")
public static void read(@Const @ByRef
                                               FileNode node,
                                               @ByRef
                                               FloatBuffer value,
                                               float default_value)

read

@Namespace(value="cv")
public static void read(@Const @ByRef
                                               FileNode node,
                                               @ByRef
                                               float[] value,
                                               float default_value)

read

@Namespace(value="cv")
public static void read(@Const @ByRef
                                               FileNode node,
                                               @ByRef
                                               DoublePointer value,
                                               double default_value)

read

@Namespace(value="cv")
public static void read(@Const @ByRef
                                               FileNode node,
                                               @ByRef
                                               DoubleBuffer value,
                                               double default_value)

read

@Namespace(value="cv")
public static void read(@Const @ByRef
                                               FileNode node,
                                               @ByRef
                                               double[] value,
                                               double default_value)

read

@Namespace(value="cv")
public static void read(@Const @ByRef
                                               FileNode node,
                                               @StdString @ByRef
                                               BytePointer value,
                                               @StdString
                                               BytePointer default_value)

read

@Namespace(value="cv")
public static void read(@Const @ByRef
                                               FileNode node,
                                               @StdString @ByRef
                                               BytePointer value,
                                               @StdString
                                               String default_value)

read

@Namespace(value="cv")
public static void read(@Const @ByRef
                                               FileNode node,
                                               @ByRef
                                               Mat mat,
                                               @Const @ByRef(nullValue="cv::Mat()")
                                               Mat default_mat)

read

@Namespace(value="cv")
public static void read(@Const @ByRef
                                               FileNode node,
                                               @ByRef
                                               Mat mat)

read

@Namespace(value="cv")
public static void read(@Const @ByRef
                                               FileNode node,
                                               @ByRef
                                               SparseMat mat,
                                               @Const @ByRef(nullValue="cv::SparseMat()")
                                               SparseMat default_mat)

read

@Namespace(value="cv")
public static void read(@Const @ByRef
                                               FileNode node,
                                               @ByRef
                                               SparseMat mat)

read

@Namespace(value="cv")
public static void read(@Const @ByRef
                                               FileNode node,
                                               @ByRef
                                               KeyPointVector keypoints)

read

@Namespace(value="cv")
public static void read(@Const @ByRef
                                               FileNode node,
                                               @ByRef
                                               DMatchVector matches)

read

@Namespace(value="cv")
public static void read(@Const @ByRef
                                               FileNode node,
                                               @ByRef
                                               KeyPoint value,
                                               @Const @ByRef
                                               KeyPoint default_value)

read

@Namespace(value="cv")
public static void read(@Const @ByRef
                                               FileNode node,
                                               @ByRef
                                               DMatch value,
                                               @Const @ByRef
                                               DMatch default_value)

read

@Namespace(value="cv")
public static void read(@Const @ByRef
                                               FileNode node,
                                               @ByRef
                                               Range value,
                                               @Const @ByRef
                                               Range default_value)

shiftLeft

@Namespace(value="cv")
 @ByRef
 @Name(value="operator <<")
public static FileStorage shiftLeft(@ByRef
                                                                                               FileStorage fs,
                                                                                               @opencv_core.Str
                                                                                               BytePointer str)

/** \brief Writes string to a file storage. \relates cv::FileStorage

shiftLeft

@Namespace(value="cv")
 @ByRef
 @Name(value="operator <<")
public static FileStorage shiftLeft(@ByRef
                                                                                               FileStorage fs,
                                                                                               @opencv_core.Str
                                                                                               String str)

write

@Namespace(value="cv")
public static void write(@ByRef
                                                FileStorage fs,
                                                int value)

\endcond

\relates cv::FileStorage \{

write

@Namespace(value="cv")
public static void write(@ByRef
                                                FileStorage fs,
                                                float value)

write

@Namespace(value="cv")
public static void write(@ByRef
                                                FileStorage fs,
                                                double value)

write

@Namespace(value="cv")
public static void write(@ByRef
                                                FileStorage fs,
                                                @opencv_core.Str
                                                BytePointer value)

write

@Namespace(value="cv")
public static void write(@ByRef
                                                FileStorage fs,
                                                @opencv_core.Str
                                                String value)

write

@Namespace(value="cv")
public static void write(@ByRef
                                                FileStorage fs,
                                                @Const @ByRef
                                                Range r)

write

@Namespace(value="cv")
public static void write(@ByRef
                                                FileStorage fs,
                                                @opencv_core.Str
                                                BytePointer name,
                                                @Const @ByRef
                                                Range r)

write

@Namespace(value="cv")
public static void write(@ByRef
                                                FileStorage fs,
                                                @opencv_core.Str
                                                String name,
                                                @Const @ByRef
                                                Range r)

write

@Namespace(value="cv")
public static void write(@ByRef
                                                FileStorage fs,
                                                @opencv_core.Str
                                                BytePointer name,
                                                @Const @ByRef
                                                KeyPoint kpt)

write

@Namespace(value="cv")
public static void write(@ByRef
                                                FileStorage fs,
                                                @opencv_core.Str
                                                String name,
                                                @Const @ByRef
                                                KeyPoint kpt)

write

@Namespace(value="cv")
public static void write(@ByRef
                                                FileStorage fs,
                                                @opencv_core.Str
                                                BytePointer name,
                                                @Const @ByRef
                                                DMatch m)

write

@Namespace(value="cv")
public static void write(@ByRef
                                                FileStorage fs,
                                                @opencv_core.Str
                                                String name,
                                                @Const @ByRef
                                                DMatch m)

write

@Namespace(value="cv")
public static void write(@ByRef
                                                FileStorage fs,
                                                @Const @ByRef
                                                KeyPoint kpt)

write

@Namespace(value="cv")
public static void write(@ByRef
                                                FileStorage fs,
                                                @Const @ByRef
                                                DMatch m)

write

@Namespace(value="cv")
public static void write(@ByRef
                                                FileStorage fs,
                                                @Const @ByRef
                                                KeyPointVector vec)

write

@Namespace(value="cv")
public static void write(@ByRef
                                                FileStorage fs,
                                                @Const @ByRef
                                                DMatchVector vec)

read

@Namespace(value="cv")
public static void read(@Const @ByRef
                                               FileNode node,
                                               @Cast(value="bool*") @ByRef
                                               BoolPointer value,
                                               @Cast(value="bool")
                                               boolean default_value)

\} FileStorage

\relates cv::FileNode \{

read

@Namespace(value="cv")
public static void read(@Const @ByRef
                                               FileNode node,
                                               @Cast(value="bool*") @ByRef
                                               boolean[] value,
                                               @Cast(value="bool")
                                               boolean default_value)

read

@Namespace(value="cv")
public static void read(@Const @ByRef
                                               FileNode node,
                                               @Cast(value="uchar*") @ByRef
                                               BytePointer value,
                                               @Cast(value="uchar")
                                               byte default_value)

read

@Namespace(value="cv")
public static void read(@Const @ByRef
                                               FileNode node,
                                               @Cast(value="uchar*") @ByRef
                                               ByteBuffer value,
                                               @Cast(value="uchar")
                                               byte default_value)

read

@Namespace(value="cv")
public static void read(@Const @ByRef
                                               FileNode node,
                                               @Cast(value="uchar*") @ByRef
                                               byte[] value,
                                               @Cast(value="uchar")
                                               byte default_value)

read

@Namespace(value="cv")
public static void read(@Const @ByRef
                                               FileNode node,
                                               @Cast(value="ushort*") @ByRef
                                               ShortPointer value,
                                               @Cast(value="ushort")
                                               short default_value)

read

@Namespace(value="cv")
public static void read(@Const @ByRef
                                               FileNode node,
                                               @Cast(value="ushort*") @ByRef
                                               ShortBuffer value,
                                               @Cast(value="ushort")
                                               short default_value)

read

@Namespace(value="cv")
public static void read(@Const @ByRef
                                               FileNode node,
                                               @Cast(value="ushort*") @ByRef
                                               short[] value,
                                               @Cast(value="ushort")
                                               short default_value)

read

@Namespace(value="cv")
public static void read(@Const @ByRef
                                               FileNode node,
                                               @ByRef
                                               KeyPointVector vec,
                                               @Const @ByRef
                                               KeyPointVector default_value)

read

@Namespace(value="cv")
public static void read(@Const @ByRef
                                               FileNode node,
                                               @ByRef
                                               DMatchVector vec,
                                               @Const @ByRef
                                               DMatchVector default_value)

shiftLeft

@Namespace(value="cv")
 @ByRef
 @Name(value="operator <<")
public static FileStorage shiftLeft(@ByRef
                                                                                               FileStorage fs,
                                                                                               @Cast(value="char*")
                                                                                               ByteBuffer value)

\brief Writes data to a file storage.

shiftLeft

@Namespace(value="cv")
 @ByRef
 @Name(value="operator <<")
public static FileStorage shiftLeft(@ByRef
                                                                                               FileStorage fs,
                                                                                               @Cast(value="char*")
                                                                                               byte[] value)

shiftRight

@Namespace(value="cv")
 @Name(value="operator >>")
public static void shiftRight(@Const @ByRef
                                                                                 FileNode n,
                                                                                 @ByRef
                                                                                 KeyPoint kpt)

\brief Reads KeyPoint from a file storage.

shiftRight

@Namespace(value="cv")
 @Name(value="operator >>")
public static void shiftRight(@Const @ByRef
                                                                                 FileNode n,
                                                                                 @ByRef
                                                                                 KeyPointVector vec)

shiftRight

@Namespace(value="cv")
 @Name(value="operator >>")
public static void shiftRight(@Const @ByRef
                                                                                 FileNode n,
                                                                                 @ByRef
                                                                                 DMatchVector vec)

shiftRight

@Namespace(value="cv")
 @Name(value="operator >>")
public static void shiftRight(@Const @ByRef
                                                                                 FileNode n,
                                                                                 @ByRef
                                                                                 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
                                                                                                     FileNodeIterator it1,
                                                                                                     @Const @ByRef
                                                                                                     FileNodeIterator it2)

\} FileNode

\relates cv::FileNodeIterator \{

notEquals

@Namespace(value="cv")
 @Cast(value="bool")
 @Name(value="operator !=")
public static boolean notEquals(@Const @ByRef
                                                                                                        FileNodeIterator it1,
                                                                                                        @Const @ByRef
                                                                                                        FileNodeIterator it2)

subtract

@Namespace(value="cv")
 @Cast(value="ptrdiff_t")
 @Name(value="operator -")
public static long subtract(@Const @ByRef
                                                                                                        FileNodeIterator it1,
                                                                                                        @Const @ByRef
                                                                                                        FileNodeIterator it2)

lessThan

@Namespace(value="cv")
 @Cast(value="bool")
 @Name(value="operator <")
public static boolean lessThan(@Const @ByRef
                                                                                                      FileNodeIterator it1,
                                                                                                      @Const @ByRef
                                                                                                      FileNodeIterator it2)

solveLP
```
@Namespace(value="cv")
public static int solveLP(@ByVal
                                                 Mat Func,
                                                 @ByVal
                                                 Mat Constr,
                                                 @ByVal
                                                 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:
```
 \[\mbox{Maximize } c\cdot x\\
 \mbox{Subject to:}\\
 Ax\leq b\\
 x\geq 0\]
```
Where c is fixed 1-by-n row-vector, A is fixed m-by-n matrix, b is fixed m-by-1 column vector and x 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 c 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 c^T.

Constr - m-by-n+1 matrix, whose rightmost column corresponds to b in formulation above and the remaining to A. It should contain 32- or 64-bit floating point numbers.

z - The solution will be returned here as a column-vector - it corresponds to c in the formulation above. It will contain 64-bit floating point numbers.

Returns:

One of cv::SolveLPResult

solveLP

@Namespace(value="cv")
public static int solveLP(@ByVal
                                                 UMat Func,
                                                 @ByVal
                                                 UMat Constr,
                                                 @ByVal
                                                 UMat z)

solveLP

@Namespace(value="cv")
public static int solveLP(@ByVal
                                                 GpuMat Func,
                                                 @ByVal
                                                 GpuMat Constr,
                                                 @ByVal
                                                 GpuMat z)

Class opencv_core

Nested Class Summary

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

Field Summary

Constructor Summary

Method Summary

Methods inherited from class org.bytedeco.opencv.helper.opencv_core

Methods inherited from class org.bytedeco.opencv.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_16F

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_16FC1

CV_16FC2

CV_16FC3

CV_16FC4

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