base.hpp#

#include <opencv2/opencv_modules.hpp>
#include <climits>
#include <algorithm>
#include <opencv2/core/cvdef.h>
#include <opencv2/core/cvstd.hpp>
#include <opencv2/core/fwddecl.hpp>
#include <opencv2/core/neon_utils.hpp>
#include <opencv2/core/vsx_utils.hpp>
#include <opencv2/core/exception.hpp>
#include <opencv2/core/check.hpp>

Include dependency graph for base.hpp:

This graph shows which files directly or indirectly include base.hpp:

Classes#

struct cv::Hamming

Namespaces#

namespace cv

Enumerations#

enum cv::BorderTypes {
BORDER_CONSTANT = 0,
BORDER_REPLICATE = 1,
BORDER_REFLECT = 2,
BORDER_WRAP = 3,
BORDER_REFLECT_101 = 4,
BORDER_TRANSPARENT = 5,
BORDER_REFLECT101 = BORDER_REFLECT_101,
BORDER_DEFAULT = BORDER_REFLECT_101,
BORDER_ISOLATED = 16
}

enum cv::CmpTypes {
CMP_EQ = 0,
CMP_GT = 1,
CMP_GE = 2,
CMP_LT = 3,
CMP_LE = 4,
CMP_NE = 5
}

comparison types More…

enum cv::DecompTypes {
DECOMP_LU = 0,
DECOMP_SVD = 1,
DECOMP_EIG = 2,
DECOMP_CHOLESKY = 3,
DECOMP_QR = 4,
DECOMP_NORMAL = 16
}

matrix decomposition types More…

enum cv::DftFlags {
DFT_INVERSE = 1,
DFT_SCALE = 2,
DFT_ROWS = 4,
DFT_COMPLEX_OUTPUT = 16,
DFT_REAL_OUTPUT = 32,
DFT_COMPLEX_INPUT = 64,
DCT_INVERSE = DFT_INVERSE,
DCT_ROWS = DFT_ROWS
}

enum cv::GemmFlags {
GEMM_1_T = 1,
GEMM_2_T = 2,
GEMM_3_T = 4
}

generalized matrix multiplication flags More…

enum cv::NormTypes {
NORM_INF = 1,
NORM_L1 = 2,
NORM_L2 = 4,
NORM_L2SQR = 5,
NORM_HAMMING = 6,
NORM_HAMMING2 = 7,
NORM_TYPE_MASK = 7,
NORM_RELATIVE = 8,
NORM_MINMAX = 32
}

Functions#

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.

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

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

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

Calculates the angle of a 2D vector in degrees.

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)

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

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

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

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

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

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