| OpenCV 5.0.0alpha Open Source Computer Vision

Loading...
Searching...
No Matches
Topics | Namespaces | Classes | Macros | Typedefs | Enumerations | Functions
Utility and system functions and macros
Core functionality

## Topics
| Logging facilities
| SSE utilities
| NEON utilities
| VSX utilities
| Softfloat support
| Utility functions for OpenCV samples

## Detailed Description

## Namespaces
namespace | cv
namespace | cv::details
namespace | cv::Error
namespace | cv::instr
namespace | cv::utils::fs

## Classes
class | cv::Allocator< _Tp >
class | cv::AutoBuffer< _Tp, fixed_size >
| Automatically Allocated Buffer Class. More...
class | cv::utils::BufferArea
| Manages memory block shared by muliple buffers. More...
class | cv::CommandLineParser
| Designed for command line parsing. More...
union | Cv16suf
union | Cv32suf
union | Cv64suf
class | cv::Exception
| Class passed to an error. More...
struct | cv::Hamming
class | cv::ParallelLoopBody
| Base class for parallel data processors. More...
class | cv::ParallelLoopBodyLambdaWrapper
class | cv::TickMeter
| a Class to measure passing time. More...
class | cv::TLSData< T >
| Simple TLS data class. More...
class | cv::TLSDataAccumulator< T >
| TLS data accumulator with gathering methods. More...
class | cv::TLSDataContainer

## Macros
#define | __has_cpp_attribute(__x)
#define | CV_2PI 6.283185307179586476925286766559
#define | CV_ALWAYS_INLINE inline
#define | CV_Assert(expr)
| Checks a condition at runtime and throws exception if it fails.
#define | CV_AssertTerminate(expr)
#define | CV_AUTOSTEP 0x7fffffff
#define | CV_CDECL
#define | CV_CMP(a, b)
#define | CV_CONSTEXPR constexpr
#define | CV_CPU_AVX 10
#define | CV_CPU_AVX2 11
#define | CV_CPU_AVX512_CLX 261
#define | CV_CPU_AVX512_CNL 260
#define | CV_CPU_AVX512_COMMON 257
#define | CV_CPU_AVX512_ICL 262
#define | CV_CPU_AVX512_KNL 258
#define | CV_CPU_AVX512_KNM 259
#define | CV_CPU_AVX512_SKX 256
#define | CV_CPU_AVX_5124FMAPS 27
#define | CV_CPU_AVX_5124VNNIW 26
#define | CV_CPU_AVX_512BITALG 24
#define | CV_CPU_AVX_512BW 14
#define | CV_CPU_AVX_512CD 15
#define | CV_CPU_AVX_512DQ 16
#define | CV_CPU_AVX_512ER 17
#define | CV_CPU_AVX_512F 13
#define | CV_CPU_AVX_512IFMA 18
#define | CV_CPU_AVX_512IFMA512 18
#define | CV_CPU_AVX_512PF 19
#define | CV_CPU_AVX_512VBMI 20
#define | CV_CPU_AVX_512VBMI2 22
#define | CV_CPU_AVX_512VL 21
#define | CV_CPU_AVX_512VNNI 23
#define | CV_CPU_AVX_512VPOPCNTDQ 25
#define | CV_CPU_FMA3 12
#define | CV_CPU_FP16 9
#define | CV_CPU_LASX 231
#define | CV_CPU_LSX 230
#define | CV_CPU_MMX 1
#define | CV_CPU_MSA 150
#define | CV_CPU_NEON 100
#define | CV_CPU_NEON_BF16 103
#define | CV_CPU_NEON_DOTPROD 101
#define | CV_CPU_NEON_FP16 102
#define | CV_CPU_NONE 0
#define | CV_CPU_POPCNT 8
#define | CV_CPU_RISCVV 170
#define | CV_CPU_RVV 210
#define | CV_CPU_RVV_ZVFH 211
#define | CV_CPU_SSE 2
#define | CV_CPU_SSE2 3
#define | CV_CPU_SSE3 4
#define | CV_CPU_SSE4_1 6
#define | CV_CPU_SSE4_2 7
#define | CV_CPU_SSSE3 5
#define | CV_CPU_VSX 200
#define | CV_CPU_VSX3 201
#define | CV_CXX11 1
#define | CV_DbgAssert(expr)
#define | CV_DECL_ALIGNED(x)
#define | CV_ELEM_SIZE(type)
#define | CV_ELEM_SIZE1(type)
#define | CV_ENABLE_UNROLLED 1
#define | CV_ENUM_CLASS_EXPOSE(EnumType, ...)
#define | CV_ENUM_FLAGS(EnumType)
#define | CV_Error(code, msg)
| Call the error handler.
#define | CV_Error_(code, args)
| Call the error handler.
#define | CV_EXPORTS_AS(synonym)
#define | CV_EXPORTS_TEMPLATE CV_EXPORTS
#define | CV_EXPORTS_W CV_EXPORTS
#define | CV_EXPORTS_W_MAP CV_EXPORTS
#define | CV_EXPORTS_W_PARAMS CV_EXPORTS
#define | CV_EXPORTS_W_SIMPLE CV_EXPORTS
#define | CV_EXTERN_C extern "C"
#define | CV_FINAL final
#define | CV_FOURCC_MACRO(c1, c2, c3, c4)
| Macro to construct the fourcc code of the codec. Same as CV_FOURCC()
#define | CV_FP16_TYPE 0
#define | CV_HARDWARE_MAX_FEATURE 512
#define | CV_IMAX(a, b)
#define | CV_IMIN(a, b)
#define | CV_IN_OUT
#define | CV_IS_CONT_MAT CV_IS_MAT_CONT
#define | CV_IS_MAT_CONT(flags)
#define | CV_IS_SUBMAT(flags)
#define | CV_LOG2 0.69314718055994530941723212145818
#define | CV_MAT_CN(flags)
#define | CV_MAT_CN_MASK ((CV_CN_MAX - 1) << CV_CN_SHIFT)
#define | CV_MAT_CONT_FLAG (1 << CV_MAT_CONT_FLAG_SHIFT)
#define | CV_MAT_CONT_FLAG_SHIFT 14
#define | CV_MAT_TYPE(flags)
#define | CV_MAT_TYPE_MASK (CV_DEPTH_MAX*CV_CN_MAX - 1)
#define | CV_MAX_DIM 32
#define | CV_ND
#define | CV_NODISCARD_STD /* nothing by default */
#define | CV_NOEXCEPT noexcept
#define | CV_OUT
#define | CV_OVERRIDE override
#define | CV_PI 3.1415926535897932384626433832795
#define | CV_PROP
#define | CV_PROP_RW
#define | CV_SIGN(a)
#define | CV_STDCALL
#define | CV_STRONG_ALIGNMENT 0
#define | CV_SUBMAT_FLAG (1 << CV_SUBMAT_FLAG_SHIFT)
#define | CV_SUBMAT_FLAG_SHIFT 15
#define | CV_SWAP(a, b, t)
#define | CV_WRAP
#define | CV_WRAP_AS(synonym)
#define | CV_WRAP_DEFAULT(val)
#define | CV_WRAP_FILE_PATH
#define | CV_WRAP_MAPPABLE(mappable)
#define | CV_WRAP_PHANTOM(phantom_header)
#define | MAX(a, b)
#define | MIN(a, b)
#define | OPENCV_ABI_COMPATIBILITY 500

## Typedefs
typedef std::lock_guard< cv::Mutex > | cv::AutoLock
typedef int(* | cv::ErrorCallback) (int status, const char *func_name, const char *err_msg, const char *file_name, int line, void *userdata)
typedef Hamming | cv::HammingLUT
typedef std::recursive_mutex | cv::Mutex

## Enumerations
enum | cv::AlgorithmHint { cv::ALGO_HINT_DEFAULT = 0 , cv::ALGO_HINT_ACCURATE = 1 , cv::ALGO_HINT_APPROX = 2 }
| Flags that allow to modify some functions' behavior. Used as set of flags. More...
enum | CpuFeatures { CPU_MMX = 1 , CPU_SSE = 2 , CPU_SSE2 = 3 , CPU_SSE3 = 4 , CPU_SSSE3 = 5 , CPU_SSE4_1 = 6 , CPU_SSE4_2 = 7 , CPU_POPCNT = 8 , CPU_FP16 = 9 , CPU_AVX = 10 , CPU_AVX2 = 11 , CPU_FMA3 = 12 , CPU_AVX_512F = 13 , CPU_AVX_512BW = 14 , CPU_AVX_512CD = 15 , CPU_AVX_512DQ = 16 , CPU_AVX_512ER = 17 , CPU_AVX_512IFMA512 = 18 , CPU_AVX_512IFMA = 18 , CPU_AVX_512PF = 19 , CPU_AVX_512VBMI = 20 , CPU_AVX_512VL = 21 , CPU_AVX_512VBMI2 = 22 , CPU_AVX_512VNNI = 23 , CPU_AVX_512BITALG = 24 , CPU_AVX_512VPOPCNTDQ = 25 , CPU_AVX_5124VNNIW = 26 , CPU_AVX_5124FMAPS = 27 , CPU_NEON = 100 , CPU_NEON_DOTPROD = 101 , CPU_NEON_FP16 = 102 , CPU_NEON_BF16 = 103 , CPU_MSA = 150 , CPU_RISCVV = 170 , CPU_VSX = 200 , CPU_VSX3 = 201 , CPU_RVV = 210 , CPU_RVV_ZVFH = 211 , CPU_LSX = 230 , CPU_LASX = 231 , CPU_AVX512_SKX = 256 , CPU_AVX512_COMMON = 257 , CPU_AVX512_KNL = 258 , CPU_AVX512_KNM = 259 , CPU_AVX512_CNL = 260 , CPU_AVX512_CLX = 261 , CPU_AVX512_ICL = 262 , CPU_MAX_FEATURE = 512 }
| Available CPU features. More...
enum | cv::SortFlags { cv::SORT_EVERY_ROW = 0 , cv::SORT_EVERY_COLUMN = 1 , cv::SORT_ASCENDING = 0 , cv::SORT_DESCENDING = 16 }

## Functions
template<typename _Tp >
static _Tp * | cv::alignPtr (_Tp *ptr, int n=(int) sizeof(_Tp))
| Aligns a pointer to the specified number of bytes.
static size_t | cv::alignSize (size_t sz, int n)
| Aligns a buffer size to the specified number of bytes.
bool | cv::checkHardwareSupport (int feature)
| Returns true if the specified feature is supported by the host hardware.
bool | cv::Cholesky (double *A, size_t astep, int m, double *b, size_t bstep, int n)
bool | cv::Cholesky (float *A, size_t astep, int m, float *b, size_t bstep, int n)
static double | cv::cubeRoot (double val)
float | cv::cubeRoot (float val)
| Computes the cube root of an argument.
template<typename _Tp >
_Tp | cv::cv_abs (_Tp x)
float | cv::cv_abs (bfloat x)
float | cv::cv_abs (hfloat x)
unsigned | cv::cv_abs (int x)
uint64 | cv::cv_abs (int64 x)
int | cv::cv_abs (schar x)
int | cv::cv_abs (short x)
int | cv::cv_abs (uchar x)
uint64 | cv::cv_abs (uint64 x)
unsigned | cv::cv_abs (unsigned x)
int | cv::cv_abs (ushort x)
template<typename _Tp >
_Tp | cv::cv_absdiff (_Tp x, _Tp y)
float | cv::cv_absdiff (bfloat x, bfloat y)
float | cv::cv_absdiff (hfloat x, hfloat y)
unsigned | cv::cv_absdiff (int x, int y)
int | cv::cv_absdiff (schar x, schar y)
int | cv::cv_absdiff (short x, short y)
int | cv::cv_absdiff (uchar x, uchar y)
uint64 | cv::cv_absdiff (uint64 x, uint64 y)
unsigned | cv::cv_absdiff (unsigned x, unsigned y)
int | cv::cv_absdiff (ushort x, ushort y)
int | CV_FOURCC (char c1, char c2, char c3, char c4)
| Constructs the 'fourcc' code, used in video codecs and many other places. Simply call it with 4 chars like ‘CV_FOURCC('I’, 'Y', 'U', 'V')`.
int | cvCeil (double value)
| Rounds floating-point number to the nearest integer not smaller than the original.
int | cvCeil (float value)
int | cvCeil (int value)
int | cvFloor (double value)
| Rounds floating-point number to the nearest integer not larger than the original.
int | cvFloor (float value)
int | cvFloor (int value)
int | cvIsInf (double value)
| Determines if the argument is Infinity.
int | cvIsInf (float value)
int | cvIsNaN (double value)
| Determines if the argument is Not A Number.
int | cvIsNaN (float value)
int | cvRound (double value)
| Rounds floating-point number to the nearest integer.
int | cvRound (float value)
int | cvRound (int value)
static int | cv::divUp (int a, unsigned int b)
| Integer division with result round up.
static size_t | cv::divUp (size_t a, unsigned int b)
static String | cv::utils::dumpBool (bool argument)
static String | cv::utils::dumpCString (const char *argument)
static String | cv::utils::dumpDouble (double argument)
static String | cv::utils::dumpFloat (float argument)
String | cv::utils::dumpInputArray (InputArray argument)
String | cv::utils::dumpInputArrayOfArrays (InputArrayOfArrays argument)
String | cv::utils::dumpInputOutputArray (InputOutputArray argument)
String | cv::utils::dumpInputOutputArrayOfArrays (InputOutputArrayOfArrays argument)
static String | cv::utils::dumpInt (int argument)
static String | cv::utils::dumpInt64 (int64 argument)
static String | cv::utils::dumpRange (const Range &argument)
static String | cv::utils::dumpRect (const Rect &argument)
static String | cv::utils::dumpRotatedRect (const RotatedRect &argument)
static String | cv::utils::dumpSizeT (size_t argument)
static String | cv::utils::dumpString (const String &argument)
static String | cv::utils::dumpTermCriteria (const TermCriteria &argument)
String | cv::utils::dumpVectorOfDouble (const std::vector< double > &vec)
String | cv::utils::dumpVectorOfInt (const std::vector< int > &vec)
String | cv::utils::dumpVectorOfRect (const std::vector< Rect > &vec)
void | cv::error (const Exception &exc)
| Signals an error and raises the exception.
void | cv::error (Error::Code code, const String &err, const char *func, const char *file, int line)
| Signals an error and raises the exception.
float | cv::fastAtan2 (float y, float x)
| Calculates the angle of a 2D vector in degrees.
void | cv::fastFree (void *ptr)
| Deallocates a memory buffer.
void * | cv::fastMalloc (size_t bufSize)
| Allocates an aligned memory buffer.
template<typename _Tp , typename Functor >
void | cv::Mat::forEach_impl (const Functor &operation)
String | cv::format (const char *fmt,...)
| Returns a text string formatted using the printf-like expression.
const String & | cv::getBuildInformation ()
| Returns full configuration time cmake output.
std::string | cv::getCPUFeaturesLine ()
| Returns list of CPU features enabled during compilation.
int64 | cv::getCPUTickCount ()
| Returns the number of CPU ticks.
AlgorithmHint | cv::getDefaultAlgorithmHint ()
| Returns AlgorithmHint defined during OpenCV compilation. Defines ALGO_HINT_DEFAULT behavior.
static size_t | cv::getElemSize (int type)
String | cv::getHardwareFeatureName (int feature)
| Returns feature name by ID.
int | cv::getNumberOfCPUs ()
| Returns the number of logical CPUs available for the process.
int | cv::getNumThreads ()
| Returns the number of threads used by OpenCV for parallel regions.
int | cv::getThreadNum ()
| Returns the index of the currently executed thread within the current parallel region. Always returns 0 if called outside of parallel region.
int64 | cv::getTickCount ()
| Returns the number of ticks.
double | cv::getTickFrequency ()
| Returns the number of ticks per second.
int | cv::getVersionMajor ()
| Returns major library version.
int | cv::getVersionMinor ()
| Returns minor library version.
int | cv::getVersionRevision ()
| Returns revision field of the library version.
String | cv::getVersionString ()
| Returns library version string.
void | cv::glob (String pattern, std::vector< String > &result, bool recursive=false)
| Searches for files matching the specified pattern in a directory.
template<int N, typename T >
static bool | cv::isAligned (const T &data)
| Alignment check of passed values.
template<int N>
static bool | cv::isAligned (const void *p1)
template<int N>
static bool | cv::isAligned (const void *p1, const void *p2)
template<int N>
static bool | cv::isAligned (const void *p1, const void *p2, const void *p3)
template<int N>
static bool | cv::isAligned (const void *p1, const void *p2, const void *p3, const void *p4)
int | cv::LU (double *A, size_t astep, int m, double *b, size_t bstep, int n)
int | cv::LU (float *A, size_t astep, int m, float *b, size_t bstep, int n)
template<typename _Tp , typename _AccTp >
static _AccTp | cv::normInf (const _Tp *a, const _Tp *b, int n)
template<typename _Tp , typename _AccTp >
static _AccTp | cv::normInf (const _Tp *a, int n)
template<typename _Tp , typename _AccTp >
static _AccTp | cv::normL1 (const _Tp *a, const _Tp *b, int n)
template<typename _Tp , typename _AccTp >
static _AccTp | cv::normL1 (const _Tp *a, int n)
template<typename _Tp , typename _AccTp >
static _AccTp | cv::normL2Sqr (const _Tp *a, const _Tp *b, int n)
template<typename _Tp , typename _AccTp >
static _AccTp | cv::normL2Sqr (const _Tp *a, int n)
static std::ostream & | cv::operator<< (std::ostream &out, const TickMeter &tm)
| output operator
ErrorCallback | cv::redirectError (ErrorCallback errCallback, void *userdata=0, void **prevUserdata=0)
| Sets the new error handler and the optional user data.
static int | cv::roundUp (int a, unsigned int b)
| Round first value up to the nearest multiple of second value.
static size_t | cv::roundUp (size_t a, unsigned int b)
template<typename _Tp >
static _Tp | cv::saturate_cast (bfloat v)
template<typename _Tp >
static _Tp | cv::saturate_cast (bool v)
template<typename _Tp >
static _Tp | cv::saturate_cast (double v)
template<typename _Tp >
static _Tp | cv::saturate_cast (float v)
template<typename _Tp >
static _Tp | cv::saturate_cast (hfloat v)
template<typename _Tp >
static _Tp | cv::saturate_cast (int v)
template<typename _Tp >
static _Tp | cv::saturate_cast (int64 v)
template<typename _Tp >
static _Tp | cv::saturate_cast (schar v)
template<typename _Tp >
static _Tp | cv::saturate_cast (short v)
template<typename _Tp >
static _Tp | cv::saturate_cast (uchar v)
| Template function for accurate conversion from one primitive type to another.
template<typename _Tp >
static _Tp | cv::saturate_cast (uint64 v)
template<typename _Tp >
static _Tp | cv::saturate_cast (unsigned v)
template<typename _Tp >
static _Tp | cv::saturate_cast (ushort v)
template<>
bfloat | cv::saturate_cast< bfloat > (bfloat v)
template<>
bfloat | cv::saturate_cast< bfloat > (double v)
template<>
bfloat | cv::saturate_cast< bfloat > (float v)
template<>
bfloat | cv::saturate_cast< bfloat > (hfloat v)
template<>
bfloat | cv::saturate_cast< bfloat > (int v)
template<>
bfloat | cv::saturate_cast< bfloat > (int64 v)
template<>
bfloat | cv::saturate_cast< bfloat > (schar v)
template<>
bfloat | cv::saturate_cast< bfloat > (short v)
template<>
bfloat | cv::saturate_cast< bfloat > (uchar v)
template<>
bfloat | cv::saturate_cast< bfloat > (uint64 v)
template<>
bfloat | cv::saturate_cast< bfloat > (unsigned v)
template<>
bfloat | cv::saturate_cast< bfloat > (ushort v)
template<>
bool | cv::saturate_cast< bool > (bfloat v)
template<>
bool | cv::saturate_cast< bool > (double v)
template<>
bool | cv::saturate_cast< bool > (float v)
template<>
bool | cv::saturate_cast< bool > (hfloat v)
template<>
bool | cv::saturate_cast< bool > (int v)
template<>
bool | cv::saturate_cast< bool > (int64_t v)
template<>
bool | cv::saturate_cast< bool > (schar v)
template<>
bool | cv::saturate_cast< bool > (short v)
template<>
bool | cv::saturate_cast< bool > (uchar v)
template<>
bool | cv::saturate_cast< bool > (uint64_t v)
template<>
bool | cv::saturate_cast< bool > (unsigned v)
template<>
bool | cv::saturate_cast< bool > (ushort v)
template<>
hfloat | cv::saturate_cast< hfloat > (bfloat v)
template<>
hfloat | cv::saturate_cast< hfloat > (double v)
template<>
hfloat | cv::saturate_cast< hfloat > (float v)
template<>
hfloat | cv::saturate_cast< hfloat > (hfloat v)
template<>
hfloat | cv::saturate_cast< hfloat > (int v)
template<>
hfloat | cv::saturate_cast< hfloat > (int64 v)
template<>
hfloat | cv::saturate_cast< hfloat > (schar v)
template<>
hfloat | cv::saturate_cast< hfloat > (short v)
template<>
hfloat | cv::saturate_cast< hfloat > (uchar v)
template<>
hfloat | cv::saturate_cast< hfloat > (uint64 v)
template<>
hfloat | cv::saturate_cast< hfloat > (unsigned v)
template<>
hfloat | cv::saturate_cast< hfloat > (ushort v)
template<>
int64 | cv::saturate_cast< int64 > (double v)
template<>
int64 | cv::saturate_cast< int64 > (float v)
template<>
int64 | cv::saturate_cast< int64 > (uint64 v)
template<>
schar | cv::saturate_cast< schar > (double v)
template<>
schar | cv::saturate_cast< schar > (float v)
template<>
schar | cv::saturate_cast< schar > (int v)
template<>
schar | cv::saturate_cast< schar > (int64 v)
template<>
schar | cv::saturate_cast< schar > (short v)
template<>
schar | cv::saturate_cast< schar > (uchar v)
template<>
schar | cv::saturate_cast< schar > (uint64 v)
template<>
schar | cv::saturate_cast< schar > (unsigned v)
template<>
schar | cv::saturate_cast< schar > (ushort v)
template<>
short | cv::saturate_cast< short > (double v)
template<>
short | cv::saturate_cast< short > (float v)
template<>
short | cv::saturate_cast< short > (int v)
template<>
short | cv::saturate_cast< short > (int64 v)
template<>
short | cv::saturate_cast< short > (uint64 v)
template<>
short | cv::saturate_cast< short > (unsigned v)
template<>
short | cv::saturate_cast< short > (ushort v)
template<>
uchar | cv::saturate_cast< uchar > (double v)
template<>
uchar | cv::saturate_cast< uchar > (float v)
template<>
uchar | cv::saturate_cast< uchar > (int v)
template<>
uchar | cv::saturate_cast< uchar > (int64 v)
template<>
uchar | cv::saturate_cast< uchar > (schar v)
template<>
uchar | cv::saturate_cast< uchar > (short v)
template<>
uchar | cv::saturate_cast< uchar > (uint64 v)
template<>
uchar | cv::saturate_cast< uchar > (unsigned v)
template<>
uchar | cv::saturate_cast< uchar > (ushort v)
template<>
uint64 | cv::saturate_cast< uint64 > (double v)
template<>
uint64 | cv::saturate_cast< uint64 > (float v)
template<>
uint64 | cv::saturate_cast< uint64 > (int v)
template<>
uint64 | cv::saturate_cast< uint64 > (int64 v)
template<>
uint64 | cv::saturate_cast< uint64 > (schar v)
template<>
uint64 | cv::saturate_cast< uint64 > (short v)
template<>
unsigned | cv::saturate_cast< unsigned > (double v)
template<>
unsigned | cv::saturate_cast< unsigned > (float v)
template<>
unsigned | cv::saturate_cast< unsigned > (int v)
template<>
unsigned | cv::saturate_cast< unsigned > (int64 v)
template<>
unsigned | cv::saturate_cast< unsigned > (schar v)
template<>
unsigned | cv::saturate_cast< unsigned > (short v)
template<>
unsigned | cv::saturate_cast< unsigned > (uint64 v)
template<>
ushort | cv::saturate_cast< ushort > (double v)
template<>
ushort | cv::saturate_cast< ushort > (float v)
template<>
ushort | cv::saturate_cast< ushort > (int v)
template<>
ushort | cv::saturate_cast< ushort > (int64 v)
template<>
ushort | cv::saturate_cast< ushort > (schar v)
template<>
ushort | cv::saturate_cast< ushort > (short v)
template<>
ushort | cv::saturate_cast< ushort > (uint64 v)
template<>
ushort | cv::saturate_cast< ushort > (unsigned v)
bool | cv::setBreakOnError (bool flag)
| Sets/resets the break-on-error mode.
void | cv::setNumThreads (int nthreads)
| OpenCV will try to set the number of threads for subsequent parallel regions.
void | cv::setUseOptimized (bool onoff)
| Enables or disables the optimized code.
String | cv::tempfile (const char *suffix=0)
| Generates a unique temporary file name.
void | cv::terminate (Error::Code code, const String &err, const char *func, const char *file, int line) CV_NOEXCEPT
| Signals an error and terminate application.
bool | cv::useOptimized ()
| Returns the status of optimized code usage.

## Macro Definition Documentation

## ◆ __has_cpp_attribute

#define __has_cpp_attribute | ( |  | __x | ) |

`#include <opencv2/core/cvdef.h>`

Value:
0

## ◆ CV_2PI

#define CV_2PI 6.283185307179586476925286766559

`#include <opencv2/core/cvdef.h>`

Examples
  samples/cpp/snippets/polar_transforms.cpp.

## ◆ CV_ALWAYS_INLINE

#define CV_ALWAYS_INLINE inline

`#include <opencv2/core/cvdef.h>`

## ◆ CV_Assert

#define CV_Assert | ( |  | expr | ) |

`#include <opencv2/core/exception.hpp>`

Value:
do { if(!!(expr)) ; else cv::error( cv::Error::StsAssert, #expr, CV_Func, __FILE__, __LINE__ ); } while(0)
cv::error
void error(const Exception &exc)
Signals an error and raises the exception.
cv::Error::StsAssert
@ StsAssert
assertion failed
Definition exception.hpp:65

Checks a condition at runtime and throws exception if it fails.

The macros CV_Assert (and CV_DbgAssert(expr)) evaluate the specified expression. If it is 0, the macros raise an error (see cv::error). The macro CV_Assert checks the condition in both Debug and Release configurations while CV_DbgAssert is only retained in the Debug configuration. CV_AssertTerminate is analog of CV_Assert for invariants check in functions with noexcept attribute. It does not throw exception, but terminates the application.

Examples
  samples/cpp/grabcut.cpp, samples/cpp/image_alignment.cpp, samples/cpp/tutorial_code/core/how_to_scan_images/how_to_scan_images.cpp, samples/dnn/classification.cpp, samples/dnn/object_detection.cpp, samples/dnn/segmentation.cpp, and samples/dnn/text_detection.cpp.

## ◆ CV_AssertTerminate

#define CV_AssertTerminate | ( |  | expr | ) |

`#include <opencv2/core/exception.hpp>`

Value:
do { if(!!(expr)) ; else cv::terminate( #expr, CV_Func, __FILE__, __LINE__ ); } while(0)
cv::terminate
void terminate(Error::Code code, const String &err, const char *func, const char *file, int line) CV_NOEXCEPT
Signals an error and terminate application.

## ◆ CV_AUTOSTEP

#define CV_AUTOSTEP 0x7fffffff

`#include <opencv2/core/cvdef.h>`

## ◆ CV_CDECL

#define CV_CDECL

`#include <opencv2/core/cvdef.h>`

## ◆ CV_CMP

#define CV_CMP | ( |  | a,
|  |  | b )

`#include <opencv2/core/cvdef.h>`

Value:
(((a) > (b)) - ((a) < (b)))

## ◆ CV_CONSTEXPR

#define CV_CONSTEXPR constexpr

`#include <opencv2/core/cvdef.h>`

## ◆ CV_CPU_AVX

#define CV_CPU_AVX 10

`#include <opencv2/core/cvdef.h>`

## ◆ CV_CPU_AVX2

#define CV_CPU_AVX2 11

`#include <opencv2/core/cvdef.h>`

## ◆ CV_CPU_AVX512_CLX

#define CV_CPU_AVX512_CLX 261

`#include <opencv2/core/cvdef.h>`

## ◆ CV_CPU_AVX512_CNL

#define CV_CPU_AVX512_CNL 260

`#include <opencv2/core/cvdef.h>`

## ◆ CV_CPU_AVX512_COMMON

#define CV_CPU_AVX512_COMMON 257

`#include <opencv2/core/cvdef.h>`

## ◆ CV_CPU_AVX512_ICL

#define CV_CPU_AVX512_ICL 262

`#include <opencv2/core/cvdef.h>`

## ◆ CV_CPU_AVX512_KNL

#define CV_CPU_AVX512_KNL 258

`#include <opencv2/core/cvdef.h>`

## ◆ CV_CPU_AVX512_KNM

#define CV_CPU_AVX512_KNM 259

`#include <opencv2/core/cvdef.h>`

## ◆ CV_CPU_AVX512_SKX

#define CV_CPU_AVX512_SKX 256

`#include <opencv2/core/cvdef.h>`

## ◆ CV_CPU_AVX_5124FMAPS

#define CV_CPU_AVX_5124FMAPS 27

`#include <opencv2/core/cvdef.h>`

## ◆ CV_CPU_AVX_5124VNNIW

#define CV_CPU_AVX_5124VNNIW 26

`#include <opencv2/core/cvdef.h>`

## ◆ CV_CPU_AVX_512BITALG

#define CV_CPU_AVX_512BITALG 24

`#include <opencv2/core/cvdef.h>`

## ◆ CV_CPU_AVX_512BW

#define CV_CPU_AVX_512BW 14

`#include <opencv2/core/cvdef.h>`

## ◆ CV_CPU_AVX_512CD

#define CV_CPU_AVX_512CD 15

`#include <opencv2/core/cvdef.h>`

## ◆ CV_CPU_AVX_512DQ

#define CV_CPU_AVX_512DQ 16

`#include <opencv2/core/cvdef.h>`

## ◆ CV_CPU_AVX_512ER

#define CV_CPU_AVX_512ER 17

`#include <opencv2/core/cvdef.h>`

## ◆ CV_CPU_AVX_512F

#define CV_CPU_AVX_512F 13

`#include <opencv2/core/cvdef.h>`

## ◆ CV_CPU_AVX_512IFMA

#define CV_CPU_AVX_512IFMA 18

`#include <opencv2/core/cvdef.h>`

## ◆ CV_CPU_AVX_512IFMA512

#define CV_CPU_AVX_512IFMA512 18

`#include <opencv2/core/cvdef.h>`

## ◆ CV_CPU_AVX_512PF

#define CV_CPU_AVX_512PF 19

`#include <opencv2/core/cvdef.h>`

## ◆ CV_CPU_AVX_512VBMI

#define CV_CPU_AVX_512VBMI 20

`#include <opencv2/core/cvdef.h>`

## ◆ CV_CPU_AVX_512VBMI2

#define CV_CPU_AVX_512VBMI2 22

`#include <opencv2/core/cvdef.h>`

## ◆ CV_CPU_AVX_512VL

#define CV_CPU_AVX_512VL 21

`#include <opencv2/core/cvdef.h>`

## ◆ CV_CPU_AVX_512VNNI

#define CV_CPU_AVX_512VNNI 23

`#include <opencv2/core/cvdef.h>`

## ◆ CV_CPU_AVX_512VPOPCNTDQ

#define CV_CPU_AVX_512VPOPCNTDQ 25

`#include <opencv2/core/cvdef.h>`

## ◆ CV_CPU_FMA3

#define CV_CPU_FMA3 12

`#include <opencv2/core/cvdef.h>`

## ◆ CV_CPU_FP16

#define CV_CPU_FP16 9

`#include <opencv2/core/cvdef.h>`

## ◆ CV_CPU_LASX

#define CV_CPU_LASX 231

`#include <opencv2/core/cvdef.h>`

## ◆ CV_CPU_LSX

#define CV_CPU_LSX 230

`#include <opencv2/core/cvdef.h>`

## ◆ CV_CPU_MMX

#define CV_CPU_MMX 1

`#include <opencv2/core/cvdef.h>`

## ◆ CV_CPU_MSA

#define CV_CPU_MSA 150

`#include <opencv2/core/cvdef.h>`

## ◆ CV_CPU_NEON

#define CV_CPU_NEON 100

`#include <opencv2/core/cvdef.h>`

## ◆ CV_CPU_NEON_BF16

#define CV_CPU_NEON_BF16 103

`#include <opencv2/core/cvdef.h>`

## ◆ CV_CPU_NEON_DOTPROD

#define CV_CPU_NEON_DOTPROD 101

`#include <opencv2/core/cvdef.h>`

## ◆ CV_CPU_NEON_FP16

#define CV_CPU_NEON_FP16 102

`#include <opencv2/core/cvdef.h>`

## ◆ CV_CPU_NONE

#define CV_CPU_NONE 0

`#include <opencv2/core/cvdef.h>`

## ◆ CV_CPU_POPCNT

#define CV_CPU_POPCNT 8

`#include <opencv2/core/cvdef.h>`

## ◆ CV_CPU_RISCVV

#define CV_CPU_RISCVV 170

`#include <opencv2/core/cvdef.h>`

## ◆ CV_CPU_RVV

#define CV_CPU_RVV 210

`#include <opencv2/core/cvdef.h>`

## ◆ CV_CPU_RVV_ZVFH

#define CV_CPU_RVV_ZVFH 211

`#include <opencv2/core/cvdef.h>`

## ◆ CV_CPU_SSE

#define CV_CPU_SSE 2

`#include <opencv2/core/cvdef.h>`

## ◆ CV_CPU_SSE2

#define CV_CPU_SSE2 3

`#include <opencv2/core/cvdef.h>`

## ◆ CV_CPU_SSE3

#define CV_CPU_SSE3 4

`#include <opencv2/core/cvdef.h>`

## ◆ CV_CPU_SSE4_1

#define CV_CPU_SSE4_1 6

`#include <opencv2/core/cvdef.h>`

## ◆ CV_CPU_SSE4_2

#define CV_CPU_SSE4_2 7

`#include <opencv2/core/cvdef.h>`

## ◆ CV_CPU_SSSE3

#define CV_CPU_SSSE3 5

`#include <opencv2/core/cvdef.h>`

## ◆ CV_CPU_VSX

#define CV_CPU_VSX 200

`#include <opencv2/core/cvdef.h>`

## ◆ CV_CPU_VSX3

#define CV_CPU_VSX3 201

`#include <opencv2/core/cvdef.h>`

## ◆ CV_CXX11

#define CV_CXX11 1

`#include <opencv2/core/cvdef.h>`

## ◆ CV_DbgAssert

#define CV_DbgAssert | ( |  | expr | ) |

`#include <opencv2/core/exception.hpp>`

replaced with CV_Assert(expr) in Debug configuration

## ◆ CV_DECL_ALIGNED

#define CV_DECL_ALIGNED | ( |  | x | ) |

`#include <opencv2/core/cvdef.h>`

## ◆ CV_ELEM_SIZE

#define CV_ELEM_SIZE | ( |  | type | ) |

`#include <opencv2/core/cvdef.h>`

Value:
(CV_MAT_CN(type)*CV_ELEM_SIZE1(type))
CV_ELEM_SIZE1
#define CV_ELEM_SIZE1(type)
Definition cvdef.h:520
CV_MAT_CN
#define CV_MAT_CN(flags)
Definition cvdef.h:503

## ◆ CV_ELEM_SIZE1

#define CV_ELEM_SIZE1 | ( |  | type | ) |

`#include <opencv2/core/cvdef.h>`

Value:
((int)((0x4881228442211ULL >> (CV_MAT_DEPTH(type) * 4)) & 15))
CV_MAT_DEPTH
#define CV_MAT_DEPTH(flags)
Definition interface.h:92

Size of an array/scalar single-channel value, 4 bits per type: CV_8U - 1 byte CV_8S - 1 byte CV_16U - 2 bytes ...

## ◆ CV_ENABLE_UNROLLED

#define CV_ENABLE_UNROLLED 1

`#include <opencv2/core/cvdef.h>`

## ◆ CV_ENUM_CLASS_EXPOSE

#define CV_ENUM_CLASS_EXPOSE | ( |  | EnumType,
|  |  | ... )

`#include <opencv2/core/cvdef.h>`

Value:
__CV_EXPAND(__CV_CAT(__CV_ENUM_CLASS_EXPOSE_, __CV_VA_NUM_ARGS(__VA_ARGS__))(EnumType, __VA_ARGS__)); \

## ◆ CV_ENUM_FLAGS

#define CV_ENUM_FLAGS | ( |  | EnumType | ) |

`#include <opencv2/core/cvdef.h>`

Value:
__CV_ENUM_FLAGS_LOGICAL_NOT (EnumType) \
__CV_ENUM_FLAGS_LOGICAL_EQ (EnumType, int) \
__CV_ENUM_FLAGS_LOGICAL_NOT_EQ (EnumType, int) \
\
__CV_ENUM_FLAGS_BITWISE_NOT (EnumType) \
__CV_ENUM_FLAGS_BITWISE_OR (EnumType, EnumType, EnumType) \
__CV_ENUM_FLAGS_BITWISE_AND (EnumType, EnumType, EnumType) \
__CV_ENUM_FLAGS_BITWISE_XOR (EnumType, EnumType, EnumType) \
\
__CV_ENUM_FLAGS_BITWISE_OR_EQ (EnumType, EnumType) \
__CV_ENUM_FLAGS_BITWISE_AND_EQ (EnumType, EnumType) \
__CV_ENUM_FLAGS_BITWISE_XOR_EQ (EnumType, EnumType) \

## ◆ CV_Error

#define CV_Error | ( |  | code,
|  |  | msg )

`#include <opencv2/core/exception.hpp>`

Value:
cv::error( code, msg, CV_Func, __FILE__, __LINE__ )

Call the error handler.

Currently, the error handler prints the error code and the error message to the standard error stream `stderr`. In the Debug configuration, it then provokes memory access violation, so that the execution stack and all the parameters can be analyzed by the debugger. In the Release configuration, the exception is thrown.

Parameters

  code | one of Error::Code
  msg | error message

Examples
  samples/cpp/grabcut.cpp, samples/cpp/pca.cpp, samples/cpp/snippets/epipolar_lines.cpp, samples/cpp/tutorial_code/features/Homography/decompose_homography.cpp, samples/cpp/tutorial_code/features/Homography/homography_from_camera_displacement.cpp, samples/cpp/tutorial_code/features/Homography/pose_from_homography.cpp, samples/dnn/object_detection.cpp, and samples/dnn/segmentation.cpp.

## ◆ CV_Error_

#define CV_Error_ | ( |  | code,
|  |  | args )

`#include <opencv2/core/exception.hpp>`

Value:
cv::error( code, cv::format args, CV_Func, __FILE__, __LINE__ )
cv::format
String format(const char *fmt,...)
Returns a text string formatted using the printf-like expression.

Call the error handler.

This macro can be used to construct an error message on-fly to include some dynamic information, for example:

// note the extra parentheses around the formatted text message
CV_Error_(Error::StsOutOfRange,
("the value at (%d, %d)=%g is out of range", badPt.x, badPt.y, badValue));
CV_Error_
#define CV_Error_(code, args)
Call the error handler.
Definition exception.hpp:188

Parameters

  code | one of Error::Code
  args | printf-like formatted error message in parentheses

## ◆ CV_EXPORTS_AS

#define CV_EXPORTS_AS | ( |  | synonym | ) |

`#include <opencv2/core/cvdef.h>`

Value:
CV_EXPORTS

## ◆ CV_EXPORTS_TEMPLATE

#define CV_EXPORTS_TEMPLATE CV_EXPORTS

`#include <opencv2/core/cvdef.h>`

## ◆ CV_EXPORTS_W

#define CV_EXPORTS_W CV_EXPORTS

`#include <opencv2/core/cvdef.h>`

## ◆ CV_EXPORTS_W_MAP

#define CV_EXPORTS_W_MAP CV_EXPORTS

`#include <opencv2/core/cvdef.h>`

## ◆ CV_EXPORTS_W_PARAMS

#define CV_EXPORTS_W_PARAMS CV_EXPORTS

`#include <opencv2/core/cvdef.h>`

## ◆ CV_EXPORTS_W_SIMPLE

#define CV_EXPORTS_W_SIMPLE CV_EXPORTS

`#include <opencv2/core/cvdef.h>`

## ◆ CV_EXTERN_C

#define CV_EXTERN_C extern "C"

`#include <opencv2/core/cvdef.h>`

## ◆ CV_FINAL

#define CV_FINAL final

`#include <opencv2/core/cvdef.h>`

## ◆ CV_FOURCC_MACRO

#define CV_FOURCC_MACRO | ( |  | c1,
|  |  | c2,
|  |  | c3,
|  |  | c4 )

`#include <opencv2/core/cvdef.h>`

Value:
(((c1) & 255) + (((c2) & 255) << 8) + (((c3) & 255) << 16) + (((c4) & 255) << 24))

Macro to construct the fourcc code of the codec. Same as CV_FOURCC()

## ◆ CV_FP16_TYPE

#define CV_FP16_TYPE 0

`#include <opencv2/core/cvdef.h>`

## ◆ CV_HARDWARE_MAX_FEATURE

#define CV_HARDWARE_MAX_FEATURE 512

`#include <opencv2/core/cvdef.h>`

## ◆ CV_IMAX

#define CV_IMAX | ( |  | a,
|  |  | b )

`#include <opencv2/core/cvdef.h>`

Value:
((a) ^ (((a)^(b)) & (((a) > (b)) - 1)))

## ◆ CV_IMIN

#define CV_IMIN | ( |  | a,
|  |  | b )

`#include <opencv2/core/cvdef.h>`

Value:
((a) ^ (((a)^(b)) & (((a) < (b)) - 1)))

min & max without jumps

## ◆ CV_IN_OUT

#define CV_IN_OUT

`#include <opencv2/core/cvdef.h>`

## ◆ CV_IS_CONT_MAT

#define CV_IS_CONT_MAT CV_IS_MAT_CONT

`#include <opencv2/core/cvdef.h>`

## ◆ CV_IS_MAT_CONT

#define CV_IS_MAT_CONT | ( |  | flags | ) |

`#include <opencv2/core/cvdef.h>`

Value:
((flags) & CV_MAT_CONT_FLAG)
CV_MAT_CONT_FLAG
#define CV_MAT_CONT_FLAG
Definition cvdef.h:507

## ◆ CV_IS_SUBMAT

#define CV_IS_SUBMAT | ( |  | flags | ) |

`#include <opencv2/core/cvdef.h>`

Value:
((flags) & CV_MAT_SUBMAT_FLAG)

## ◆ CV_LOG2

#define CV_LOG2 0.69314718055994530941723212145818

`#include <opencv2/core/cvdef.h>`

## ◆ CV_MAT_CN

#define CV_MAT_CN | ( |  | flags | ) |

`#include <opencv2/core/cvdef.h>`

Value:
((((flags) & CV_MAT_CN_MASK) >> CV_CN_SHIFT) + 1)
CV_CN_SHIFT
#define CV_CN_SHIFT
Definition interface.h:73
CV_MAT_CN_MASK
#define CV_MAT_CN_MASK
Definition cvdef.h:502

## ◆ CV_MAT_CN_MASK

#define CV_MAT_CN_MASK ((CV_CN_MAX - 1) << CV_CN_SHIFT)

`#include <opencv2/core/cvdef.h>`

## ◆ CV_MAT_CONT_FLAG

#define CV_MAT_CONT_FLAG (1 << CV_MAT_CONT_FLAG_SHIFT)

`#include <opencv2/core/cvdef.h>`

## ◆ CV_MAT_CONT_FLAG_SHIFT

#define CV_MAT_CONT_FLAG_SHIFT 14

`#include <opencv2/core/cvdef.h>`

## ◆ CV_MAT_TYPE

#define CV_MAT_TYPE | ( |  | flags | ) |

`#include <opencv2/core/cvdef.h>`

Value:
((flags) & CV_MAT_TYPE_MASK)
CV_MAT_TYPE_MASK
#define CV_MAT_TYPE_MASK
Definition cvdef.h:504

## ◆ CV_MAT_TYPE_MASK

#define CV_MAT_TYPE_MASK (CV_DEPTH_MAX*CV_CN_MAX - 1)

`#include <opencv2/core/cvdef.h>`

## ◆ CV_MAX_DIM

#define CV_MAX_DIM 32

`#include <opencv2/core/cvdef.h>`

## ◆ CV_ND

#define CV_ND

`#include <opencv2/core/cvdef.h>`

## ◆ CV_NODISCARD_STD

#define CV_NODISCARD_STD /* nothing by default */

`#include <opencv2/core/cvdef.h>`

## ◆ CV_NOEXCEPT

#define CV_NOEXCEPT noexcept

`#include <opencv2/core/cvdef.h>`

## ◆ CV_OUT

#define CV_OUT

`#include <opencv2/core/cvdef.h>`

## ◆ CV_OVERRIDE

#define CV_OVERRIDE override

`#include <opencv2/core/cvdef.h>`

## ◆ CV_PI

#define CV_PI 3.1415926535897932384626433832795

`#include <opencv2/core/cvdef.h>`

Examples
  samples/cpp/cout_mat.cpp, samples/cpp/image_alignment.cpp, samples/cpp/snippets/kalman.cpp, samples/cpp/tutorial_code/ImgTrans/houghlines.cpp, samples/cpp/tutorial_code/core/file_input_output/file_input_output.cpp, and samples/cpp/tutorial_code/ml/introduction_to_pca/introduction_to_pca.cpp.

## ◆ CV_PROP

#define CV_PROP

`#include <opencv2/core/cvdef.h>`

## ◆ CV_PROP_RW

#define CV_PROP_RW

`#include <opencv2/core/cvdef.h>`

## ◆ CV_SIGN

#define CV_SIGN | ( |  | a | ) |

`#include <opencv2/core/cvdef.h>`

Value:
CV_CMP((a),0)
CV_CMP
#define CV_CMP(a, b)
Definition cvdef.h:538

## ◆ CV_STDCALL

#define CV_STDCALL

`#include <opencv2/core/cvdef.h>`

## ◆ CV_STRONG_ALIGNMENT

#define CV_STRONG_ALIGNMENT 0

`#include <opencv2/core/cvdef.h>`

## ◆ CV_SUBMAT_FLAG

#define CV_SUBMAT_FLAG (1 << CV_SUBMAT_FLAG_SHIFT)

`#include <opencv2/core/cvdef.h>`

## ◆ CV_SUBMAT_FLAG_SHIFT

#define CV_SUBMAT_FLAG_SHIFT 15

`#include <opencv2/core/cvdef.h>`

## ◆ CV_SWAP

#define CV_SWAP | ( |  | a,
|  |  | b,
|  |  | t )

`#include <opencv2/core/cvdef.h>`

Value:
((t) = (a), (a) = (b), (b) = (t))

## ◆ CV_WRAP

#define CV_WRAP

`#include <opencv2/core/cvdef.h>`

## ◆ CV_WRAP_AS

#define CV_WRAP_AS | ( |  | synonym | ) |

`#include <opencv2/core/cvdef.h>`

## ◆ CV_WRAP_DEFAULT

#define CV_WRAP_DEFAULT | ( |  | val | ) |

`#include <opencv2/core/cvdef.h>`

## ◆ CV_WRAP_FILE_PATH

#define CV_WRAP_FILE_PATH

`#include <opencv2/core/cvdef.h>`

## ◆ CV_WRAP_MAPPABLE

#define CV_WRAP_MAPPABLE | ( |  | mappable | ) |

`#include <opencv2/core/cvdef.h>`

## ◆ CV_WRAP_PHANTOM

#define CV_WRAP_PHANTOM | ( |  | phantom_header | ) |

`#include <opencv2/core/cvdef.h>`

## ◆ MAX

#define MAX | ( |  | a,
|  |  | b )

`#include <opencv2/core/cvdef.h>`

Value:
((a) < (b) ? (b) : (a))

Examples
  samples/cpp/snippets/camshiftdemo.cpp, and samples/cpp/tutorial_code/ImgProc/basic_drawing/Drawing_2.cpp.

## ◆ MIN

#define MIN | ( |  | a,
|  |  | b )

`#include <opencv2/core/cvdef.h>`

Value:
((a) > (b) ? (b) : (a))

Examples
  samples/cpp/snippets/camshiftdemo.cpp, and samples/cpp/snippets/kmeans.cpp.

## ◆ OPENCV_ABI_COMPATIBILITY

#define OPENCV_ABI_COMPATIBILITY 500

`#include <opencv2/core/cvdef.h>`

## Typedef Documentation

## ◆ AutoLock

typedef std::lock_guard<cv::Mutex> cv::AutoLock

`#include <opencv2/core/utility.hpp>`

## ◆ ErrorCallback

typedef int(* cv::ErrorCallback) (int status, const char *func_name, const char *err_msg, const char *file_name, int line, void *userdata)

`#include <opencv2/core/utility.hpp>`

## ◆ HammingLUT

typedef Hamming cv::HammingLUT

`#include <opencv2/core/base.hpp>`

## ◆ Mutex

typedef std::recursive_mutex cv::Mutex

`#include <opencv2/core/utility.hpp>`

## Enumeration Type Documentation

## ◆ AlgorithmHint

enum cv::AlgorithmHint

`#include <opencv2/core/utility.hpp>`

Flags that allow to modify some functions' behavior. Used as set of flags.

Enumerator
ALGO_HINT_DEFAULT Python: cv.ALGO_HINT_DEFAULT | Default algorithm behaviour defined during OpenCV build.
ALGO_HINT_ACCURATE Python: cv.ALGO_HINT_ACCURATE | Use generic portable implementation.
ALGO_HINT_APPROX Python: cv.ALGO_HINT_APPROX | Allow alternative approximations to get faster implementation. Behaviour and result depends on a platform.

## ◆ CpuFeatures

enum CpuFeatures

`#include <opencv2/core/cvdef.h>`

Available CPU features.

Enumerator
CPU_MMX |
CPU_SSE |
CPU_SSE2 |
CPU_SSE3 |
CPU_SSSE3 |
CPU_SSE4_1 |
CPU_SSE4_2 |
CPU_POPCNT |
CPU_FP16 |
CPU_AVX |
CPU_AVX2 |
CPU_FMA3 |
CPU_AVX_512F |
CPU_AVX_512BW |
CPU_AVX_512CD |
CPU_AVX_512DQ |
CPU_AVX_512ER |
CPU_AVX_512IFMA512 |
CPU_AVX_512IFMA |
CPU_AVX_512PF |
CPU_AVX_512VBMI |
CPU_AVX_512VL |
CPU_AVX_512VBMI2 |
CPU_AVX_512VNNI |
CPU_AVX_512BITALG |
CPU_AVX_512VPOPCNTDQ |
CPU_AVX_5124VNNIW |
CPU_AVX_5124FMAPS |
CPU_NEON |
CPU_NEON_DOTPROD |
CPU_NEON_FP16 |
CPU_NEON_BF16 |
CPU_MSA |
CPU_RISCVV |
CPU_VSX |
CPU_VSX3 |
CPU_RVV |
CPU_RVV_ZVFH |
CPU_LSX |
CPU_LASX |
CPU_AVX512_SKX | Skylake-X with AVX-512F/CD/BW/DQ/VL.
CPU_AVX512_COMMON | Common instructions AVX-512F/CD for all CPUs that support AVX-512.
CPU_AVX512_KNL | Knights Landing with AVX-512F/CD/ER/PF.
CPU_AVX512_KNM | Knights Mill with AVX-512F/CD/ER/PF/4FMAPS/4VNNIW/VPOPCNTDQ.
CPU_AVX512_CNL | Cannon Lake with AVX-512F/CD/BW/DQ/VL/IFMA/VBMI.
CPU_AVX512_CLX | Cascade Lake with AVX-512F/CD/BW/DQ/VL/VNNI.
CPU_AVX512_ICL | Ice Lake with AVX-512F/CD/BW/DQ/VL/IFMA/VBMI/VNNI/VBMI2/BITALG/VPOPCNTDQ.
CPU_MAX_FEATURE |

## ◆ SortFlags

enum cv::SortFlags

`#include <opencv2/core.hpp>`

Enumerator
SORT_EVERY_ROW Python: cv.SORT_EVERY_ROW | each matrix row is sorted independently
SORT_EVERY_COLUMN Python: cv.SORT_EVERY_COLUMN | each matrix column is sorted independently; this flag and the previous one are mutually exclusive.
SORT_ASCENDING Python: cv.SORT_ASCENDING | each matrix row is sorted in the ascending order.
SORT_DESCENDING Python: cv.SORT_DESCENDING | each matrix row is sorted in the descending order; this flag and the previous one are also mutually exclusive.

## Function Documentation

## ◆ alignPtr()

template<typename _Tp >

static _Tp * cv::alignPtr | ( | _Tp * | ptr,
|  | int | n = (int)sizeof(_Tp) )
| inline static

`#include <opencv2/core/utility.hpp>`

Aligns a pointer to the specified number of bytes.

The function returns the aligned pointer of the same type as the input pointer:

\[\texttt{(_Tp*)(((size_t)ptr + n-1) & -n)}\]

Parameters

  ptr | Aligned pointer.
  n | Alignment size that must be a power of two.

## ◆ alignSize()

static size_t cv::alignSize | ( | size_t | sz,
|  | int | n )
| inline static

`#include <opencv2/core/utility.hpp>`

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.

## ◆ checkHardwareSupport()

bool cv::checkHardwareSupport | ( | int | feature | ) |

Python:
| cv.checkHardwareSupport( | feature | ) -> | retval

`#include <opencv2/core/utility.hpp>`

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

## ◆ Cholesky() [1/2]

bool cv::Cholesky | ( | double * | A,
|  | size_t | astep,
|  | int | m,
|  | double * | b,
|  | size_t | bstep,
|  | int | n )

`#include <opencv2/core/base.hpp>`

proxy for hal::Cholesky

## ◆ Cholesky() [2/2]

bool cv::Cholesky | ( | float * | A,
|  | size_t | astep,
|  | int | m,
|  | float * | b,
|  | size_t | bstep,
|  | int | n )

`#include <opencv2/core/base.hpp>`

proxy for hal::Cholesky

## ◆ cubeRoot() [1/2]

static double cv::cubeRoot | ( | double | val | ) |
| inline static

Python:
| cv.cubeRoot( | val | ) -> | retval

`#include <opencv2/core/base.hpp>`

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

cubeRoot with argument of `double` type calls `std::cbrt(double)`

## ◆ cubeRoot() [2/2]

float cv::cubeRoot | ( | float | val | ) |

Python:
| cv.cubeRoot( | val | ) -> | retval

`#include <opencv2/core/base.hpp>`

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.

## ◆ cv_abs() [1/11]

template<typename _Tp >

_Tp cv::cv_abs | ( | _Tp | x | ) |
| inline

`#include <opencv2/core/base.hpp>`

## ◆ cv_abs() [2/11]

float cv::cv_abs | ( | bfloat | x | ) |
| inline

`#include <opencv2/core/base.hpp>`

## ◆ cv_abs() [3/11]

float cv::cv_abs | ( | hfloat | x | ) |
| inline

`#include <opencv2/core/base.hpp>`

## ◆ cv_abs() [4/11]

unsigned cv::cv_abs | ( | int | x | ) |
| inline

`#include <opencv2/core/base.hpp>`

## ◆ cv_abs() [5/11]

uint64 cv::cv_abs | ( | int64 | x | ) |
| inline

`#include <opencv2/core/base.hpp>`

## ◆ cv_abs() [6/11]

int cv::cv_abs | ( | schar | x | ) |
| inline

`#include <opencv2/core/base.hpp>`

## ◆ cv_abs() [7/11]

int cv::cv_abs | ( | short | x | ) |
| inline

`#include <opencv2/core/base.hpp>`

## ◆ cv_abs() [8/11]

int cv::cv_abs | ( | uchar | x | ) |
| inline

`#include <opencv2/core/base.hpp>`

## ◆ cv_abs() [9/11]

uint64 cv::cv_abs | ( | uint64 | x | ) |
| inline

`#include <opencv2/core/base.hpp>`

## ◆ cv_abs() [10/11]

unsigned cv::cv_abs | ( | unsigned | x | ) |
| inline

`#include <opencv2/core/base.hpp>`

## ◆ cv_abs() [11/11]

int cv::cv_abs | ( | ushort | x | ) |
| inline

`#include <opencv2/core/base.hpp>`

## ◆ cv_absdiff() [1/10]

template<typename _Tp >

_Tp cv::cv_absdiff | ( | _Tp | x,
|  | _Tp | y )
| inline

`#include <opencv2/core/base.hpp>`

## ◆ cv_absdiff() [2/10]

float cv::cv_absdiff | ( | bfloat | x,
|  | bfloat | y )
| inline

`#include <opencv2/core/base.hpp>`

## ◆ cv_absdiff() [3/10]

float cv::cv_absdiff | ( | hfloat | x,
|  | hfloat | y )
| inline

`#include <opencv2/core/base.hpp>`

## ◆ cv_absdiff() [4/10]

unsigned cv::cv_absdiff | ( | int | x,
|  | int | y )
| inline

`#include <opencv2/core/base.hpp>`

## ◆ cv_absdiff() [5/10]

int cv::cv_absdiff | ( | schar | x,
|  | schar | y )
| inline

`#include <opencv2/core/base.hpp>`

## ◆ cv_absdiff() [6/10]

int cv::cv_absdiff | ( | short | x,
|  | short | y )
| inline

`#include <opencv2/core/base.hpp>`

## ◆ cv_absdiff() [7/10]

int cv::cv_absdiff | ( | uchar | x,
|  | uchar | y )
| inline

`#include <opencv2/core/base.hpp>`

## ◆ cv_absdiff() [8/10]

uint64 cv::cv_absdiff | ( | uint64 | x,
|  | uint64 | y )
| inline

`#include <opencv2/core/base.hpp>`

## ◆ cv_absdiff() [9/10]

unsigned cv::cv_absdiff | ( | unsigned | x,
|  | unsigned | y )
| inline

`#include <opencv2/core/base.hpp>`

## ◆ cv_absdiff() [10/10]

int cv::cv_absdiff | ( | ushort | x,
|  | ushort | y )
| inline

`#include <opencv2/core/base.hpp>`

## ◆ CV_FOURCC()

int CV_FOURCC | ( | char | c1,
|  | char | c2,
|  | char | c3,
|  | char | c4 )

`#include <opencv2/core/cvdef.h>`

Constructs the 'fourcc' code, used in video codecs and many other places. Simply call it with 4 chars like ‘CV_FOURCC('I’, 'Y', 'U', 'V')`.

## ◆ cvCeil() [1/3]

int cvCeil | ( | double | value | ) |

`#include <opencv2/core/fast_math.hpp>`

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.

## ◆ cvCeil() [2/3]

int cvCeil | ( | float | value | ) |

`#include <opencv2/core/fast_math.hpp>`

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

## ◆ cvCeil() [3/3]

int cvCeil | ( | int | value | ) |

`#include <opencv2/core/fast_math.hpp>`

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

## ◆ cvFloor() [1/3]

int cvFloor | ( | double | value | ) |

`#include <opencv2/core/fast_math.hpp>`

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.

Examples
  samples/dnn/object_detection.cpp.

## ◆ cvFloor() [2/3]

int cvFloor | ( | float | value | ) |

`#include <opencv2/core/fast_math.hpp>`

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

## ◆ cvFloor() [3/3]

int cvFloor | ( | int | value | ) |

`#include <opencv2/core/fast_math.hpp>`

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

## ◆ cvIsInf() [1/2]

int cvIsInf | ( | double | value | ) |

`#include <opencv2/core/fast_math.hpp>`

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.

## ◆ cvIsInf() [2/2]

int cvIsInf | ( | float | value | ) |

`#include <opencv2/core/fast_math.hpp>`

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

## ◆ cvIsNaN() [1/2]

int cvIsNaN | ( | double | value | ) |

`#include <opencv2/core/fast_math.hpp>`

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.

## ◆ cvIsNaN() [2/2]

int cvIsNaN | ( | float | value | ) |

`#include <opencv2/core/fast_math.hpp>`

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

## ◆ cvRound() [1/3]

int cvRound | ( | double | value | ) |

`#include <opencv2/core/fast_math.hpp>`

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.

Examples
  samples/cpp/demhist.cpp, samples/cpp/geometry.cpp, samples/cpp/snippets/distrans.cpp, samples/cpp/snippets/polar_transforms.cpp, samples/cpp/snippets/warpPerspective_demo.cpp, samples/cpp/stitching_detailed.cpp, samples/cpp/tutorial_code/ImgTrans/houghlines.cpp, samples/facedetect.cpp, and samples/peopledetect.cpp.

## ◆ cvRound() [2/3]

int cvRound | ( | float | value | ) |

`#include <opencv2/core/fast_math.hpp>`

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

## ◆ cvRound() [3/3]

int cvRound | ( | int | value | ) |

`#include <opencv2/core/fast_math.hpp>`

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

## ◆ divUp() [1/2]

static int cv::divUp | ( | int | a,
|  | unsigned int | b )
| inline static

`#include <opencv2/core/utility.hpp>`

Integer division with result round up.

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

See also
  alignSize

## ◆ divUp() [2/2]

static size_t cv::divUp | ( | size_t | a,
|  | unsigned int | b )
| inline static

`#include <opencv2/core/utility.hpp>`

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

## ◆ dumpBool()

static String cv::utils::dumpBool | ( | bool | argument | ) |
| inline static

Python:
| cv.utils.dumpBool( | argument | ) -> | retval

`#include <opencv2/core/bindings_utils.hpp>`

## ◆ dumpCString()

static String cv::utils::dumpCString | ( | const char * | argument | ) |
| inline static

Python:
| cv.utils.dumpCString( | argument | ) -> | retval

`#include <opencv2/core/bindings_utils.hpp>`

Here is the call graph for this function:

## ◆ dumpDouble()

static String cv::utils::dumpDouble | ( | double | argument | ) |
| inline static

Python:
| cv.utils.dumpDouble( | argument | ) -> | retval

`#include <opencv2/core/bindings_utils.hpp>`

Here is the call graph for this function:

## ◆ dumpFloat()

static String cv::utils::dumpFloat | ( | float | argument | ) |
| inline static

Python:
| cv.utils.dumpFloat( | argument | ) -> | retval

`#include <opencv2/core/bindings_utils.hpp>`

Here is the call graph for this function:

## ◆ dumpInputArray()

String cv::utils::dumpInputArray | ( | InputArray | argument | ) |

Python:
| cv.utils.dumpInputArray( | argument | ) -> | retval

`#include <opencv2/core/bindings_utils.hpp>`

## ◆ dumpInputArrayOfArrays()

String cv::utils::dumpInputArrayOfArrays | ( | InputArrayOfArrays | argument | ) |

Python:
| cv.utils.dumpInputArrayOfArrays( | argument | ) -> | retval

`#include <opencv2/core/bindings_utils.hpp>`

## ◆ dumpInputOutputArray()

String cv::utils::dumpInputOutputArray | ( | InputOutputArray | argument | ) |

Python:
| cv.utils.dumpInputOutputArray( | argument | ) -> | retval, argument

`#include <opencv2/core/bindings_utils.hpp>`

## ◆ dumpInputOutputArrayOfArrays()

String cv::utils::dumpInputOutputArrayOfArrays | ( | InputOutputArrayOfArrays | argument | ) |

Python:
| cv.utils.dumpInputOutputArrayOfArrays( | argument | ) -> | retval, argument

`#include <opencv2/core/bindings_utils.hpp>`

## ◆ dumpInt()

static String cv::utils::dumpInt | ( | int | argument | ) |
| inline static

Python:
| cv.utils.dumpInt( | argument | ) -> | retval

`#include <opencv2/core/bindings_utils.hpp>`

Here is the call graph for this function:

## ◆ dumpInt64()

static String cv::utils::dumpInt64 | ( | int64 | argument | ) |
| inline static

Python:
| cv.utils.dumpInt64( | argument | ) -> | retval

`#include <opencv2/core/bindings_utils.hpp>`

## ◆ dumpRange()

static String cv::utils::dumpRange | ( | const Range & | argument | ) |
| inline static

Python:
| cv.utils.dumpRange( | argument | ) -> | retval

`#include <opencv2/core/bindings_utils.hpp>`

Here is the call graph for this function:

## ◆ dumpRect()

static String cv::utils::dumpRect | ( | const Rect & | argument | ) |
| inline static

Python:
| cv.utils.dumpRect( | argument | ) -> | retval

`#include <opencv2/core/bindings_utils.hpp>`

Here is the call graph for this function:

## ◆ dumpRotatedRect()

static String cv::utils::dumpRotatedRect | ( | const RotatedRect & | argument | ) |
| inline static

Python:
| cv.utils.dumpRotatedRect( | argument | ) -> | retval

`#include <opencv2/core/bindings_utils.hpp>`

Here is the call graph for this function:

## ◆ dumpSizeT()

static String cv::utils::dumpSizeT | ( | size_t | argument | ) |
| inline static

Python:
| cv.utils.dumpSizeT( | argument | ) -> | retval

`#include <opencv2/core/bindings_utils.hpp>`

## ◆ dumpString()

static String cv::utils::dumpString | ( | const String & | argument | ) |
| inline static

Python:
| cv.utils.dumpString( | argument | ) -> | retval

`#include <opencv2/core/bindings_utils.hpp>`

Here is the call graph for this function:

## ◆ dumpTermCriteria()

static String cv::utils::dumpTermCriteria | ( | const TermCriteria & | argument | ) |
| inline static

Python:
| cv.utils.dumpTermCriteria( | argument | ) -> | retval

`#include <opencv2/core/bindings_utils.hpp>`

Here is the call graph for this function:

## ◆ dumpVectorOfDouble()

String cv::utils::dumpVectorOfDouble | ( | const std::vector< double > & | vec | ) |

Python:
| cv.utils.dumpVectorOfDouble( | vec | ) -> | retval

`#include <opencv2/core/bindings_utils.hpp>`

## ◆ dumpVectorOfInt()

String cv::utils::dumpVectorOfInt | ( | const std::vector< int > & | vec | ) |

Python:
| cv.utils.dumpVectorOfInt( | vec | ) -> | retval

`#include <opencv2/core/bindings_utils.hpp>`

## ◆ dumpVectorOfRect()

String cv::utils::dumpVectorOfRect | ( | const std::vector< Rect > & | vec | ) |

Python:
| cv.utils.dumpVectorOfRect( | vec | ) -> | retval

`#include <opencv2/core/bindings_utils.hpp>`

## ◆ error() [1/2]

void cv::error | ( | const Exception & | exc | ) |

`#include <opencv2/core/exception.hpp>`

Signals an error and raises the exception.

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

Parameters

  exc | the exception raisen.

Deprecated
  drop this version

## ◆ error() [2/2]

void cv::error | ( | Error::Code | code,
|  | const String & | err,
|  | const char * | func,
|  | const char * | file,
|  | int | line )

`#include <opencv2/core/exception.hpp>`

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

## ◆ fastAtan2()

float cv::fastAtan2 | ( | float | y,
|  | float | x )

Python:
| cv.fastAtan2( | y, x | ) -> | retval

`#include <opencv2/core/base.hpp>`

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.

## ◆ fastFree()

void cv::fastFree | ( | void * | ptr | ) |

`#include <opencv2/core/cvstd.hpp>`

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.

## ◆ fastMalloc()

void * cv::fastMalloc | ( | size_t | bufSize | ) |

`#include <opencv2/core/cvstd.hpp>`

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.

## ◆ forEach_impl()

template<typename _Tp , typename Functor >

void cv::Mat::forEach_impl | ( | const Functor & | operation | ) |
| inline protected

`#include <opencv2/core/mat.hpp>`

idx is modified in this->rowCall

Here is the call graph for this function:

## ◆ format()

String cv::format | ( | const char * | fmt,
|  |  | ... )

`#include <opencv2/core/operations.hpp>`

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`

## ◆ getBuildInformation()

const String & cv::getBuildInformation | ( |  | ) |

Python:
| cv.getBuildInformation( |  | ) -> | retval

`#include <opencv2/core/utility.hpp>`

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.

## ◆ getCPUFeaturesLine()

std::string cv::getCPUFeaturesLine | ( |  | ) |

Python:
| cv.getCPUFeaturesLine( |  | ) -> | retval

`#include <opencv2/core/utility.hpp>`

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?`

## ◆ getCPUTickCount()

int64 cv::getCPUTickCount | ( |  | ) |

Python:
| cv.getCPUTickCount( |  | ) -> | retval

`#include <opencv2/core/utility.hpp>`

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.

## ◆ getDefaultAlgorithmHint()

AlgorithmHint cv::getDefaultAlgorithmHint | ( |  | ) |

Python:
| cv.getDefaultAlgorithmHint( |  | ) -> | retval

`#include <opencv2/core/utility.hpp>`

Returns AlgorithmHint defined during OpenCV compilation. Defines ALGO_HINT_DEFAULT behavior.

## ◆ getElemSize()

static size_t cv::getElemSize | ( | int | type | ) |
| inline static

`#include <opencv2/core/utility.hpp>`

## ◆ getHardwareFeatureName()

String cv::getHardwareFeatureName | ( | int | feature | ) |

Python:
| cv.getHardwareFeatureName( | feature | ) -> | retval

`#include <opencv2/core/utility.hpp>`

Returns feature name by ID.

Returns empty string if feature is not defined

## ◆ getNumberOfCPUs()

int cv::getNumberOfCPUs | ( |  | ) |

Python:
| cv.getNumberOfCPUs( |  | ) -> | retval

`#include <opencv2/core/utility.hpp>`

Returns the number of logical CPUs available for the process.

## ◆ getNumThreads()

int cv::getNumThreads | ( |  | ) |

Python:
| cv.getNumThreads( |  | ) -> | retval

`#include <opencv2/core/utility.hpp>`

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

int cv::getThreadNum | ( |  | ) |

Python:
| cv.getThreadNum( |  | ) -> | retval

`#include <opencv2/core/utility.hpp>`

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

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.
  See also
    setNumThreads, getNumThreads

## ◆ getTickCount()

int64 cv::getTickCount | ( |  | ) |

Python:
| cv.getTickCount( |  | ) -> | retval

`#include <opencv2/core/utility.hpp>`

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

double cv::getTickFrequency | ( |  | ) |

Python:
| cv.getTickFrequency( |  | ) -> | retval

`#include <opencv2/core/utility.hpp>`

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();
cv::getTickFrequency
double getTickFrequency()
Returns the number of ticks per second.
cv::getTickCount
int64 getTickCount()
Returns the number of ticks.

See also
  getTickCount, TickMeter

## ◆ getVersionMajor()

int cv::getVersionMajor | ( |  | ) |

Python:
| cv.getVersionMajor( |  | ) -> | retval

`#include <opencv2/core/utility.hpp>`

Returns major library version.

## ◆ getVersionMinor()

int cv::getVersionMinor | ( |  | ) |

Python:
| cv.getVersionMinor( |  | ) -> | retval

`#include <opencv2/core/utility.hpp>`

Returns minor library version.

## ◆ getVersionRevision()

int cv::getVersionRevision | ( |  | ) |

Python:
| cv.getVersionRevision( |  | ) -> | retval

`#include <opencv2/core/utility.hpp>`

Returns revision field of the library version.

## ◆ getVersionString()

String cv::getVersionString | ( |  | ) |

Python:
| cv.getVersionString( |  | ) -> | retval

`#include <opencv2/core/utility.hpp>`

Returns library version string.

For example "3.4.1-dev".

See also
  getMajorVersion, getMinorVersion, getRevisionVersion

## ◆ glob()

void cv::glob | ( | String | pattern,
|  | std::vector< String > & | result,
|  | bool | recursive = false )

`#include <opencv2/core/utility.hpp>`

Searches for files matching the specified pattern in a directory.

This function searches for files that match a given pattern (e.g., `*.jpg`) in the specified directory. The search can be limited to the directory itself or be recursive, including subdirectories.

Parameters

  pattern | The file search pattern, which can include wildcards like `*` (for matching multiple characters) or `?` (for matching a single character).
  result | Output vector where the file paths matching the search pattern will be stored.
  recursive | (optional) Boolean flag indicating whether to search subdirectories recursively. If true, the search will include all subdirectories. The default value is `false`.

## ◆ isAligned() [1/5]

template<int N, typename T >

static bool cv::isAligned | ( | const T & | data | ) |
| inline static

`#include <opencv2/core/utility.hpp>`

Alignment check of passed values.

Usage: `isAligned<sizeof(int)>(...)`

Note
  Alignment(N) must be a power of 2 (2**k, 2^k)

## ◆ isAligned() [2/5]

template<int N>

static bool cv::isAligned | ( | const void * | p1 | ) |
| inline static

`#include <opencv2/core/utility.hpp>`

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

Here is the call graph for this function:

## ◆ isAligned() [3/5]

template<int N>

static bool cv::isAligned | ( | const void * | p1,
|  | const void * | p2 )
| inline static

`#include <opencv2/core/utility.hpp>`

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

Here is the call graph for this function:

## ◆ isAligned() [4/5]

template<int N>

static bool cv::isAligned | ( | const void * | p1,
|  | const void * | p2,
|  | const void * | p3 )
| inline static

`#include <opencv2/core/utility.hpp>`

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

Here is the call graph for this function:

## ◆ isAligned() [5/5]

template<int N>

static bool cv::isAligned | ( | const void * | p1,
|  | const void * | p2,
|  | const void * | p3,
|  | const void * | p4 )
| inline static

`#include <opencv2/core/utility.hpp>`

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

Here is the call graph for this function:

## ◆ LU() [1/2]

int cv::LU | ( | double * | A,
|  | size_t | astep,
|  | int | m,
|  | double * | b,
|  | size_t | bstep,
|  | int | n )

`#include <opencv2/core/base.hpp>`

proxy for hal::LU

## ◆ LU() [2/2]

int cv::LU | ( | float * | A,
|  | size_t | astep,
|  | int | m,
|  | float * | b,
|  | size_t | bstep,
|  | int | n )

`#include <opencv2/core/base.hpp>`

proxy for hal::LU

## ◆ normInf() [1/2]

template<typename _Tp , typename _AccTp >

static _AccTp cv::normInf | ( | const _Tp * | a,
|  | const _Tp * | b,
|  | int | n )
| inline static

`#include <opencv2/core/base.hpp>`

Here is the call graph for this function:

## ◆ normInf() [2/2]

template<typename _Tp , typename _AccTp >

static _AccTp cv::normInf | ( | const _Tp * | a,
|  | int | n )
| inline static

`#include <opencv2/core/base.hpp>`

Here is the call graph for this function:

## ◆ normL1() [1/2]

template<typename _Tp , typename _AccTp >

static _AccTp cv::normL1 | ( | const _Tp * | a,
|  | const _Tp * | b,
|  | int | n )
| inline static

`#include <opencv2/core/base.hpp>`

Here is the call graph for this function:

## ◆ normL1() [2/2]

template<typename _Tp , typename _AccTp >

static _AccTp cv::normL1 | ( | const _Tp * | a,
|  | int | n )
| inline static

`#include <opencv2/core/base.hpp>`

Here is the call graph for this function:

## ◆ normL2Sqr() [1/2]

template<typename _Tp , typename _AccTp >

static _AccTp cv::normL2Sqr | ( | const _Tp * | a,
|  | const _Tp * | b,
|  | int | n )
| inline static

`#include <opencv2/core/base.hpp>`

## ◆ normL2Sqr() [2/2]

template<typename _Tp , typename _AccTp >

static _AccTp cv::normL2Sqr | ( | const _Tp * | a,
|  | int | n )
| inline static

`#include <opencv2/core/base.hpp>`

## ◆ operator<<()

static std::ostream & cv::operator<< | ( | std::ostream & | out,
|  | const TickMeter & | tm )
| inline static

`#include <opencv2/core/utility.hpp>`

output operator

TickMeter tm;
tm.start();
// do something ...
tm.stop();
std::cout << tm;
cv::TickMeter
a Class to measure passing time.
Definition utility.hpp:326
cv::TickMeter::start
void start()
starts counting ticks.
Definition utility.hpp:335
cv::TickMeter::stop
void stop()
stops counting ticks.
Definition utility.hpp:341
Here is the call graph for this function:

## ◆ redirectError()

ErrorCallback cv::redirectError | ( | ErrorCallback | errCallback,
|  | void * | userdata = 0,
|  | void ** | prevUserdata = 0 )

`#include <opencv2/core/utility.hpp>`

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

## ◆ roundUp() [1/2]

static int cv::roundUp | ( | int | a,
|  | unsigned int | b )
| inline static

`#include <opencv2/core/utility.hpp>`

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() [2/2]

static size_t cv::roundUp | ( | size_t | a,
|  | unsigned int | b )
| inline static

`#include <opencv2/core/utility.hpp>`

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

## ◆ saturate_cast() [1/13]

template<typename _Tp >

static _Tp cv::saturate_cast | ( | bfloat | v | ) |
| inline static

`#include <opencv2/core/saturate.hpp>`

Here is the call graph for this function:

## ◆ saturate_cast() [2/13]

template<typename _Tp >

static _Tp cv::saturate_cast | ( | bool | v | ) |
| inline static

`#include <opencv2/core/saturate.hpp>`

Here is the call graph for this function:

## ◆ saturate_cast() [3/13]

template<typename _Tp >

static _Tp cv::saturate_cast | ( | double | v | ) |
| inline static

`#include <opencv2/core/saturate.hpp>`

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

## ◆ saturate_cast() [4/13]

template<typename _Tp >

static _Tp cv::saturate_cast | ( | float | v | ) |
| inline static

`#include <opencv2/core/saturate.hpp>`

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

## ◆ saturate_cast() [5/13]

template<typename _Tp >

static _Tp cv::saturate_cast | ( | hfloat | v | ) |
| inline static

`#include <opencv2/core/saturate.hpp>`

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

Here is the call graph for this function:

## ◆ saturate_cast() [6/13]

template<typename _Tp >

static _Tp cv::saturate_cast | ( | int | v | ) |
| inline static

`#include <opencv2/core/saturate.hpp>`

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

## ◆ saturate_cast() [7/13]

template<typename _Tp >

static _Tp cv::saturate_cast | ( | int64 | v | ) |
| inline static

`#include <opencv2/core/saturate.hpp>`

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

## ◆ saturate_cast() [8/13]

template<typename _Tp >

static _Tp cv::saturate_cast | ( | schar | v | ) |
| inline static

`#include <opencv2/core/saturate.hpp>`

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

## ◆ saturate_cast() [9/13]

template<typename _Tp >

static _Tp cv::saturate_cast | ( | short | v | ) |
| inline static

`#include <opencv2/core/saturate.hpp>`

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

## ◆ saturate_cast() [10/13]

template<typename _Tp >

static _Tp cv::saturate_cast | ( | uchar | v | ) |
| inline static

`#include <opencv2/core/saturate.hpp>`

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<T>() 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)
uchar
unsigned char uchar
Definition interface.h:51
cv::saturate_cast< uchar >
uchar saturate_cast< uchar >(schar v)
Definition saturate.hpp:101
cv::saturate_cast< short >
short saturate_cast< short >(ushort v)
Definition saturate.hpp:130

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

## ◆ saturate_cast() [11/13]

template<typename _Tp >

static _Tp cv::saturate_cast | ( | uint64 | v | ) |
| inline static

`#include <opencv2/core/saturate.hpp>`

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

## ◆ saturate_cast() [12/13]

template<typename _Tp >

static _Tp cv::saturate_cast | ( | unsigned | v | ) |
| inline static

`#include <opencv2/core/saturate.hpp>`

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

## ◆ saturate_cast() [13/13]

template<typename _Tp >

static _Tp cv::saturate_cast | ( | ushort | v | ) |
| inline static

`#include <opencv2/core/saturate.hpp>`

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

## ◆ saturate_cast< bfloat >() [1/12]

template<>

bfloat cv::saturate_cast< bfloat > | ( | bfloat | v | ) |
| inline

`#include <opencv2/core/saturate.hpp>`

## ◆ saturate_cast< bfloat >() [2/12]

template<>

bfloat cv::saturate_cast< bfloat > | ( | double | v | ) |
| inline

`#include <opencv2/core/saturate.hpp>`

## ◆ saturate_cast< bfloat >() [3/12]

template<>

bfloat cv::saturate_cast< bfloat > | ( | float | v | ) |
| inline

`#include <opencv2/core/saturate.hpp>`

## ◆ saturate_cast< bfloat >() [4/12]

template<>

bfloat cv::saturate_cast< bfloat > | ( | hfloat | v | ) |
| inline

`#include <opencv2/core/saturate.hpp>`

## ◆ saturate_cast< bfloat >() [5/12]

template<>

bfloat cv::saturate_cast< bfloat > | ( | int | v | ) |
| inline

`#include <opencv2/core/saturate.hpp>`

## ◆ saturate_cast< bfloat >() [6/12]

template<>

bfloat cv::saturate_cast< bfloat > | ( | int64 | v | ) |
| inline

`#include <opencv2/core/saturate.hpp>`

## ◆ saturate_cast< bfloat >() [7/12]

template<>

bfloat cv::saturate_cast< bfloat > | ( | schar | v | ) |
| inline

`#include <opencv2/core/saturate.hpp>`

## ◆ saturate_cast< bfloat >() [8/12]

template<>

bfloat cv::saturate_cast< bfloat > | ( | short | v | ) |
| inline

`#include <opencv2/core/saturate.hpp>`

## ◆ saturate_cast< bfloat >() [9/12]

template<>

bfloat cv::saturate_cast< bfloat > | ( | uchar | v | ) |
| inline

`#include <opencv2/core/saturate.hpp>`

## ◆ saturate_cast< bfloat >() [10/12]

template<>

bfloat cv::saturate_cast< bfloat > | ( | uint64 | v | ) |
| inline

`#include <opencv2/core/saturate.hpp>`

## ◆ saturate_cast< bfloat >() [11/12]

template<>

bfloat cv::saturate_cast< bfloat > | ( | unsigned | v | ) |
| inline

`#include <opencv2/core/saturate.hpp>`

## ◆ saturate_cast< bfloat >() [12/12]

template<>

bfloat cv::saturate_cast< bfloat > | ( | ushort | v | ) |
| inline

`#include <opencv2/core/saturate.hpp>`

## ◆ saturate_cast< bool >() [1/12]

template<>

bool cv::saturate_cast< bool > | ( | bfloat | v | ) |
| inline

`#include <opencv2/core/saturate.hpp>`

## ◆ saturate_cast< bool >() [2/12]

template<>

bool cv::saturate_cast< bool > | ( | double | v | ) |
| inline

`#include <opencv2/core/saturate.hpp>`

## ◆ saturate_cast< bool >() [3/12]

template<>

bool cv::saturate_cast< bool > | ( | float | v | ) |
| inline

`#include <opencv2/core/saturate.hpp>`

## ◆ saturate_cast< bool >() [4/12]

template<>

bool cv::saturate_cast< bool > | ( | hfloat | v | ) |
| inline

`#include <opencv2/core/saturate.hpp>`

## ◆ saturate_cast< bool >() [5/12]

template<>

bool cv::saturate_cast< bool > | ( | int | v | ) |
| inline

`#include <opencv2/core/saturate.hpp>`

## ◆ saturate_cast< bool >() [6/12]

template<>

bool cv::saturate_cast< bool > | ( | int64_t | v | ) |
| inline

`#include <opencv2/core/saturate.hpp>`

## ◆ saturate_cast< bool >() [7/12]

template<>

bool cv::saturate_cast< bool > | ( | schar | v | ) |
| inline

`#include <opencv2/core/saturate.hpp>`

## ◆ saturate_cast< bool >() [8/12]

template<>

bool cv::saturate_cast< bool > | ( | short | v | ) |
| inline

`#include <opencv2/core/saturate.hpp>`

## ◆ saturate_cast< bool >() [9/12]

template<>

bool cv::saturate_cast< bool > | ( | uchar | v | ) |
| inline

`#include <opencv2/core/saturate.hpp>`

## ◆ saturate_cast< bool >() [10/12]

template<>

bool cv::saturate_cast< bool > | ( | uint64_t | v | ) |
| inline

`#include <opencv2/core/saturate.hpp>`

## ◆ saturate_cast< bool >() [11/12]

template<>

bool cv::saturate_cast< bool > | ( | unsigned | v | ) |
| inline

`#include <opencv2/core/saturate.hpp>`

## ◆ saturate_cast< bool >() [12/12]

template<>

bool cv::saturate_cast< bool > | ( | ushort | v | ) |
| inline

`#include <opencv2/core/saturate.hpp>`

## ◆ saturate_cast< hfloat >() [1/12]

template<>

hfloat cv::saturate_cast< hfloat > | ( | bfloat | v | ) |
| inline

`#include <opencv2/core/saturate.hpp>`

## ◆ saturate_cast< hfloat >() [2/12]

template<>

hfloat cv::saturate_cast< hfloat > | ( | double | v | ) |
| inline

`#include <opencv2/core/saturate.hpp>`

## ◆ saturate_cast< hfloat >() [3/12]

template<>

hfloat cv::saturate_cast< hfloat > | ( | float | v | ) |
| inline

`#include <opencv2/core/saturate.hpp>`

## ◆ saturate_cast< hfloat >() [4/12]

template<>

hfloat cv::saturate_cast< hfloat > | ( | hfloat | v | ) |
| inline

`#include <opencv2/core/saturate.hpp>`

## ◆ saturate_cast< hfloat >() [5/12]

template<>

hfloat cv::saturate_cast< hfloat > | ( | int | v | ) |
| inline

`#include <opencv2/core/saturate.hpp>`

## ◆ saturate_cast< hfloat >() [6/12]

template<>

hfloat cv::saturate_cast< hfloat > | ( | int64 | v | ) |
| inline

`#include <opencv2/core/saturate.hpp>`

## ◆ saturate_cast< hfloat >() [7/12]

template<>

hfloat cv::saturate_cast< hfloat > | ( | schar | v | ) |
| inline

`#include <opencv2/core/saturate.hpp>`

## ◆ saturate_cast< hfloat >() [8/12]

template<>

hfloat cv::saturate_cast< hfloat > | ( | short | v | ) |
| inline

`#include <opencv2/core/saturate.hpp>`

## ◆ saturate_cast< hfloat >() [9/12]

template<>

hfloat cv::saturate_cast< hfloat > | ( | uchar | v | ) |
| inline

`#include <opencv2/core/saturate.hpp>`

## ◆ saturate_cast< hfloat >() [10/12]

template<>

hfloat cv::saturate_cast< hfloat > | ( | uint64 | v | ) |
| inline

`#include <opencv2/core/saturate.hpp>`

## ◆ saturate_cast< hfloat >() [11/12]

template<>

hfloat cv::saturate_cast< hfloat > | ( | unsigned | v | ) |
| inline

`#include <opencv2/core/saturate.hpp>`

## ◆ saturate_cast< hfloat >() [12/12]

template<>

hfloat cv::saturate_cast< hfloat > | ( | ushort | v | ) |
| inline

`#include <opencv2/core/saturate.hpp>`

## ◆ saturate_cast< int64 >() [1/3]

template<>

int64 cv::saturate_cast< int64 > | ( | double | v | ) |
| inline

`#include <opencv2/core/saturate.hpp>`

## ◆ saturate_cast< int64 >() [2/3]

template<>

int64 cv::saturate_cast< int64 > | ( | float | v | ) |
| inline

`#include <opencv2/core/saturate.hpp>`

## ◆ saturate_cast< int64 >() [3/3]

template<>

int64 cv::saturate_cast< int64 > | ( | uint64 | v | ) |
| inline

`#include <opencv2/core/saturate.hpp>`

## ◆ saturate_cast< schar >() [1/9]

template<>

schar cv::saturate_cast< schar > | ( | double | v | ) |
| inline

`#include <opencv2/core/saturate.hpp>`

Here is the call graph for this function:

## ◆ saturate_cast< schar >() [2/9]

template<>

schar cv::saturate_cast< schar > | ( | float | v | ) |
| inline

`#include <opencv2/core/saturate.hpp>`

Here is the call graph for this function:

## ◆ saturate_cast< schar >() [3/9]

template<>

schar cv::saturate_cast< schar > | ( | int | v | ) |
| inline

`#include <opencv2/core/saturate.hpp>`

## ◆ saturate_cast< schar >() [4/9]

template<>

schar cv::saturate_cast< schar > | ( | int64 | v | ) |
| inline

`#include <opencv2/core/saturate.hpp>`

## ◆ saturate_cast< schar >() [5/9]

template<>

schar cv::saturate_cast< schar > | ( | short | v | ) |
| inline

`#include <opencv2/core/saturate.hpp>`

Here is the call graph for this function:

## ◆ saturate_cast< schar >() [6/9]

template<>

schar cv::saturate_cast< schar > | ( | uchar | v | ) |
| inline

`#include <opencv2/core/saturate.hpp>`

## ◆ saturate_cast< schar >() [7/9]

template<>

schar cv::saturate_cast< schar > | ( | uint64 | v | ) |
| inline

`#include <opencv2/core/saturate.hpp>`

## ◆ saturate_cast< schar >() [8/9]

template<>

schar cv::saturate_cast< schar > | ( | unsigned | v | ) |
| inline

`#include <opencv2/core/saturate.hpp>`

## ◆ saturate_cast< schar >() [9/9]

template<>

schar cv::saturate_cast< schar > | ( | ushort | v | ) |
| inline

`#include <opencv2/core/saturate.hpp>`

## ◆ saturate_cast< short >() [1/7]

template<>

short cv::saturate_cast< short > | ( | double | v | ) |
| inline

`#include <opencv2/core/saturate.hpp>`

Here is the call graph for this function:

## ◆ saturate_cast< short >() [2/7]

template<>

short cv::saturate_cast< short > | ( | float | v | ) |
| inline

`#include <opencv2/core/saturate.hpp>`

Here is the call graph for this function:

## ◆ saturate_cast< short >() [3/7]

template<>

short cv::saturate_cast< short > | ( | int | v | ) |
| inline

`#include <opencv2/core/saturate.hpp>`

## ◆ saturate_cast< short >() [4/7]

template<>

short cv::saturate_cast< short > | ( | int64 | v | ) |
| inline

`#include <opencv2/core/saturate.hpp>`

## ◆ saturate_cast< short >() [5/7]

template<>

short cv::saturate_cast< short > | ( | uint64 | v | ) |
| inline

`#include <opencv2/core/saturate.hpp>`

## ◆ saturate_cast< short >() [6/7]

template<>

short cv::saturate_cast< short > | ( | unsigned | v | ) |
| inline

`#include <opencv2/core/saturate.hpp>`

## ◆ saturate_cast< short >() [7/7]

template<>

short cv::saturate_cast< short > | ( | ushort | v | ) |
| inline

`#include <opencv2/core/saturate.hpp>`

## ◆ saturate_cast< uchar >() [1/9]

template<>

uchar cv::saturate_cast< uchar > | ( | double | v | ) |
| inline

`#include <opencv2/core/saturate.hpp>`

Here is the call graph for this function:

## ◆ saturate_cast< uchar >() [2/9]

template<>

uchar cv::saturate_cast< uchar > | ( | float | v | ) |
| inline

`#include <opencv2/core/saturate.hpp>`

Here is the call graph for this function:

## ◆ saturate_cast< uchar >() [3/9]

template<>

uchar cv::saturate_cast< uchar > | ( | int | v | ) |
| inline

`#include <opencv2/core/saturate.hpp>`

## ◆ saturate_cast< uchar >() [4/9]

template<>

uchar cv::saturate_cast< uchar > | ( | int64 | v | ) |
| inline

`#include <opencv2/core/saturate.hpp>`

## ◆ saturate_cast< uchar >() [5/9]

template<>

uchar cv::saturate_cast< uchar > | ( | schar | v | ) |
| inline

`#include <opencv2/core/saturate.hpp>`

## ◆ saturate_cast< uchar >() [6/9]

template<>

uchar cv::saturate_cast< uchar > | ( | short | v | ) |
| inline

`#include <opencv2/core/saturate.hpp>`

Here is the call graph for this function:

## ◆ saturate_cast< uchar >() [7/9]

template<>

uchar cv::saturate_cast< uchar > | ( | uint64 | v | ) |
| inline

`#include <opencv2/core/saturate.hpp>`

## ◆ saturate_cast< uchar >() [8/9]

template<>

uchar cv::saturate_cast< uchar > | ( | unsigned | v | ) |
| inline

`#include <opencv2/core/saturate.hpp>`

## ◆ saturate_cast< uchar >() [9/9]

template<>

uchar cv::saturate_cast< uchar > | ( | ushort | v | ) |
| inline

`#include <opencv2/core/saturate.hpp>`

## ◆ saturate_cast< uint64 >() [1/6]

template<>

uint64 cv::saturate_cast< uint64 > | ( | double | v | ) |
| inline

`#include <opencv2/core/saturate.hpp>`

## ◆ saturate_cast< uint64 >() [2/6]

template<>

uint64 cv::saturate_cast< uint64 > | ( | float | v | ) |
| inline

`#include <opencv2/core/saturate.hpp>`

## ◆ saturate_cast< uint64 >() [3/6]

template<>

uint64 cv::saturate_cast< uint64 > | ( | int | v | ) |
| inline

`#include <opencv2/core/saturate.hpp>`

## ◆ saturate_cast< uint64 >() [4/6]

template<>

uint64 cv::saturate_cast< uint64 > | ( | int64 | v | ) |
| inline

`#include <opencv2/core/saturate.hpp>`

## ◆ saturate_cast< uint64 >() [5/6]

template<>

uint64 cv::saturate_cast< uint64 > | ( | schar | v | ) |
| inline

`#include <opencv2/core/saturate.hpp>`

## ◆ saturate_cast< uint64 >() [6/6]

template<>

uint64 cv::saturate_cast< uint64 > | ( | short | v | ) |
| inline

`#include <opencv2/core/saturate.hpp>`

## ◆ saturate_cast< unsigned >() [1/7]

template<>

unsigned cv::saturate_cast< unsigned > | ( | double | v | ) |
| inline

`#include <opencv2/core/saturate.hpp>`

## ◆ saturate_cast< unsigned >() [2/7]

template<>

unsigned cv::saturate_cast< unsigned > | ( | float | v | ) |
| inline

`#include <opencv2/core/saturate.hpp>`

## ◆ saturate_cast< unsigned >() [3/7]

template<>

unsigned cv::saturate_cast< unsigned > | ( | int | v | ) |
| inline

`#include <opencv2/core/saturate.hpp>`

## ◆ saturate_cast< unsigned >() [4/7]

template<>

unsigned cv::saturate_cast< unsigned > | ( | int64 | v | ) |
| inline

`#include <opencv2/core/saturate.hpp>`

## ◆ saturate_cast< unsigned >() [5/7]

template<>

unsigned cv::saturate_cast< unsigned > | ( | schar | v | ) |
| inline

`#include <opencv2/core/saturate.hpp>`

## ◆ saturate_cast< unsigned >() [6/7]

template<>

unsigned cv::saturate_cast< unsigned > | ( | short | v | ) |
| inline

`#include <opencv2/core/saturate.hpp>`

## ◆ saturate_cast< unsigned >() [7/7]

template<>

unsigned cv::saturate_cast< unsigned > | ( | uint64 | v | ) |
| inline

`#include <opencv2/core/saturate.hpp>`

## ◆ saturate_cast< ushort >() [1/8]

template<>

ushort cv::saturate_cast< ushort > | ( | double | v | ) |
| inline

`#include <opencv2/core/saturate.hpp>`

Here is the call graph for this function:

## ◆ saturate_cast< ushort >() [2/8]

template<>

ushort cv::saturate_cast< ushort > | ( | float | v | ) |
| inline

`#include <opencv2/core/saturate.hpp>`

Here is the call graph for this function:

## ◆ saturate_cast< ushort >() [3/8]

template<>

ushort cv::saturate_cast< ushort > | ( | int | v | ) |
| inline

`#include <opencv2/core/saturate.hpp>`

## ◆ saturate_cast< ushort >() [4/8]

template<>

ushort cv::saturate_cast< ushort > | ( | int64 | v | ) |
| inline

`#include <opencv2/core/saturate.hpp>`

## ◆ saturate_cast< ushort >() [5/8]

template<>

ushort cv::saturate_cast< ushort > | ( | schar | v | ) |
| inline

`#include <opencv2/core/saturate.hpp>`

## ◆ saturate_cast< ushort >() [6/8]

template<>

ushort cv::saturate_cast< ushort > | ( | short | v | ) |
| inline

`#include <opencv2/core/saturate.hpp>`

## ◆ saturate_cast< ushort >() [7/8]

template<>

ushort cv::saturate_cast< ushort > | ( | uint64 | v | ) |
| inline

`#include <opencv2/core/saturate.hpp>`

## ◆ saturate_cast< ushort >() [8/8]

template<>

ushort cv::saturate_cast< ushort > | ( | unsigned | v | ) |
| inline

`#include <opencv2/core/saturate.hpp>`

## ◆ setBreakOnError()

bool cv::setBreakOnError | ( | bool | flag | ) |

`#include <opencv2/core/utility.hpp>`

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

Examples
  samples/cpp/stitching_detailed.cpp.

## ◆ setNumThreads()

void cv::setNumThreads | ( | int | nthreads | ) |

Python:
| cv.setNumThreads( | nthreads | ) -> | None

`#include <opencv2/core/utility.hpp>`

OpenCV will try to set the number of threads for subsequent parallel regions.

If threads == 1, OpenCV will disable threading optimizations and run all it's functions sequentially. Passing threads < 0 will reset threads number to system default. The function is not thread-safe. It must not be called in parallel region or concurrent threads.

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

## ◆ setUseOptimized()

void cv::setUseOptimized | ( | bool | onoff | ) |

Python:
| cv.setUseOptimized( | onoff | ) -> | None

`#include <opencv2/core/utility.hpp>`

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

## ◆ tempfile()

String cv::tempfile | ( | const char * | suffix = 0 | ) |

`#include <opencv2/core/utility.hpp>`

Generates a unique temporary file name.

This function generates a full, unique file path for a temporary file, which can be used to create temporary files for various purposes.

Parameters

  suffix | (optional) The desired file extension or suffix for the temporary file (e.g., ".png", ".txt"). If no suffix is provided (suffix = 0), the file will not have a specific extension.

Returns
  cv::String A full unique path for the temporary file.

Note
  - The function does not create the file, it only generates the name.
  - The file name is unique for the system session.
  - Works cross-platform (Windows, Linux, macOS).

## ◆ terminate()

void cv::terminate | ( | Error::Code | code,
|  | const String & | err,
|  | const char * | func,
|  | const char * | file,
|  | int | line )

`#include <opencv2/core/exception.hpp>`

Signals an error and terminate application.

By default the function prints information about the error to stderr, then it terminates application with std::terminate. The function is designed for invariants check in functions and methods with noexcept attribute.

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_AssertTerminate

## ◆ useOptimized()

bool cv::useOptimized | ( |  | ) |

Python:
| cv.useOptimized( |  | ) -> | retval

`#include <opencv2/core/utility.hpp>`

Returns the status of optimized code usage.

The function returns true if the optimized code is enabled. Otherwise, it returns false.