陣列操作

詳細描述

類
類	cv::LDA
	線性判別分析。更多...
類	cv::PCA
	主成分分析。更多...
類	cv::RNG
	隨機數生成器。更多...
類	cv::RNG_MT19937
	Mersenne Twister 隨機數生成器。更多...
類	cv::SVD
	奇異值分解。更多...

列舉
列舉	cv::BorderTypes {   cv::BORDER_CONSTANT = 0 ,   cv::BORDER_REPLICATE = 1 ,   cv::BORDER_REFLECT = 2 ,   cv::BORDER_WRAP = 3 ,   cv::BORDER_REFLECT_101 = 4 ,   cv::BORDER_TRANSPARENT = 5 ,   cv::BORDER_REFLECT101 = BORDER_REFLECT_101 ,   cv::BORDER_DEFAULT = BORDER_REFLECT_101 ,   cv::BORDER_ISOLATED = 16 }
列舉	cv::CmpTypes {   cv::CMP_EQ = 0 ,   cv::CMP_GT = 1 ,   cv::CMP_GE = 2 ,   cv::CMP_LT = 3 ,   cv::CMP_LE = 4 ,   cv::CMP_NE = 5 }
	比較型別 更多...
列舉	cv::CovarFlags {   cv::COVAR_SCRAMBLED = 0 ,   cv::COVAR_NORMAL = 1 ,   cv::COVAR_USE_AVG = 2 ,   cv::COVAR_SCALE = 4 ,   cv::COVAR_ROWS = 8 ,   cv::COVAR_COLS = 16 }
	協方差標誌。更多...
列舉	cv::DecompTypes {   cv::DECOMP_LU = 0 ,   cv::DECOMP_SVD = 1 ,   cv::DECOMP_EIG = 2 ,   cv::DECOMP_CHOLESKY = 3 ,   cv::DECOMP_QR = 4 ,   cv::DECOMP_NORMAL = 16 }
	矩陣分解型別 更多...
列舉	cv::DftFlags {   cv::DFT_INVERSE = 1 ,   cv::DFT_SCALE = 2 ,   cv::DFT_ROWS = 4 ,   cv::DFT_COMPLEX_OUTPUT = 16 ,   cv::DFT_REAL_OUTPUT = 32 ,   cv::DFT_COMPLEX_INPUT = 64 ,   cv::DCT_INVERSE = DFT_INVERSE ,   cv::DCT_ROWS = DFT_ROWS }
列舉	cv::GemmFlags {   cv::GEMM_1_T = 1 ,   cv::GEMM_2_T = 2 ,   cv::GEMM_3_T = 4 }
	廣義矩陣乘法標誌 更多...
列舉	cv::NormTypes {   cv::NORM_INF = 1 ,   cv::NORM_L1 = 2 ,   cv::NORM_L2 = 4 ,   cv::NORM_L2SQR = 5 ,   cv::NORM_HAMMING = 6 ,   cv::NORM_HAMMING2 = 7 ,   cv::NORM_TYPE_MASK = 7 ,   cv::NORM_RELATIVE = 8 ,   cv::NORM_MINMAX = 32 }
列舉	cv::ReduceTypes {   cv::REDUCE_SUM = 0 ,   cv::REDUCE_AVG = 1 ,   cv::REDUCE_MAX = 2 ,   cv::REDUCE_MIN = 3 ,   cv::REDUCE_SUM2 = 4 }
列舉	cv::RotateFlags {   cv::ROTATE_90_CLOCKWISE = 0 ,   cv::ROTATE_180 = 1 ,   cv::ROTATE_90_COUNTERCLOCKWISE = 2 }

函式
void	cv::absdiff (InputArray src1, InputArray src2, OutputArray dst)
	計算兩個陣列之間或陣列與標量之間的逐元素絕對差。
void	cv::add (InputArray src1, InputArray src2, OutputArray dst, InputArray mask=noArray(), int dtype=-1)
	計算兩個陣列或陣列與標量之間的逐元素和。
void	cv::addWeighted (InputArray src1, double alpha, InputArray src2, double beta, double gamma, OutputArray dst, int dtype=-1)
	計算兩個陣列的加權和。
void	cv::batchDistance (InputArray src1, InputArray src2, OutputArray dist, int dtype, OutputArray nidx, int normType=NORM_L2, int K=0, InputArray mask=noArray(), int update=0, bool crosscheck=false)
	樸素最近鄰查詢器
void	cv::bitwise_and (InputArray src1, InputArray src2, OutputArray dst, InputArray mask=noArray())
	計算兩個陣列的逐位合取 (dst = src1 & src2) 計算兩個陣列或陣列與標量的逐元素位合取。
void	cv::bitwise_not (InputArray src, OutputArray dst, InputArray mask=noArray())
	反轉陣列的每個位。
void	cv::bitwise_or (InputArray src1, InputArray src2, OutputArray dst, InputArray mask=noArray())
	計算兩個陣列或陣列與標量的逐元素位析取。
void	cv::bitwise_xor (InputArray src1, InputArray src2, OutputArray dst, InputArray mask=noArray())
	計算兩個陣列或陣列與標量的逐元素位“異或”操作。
int	cv::borderInterpolate (int p, int len, int borderType)
	計算外推畫素的源位置。
void	cv::broadcast (InputArray src, InputArray shape, OutputArray dst)
	將給定的 Mat 廣播到給定的形狀。
void	cv::calcCovarMatrix (const Mat *samples, int nsamples, Mat &covar, Mat &mean, int flags, int ctype=6)
	計算一組向量的協方差矩陣。
void	cv::calcCovarMatrix (InputArray samples, OutputArray covar, InputOutputArray mean, int flags, int ctype=6)
void	cv::cartToPolar (InputArray x, InputArray y, OutputArray magnitude, OutputArray angle, bool angleInDegrees=false)
	Calculates the magnitude and angle of 2D vectors.
bool	cv::checkRange (InputArray a, bool quiet=true, Point *pos=0, double minVal=-DBL_MAX, double maxVal=DBL_MAX)
	Checks every element of an input array for invalid values.
void	cv::compare (InputArray src1, InputArray src2, OutputArray dst, int cmpop)
	執行兩個陣列或陣列與標量值的逐元素比較。
void	cv::completeSymm (InputOutputArray m, bool lowerToUpper=false)
	將方陣的下半部分或上半部分複製到另一半。
void	cv::convertFp16 (InputArray src, OutputArray dst)
	Converts an array to half precision floating number.
void	cv::convertScaleAbs (InputArray src, OutputArray dst, double alpha=1, double beta=0)
	縮放、計算絕對值並將結果轉換為 8 位。
void	cv::copyMakeBorder (InputArray src, OutputArray dst, int top, int bottom, int left, int right, int borderType, const Scalar &value=Scalar())
	Forms a border around an image.
void	cv::copyTo (InputArray src, OutputArray dst, InputArray mask)
	這是一個為方便起見提供的過載成員函式 (Python) 將矩陣複製到另一個矩陣。當指定操作掩碼時，如果上面所示的 Mat::create 呼叫重新分配了矩陣，則在新分配的矩陣在複製資料之前將用全零初始化。
int	cv::countNonZero (InputArray src)
	Counts non-zero array elements.
void	cv::dct (InputArray src, OutputArray dst, int flags=0)
	執行一維或二維陣列的正向或逆向離散餘弦變換。
double	cv::determinant (InputArray mtx)
	返回方陣的浮點行列式。
void	cv::dft (InputArray src, OutputArray dst, int flags=0, int nonzeroRows=0)
	執行一維或二維浮點陣列的正向或逆向離散傅立葉變換。
void	cv::divide (double scale, InputArray src2, OutputArray dst, int dtype=-1)
void	cv::divide (InputArray src1, InputArray src2, OutputArray dst, double scale=1, int dtype=-1)
	執行兩個陣列或標量除以陣列的逐元素除法。
bool	cv::eigen (InputArray src, OutputArray eigenvalues, OutputArray eigenvectors=noArray())
	計算對稱矩陣的特徵值和特徵向量。
void	cv::eigenNonSymmetric (InputArray src, OutputArray eigenvalues, OutputArray eigenvectors)
	計算非對稱矩陣的特徵值和特徵向量（僅實特徵值）。
void	cv::exp (InputArray src, OutputArray dst)
	計算每個陣列元素的指數。
void	cv::extractChannel (InputArray src, OutputArray dst, int coi)
	從 src 中提取單個通道（coi 是基於 0 的索引）
void	cv::findNonZero (InputArray src, OutputArray idx)
	返回非零畫素的位置列表。
void	cv::flip (InputArray src, OutputArray dst, int flipCode)
	沿垂直、水平或兩個軸翻轉 2D 陣列。
void	cv::flipND (InputArray src, OutputArray dst, int axis)
	沿給定軸翻轉 N 維陣列。
void	cv::gemm (InputArray src1, InputArray src2, double alpha, InputArray src3, double beta, OutputArray dst, int flags=0)
	執行廣義矩陣乘法。
int	cv::getOptimalDFTSize (int vecsize)
	返回給定向量大小的最佳 DFT 大小。
bool	cv::hasNonZero (InputArray src)
	檢查是否存在至少一個非零陣列元素。
void	cv::hconcat (const Mat *src, size_t nsrc, OutputArray dst)
	對給定矩陣進行水平連線。
void	cv::hconcat (InputArray src1, InputArray src2, OutputArray dst)
void	cv::hconcat (InputArrayOfArrays src, OutputArray dst)
void	cv::idct (InputArray src, OutputArray dst, int flags=0)
	計算一維或二維陣列的逆離散餘弦變換。
void	cv::idft (InputArray src, OutputArray dst, int flags=0, int nonzeroRows=0)
	計算一維或二維陣列的逆離散傅立葉變換。
void	cv::inRange (InputArray src, InputArray lowerb, InputArray upperb, OutputArray dst)
	檢查陣列元素是否位於另外兩個陣列的元素之間。
void	cv::insertChannel (InputArray src, InputOutputArray dst, int coi)
	將單個通道插入 dst（coi 是基於 0 的索引）
double	cv::invert (InputArray src, OutputArray dst, int flags=DECOMP_LU)
	查詢矩陣的逆或偽逆。
void	cv::log (InputArray src, OutputArray dst)
	計算每個陣列元素的自然對數。
void	cv::LUT (InputArray src, InputArray lut, OutputArray dst)
	對陣列執行查詢表變換。
void	cv::magnitude (InputArray x, InputArray y, OutputArray magnitude)
	計算二維向量的幅度。
double	cv::Mahalanobis (InputArray v1, InputArray v2, InputArray icovar)
	計算兩個向量之間的馬哈拉諾比斯距離。
void	cv::max (const Mat &src1, const Mat &src2, Mat &dst)
void	cv::max (const UMat &src1, const UMat &src2, UMat &dst)
void	cv::max (InputArray src1, InputArray src2, OutputArray dst)
	計算兩個陣列或陣列與標量的逐元素最大值。
Scalar	cv::mean (InputArray src, InputArray mask=noArray())
	計算陣列元素的平均值（均值）。
void	cv::meanStdDev (InputArray src, OutputArray mean, OutputArray stddev, InputArray mask=noArray())
void	cv::merge (const Mat *mv, size_t count, OutputArray dst)
	將多個單通道數組合併為一個多通道陣列。
void	cv::merge (InputArrayOfArrays mv, OutputArray dst)
void	cv::min (const Mat &src1, const Mat &src2, Mat &dst)
void	cv::min (const UMat &src1, const UMat &src2, UMat &dst)
void	cv::min (InputArray src1, InputArray src2, OutputArray dst)
	計算兩個陣列或陣列與標量的逐元素最小值。
void	cv::minMaxIdx (InputArray src, double *minVal, double *maxVal=0, int *minIdx=0, int *maxIdx=0, InputArray mask=noArray())
	查詢陣列中的全域性最小值和最大值。
void	cv::minMaxLoc (const SparseMat &a, double *minVal, double *maxVal, int *minIdx=0, int *maxIdx=0)
void	cv::minMaxLoc (InputArray src, double *minVal, double *maxVal=0, Point *minLoc=0, Point *maxLoc=0, InputArray mask=noArray())
	查詢陣列中的全域性最小值和最大值。
void	cv::mixChannels (const Mat *src, size_t nsrcs, Mat *dst, size_t ndsts, const int *fromTo, size_t npairs)
	將指定通道從輸入陣列複製到輸出陣列的指定通道。
void	cv::mixChannels (InputArrayOfArrays src, InputOutputArrayOfArrays dst, const int *fromTo, size_t npairs)
void	cv::mixChannels (InputArrayOfArrays src, InputOutputArrayOfArrays dst, const std::vector< int > &fromTo)
void	cv::mulSpectrums (InputArray a, InputArray b, OutputArray c, int flags, bool conjB=false)
	執行兩個傅立葉頻譜的逐元素乘法。
void	cv::multiply (InputArray src1, InputArray src2, OutputArray dst, double scale=1, int dtype=-1)
	計算兩個陣列的逐元素縮放積。
void	cv::mulTransposed (InputArray src, OutputArray dst, bool aTa, InputArray delta=noArray(), double scale=1, int dtype=-1)
	計算矩陣及其轉置的乘積。
double	cv::norm (const SparseMat &src, int normType)
double	cv::norm (InputArray src1, InputArray src2, int normType=NORM_L2, InputArray mask=noArray())
	計算絕對差範數或相對差範數。
double	cv::norm (InputArray src1, int normType=NORM_L2, InputArray mask=noArray())
	計算陣列的絕對範數。
void	cv::normalize (const SparseMat &src, SparseMat &dst, double alpha, int normType)
void	cv::normalize (InputArray src, InputOutputArray dst, double alpha=1, double beta=0, int norm_type=NORM_L2, int dtype=-1, InputArray mask=noArray())
	對陣列的範數或值範圍進行歸一化。
void	cv::patchNaNs (InputOutputArray a, double val=0)
	將 NaN 替換為給定數字。
void	cv::PCABackProject (InputArray data, InputArray mean, InputArray eigenvectors, OutputArray result)
void	cv::PCACompute (InputArray data, InputOutputArray mean, OutputArray eigenvectors, double retainedVariance)
void	cv::PCACompute (InputArray data, InputOutputArray mean, OutputArray eigenvectors, int maxComponents=0)
void	cv::PCACompute (InputArray data, InputOutputArray mean, OutputArray eigenvectors, OutputArray eigenvalues, double retainedVariance)
void	cv::PCACompute (InputArray data, InputOutputArray mean, OutputArray eigenvectors, OutputArray eigenvalues, int maxComponents=0)
void	cv::PCAProject (InputArray data, InputArray mean, InputArray eigenvectors, OutputArray result)
void	cv::perspectiveTransform (InputArray src, OutputArray dst, InputArray m)
	執行向量的透視矩陣變換。
void	cv::phase (InputArray x, InputArray y, OutputArray angle, bool angleInDegrees=false)
	計算二維向量的旋轉角度。
void	cv::polarToCart (InputArray magnitude, InputArray angle, OutputArray x, OutputArray y, bool angleInDegrees=false)
	根據二維向量的幅度和角度計算其 x 和 y 座標。
void	cv::pow (InputArray src, double power, OutputArray dst)
	將每個陣列元素提升到指定冪。
double	cv::PSNR (InputArray src1, InputArray src2, double R=255.)
	計算峰值信噪比（PSNR）影像質量指標。
void	cv::randn (InputOutputArray dst, InputArray mean, InputArray stddev)
	用正態分佈的隨機數填充陣列。
void	cv::randShuffle (InputOutputArray dst, double iterFactor=1., RNG *rng=0)
	隨機打亂陣列元素。
void	cv::randu (InputOutputArray dst, InputArray low, InputArray high)
	生成單個均勻分佈的隨機數或隨機數陣列。
void	cv::reduce (InputArray src, OutputArray dst, int dim, int rtype, int dtype=-1)
	將矩陣降維為向量。
void	cv::reduceArgMax (InputArray src, OutputArray dst, int axis, bool lastIndex=false)
	沿給定軸查詢最大元素的索引。
void	cv::reduceArgMin (InputArray src, OutputArray dst, int axis, bool lastIndex=false)
	沿給定軸查詢最小元素的索引。
Mat	cv::repeat (const Mat &src, int ny, int nx)
void	cv::repeat (InputArray src, int ny, int nx, OutputArray dst)
	用輸入陣列的重複副本填充輸出陣列。
void	cv::rotate (InputArray src, OutputArray dst, int rotateCode)
	將二維陣列旋轉 90 度的倍數。函式 cv::rotate 以三種不同方式之一旋轉陣列：順時針旋轉 90 度 (rotateCode = ROTATE_90_CLOCKWISE)。順時針旋轉 180 度 (rotateCode = ROTATE_180)。順時針旋轉 270 度 (rotateCode = ROTATE_90_COUNTERCLOCKWISE)。
void	cv::scaleAdd (InputArray src1, double alpha, InputArray src2, OutputArray dst)
	計算縮放陣列與另一個數組的和。
void	cv::setIdentity (InputOutputArray mtx, const Scalar &s=Scalar(1))
	初始化一個縮放的單位矩陣。
void	cv::setRNGSeed (int seed)
	設定預設隨機數生成器的狀態。
bool	cv::solve (InputArray src1, InputArray src2, OutputArray dst, int flags=DECOMP_LU)
	求解一個或多個線性系統或最小二乘問題。
int	cv::solveCubic (InputArray coeffs, OutputArray roots)
	查詢三次方程的實根。
double	cv::solvePoly (InputArray coeffs, OutputArray roots, int maxIters=300)
	查詢多項式方程的實根或復根。
void	cv::sort (InputArray src, OutputArray dst, int flags)
	對矩陣的每行或每列進行排序。
void	cv::sortIdx (InputArray src, OutputArray dst, int flags)
	對矩陣的每行或每列進行排序。
void	cv::split (const Mat &src, Mat *mvbegin)
	將多通道陣列分割為多個單通道陣列。
void	cv::split (InputArray m, OutputArrayOfArrays mv)
void	cv::sqrt (InputArray src, OutputArray dst)
	計算陣列元素的平方根。
void	cv::subtract (InputArray src1, InputArray src2, OutputArray dst, InputArray mask=noArray(), int dtype=-1)
	計算兩個陣列或陣列與標量之間的逐元素差。
Scalar	cv::sum (InputArray src)
	計算陣列元素的和。
void	cv::SVBackSubst (InputArray w, InputArray u, InputArray vt, InputArray rhs, OutputArray dst)
void	cv::SVDecomp (InputArray src, OutputArray w, OutputArray u, OutputArray vt, int flags=0)
void	cv::swap (Mat &a, Mat &b)
	交換兩個矩陣。
void	cv::swap (UMat &a, UMat &b)
RNG &	cv::theRNG ()
	返回預設的隨機數生成器。
Scalar	cv::trace (InputArray mtx)
	返回矩陣的跡。
void	cv::transform (InputArray src, OutputArray dst, InputArray m)
	對每個陣列元素執行矩陣變換。
void	cv::transpose (InputArray src, OutputArray dst)
	轉置矩陣。
void	cv::transposeND (InputArray src, const std::vector< int > &order, OutputArray dst)
	n維矩陣的轉置。
void	cv::vconcat (const Mat *src, size_t nsrc, OutputArray dst)
	對給定矩陣執行垂直連線。
void	cv::vconcat (InputArray src1, InputArray src2, OutputArray dst)
void	cv::vconcat (InputArrayOfArrays src, OutputArray dst)

列舉型別文件

BorderTypes

列舉 cv::BorderTypes

#include <opencv2/core/base.hpp>

各種邊界型別，下表中的影像邊界用 | 字元表示，描述每種方法時使用。

以下示例顯示了根據不同方法呼叫 copyMakeBorder 的結果。輸入影像尺寸為 6x4（寬 x 高），並且 copyMakeBorder 函式在每個方向上都使用了 2 畫素的邊界大小，從而生成 10x8 解析度的結果影像。

輸入影像
[[ 0  1  2  3  4  5]
 [ 6  7  8  9 10 11]
 [12 13 14 15 16 17]
 [18 19 20 21 22 23]]
 
邊界型別：BORDER_CONSTANT (使用常數值 255)
[[255 255 255 255 255 255 255 255 255 255]
 [255 255 255 255 255 255 255 255 255 255]
 [255 255   0   1   2   3   4   5 255 255]
 [255 255   6   7   8   9  10  11 255 255]
 [255 255  12  13  14  15  16  17 255 255]
 [255 255  18  19  20  21  22  23 255 255]
 [255 255 255 255 255 255 255 255 255 255]
 [255 255 255 255 255 255 255 255 255 255]]
 
邊界型別：BORDER_REPLICATE
[[ 0  0  0  1  2  3  4  5  5  5]
 [ 0  0  0  1  2  3  4  5  5  5]
 [ 0  0  0  1  2  3  4  5  5  5]
 [ 6  6  6  7  8  9 10 11 11 11]
 [12 12 12 13 14 15 16 17 17 17]
 [18 18 18 19 20 21 22 23 23 23]
 [18 18 18 19 20 21 22 23 23 23]
 [18 18 18 19 20 21 22 23 23 23]]
 
邊界型別：BORDER_REFLECT
[[ 7  6  6  7  8  9 10 11 11 10]
 [ 1  0  0  1  2  3  4  5  5  4]
 [ 1  0  0  1  2  3  4  5  5  4]
 [ 7  6  6  7  8  9 10 11 11 10]
 [13 12 12 13 14 15 16 17 17 16]
 [19 18 18 19 20 21 22 23 23 22]
 [19 18 18 19 20 21 22 23 23 22]
 [13 12 12 13 14 15 16 17 17 16]]
 
邊界型別：BORDER_WRAP
[[16 17 12 13 14 15 16 17 12 13]
 [22 23 18 19 20 21 22 23 18 19]
 [ 4  5  0  1  2  3  4  5  0  1]
 [10 11  6  7  8  9 10 11  6  7]
 [16 17 12 13 14 15 16 17 12 13]
 [22 23 18 19 20 21 22 23 18 19]
 [ 4  5  0  1  2  3  4  5  0  1]
 [10 11  6  7  8  9 10 11  6  7]]
 
邊界型別：BORDER_REFLECT_101
[[14 13 12 13 14 15 16 17 16 15]
 [ 8  7  6  7  8  9 10 11 10  9]
 [ 2  1  0  1  2  3  4  5  4  3]
 [ 8  7  6  7  8  9 10 11 10  9]
 [14 13 12 13 14 15 16 17 16 15]
 [20 19 18 19 20 21 22 23 22 21]
 [14 13 12 13 14 15 16 17 16 15]
 [ 8  7  6  7  8  9 10 11 10  9]]

另請參見

borderInterpolate, copyMakeBorder

列舉器
BORDER_CONSTANT  Python: cv.BORDER_CONSTANT	iiiiii|abcdefgh|iiiiiii 帶有某些指定的 i
BORDER_REPLICATE  Python: cv.BORDER_REPLICATE	aaaaaa|abcdefgh|hhhhhhh
BORDER_REFLECT  Python: cv.BORDER_REFLECT	fedcba|abcdefgh|hgfedcb
BORDER_WRAP  Python: cv.BORDER_WRAP	cdefgh|abcdefgh|abcdefg
BORDER_REFLECT_101  Python: cv.BORDER_REFLECT_101	gfedcb|abcdefgh|gfedcba
BORDER_TRANSPARENT  Python: cv.BORDER_TRANSPARENT	uvwxyz|abcdefgh|ijklmno - 將異常值視為透明。
BORDER_REFLECT101  Python: cv.BORDER_REFLECT101	與 BORDER_REFLECT_101 相同
BORDER_DEFAULT  Python: cv.BORDER_DEFAULT	與 BORDER_REFLECT_101 相同
BORDER_ISOLATED  Python: cv.BORDER_ISOLATED	插值受限於 ROI 邊界內。

CmpTypes

列舉 cv::CmpTypes

#include <opencv2/core/base.hpp>

比較型別

列舉器
CMP_EQ  Python: cv.CMP_EQ	src1 等於 src2。
CMP_GT  Python: cv.CMP_GT	src1 大於 src2。
CMP_GE  Python: cv.CMP_GE	src1 大於或等於 src2。
CMP_LT  Python: cv.CMP_LT	src1 小於 src2。
CMP_LE  Python: cv.CMP_LE	src1 小於或等於 src2。
CMP_NE  Python: cv.CMP_NE	src1 不等於 src2。

CovarFlags

列舉 cv::CovarFlags

#include <opencv2/core.hpp>

協方差標誌。

列舉器
COVAR_SCRAMBLED  Python: cv.COVAR_SCRAMBLED	輸出協方差矩陣計算為 \[\texttt{scale} \cdot [ \texttt{vects} [0]- \texttt{mean} , \texttt{vects} [1]- \texttt{mean} ,...]^T \cdot [ \texttt{vects} [0]- \texttt{mean} , \texttt{vects} [1]- \texttt{mean} ,...],\] 協方差矩陣將是 nsamples x nsamples。這種不尋常的協方差矩陣用於對一組非常大的向量進行快速 PCA（例如，參見用於人臉識別的 EigenFaces 技術）。這個“加擾”矩陣的特徵值與真實協方差矩陣的特徵值匹配。“真實”特徵向量可以很容易地從“加擾”協方差矩陣的特徵向量計算出來。
COVAR_NORMAL  Python: cv.COVAR_NORMAL	輸出協方差矩陣計算為 \[\texttt{scale} \cdot [ \texttt{vects} [0]- \texttt{mean} , \texttt{vects} [1]- \texttt{mean} ,...] \cdot [ \texttt{vects} [0]- \texttt{mean} , \texttt{vects} [1]- \texttt{mean} ,...]^T,\] 協方差將是一個方陣，其大小與每個輸入向量中的元素總數相同。COVAR_SCRAMBLED 和 COVAR_NORMAL 必須且只能指定其中一個。
COVAR_USE_AVG  Python: cv.COVAR_USE_AVG	如果指定了該標誌，函式將不從輸入向量計算均值，而是使用傳入的均值向量。當均值已預先計算或已知時，或者當協方差矩陣分部分計算時，這很有用。在這種情況下，均值不是輸入向量子集的均值向量，而是整個集的均值向量。
COVAR_SCALE  Python: cv.COVAR_SCALE	如果指定了該標誌，則協方差矩陣將被縮放。在“正常”模式下，比例為 1./nsamples。在“加擾”模式下，比例是每個輸入向量中元素總數的倒數。預設情況下（如果未指定該標誌），協方差矩陣不進行縮放（scale=1）。
COVAR_ROWS  Python: cv.COVAR_ROWS	如果指定了該標誌，則所有輸入向量都將作為樣本矩陣的行儲存。在這種情況下，均值應為單行向量。
COVAR_COLS  Python: cv.COVAR_COLS	如果指定了該標誌，則所有輸入向量都將作為樣本矩陣的列儲存。在這種情況下，均值應為單列向量。

DecompTypes

列舉 cv::DecompTypes

#include <opencv2/core/base.hpp>

矩陣分解型別

列舉器
DECOMP_LU  Python: cv.DECOMP_LU	使用選擇的最佳主元進行高斯消元。
DECOMP_SVD  Python: cv.DECOMP_SVD	奇異值分解 (SVD) 方法；系統可能超定和/或矩陣 src1 可能奇異
DECOMP_EIG  Python: cv.DECOMP_EIG	特徵值分解；矩陣 src1 必須對稱
DECOMP_CHOLESKY  Python: cv.DECOMP_CHOLESKY	Cholesky \(LL^T\) 分解；矩陣 src1 必須對稱且正定
DECOMP_QR  Python: cv.DECOMP_QR	QR 分解；系統可能超定和/或矩陣 src1 可能奇異
DECOMP_NORMAL  Python: cv.DECOMP_NORMAL	雖然所有先前的標誌都是互斥的，但此標誌可以與任何先前標誌一起使用；這意味著求解的是正規方程 \(\texttt{src1}^T\cdot\texttt{src1}\cdot\texttt{dst}=\texttt{src1}^T\texttt{src2}\)，而不是原始系統 \(\texttt{src1}\cdot\texttt{dst}=\texttt{src2}\)

DftFlags

列舉 cv::DftFlags

#include <opencv2/core/base.hpp>

列舉器
DFT_INVERSE  Python: cv.DFT_INVERSE	執行逆向一維或二維變換，而不是預設的正向變換。
DFT_SCALE  Python: cv.DFT_SCALE	縮放結果：將其除以陣列元素的數量。通常，它與 DFT_INVERSE 結合使用。
DFT_ROWS  Python: cv.DFT_ROWS	對輸入矩陣的每個獨立行執行正向或逆向變換；此標誌使您能夠同時變換多個向量，並可用於減少開銷（有時是處理本身開銷的幾倍）以執行 3D 及更高維度的變換等等。
DFT_COMPLEX_OUTPUT  Python: cv.DFT_COMPLEX_OUTPUT	執行一維或二維實數陣列的正向變換；結果雖然是複數陣列，但具有共軛對稱性（CCS，詳見下面的函式描述），並且這樣的陣列可以打包成與輸入大小相同的實數陣列，這是最快的選項，也是函式預設執行的操作；但是，您可能希望獲得一個完整的複數陣列（為了更簡單的頻譜分析等）——傳遞該標誌以使函式生成一個完整大小的複數輸出陣列。
DFT_REAL_OUTPUT  Python: cv.DFT_REAL_OUTPUT	執行一維或二維複數陣列的逆向變換；結果通常是相同大小的複數陣列，但是，如果輸入陣列具有共軛複數對稱性（例如，它是帶有 DFT_COMPLEX_OUTPUT 標誌的正向變換的結果），則輸出是實數陣列；雖然函式本身不檢查輸入是否對稱，但您可以傳遞此標誌，然後函式將假定對稱性並生成實數輸出陣列（請注意，當輸入打包成實數陣列並執行逆向變換時，函式將輸入視為打包的共軛複數對稱陣列，輸出也將是實數陣列）。
DFT_COMPLEX_INPUT  Python: cv.DFT_COMPLEX_INPUT	指定輸入為複數輸入。如果設定此標誌，輸入必須有 2 個通道。另一方面，為了向後相容，如果輸入有 2 個通道，則輸入已被視為複數。
DCT_INVERSE  Python: cv.DCT_INVERSE	執行逆向一維或二維變換，而不是預設的正向變換。
DCT_ROWS  Python: cv.DCT_ROWS	對輸入矩陣的每個獨立行執行正向或逆向變換。此標誌使您能夠同時變換多個向量，並可用於減少開銷（有時是處理本身開銷的幾倍）以執行 3D 及更高維度的變換等等。

GemmFlags

列舉 cv::GemmFlags

#include <opencv2/core/base.hpp>

廣義矩陣乘法標誌

列舉器
GEMM_1_T  Python: cv.GEMM_1_T	轉置 src1
GEMM_2_T  Python: cv.GEMM_2_T	轉置 src2
GEMM_3_T  Python: cv.GEMM_3_T	轉置 src3

NormTypes

列舉 cv::NormTypes

#include <opencv2/core/base.hpp>

範數型別

src1 和 src2 表示輸入陣列。

列舉器
NORM_INF  Python: cv.NORM_INF	\[ norm = \forkthree {\|\texttt{src1}\|_{L_{\infty}} = \max _I | \texttt{src1} (I)|}{if \(\texttt{normType} = \texttt{NORM_INF}\) } {\|\texttt{src1}-\texttt{src2}\|_{L_{\infty}} = \max _I | \texttt{src1} (I) - \texttt{src2} (I)|}{if \(\texttt{normType} = \texttt{NORM_INF}\) } {\frac{\|\texttt{src1}-\texttt{src2}\|_{L_{\infty}} }{\|\texttt{src2}\|_{L_{\infty}} }}{if \(\texttt{normType} = \texttt{NORM_RELATIVE | NORM_INF}\) } \]
NORM_L1  Python: cv.NORM_L1	\[ norm = \forkthree {\| \texttt{src1} \| _{L_1} = \sum _I | \texttt{src1} (I)|}{if \(\texttt{normType} = \texttt{NORM_L1}\)} { \| \texttt{src1} - \texttt{src2} \| _{L_1} = \sum _I | \texttt{src1} (I) - \texttt{src2} (I)|}{if \(\texttt{normType} = \texttt{NORM_L1}\) } { \frac{\|\texttt{src1}-\texttt{src2}\|_{L_1} }{\|\texttt{src2}\|_{L_1}} }{if \(\texttt{normType} = \texttt{NORM_RELATIVE | NORM_L1}\) } \]
NORM_L2  Python: cv.NORM_L2	\[ norm = \forkthree { \| \texttt{src1} \| _{L_2} = \sqrt{\sum_I \texttt{src1}(I)^2} }{if \(\texttt{normType} = \texttt{NORM_L2}\) } { \| \texttt{src1} - \texttt{src2} \| _{L_2} = \sqrt{\sum_I (\texttt{src1}(I) - \texttt{src2}(I))^2} }{if \(\texttt{normType} = \texttt{NORM_L2}\) } { \frac{\|\texttt{src1}-\texttt{src2}\|_{L_2} }{\|\texttt{src2}\|_{L_2}} }{if \(\texttt{normType} = \texttt{NORM_RELATIVE | NORM_L2}\) } \]
NORM_L2SQR  Python: cv.NORM_L2SQR	\[ norm = \forkthree { \| \texttt{src1} \| _{L_2} ^{2} = \sum_I \texttt{src1}(I)^2} {if \(\texttt{normType} = \texttt{NORM_L2SQR}\)} { \| \texttt{src1} - \texttt{src2} \| _{L_2} ^{2} = \sum_I (\texttt{src1}(I) - \texttt{src2}(I))^2 }{if \(\texttt{normType} = \texttt{NORM_L2SQR}\) } { \left(\frac{\|\texttt{src1}-\texttt{src2}\|_{L_2} }{\|\texttt{src2}\|_{L_2}}\right)^2 }{if \(\texttt{normType} = \texttt{NORM_RELATIVE | NORM_L2SQR}\) } \]
NORM_HAMMING  Python: cv.NORM_HAMMING	當有一個輸入陣列時，計算陣列與零的 漢明 距離；當有兩個輸入陣列時，計算兩個陣列之間的 漢明 距離。
NORM_HAMMING2  Python: cv.NORM_HAMMING2	類似於 NORM_HAMMING，但在計算中，輸入序列的每兩位將被相加並視為一位，用於與 NORM_HAMMING 相同的計算中。
NORM_TYPE_MASK  Python: cv.NORM_TYPE_MASK	位掩碼，可用於將範數型別與範數標誌分開
NORM_RELATIVE  Python: cv.NORM_RELATIVE	flag
NORM_MINMAX  Python: cv.NORM_MINMAX	flag

ReduceTypes

列舉 cv::ReduceTypes

#include <opencv2/core.hpp>

列舉器
REDUCE_SUM  Python: cv.REDUCE_SUM	輸出是矩陣所有行/列的總和。
REDUCE_AVG  Python: cv.REDUCE_AVG	輸出是矩陣所有行/列的平均向量。
REDUCE_MAX  Python: cv.REDUCE_MAX	輸出是矩陣所有行/列的最大值（按列/行）。
REDUCE_MIN  Python: cv.REDUCE_MIN	輸出是矩陣所有行/列的最小值（按列/行）。
REDUCE_SUM2  Python: cv.REDUCE_SUM2	輸出是矩陣所有行/列的平方和。

RotateFlags

列舉 cv::RotateFlags

#include <opencv2/core.hpp>

列舉器
ROTATE_90_CLOCKWISE  Python: cv.ROTATE_90_CLOCKWISE	順時針旋轉 90 度。
ROTATE_180  Python: cv.ROTATE_180	順時針旋轉 180 度。
ROTATE_90_COUNTERCLOCKWISE  Python: cv.ROTATE_90_COUNTERCLOCKWISE	順時針旋轉 270 度。

函式文件

absdiff()

void cv::absdiff	(	InputArray	src1,
		InputArray	src2,
		OutputArray	dst )

Python
	cv.absdiff(	src1, src2[, dst]	) ->	dst

#include <opencv2/core.hpp>

計算兩個陣列之間或陣列與標量之間的逐元素絕對差。

函式 cv::absdiff 計算：當兩個陣列具有相同大小和型別時的逐元素絕對差

\[\texttt{dst}(I) = \texttt{saturate} (| \texttt{src1}(I) - \texttt{src2}(I)|)\]

當第二個陣列由 Scalar 構造或具有與 src1 通道數相同數量的元素時，陣列與標量之間的絕對差

\[\texttt{dst}(I) = \texttt{saturate} (| \texttt{src1}(I) - \texttt{src2} |)\]

當第一個陣列由 Scalar 構造或具有與 src2 通道數相同數量的元素時，標量與陣列之間的絕對差

\[\texttt{dst}(I) = \texttt{saturate} (| \texttt{src1} - \texttt{src2}(I) |)\]

其中 I 是陣列元素的（多維）索引。在多通道陣列的情況下，每個通道獨立處理。

注意

當陣列深度為 CV_32S 時，不應用飽和。在溢位情況下，甚至可能得到負值。

(Python) 請注意 src1/src2 是單個數字與元組/陣列之間的不同行為。absdiff(src,X) 意味著 absdiff(src,(X,X,X,X))。absdiff(src,(X,)) 意味著 absdiff(src,(X,0,0,0))。

引數

src1	第一個輸入陣列或標量。
src2	第二個輸入陣列或標量。
dst	與輸入陣列具有相同大小和型別的輸出陣列。

另請參見

cv::abs(const Mat&)

此函式的呼叫圖如下

add()

void cv::add	(	InputArray	src1,
		InputArray	src2,
		OutputArray	dst,
		InputArray	mask = noArray(),
		int	dtype = -1 )

Python
	cv.add(	src1, src2[, dst[, mask[, dtype]]]	) ->	dst

#include <opencv2/core.hpp>

計算兩個陣列或陣列與標量之間的逐元素和。

函式 add 計算

• 當兩個輸入陣列具有相同大小和相同通道數時的兩個陣列的和

  \[\texttt{dst}(I) = \texttt{saturate} ( \texttt{src1}(I) + \texttt{src2}(I)) \quad \texttt{if mask}(I) \ne0\]

• 當 src2 由 Scalar 構造或具有與 src1.channels() 相同數量的元素時，陣列與標量的和

  \[\texttt{dst}(I) = \texttt{saturate} ( \texttt{src1}(I) + \texttt{src2} ) \quad \texttt{if mask}(I) \ne0\]

• 當 src1 由 Scalar 構造或具有與 src2.channels() 相同數量的元素時，標量與陣列的和

  \[\texttt{dst}(I) = \texttt{saturate} ( \texttt{src1} + \texttt{src2}(I) ) \quad \texttt{if mask}(I) \ne0\]

  其中 I 是陣列元素的多維索引。在多通道陣列的情況下，每個通道獨立處理。

列表中第一個函式可以用矩陣表示式替換

dst = src1 + src2;
dst += src1; // 等同於 add(dst, src1, dst);

輸入陣列和輸出陣列可以具有相同或不同的深度。例如，您可以將 16 位無符號陣列新增到 8 位有符號陣列，並將總和儲存為 32 位浮點陣列。輸出陣列的深度由 dtype 引數確定。在上面第二種和第三種情況中，以及在第一種情況中（當 src1.depth() == src2.depth() 時），dtype 可以設定為預設值 -1。在這種情況下，輸出陣列將具有與輸入陣列相同的深度，無論是 src1、src2 還是兩者。

注意

當輸出陣列深度為 CV_32S 時，不應用飽和。在溢位情況下，甚至可能得到不正確的符號結果。

(Python) 請注意 src1/src2 是單個數字與元組/陣列之間的不同行為。add(src,X) 意味著 add(src,(X,X,X,X))。add(src,(X,)) 意味著 add(src,(X,0,0,0))。

引數

src1	第一個輸入陣列或標量。
src2	第二個輸入陣列或標量。
dst	與輸入陣列具有相同大小和通道數的輸出陣列；深度由 dtype 或 src1/src2 定義。
mask	可選操作掩碼 - 8 位單通道陣列，指定要更改的輸出陣列元素。
dtype	輸出陣列的可選深度（參見下面的討論）。

另請參見

subtract, addWeighted, scaleAdd, Mat::convertTo

此函式的呼叫圖如下

addWeighted()

void cv::addWeighted	(	InputArray	src1,
		double	alpha,
		InputArray	src2,
		double	beta,
		double	gamma,
		OutputArray	dst,
		int	dtype = -1 )

Python
	cv.addWeighted(	src1, alpha, src2, beta, gamma[, dst[, dtype]]	) ->	dst

#include <opencv2/core.hpp>

計算兩個陣列的加權和。

函式 addWeighted 計算兩個陣列的加權和，如下所示：

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

其中 I 是陣列元素的多元索引。對於多通道陣列，每個通道都獨立處理。該函式可以用矩陣表示式替代：

dst = src1*alpha + src2*beta + gamma;

注意

當輸出陣列深度為 CV_32S 時，不應用飽和。在溢位情況下，甚至可能得到不正確的符號結果。

引數

src1	第一個輸入陣列。
alpha	第一個陣列元素的權重。
src2	第二個輸入陣列，其大小和通道數與 src1 相同。
beta	第二個陣列元素的權重。
gamma	加到每個和中的標量。
dst	輸出陣列，其大小和通道數與輸入陣列相同。
dtype	可選的輸出陣列深度；當兩個輸入陣列具有相同的深度時，dtype 可以設定為 -1，這等同於 src1.depth()。

另請參見

add, subtract, scaleAdd, Mat::convertTo

此函式的呼叫圖如下

batchDistance()

void cv::batchDistance	(	InputArray	src1,
		InputArray	src2,
		OutputArray	dist,
		int	dtype,
		OutputArray	nidx,
		int	normType = NORM_L2,
		int	K = 0,
		InputArray	mask = noArray(),
		int	update = 0,
		bool	crosscheck = false )

Python
	cv.batchDistance(	src1, src2, dtype[, dist[, nidx[, normType[, K[, mask[, update[, crosscheck]]]]]]]	) ->	dist, nidx

#include <opencv2/core.hpp>

樸素最近鄰查詢器

參見 http://en.wikipedia.org/wiki/Nearest_neighbor_search

待辦

document

此函式的呼叫圖如下

bitwise_and()

void cv::bitwise_and	(	InputArray	src1,
		InputArray	src2,
		OutputArray	dst,
		InputArray	mask = noArray() )

Python
	cv.bitwise_and(	src1, src2[, dst[, mask]]	) ->	dst

#include <opencv2/core.hpp>

計算兩個陣列的逐位合取 (dst = src1 & src2) 計算兩個陣列或陣列與標量的逐元素位合取。

函式 cv::bitwise_and 計算逐元素位邏輯合取，適用於：當 src1 和 src2 大小相同時的兩個陣列

\[\texttt{dst} (I) = \texttt{src1} (I) \wedge \texttt{src2} (I) \quad \texttt{if mask} (I) \ne0\]

當 src2 由 Scalar 構造或具有與 src1.channels() 相同的元素數量時，一個數組與一個標量進行操作：

\[\texttt{dst} (I) = \texttt{src1} (I) \wedge \texttt{src2} \quad \texttt{if mask} (I) \ne0\]

當 src1 由 Scalar 構造或具有與 src2.channels() 相同的元素數量時，一個標量與一個數組進行操作：

\[\texttt{dst} (I) = \texttt{src1} \wedge \texttt{src2} (I) \quad \texttt{if mask} (I) \ne0\]

對於浮點陣列，將使用其機器特定的位表示（通常符合 IEEE754 標準）進行操作。對於多通道陣列，每個通道都獨立處理。在上述第二種和第三種情況下，標量會首先轉換為陣列型別。

引數

src1	第一個輸入陣列或標量。
src2	第二個輸入陣列或標量。
dst	輸出陣列，其大小和型別與輸入陣列相同。
mask	可選的操作掩碼，8 位單通道陣列，指定輸出陣列中要更改的元素。

此函式的呼叫圖如下

bitwise_not()

void cv::bitwise_not	(	InputArray	src,
		OutputArray	dst,
		InputArray	mask = noArray() )

Python
	cv.bitwise_not(	src[, dst[, mask]]	) ->	dst

#include <opencv2/core.hpp>

反轉陣列的每個位。

函式 cv::bitwise_not 計算輸入陣列的逐元素位反轉：

\[\texttt{dst} (I) = \neg \texttt{src} (I)\]

對於浮點輸入陣列，將使用其機器特定的位表示（通常符合 IEEE754 標準）進行操作。對於多通道陣列，每個通道都獨立處理。

引數

src	輸入陣列。
dst	輸出陣列，其大小和型別與輸入陣列相同。
mask	可選的操作掩碼，8 位單通道陣列，指定輸出陣列中要更改的元素。

此函式的呼叫圖如下

bitwise_or()

void cv::bitwise_or	(	InputArray	src1,
		InputArray	src2,
		OutputArray	dst,
		InputArray	mask = noArray() )

Python
	cv.bitwise_or(	src1, src2[, dst[, mask]]	) ->	dst

#include <opencv2/core.hpp>

計算兩個陣列或陣列與標量的逐元素位析取。

函式 cv::bitwise_or 計算逐元素位邏輯析取，適用於：當 src1 和 src2 大小相同時的兩個陣列

\[\texttt{dst} (I) = \texttt{src1} (I) \vee \texttt{src2} (I) \quad \texttt{if mask} (I) \ne0\]

當 src2 由 Scalar 構造或具有與 src1.channels() 相同的元素數量時，一個數組與一個標量進行操作：

\[\texttt{dst} (I) = \texttt{src1} (I) \vee \texttt{src2} \quad \texttt{if mask} (I) \ne0\]

當 src1 由 Scalar 構造或具有與 src2.channels() 相同的元素數量時，一個標量與一個數組進行操作：

\[\texttt{dst} (I) = \texttt{src1} \vee \texttt{src2} (I) \quad \texttt{if mask} (I) \ne0\]

對於浮點陣列，將使用其機器特定的位表示（通常符合 IEEE754 標準）進行操作。對於多通道陣列，每個通道都獨立處理。在上述第二種和第三種情況下，標量會首先轉換為陣列型別。

引數

src1	第一個輸入陣列或標量。
src2	第二個輸入陣列或標量。
dst	輸出陣列，其大小和型別與輸入陣列相同。
mask	可選的操作掩碼，8 位單通道陣列，指定輸出陣列中要更改的元素。

此函式的呼叫圖如下

bitwise_xor()

void cv::bitwise_xor	(	InputArray	src1,
		InputArray	src2,
		OutputArray	dst,
		InputArray	mask = noArray() )

Python
	cv.bitwise_xor(	src1, src2[, dst[, mask]]	) ->	dst

#include <opencv2/core.hpp>

計算兩個陣列或陣列與標量的逐元素位“異或”操作。

函式 cv::bitwise_xor 計算逐元素位邏輯“異或”操作，適用於：當 src1 和 src2 大小相同時的兩個陣列

\[\texttt{dst} (I) = \texttt{src1} (I) \oplus \texttt{src2} (I) \quad \texttt{if mask} (I) \ne0\]

當 src2 由 Scalar 構造或具有與 src1.channels() 相同的元素數量時，一個數組與一個標量進行操作：

\[\texttt{dst} (I) = \texttt{src1} (I) \oplus \texttt{src2} \quad \texttt{if mask} (I) \ne0\]

當 src1 由 Scalar 構造或具有與 src2.channels() 相同的元素數量時，一個標量與一個數組進行操作：

\[\texttt{dst} (I) = \texttt{src1} \oplus \texttt{src2} (I) \quad \texttt{if mask} (I) \ne0\]

對於浮點陣列，將使用其機器特定的位表示（通常符合 IEEE754 標準）進行操作。對於多通道陣列，每個通道都獨立處理。在上述第 2 種和第 3 種情況下，標量會首先轉換為陣列型別。

引數

src1	第一個輸入陣列或標量。
src2	第二個輸入陣列或標量。
dst	輸出陣列，其大小和型別與輸入陣列相同。
mask	可選的操作掩碼，8 位單通道陣列，指定輸出陣列中要更改的元素。

此函式的呼叫圖如下

borderInterpolate()

int cv::borderInterpolate	(	int	p,
		int	len,
		int	borderType )

Python
	cv.borderInterpolate(	p, len, borderType	) ->	retval

#include <opencv2/core.hpp>

計算外推畫素的源位置。

該函式計算並返回在使用指定外推邊界模式時，對應於指定外推畫素的源畫素座標。例如，如果您在水平方向使用 cv::BORDER_WRAP 模式，在垂直方向使用 cv::BORDER_REFLECT_101，並想計算浮點影像 img 中“虛擬”畫素 Point(-5, 100) 的值，它看起來像這樣：

float val = img.at<float>(borderInterpolate(100, img.rows, cv::BORDER_REFLECT_101),
                          borderInterpolate(-5, img.cols, cv::BORDER_WRAP));

通常，該函式不會被直接呼叫。它在過濾函式內部和 copyMakeBorder 中使用。

引數

p	沿某個軸線的外推畫素的 0 索引座標，可能小於 0 或大於等於 len
len	陣列沿對應軸的長度。
borderType	邊界型別，BorderTypes 之一，但 BORDER_TRANSPARENT 和 BORDER_ISOLATED 除外。當 borderType == BORDER_CONSTANT 時，無論 p 和 len 的值如何，函式總是返回 -1。

另請參見

copyMakeBorder

此函式的呼叫圖如下

broadcast()

void cv::broadcast	(	InputArray	src,
		InputArray	shape,
		OutputArray	dst )

Python
	cv.broadcast(	src, shape[, dst]	) ->	dst

#include <opencv2/core.hpp>

將給定的 Mat 廣播到給定的形狀。

引數

src	輸入陣列
shape	目標形狀。應為 CV_32S 型別的數字列表。請注意，不支援負值。
dst	具有給定形狀的輸出陣列

此函式的呼叫圖如下

calcCovarMatrix() [1/2]

void cv::calcCovarMatrix	(	const Mat *	samples,
		int	nsamples,
		Mat &	covar,
		Mat &	mean,
		int	flags,
		int	ctype = 6 )

Python
	cv.calcCovarMatrix(	samples, mean, flags[, covar[, ctype]]	) ->	covar, mean

#include <opencv2/core.hpp>

計算一組向量的協方差矩陣。

函式 cv::calcCovarMatrix 計算輸入向量集的協方差矩陣，並可選地計算其均值向量。

引數

samples	以獨立矩陣形式儲存的樣本
nsamples	樣本數量
covar	型別為 ctype 且為方陣的輸出協方差矩陣。
mean	輸入或輸出（取決於標誌）陣列，作為輸入向量的平均值。
flags	操作標誌，為 CovarFlags 的組合
ctype	矩陣型別；預設為 'CV_64F'。

另請參見

PCA, mulTransposed, Mahalanobis

待辦

InputArrayOfArrays

此函式的呼叫圖如下

calcCovarMatrix() [2/2] (過載)

void cv::calcCovarMatrix	(	InputArray	samples,
		OutputArray	covar,
		InputOutputArray	mean,
		int	flags,
		int	ctype = 6 )

Python
	cv.calcCovarMatrix(	samples, mean, flags[, covar[, ctype]]	) ->	covar, mean

#include <opencv2/core.hpp>

這是一個過載成員函式，為方便起見提供。它與上述函式的區別僅在於其接受的引數。

注意

使用 COVAR_ROWS 或 COVAR_COLS 標誌

引數

samples	樣本以單個矩陣的行/列形式儲存。
covar	型別為 ctype 且為方陣的輸出協方差矩陣。
mean	輸入或輸出（取決於標誌）陣列，作為輸入向量的平均值。
flags	操作標誌，為 CovarFlags 的組合
ctype	矩陣型別；預設為 'CV_64F'。

此函式的呼叫圖如下

cartToPolar()

void cv::cartToPolar	(	InputArray	x,
		InputArray	y,
		OutputArray	magnitude,
		OutputArray	angle,
		bool	angleInDegrees = false )

Python
	cv.cartToPolar(	x, y[, magnitude[, angle[, angleInDegrees]]]	) ->	magnitude, angle

#include <opencv2/core.hpp>

Calculates the magnitude and angle of 2D vectors.

函式 cv::cartToPolar 計算每個二維向量 (x(I),y(I)) 的幅值、角度或兩者：

\[\begin{array}{l} \texttt{magnitude} (I)= \sqrt{\texttt{x}(I)^2+\texttt{y}(I)^2} , \\ \texttt{angle} (I)= \texttt{atan2} ( \texttt{y} (I), \texttt{x} (I))[ \cdot180 / \pi ] \end{array}\]

角度的計算精度約為 0.3 度。對於點 (0,0)，角度設定為 0。

引數

x	x 座標陣列；必須是單精度或雙精度浮點陣列。
y	y 座標陣列，其大小和型別必須與 x 相同。
magnitude	幅值輸出陣列，其大小和型別與 x 相同。
angle	角度輸出陣列，其大小和型別與 x 相同；角度以弧度（0 到 2*Pi）或度（0 到 360 度）為單位測量。
angleInDegrees	一個標誌，指示角度是以弧度（預設為此）還是以度為單位測量。

另請參見

Sobel, Scharr

此函式的呼叫圖如下

checkRange()

bool cv::checkRange	(	InputArray	a,
		bool	quiet = true,
		Point *	pos = 0,
		double	minVal = -DBL_MAX,
		double	maxVal = DBL_MAX )

Python
	cv.checkRange(	a[, quiet[, minVal[, maxVal]]]	) ->	retval, pos

#include <opencv2/core.hpp>

Checks every element of an input array for invalid values.

函式 cv::checkRange 檢查每個陣列元素既不是 NaN 也不是無窮大。當 minVal > -DBL_MAX 且 maxVal < DBL_MAX 時，該函式還會檢查每個值是否在 minVal 和 maxVal 之間。對於多通道陣列，每個通道都獨立處理。如果某些值超出範圍，則第一個異常值的位置將儲存在 pos 中（當 pos != NULL 時）。然後，函式要麼返回 false（當 quiet=true 時），要麼丟擲異常。

引數

a	輸入陣列。
quiet	一個標誌，指示當陣列元素超出範圍時，函式是靜默返回 false 還是丟擲異常。
pos	可選的輸出引數，當不為 NULL 時，必須是指向 src.dims 個元素的陣列的指標。
minVal	有效值範圍的包含性下限。
maxVal	有效值範圍的排他性上限。

此函式的呼叫圖如下

compare()

void cv::compare	(	InputArray	src1,
		InputArray	src2,
		OutputArray	dst,
		int	cmpop )

Python
	cv.compare(	src1, src2, cmpop[, dst]	) ->	dst

#include <opencv2/core.hpp>

執行兩個陣列或陣列與標量值的逐元素比較。

該函式比較：當 src1 和 src2 大小相同時的兩個陣列的元素：

\[\texttt{dst} (I) = \texttt{src1} (I) \,\texttt{cmpop}\, \texttt{src2} (I)\]

當 src2 由 Scalar 構造或只包含單個元素時，src1 的元素與標量 src2 進行比較：

\[\texttt{dst} (I) = \texttt{src1}(I) \,\texttt{cmpop}\, \texttt{src2}\]

當 src1 由 Scalar 構造或只包含單個元素時，src1 與 src2 的元素進行比較：

\[\texttt{dst} (I) = \texttt{src1} \,\texttt{cmpop}\, \texttt{src2} (I)\]

當比較結果為真時，輸出陣列的相應元素設定為 255。比較操作可以用等效的矩陣表示式替代：

Mat dst1 = src1 >= src2;
Mat dst2 = src1 < 8;
...

引數

src1	第一個輸入陣列或一個標量；當它是陣列時，必須是單通道。
src2	第二個輸入陣列或一個標量；當它是陣列時，必須是單通道。
dst	型別為 ref CV_8U 的輸出陣列，其大小和通道數與輸入陣列相同。
cmpop	一個標誌，指定陣列之間的對應關係（cv::CmpTypes）

另請參見

checkRange, min, max, threshold

此函式的呼叫圖如下

completeSymm()

void cv::completeSymm	(	InputOutputArray	m,
		bool	lowerToUpper = false )

Python
	cv.completeSymm(	m[, lowerToUpper]	) ->	m

#include <opencv2/core.hpp>

將方陣的下半部分或上半部分複製到另一半。

函式 cv::completeSymm 將方陣的下半部分或上半部分複製到另一半。矩陣對角線保持不變：

• \(\texttt{m}_{ij}=\texttt{m}_{ji}\) for \(i > j\) if lowerToUpper=false
• \(\texttt{m}_{ij}=\texttt{m}_{ji}\) for \(i < j\) if lowerToUpper=true

引數

m	輸入輸出浮點方陣。
lowerToUpper	操作標誌；如果為 true，則將下半部分複製到上半部分。否則，將上半部分複製到下半部分。

另請參見

flip, transpose

此函式的呼叫圖如下

convertFp16()

void cv::convertFp16	(	InputArray	src,
		OutputArray	dst )

Python
	cv.convertFp16(	src[, dst]	) ->	dst

#include <opencv2/core.hpp>

Converts an array to half precision floating number.

此函式將 FP32（單精度浮點）轉換為 FP16（半精度浮點），或反之。CV_16S 格式用於表示 FP16 資料。有兩種使用模式（src -> dst）：CV_32F -> CV_16S 和 CV_16S -> CV_32F。輸入陣列必須是 CV_32F 或 CV_16S 型別才能表示位深度。如果輸入陣列不是其中任何一種，函式將引發錯誤。半精度浮點格式定義在 IEEE 754-2008 中。

引數

src	輸入陣列。
dst	輸出陣列。

已棄用

請改用 Mat::convertTo 並使用 CV_16F。

此函式的呼叫圖如下

convertScaleAbs()

void cv::convertScaleAbs	(	InputArray	src,
		OutputArray	dst,
		double	alpha = 1,
		double	beta = 0 )

Python
	cv.convertScaleAbs(	src[, dst[, alpha[, beta]]]	) ->	dst

#include <opencv2/core.hpp>

縮放、計算絕對值並將結果轉換為 8 位。

對輸入陣列的每個元素，函式 convertScaleAbs 依次執行三個操作：縮放、取絕對值、轉換為無符號 8 位型別：

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

對於多通道陣列，該函式獨立處理每個通道。當輸出不是 8 位時，可以透過呼叫 Mat::convertTo 方法（或使用矩陣表示式），然後計算結果的絕對值來模擬此操作。例如：

Mat_<float> A(30,30);
randu(A, Scalar(-100), Scalar(100));
Mat_<float> B = A*5 + 3;
B = abs(B);
// Mat_<float> B = abs(A*5+3) will also do the job,
// but it will allocate a temporary matrix

引數

src	輸入陣列。
dst	輸出陣列。
alpha	可選的比例因子。
beta	新增到縮放值的可選增量。

另請參見

Mat::convertTo, cv::abs(const Mat&)

此函式的呼叫圖如下

copyMakeBorder()

void cv::copyMakeBorder	(	InputArray	src,
		OutputArray	dst,
		int	top,
		int	bottom,
		int	左,
		int	右,
		int	borderType,
		const Scalar &	value = Scalar() )

Python
	cv.copyMakeBorder(	src, top, bottom, left, right, borderType[, dst[, value]]	) ->	dst

#include <opencv2/core.hpp>

Forms a border around an image.

該函式將源影像複製到目標影像的中間。複製源影像的左側、右側、上方和下方區域將填充外推畫素。這並非基於此的濾波函式所做（它們即時外推畫素），而是其他更復雜的函式（包括您自己的函式）可能為簡化影像邊界處理而執行的操作。

該函式支援 src 已位於 dst 中間的情況。在這種情況下，函式不會複製 src 本身，而是簡單地構建邊界，例如：

// let border be the same in all directions
int border=2;
// constructs a larger image to fit both the image and the border
Mat gray_buf(rgb.rows + border*2, rgb.cols + border*2, rgb.depth());
// select the middle part of it w/o copying data
Mat gray(gray_canvas, Rect(border, border, rgb.cols, rgb.rows));
// convert image from RGB to grayscale
cvtColor(rgb, gray, COLOR_RGB2GRAY);
// form a border in-place
copyMakeBorder(gray, gray_buf, border, border,
border, border, BORDER_REPLICATE);
// now do some custom filtering ...
...

注意

當源影像是較大影像的一部分（ROI）時，該函式將嘗試使用 ROI 外部的畫素來形成邊界。要停用此功能並始終進行外推（就好像 src 不是 ROI 一樣），請使用 borderType | BORDER_ISOLATED。

引數

src	源影像。
dst	目標影像，其型別與 src 相同，大小為 Size(src.cols+left+right, src.rows+top+bottom) 。
top	頂部畫素
bottom	底部畫素
左	左側畫素
右	引數，指定從源影像矩形向每個方向外推的畫素數量。例如，top=1, bottom=1, left=1, right=1 表示需要構建 1 畫素寬的邊界。
borderType	邊界型別。詳見 borderInterpolate。
值	如果 borderType == BORDER_CONSTANT，則為邊界值。

另請參見

borderInterpolate

此函式的呼叫圖如下

copyTo()

void cv::copyTo	(	InputArray	src,
		OutputArray	dst,
		InputArray	mask )

Python
	cv.copyTo(	src, mask[, dst]	) ->	dst

#include <opencv2/core.hpp>

這是一個為方便起見提供的過載成員函式 (Python) 將矩陣複製到另一個矩陣。當指定操作掩碼時，如果上面所示的 Mat::create 呼叫重新分配了矩陣，則在新分配的矩陣在複製資料之前將用全零初始化。

引數

src	源矩陣。
dst	目標矩陣。如果在操作前其大小或型別不正確，則會重新分配。
mask	與 *this 大小相同的操作掩碼。其非零元素指示需要複製哪些矩陣元素。掩碼必須是 CV_8U 型別，並且可以有 1 個或多個通道。

此函式的呼叫圖如下

countNonZero()

int cv::countNonZero

(

InputArray

src

)

Python
	cv.countNonZero(	src	) ->	retval

#include <opencv2/core.hpp>

Counts non-zero array elements.

該函式返回 src 中非零元素的數量。

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

該函式不適用於多通道陣列。如果您需要計算所有通道中的非零陣列元素，請首先使用 Mat::reshape 將陣列重新解釋為單通道。或者您可以使用 extractImageCOI、mixChannels 或 split 提取特定通道。

注意

• 如果僅關心是否存在非零元素，hasNonZero 會很有用。
• 如果非零陣列元素的位置很重要，findNonZero 會很有用。

引數

src

單通道陣列。

另請參見

mean, meanStdDev, norm, minMaxLoc, calcCovarMatrix

findNonZero, hasNonZero

此函式的呼叫圖如下

dct()

void cv::dct	(	InputArray	src,
		OutputArray	dst,
		int	flags = 0 )

Python
	cv.dct(	src[, dst[, flags]]	) ->	dst

#include <opencv2/core.hpp>

執行一維或二維陣列的正向或逆向離散餘弦變換。

函式 cv::dct 對一維或二維浮點陣列執行正向或逆向離散餘弦變換 (DCT)

• 一維N元素向量的正向餘弦變換

  \[Y = C^{(N)} \cdot X\]

  其中

  \[C^{(N)}_{jk}= \sqrt{\alpha_j/N} \cos \left ( \frac{\pi(2k+1)j}{2N} \right )\]

  其中 \(\alpha_0=1\)，當 j > 0 時 \(\alpha_j=2\)。
• 一維N元素向量的逆向餘弦變換

  \[X = \left (C^{(N)} \right )^{-1} \cdot Y = \left (C^{(N)} \right )^T \cdot Y\]

  （因為 \(C^{(N)}\) 是正交矩陣，\(C^{(N)} \cdot \left(C^{(N)}\right)^T = I\) ）
• M x N 矩陣的正向二維餘弦變換

  \[Y = C^{(N)} \cdot X \cdot \left (C^{(N)} \right )^T\]

• M x N 矩陣的逆向二維餘弦變換

  \[X = \left (C^{(N)} \right )^T \cdot X \cdot C^{(N)}\]

該函式透過檢視輸入陣列的標誌和大小來選擇操作模式

• 如果 (flags & DCT_INVERSE) == 0，則函式執行正向一維或二維變換。否則，執行逆向一維或二維變換。
• 如果 (flags & DCT_ROWS) != 0，則函式對每行執行一維變換。
• 如果陣列是單列或單行，則函式執行一維變換。
• 如果以上條件均不滿足，則函式執行二維變換。

注意

目前 dct 支援偶數大小的陣列（2、4、6...）。對於資料分析和近似，您可以在必要時填充陣列。此外，函式的效能在很大程度上取決於陣列大小，並且不是單調的（參見 getOptimalDFTSize）。在當前實現中，大小為 N 的向量的 DCT 是透過大小為 N/2 的向量的 DFT 計算的。因此，最佳 DCT 大小 N1 >= N 可以計算為

size_t getOptimalDCTSize(size_t N) { return 2*getOptimalDFTSize((N+1)/2); }
N1 = getOptimalDCTSize(N);

引數

src	輸入浮點陣列。
dst	與 src 大小和型別相同的輸出陣列。
flags	變換標誌，是 cv::DftFlags (DCT_*) 的組合

另請參見

dft, getOptimalDFTSize, idct

此函式的呼叫圖如下

determinant()

double cv::determinant

(

InputArray

makePtr()

)

Python
	mtx	makePtr()	) ->	retval

#include <opencv2/core.hpp>

返回方陣的浮點行列式。

函式 cv::determinant 計算並返回指定矩陣的行列式。對於小型矩陣（mtx.cols=mtx.rows<=3），使用直接方法。對於大型矩陣，函式使用帶部分主元選擇的 LU 分解。

對於對稱正定矩陣，也可以使用特徵分解來計算行列式。

引數

makePtr()

輸入矩陣，必須是 CV_32FC1 或 CV_64FC1 型別，且為方陣。

另請參見

trace, invert, solve, eigen, MatrixExpressions

此函式的呼叫圖如下

dft()

void cv::dft	(	InputArray	src,
		OutputArray	dst,
		int	flags = 0,
		int	nonzeroRows = 0 )

Python
	cv.dft(	src[, dst[, flags[, nonzeroRows]]]	) ->	dst

#include <opencv2/core.hpp>

執行一維或二維浮點陣列的正向或逆向離散傅立葉變換。

函式 cv::dft 執行以下操作之一

• 一維N元素向量的正向傅立葉變換

  \[Y = F^{(N)} \cdot X,\]

  其中 \(F^{(N)}_{jk}=\exp(-2\pi i j k/N)\) 且 \(i=\sqrt{-1}\)
• 一維N元素向量的逆向傅立葉變換

  \[\begin{array}{l} X'= \left (F^{(N)} \right )^{-1} \cdot Y = \left (F^{(N)} \right )^* \cdot y \\ X = (1/N) \cdot X, \end{array}\]

  其中 \(F^*=\left(\textrm{Re}(F^{(N)})-\textrm{Im}(F^{(N)})\right)^T\)
• M x N 矩陣的正向二維傅立葉變換

  \[Y = F^{(M)} \cdot X \cdot F^{(N)}\]

• M x N 矩陣的逆向二維傅立葉變換

  \[\begin{array}{l} X'= \left (F^{(M)} \right )^* \cdot Y \cdot \left (F^{(N)} \right )^* \\ X = \frac{1}{M \cdot N} \cdot X' \end{array}\]

對於實數（單通道）資料，正向傅立葉變換的輸出頻譜或逆向傅立葉變換的輸入頻譜可以採用稱為 CCS（複共軛對稱）的緊湊格式表示。它借鑑自 IPL（Intel* 影像處理庫）。二維 CCS 頻譜如下所示：

\[\begin{bmatrix} Re Y_{0,0} & Re Y_{0,1} & Im Y_{0,1} & Re Y_{0,2} & Im Y_{0,2} & \cdots & Re Y_{0,N/2-1} & Im Y_{0,N/2-1} & Re Y_{0,N/2} \\ Re Y_{1,0} & Re Y_{1,1} & Im Y_{1,1} & Re Y_{1,2} & Im Y_{1,2} & \cdots & Re Y_{1,N/2-1} & Im Y_{1,N/2-1} & Re Y_{1,N/2} \\ Im Y_{1,0} & Re Y_{2,1} & Im Y_{2,1} & Re Y_{2,2} & Im Y_{2,2} & \cdots & Re Y_{2,N/2-1} & Im Y_{2,N/2-1} & Im Y_{1,N/2} \\ \hdotsfor{9} \\ Re Y_{M/2-1,0} & Re Y_{M-3,1} & Im Y_{M-3,1} & \hdotsfor{3} & Re Y_{M-3,N/2-1} & Im Y_{M-3,N/2-1}& Re Y_{M/2-1,N/2} \\ Im Y_{M/2-1,0} & Re Y_{M-2,1} & Im Y_{M-2,1} & \hdotsfor{3} & Re Y_{M-2,N/2-1} & Im Y_{M-2,N/2-1}& Im Y_{M/2-1,N/2} \\ Re Y_{M/2,0} & Re Y_{M-1,1} & Im Y_{M-1,1} & \hdotsfor{3} & Re Y_{M-1,N/2-1} & Im Y_{M-1,N/2-1}& Re Y_{M/2,N/2} \end{bmatrix}\]

對於實向量的一維變換，輸出類似於上述矩陣的第一行。

因此，函式根據輸入陣列的標誌和大小選擇操作模式

• 如果設定了 DFT_ROWS，或者輸入陣列為單行或單列，則當設定了 DFT_ROWS 時，函式對矩陣的每一行執行一維正向或逆向變換。否則，它執行二維變換。
• 如果輸入陣列為實數且未設定 DFT_INVERSE，則函式執行正向一維或二維變換
  • 當設定了 DFT_COMPLEX_OUTPUT 時，輸出是與輸入大小相同的複數矩陣。
  • 當未設定 DFT_COMPLEX_OUTPUT 時，輸出是與輸入大小相同的實數矩陣。在二維變換的情況下，它使用如上所示的緊湊格式。在單個一維變換的情況下，它看起來像上述矩陣的第一行。在多個一維變換的情況下（當使用 DFT_ROWS 標誌時），輸出矩陣的每一行看起來像上述矩陣的第一行。
• 如果輸入陣列為複數且未設定 DFT_INVERSE 或 DFT_REAL_OUTPUT，則輸出是與輸入大小相同的複數陣列。函式根據 DFT_INVERSE 和 DFT_ROWS 標誌，對整個輸入陣列或輸入陣列的每一行獨立執行正向或逆向一維或二維變換。
• 當設定了 DFT_INVERSE 且輸入陣列為實數，或者輸入陣列為複數但設定了 DFT_REAL_OUTPUT 時，輸出是與輸入大小相同的實數陣列。函式根據 DFT_INVERSE 和 DFT_ROWS 標誌，對整個輸入陣列或每個單獨的行執行一維或二維逆變換。

如果設定了 DFT_SCALE，則在變換後進行縮放。

與 dct 不同，該函式支援任意大小的陣列。但只有那些大小可以分解為小素數（當前實現中為 2、3 和 5）乘積的陣列才能高效處理。這種高效的 DFT 大小可以使用 getOptimalDFTSize 方法計算。

以下示例說明了如何計算兩個二維實數陣列的基於 DFT 的卷積

void convolveDFT(InputArray A, InputArray B, OutputArray C)
{
    // 如有需要，重新分配輸出陣列
C.create(abs(A.rows - B.rows)+1, abs(A.cols - B.cols)+1, A.type());
    Size dftSize;
    // 計算 DFT 變換的大小
dftSize.width = getOptimalDFTSize(A.cols + B.cols - 1);
dftSize.height = getOptimalDFTSize(A.rows + B.rows - 1);
 
    // 分配臨時緩衝區並用 0 初始化它們
    Mat tempA(dftSize, A.type(), Scalar::all(0));
    Mat tempB(dftSize, B.type(), Scalar::all(0));
 
    // 將 A 和 B 分別複製到 tempA 和 tempB 的左上角
    Mat roiA(tempA, Rect(0,0,A.cols,A.rows));
A.copyTo(roiA);
    Mat roiB(tempB, Rect(0,0,B.cols,B.rows));
B.copyTo(roiB);
 
    // 現在對填充後的 A 和 B 進行原地變換；
    // 使用“nonzeroRows”提示以加快處理速度
    dft(tempA, tempA, 0, A.rows);
    dft(tempB, tempB, 0, B.rows);
 
    // 頻譜相乘；
    // 該函式很好地處理了緊湊頻譜表示
    mulSpectrums(tempA, tempB, tempA);
 
    // 將乘積從頻域變換回來。
    // 即使所有結果行都將是非零的，
    // 您也只需要其中 C.rows 的前幾行，因此您
    // 傳入 nonzeroRows == C.rows
    dft(tempA, tempA, DFT_INVERSE + DFT_SCALE, C.rows);
 
    // 現在將結果複製回 C。
tempA(Rect(0, 0, C.cols, C.rows)).copyTo(C);
 
    // 所有臨時緩衝區將自動釋放
}

為了最佳化此示例，請考慮以下方法

• 由於 nonzeroRows != 0 被傳遞給正向變換呼叫，並且 A 和 B 分別複製到 tempA 和 tempB 的左上角，因此不需要清空整個 tempA 和 tempB。只需要清空矩陣最右側的 tempA.cols - A.cols (tempB.cols - B.cols) 列。
• 這種基於 DFT 的卷積不必應用於整個大型陣列，特別是當 B 明顯小於 A 或反之亦然時。相反，您可以分部分計算卷積。為此，您需要將輸出陣列 C 分割成多個瓦片（tiles）。對於每個瓦片，估計計算此瓦片中卷積所需的 A 和 B 的哪些部分。如果 C 中的瓦片太小，由於重複工作，速度會大大降低。在最終情況下，當 C 中的每個瓦片都是單個畫素時，演算法等同於樸素卷積演算法。如果瓦片太大，臨時陣列 tempA 和 tempB 會變得太大，並且由於快取區域性性差，也會導致速度下降。因此，在中間某個位置存在一個最佳瓦片大小。
• 如果 C 中不同的瓦片可以平行計算，從而分部分完成卷積，則迴圈可以多執行緒化。

上述所有改進都已在 matchTemplate 和 filter2D 中實現。因此，透過使用它們，您可以獲得比上述理論上最優實現更好的效能。然而，這兩個函式實際上計算的是互相關，而不是卷積，因此您需要使用 flip 對第二個卷積運算元 B 進行垂直和水平“翻轉”。

注意

• 使用離散傅立葉變換的示例可以在 opencv_source_code/samples/cpp/dft.cpp 中找到。
• (Python) 使用 dft 功能執行維納反捲積的示例可以在 opencv_source/samples/python/deconvolution.py 中找到。
• (Python) 重新排列傅立葉影像象限的示例可以在 opencv_source/samples/python/dft.py 中找到。

引數

src	可以是實數或複數的輸入陣列。
dst	輸出陣列，其大小和型別取決於標誌。
flags	變換標誌，表示 DftFlags 的組合
nonzeroRows	當引數不為零時，函式假定輸入陣列的（未設定 DFT_INVERSE 時）前 nonzeroRows 行或輸出陣列的（設定 DFT_INVERSE 時）前 nonzeroRows 行包含非零值，因此函式可以更高效地處理其餘行並節省時間；這種技術對於使用 DFT 計算陣列互相關或卷積非常有用。

另請參見

dct, getOptimalDFTSize, mulSpectrums, filter2D, matchTemplate, flip, cartToPolar, magnitude, phase

此函式的呼叫圖如下

divide() [1/2]

void cv::divide	(	double	scale,
		InputArray	src2,
		OutputArray	dst,
		int	dtype = -1 )

Python
	cv.divide(	src1, src2[, dst[, scale[, dtype]]]	) ->	dst
	cv.divide(	scale, src2[, dst[, dtype]]	) ->	dst

#include <opencv2/core.hpp>

這是一個過載成員函式，為方便起見提供。它與上述函式的區別僅在於其接受的引數。

此函式的呼叫圖如下

divide() [2/2]

void cv::divide	(	InputArray	src1,
		InputArray	src2,
		OutputArray	dst,
		double	scale = 1,
		int	dtype = -1 )

Python
	cv.divide(	src1, src2[, dst[, scale[, dtype]]]	) ->	dst
	cv.divide(	scale, src2[, dst[, dtype]]	) ->	dst

#include <opencv2/core.hpp>

執行兩個陣列或標量除以陣列的逐元素除法。

函式 cv::divide 將一個數組除以另一個數組

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

或者當沒有 src1 時，將標量除以陣列

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

多通道陣列的不同通道獨立處理。

對於整數型別，當 src2(I) 為零時，dst(I) 也將為零。

注意

對於浮點資料，對於零 src2(I) 值沒有特殊定義的行為。使用常規浮點除法。浮點資料預期符合正確的 IEEE-754 行為（具有 NaN、Inf 結果值）。

當輸出陣列深度為 CV_32S 時，不應用飽和。在溢位情況下，甚至可能得到不正確的符號結果。

(Python) 請注意 src1/src2 為單個數字和為元組/陣列時的行為差異。divide(src,X) 意味著 divide(src,(X,X,X,X))。divide(src,(X,)) 意味著 divide(src,(X,0,0,0))。

引數

src1	第一個輸入陣列。
src2	與 src1 大小和型別相同的第二個輸入陣列。
scale	標量因子。
dst	與 src2 大小和型別相同的輸出陣列。
dtype	輸出陣列的可選深度；如果為 -1，則 dst 將具有 src2.depth() 的深度，但在陣列對陣列的除法情況下，只有當 src1.depth()==src2.depth() 時，您才能傳遞 -1。

另請參見

multiply, add, subtract

此函式的呼叫圖如下

eigen()

bool cv::eigen	(	InputArray	src,
		OutputArray	eigenvalues （特徵值）,
		OutputArray	eigenvectors = noArray() )

Python
	cv.eigen(	src[, eigenvalues[, eigenvectors]]	) ->	retval, eigenvalues, eigenvectors

#include <opencv2/core.hpp>

計算對稱矩陣的特徵值和特徵向量。

函式 cv::eigen 計算對稱矩陣 src 的特徵值，或特徵值和特徵向量。

src*eigenvectors.row(i).t() = eigenvalues.at<srcType>(i)*eigenvectors.row(i).t()

注意

使用 cv::eigenNonSymmetric 計算非對稱矩陣的實特徵值和特徵向量。

引數

src	輸入矩陣，必須具有 CV_32FC1 或 CV_64FC1 型別、方形大小並且是對稱的 (src ^T^ == src)。
eigenvalues （特徵值）	與 src 相同型別的特徵值輸出向量；特徵值按降序儲存。
eigenvectors （特徵向量）	特徵向量輸出矩陣；其大小和型別與 src 相同；特徵向量按與相應特徵值相同的順序作為後續矩陣行儲存。

另請參見

eigenNonSymmetric, completeSymm, PCA

此函式的呼叫圖如下

eigenNonSymmetric()

void cv::eigenNonSymmetric	(	InputArray	src,
		OutputArray	eigenvalues （特徵值）,
		OutputArray	eigenvectors )

Python
	cv.eigenNonSymmetric(	src[, eigenvalues[, eigenvectors]]	) ->	eigenvalues, eigenvectors

#include <opencv2/core.hpp>

計算非對稱矩陣的特徵值和特徵向量（僅實特徵值）。

注意

假設為實特徵值。

函式計算方陣 src 的特徵值和特徵向量（可選）。

src*eigenvectors.row(i).t() = eigenvalues.at<srcType>(i)*eigenvectors.row(i).t()

引數

src	輸入矩陣（CV_32FC1 或 CV_64FC1 型別）。
eigenvalues （特徵值）	特徵值輸出向量（型別與 src 相同）。
eigenvectors （特徵向量）	特徵向量輸出矩陣（型別與 src 相同）。特徵向量按與相應特徵值相同的順序作為後續矩陣行儲存。

另請參見

eigen

此函式的呼叫圖如下

exp()

void cv::exp	(	InputArray	src,
		OutputArray	dst )

Python
	cv.exp(	src[, dst]	) ->	dst

#include <opencv2/core.hpp>

計算每個陣列元素的指數。

函式 cv::exp 計算輸入陣列每個元素的指數

\[\texttt{dst} [I] = e^{ src(I) }\]

對於單精度輸入，最大相對誤差約為 7e-6；對於雙精度輸入，小於 1e-10。目前，函式將非規格化值轉換為輸出零。特殊值（NaN、Inf）未處理。

引數

src	輸入陣列。
dst	與 `src` 相同大小和型別的輸出陣列。

另請參見

log, cartToPolar, polarToCart, phase, pow, sqrt, magnitude

示例

samples/dnn/classification.cpp.

extractChannel()

void cv::extractChannel	(	InputArray	src,
		OutputArray	dst,
		int	coi )

Python
	cv.extractChannel(	src, coi[, dst]	) ->	dst

#include <opencv2/core.hpp>

從 src 中提取單個通道（coi 是基於 0 的索引）

引數

src	輸入陣列
dst	輸出陣列
coi	要提取的通道索引

另請參見

mixChannels, split

此函式的呼叫圖如下

findNonZero()

void cv::findNonZero	(	InputArray	src,
		OutputArray	idx )

Python
	cv.findNonZero(	src[, idx]	) ->	idx

#include <opencv2/core.hpp>

返回非零畫素的位置列表。

給定一個二進位制矩陣（可能由 threshold()、compare()、>、== 等操作返回），將所有非零索引作為 cv::Mat 或 std::vector<cv::Point> (x,y) 返回。例如：

cv::Mat binaryImage; // 輸入，二進位制影像
cv::Mat locations; // 輸出，非零畫素的位置
cv::findNonZero(binaryImage, locations);
 
// 訪問畫素座標
Point pnt = locations.at<Point>(i);

或者

cv::Mat binaryImage; // 輸入，二進位制影像
vector<Point> locations; // 輸出，非零畫素的位置
cv::findNonZero(binaryImage, locations);
 
// 訪問畫素座標
Point pnt = locations[i];

該函式不適用於多通道陣列。如果您需要在所有通道中查詢非零元素，請先使用 Mat::reshape 將陣列重新解釋為單通道。或者您可以使用 extractImageCOI、mixChannels 或 split 提取特定通道。

注意

• 如果只關心非零陣列元素的數量，則 countNonZero 會很有用。
• 如果僅關心是否存在非零元素，hasNonZero 會很有用。

引數

src	單通道陣列
idx	輸出陣列，型別為 cv::Mat 或 std::vector<Point>，對應輸入中的非零索引

另請參見

countNonZero, hasNonZero

此函式的呼叫圖如下

flip()

void cv::flip	(	InputArray	src,
		OutputArray	dst,
		int	flipCode )

Python
	cv.flip(	src, flipCode[, dst]	) ->	dst

#include <opencv2/core.hpp>

沿垂直、水平或兩個軸翻轉 2D 陣列。

函式 cv::flip 以三種不同方式之一翻轉陣列（行和列索引從 0 開始）

\[\texttt{dst} _{ij} = \left\{ \begin{array}{l l} \texttt{src} _{\texttt{src.rows}-i-1,j} & if\; \texttt{flipCode} = 0 \\ \texttt{src} _{i, \texttt{src.cols} -j-1} & if\; \texttt{flipCode} > 0 \\ \texttt{src} _{ \texttt{src.rows} -i-1, \texttt{src.cols} -j-1} & if\; \texttt{flipCode} < 0 \\ \end{array} \right.\]

使用該函式的示例場景如下： 垂直翻轉影像 (flipCode == 0) 以在左上角和左下角影像原點之間切換。這是 Microsoft Windows* 作業系統中影片處理的典型操作。水平翻轉影像，然後進行水平平移和絕對差值計算，以檢查垂直軸對稱性 (flipCode > 0)。同時水平和垂直翻轉影像，然後進行平移和絕對差值計算，以檢查中心對稱性 (flipCode < 0)。反轉點陣列的順序 (flipCode > 0 或 flipCode == 0)。

引數

src	輸入陣列。
dst	與 `src` 相同大小和型別的輸出陣列。
flipCode	指定如何翻轉陣列的標誌；0 表示沿 x 軸翻轉，正值（例如，1）表示沿 y 軸翻轉。負值（例如，-1）表示沿兩個軸翻轉。

另請參見

transpose, repeat, completeSymm

此函式的呼叫圖如下

flipND()

void cv::flipND	(	InputArray	src,
		OutputArray	dst,
		int	axis )

Python
	cv.flipND(	src, axis[, dst]	) ->	dst

#include <opencv2/core.hpp>

沿給定軸翻轉 N 維陣列。

引數

src	輸入陣列
dst	與 src 形狀相同的輸出陣列
axis（軸）	執行翻轉的軸。0 <= axis < src.dims。

此函式的呼叫圖如下

gemm()

void cv::gemm	(	InputArray	src1,
		InputArray	src2,
		double	alpha,
		InputArray	src3,
		double	beta,
		OutputArray	dst,
		int	flags = 0 )

Python
	cv.gemm(	src1, src2, alpha, src3, beta[, dst[, flags]]	) ->	dst

#include <opencv2/core.hpp>

執行廣義矩陣乘法。

函式 cv::gemm 執行廣義矩陣乘法，類似於 BLAS level 3 中的 gemm 函式。例如，gemm(src1, src2, alpha, src3, beta, dst, GEMM_1_T + GEMM_3_T) 對應於

\[\texttt{dst} = \texttt{alpha} \cdot \texttt{src1} ^T \cdot \texttt{src2} + \texttt{beta} \cdot \texttt{src3} ^T\]

對於複數（雙通道）資料，執行復數矩陣乘法。

該函式可以用矩陣表示式替換。例如，上述呼叫可以替換為

dst = alpha*src1.t()*src2 + beta*src3.t();

引數

src1	第一個相乘的輸入矩陣，可以是實數（CV_32FC1, CV_64FC1）或複數（CV_32FC2, CV_64FC2）。
src2	與 src1 相同型別的第二個相乘的輸入矩陣。
alpha	矩陣乘積的權重。
src3	第三個可選的增量矩陣，新增到矩陣乘積中；它應與 src1 和 src2 具有相同的型別。
beta	src3 的權重。
dst	輸出矩陣；它具有適當的大小並且與輸入矩陣型別相同。
flags	操作標誌（cv::GemmFlags）

另請參見

mulTransposed, transform

此函式的呼叫圖如下

getOptimalDFTSize()

int cv::getOptimalDFTSize

(

int

vecsize

)

Python
	cv.getOptimalDFTSize(	vecsize	) ->	retval

#include <opencv2/core.hpp>

返回給定向量大小的最佳 DFT 大小。

DFT 效能不是向量大小的單調函式。因此，當您計算兩個陣列的卷積或對陣列進行頻譜分析時，通常透過用零填充輸入資料以獲得稍大一點的陣列會更有意義，這樣可以比原始陣列更快地進行變換。大小為二的冪（2、4、8、16、32 等）的陣列處理速度最快。但是，大小為 2、3 和 5 的乘積（例如，300 = 5*5*3*2*2）的陣列也能相當高效地處理。

函式 cv::getOptimalDFTSize 返回大於或等於 vecsize 的最小數字 N，以便可以高效地處理大小為 N 的向量的 DFT。在當前實現中，N = 2 ^p^ * 3 ^q^ * 5 ^r^，其中 p、q、r 為某些整數。

如果 vecsize 過大（非常接近 INT_MAX），函式將返回一個負數。

雖然該函式不能直接用於估計 DCT 變換的最佳向量大小（因為當前的 DCT 實現僅支援偶數大小的向量），但可以輕鬆地將其處理為 getOptimalDFTSize((vecsize+1)/2)*2。

引數

vecsize

向量大小。

另請參見

dft, dct, idft, idct, mulSpectrums

此函式的呼叫圖如下

hasNonZero()

bool cv::hasNonZero

(

InputArray

src

)

Python
	cv.hasNonZero(	src	) ->	retval

#include <opencv2/core.hpp>

檢查是否存在至少一個非零陣列元素。

該函式返回 src 中是否存在非零元素。

該函式不適用於多通道陣列。如果您需要檢查所有通道中的非零陣列元素，請先使用 Mat::reshape 將陣列重新解釋為單通道。或者您可以使用 extractImageCOI、mixChannels 或 split 提取特定通道。

注意

• 如果非零陣列元素的位置很重要，findNonZero 會很有用。
• 如果非零陣列元素的數量很重要，countNonZero 會很有用。

引數

src

單通道陣列。

另請參見

mean, meanStdDev, norm, minMaxLoc, calcCovarMatrix

findNonZero, countNonZero

此函式的呼叫圖如下

hconcat() [1/3]

void cv::hconcat	(	const Mat *	src,
		size_t	nsrc,
		OutputArray	dst )

Python
	cv.hconcat(	src[, dst]	) ->	dst

#include <opencv2/core.hpp>

對給定矩陣進行水平連線。

該函式水平連線兩個或更多（具有相同行數的）cv::Mat 矩陣。

cv::Mat matArray[] = { cv::Mat(4, 1, CV_8UC1, cv::Scalar(1)),
                       cv::Mat(4, 1, CV_8UC1, cv::Scalar(2)),
                       cv::Mat(4, 1, CV_8UC1, cv::Scalar(3)),};
 
cv::Mat out;
cv::hconcat( matArray, 3, out );
// 輸出
//[1, 2, 3;
// 1, 2, 3;
// 1, 2, 3;
// 1, 2, 3]

引數

src	輸入陣列或矩陣向量。所有矩陣必須具有相同的行數和相同的深度。
nsrc	src 中的矩陣數量。
dst	輸出陣列。它具有與 src 相同的行數和深度，以及 src 的列數之和。

另請參見

cv::vconcat(const Mat*, size_t, OutputArray),

cv::vconcat(InputArrayOfArrays, OutputArray) and

cv::vconcat(InputArray, InputArray, OutputArray)

此函式的呼叫圖如下

hconcat() [2/3]

void cv::hconcat	(	InputArray	src1,
		InputArray	src2,
		OutputArray	dst )

Python
	cv.hconcat(	src[, dst]	) ->	dst

#include <opencv2/core.hpp>

這是一個過載成員函式，為方便起見提供。它與上述函式的區別僅在於其接受的引數。

cv::Mat_<float> A = (cv::Mat_<float>(3, 2) << 1, 4,
                                              2, 5,
                                              3, 6);
cv::Mat_<float> B = (cv::Mat_<float>(3, 2) << 7, 10,
                                              8, 11,
                                              9, 12);
 
cv::Mat C;
cv::hconcat(A, B, C);
//C
//[1, 4, 7, 10;
// 2, 5, 8, 11;
// 3, 6, 9, 12]

引數

src1	要進行水平連線的第一個輸入陣列。
src2	要進行水平連線的第二個輸入陣列。
dst	輸出陣列。它具有與 src1 和 src2 相同的行數和深度，以及 src1 和 src2 的列數之和。

此函式的呼叫圖如下

hconcat() [3/3]

void cv::hconcat	(	InputArrayOfArrays	src,
		OutputArray	dst )

Python
	cv.hconcat(	src[, dst]	) ->	dst

#include <opencv2/core.hpp>

這是一個過載成員函式，為方便起見提供。它與上述函式的區別僅在於其接受的引數。

std::vector<cv::Mat> matrices = { cv::Mat(4, 1, CV_8UC1, cv::Scalar(1)),
                                  cv::Mat(4, 1, CV_8UC1, cv::Scalar(2)),
                                  cv::Mat(4, 1, CV_8UC1, cv::Scalar(3)),};
 
cv::Mat out;
cv::hconcat( matrices, out );
// 輸出
//[1, 2, 3;
// 1, 2, 3;
// 1, 2, 3;
// 1, 2, 3]

引數

src	輸入陣列或矩陣向量。所有矩陣必須具有相同的行數和相同的深度。
dst	輸出陣列。它具有與 src 相同的行數和深度，以及 src 的列數之和。相同深度。

此函式的呼叫圖如下

idct()

void cv::idct	(	InputArray	src,
		OutputArray	dst,
		int	flags = 0 )

Python
	cv.idct(	src[, dst[, flags]]	) ->	dst

#include <opencv2/core.hpp>

計算一維或二維陣列的逆離散餘弦變換。

idct(src, dst, flags) 等同於 dct(src, dst, flags | DCT_INVERSE)。

引數

src	輸入浮點單通道陣列。
dst	與 `src` 相同大小和型別的輸出陣列。
flags	操作標誌。

另請參見

dct, dft, idft, getOptimalDFTSize

此函式的呼叫圖如下

idft()

void cv::idft	(	InputArray	src,
		OutputArray	dst,
		int	flags = 0,
		int	nonzeroRows = 0 )

Python
	cv.idft(	src[, dst[, flags[, nonzeroRows]]]	) ->	dst

#include <opencv2/core.hpp>

計算一維或二維陣列的逆離散傅立葉變換。

idft(src, dst, flags) 等同於 dft(src, dst, flags | DFT_INVERSE)。

注意

dft 和 idft 預設都不縮放結果。因此，您應該將 DFT_SCALE 顯式傳遞給 dft 或 idft 之一，以使這些變換互逆。

另請參見

dft, dct, idct, mulSpectrums, getOptimalDFTSize

引數

src	輸入浮點實數或複數陣列。
dst	輸出陣列，其大小和型別取決於標誌。
flags	操作標誌（參見 dft 和 DftFlags）。
nonzeroRows	要處理的 dst 行數；其餘行的內容未定義（參見 dft 描述中的卷積示例）。

此函式的呼叫圖如下

inRange()

void cv::inRange	(	InputArray	src,
		InputArray	lowerb,
		InputArray	upperb,
		OutputArray	dst )

Python
	cv.inRange(	src, lowerb, upperb[, dst]	) ->	dst

#include <opencv2/core.hpp>

檢查陣列元素是否位於另外兩個陣列的元素之間。

函式按如下方式檢查範圍：

• 對於單通道輸入陣列的每個元素

  \[\texttt{dst} (I)= \texttt{lowerb} (I)_0 \leq \texttt{src} (I)_0 \leq \texttt{upperb} (I)_0\]

• 對於雙通道陣列

  \[\texttt{dst} (I)= \texttt{lowerb} (I)_0 \leq \texttt{src} (I)_0 \leq \texttt{upperb} (I)_0 \land \texttt{lowerb} (I)_1 \leq \texttt{src} (I)_1 \leq \texttt{upperb} (I)_1\]

• 以此類推。

也就是說，如果 src(I) 在指定的一維、二維、三維等框內，則 dst(I) 設定為 255（所有 1 位），否則為 0。

當上下限引數是標量時，上述公式中 lowerb 和 upperb 處的索引 (I) 應省略。

引數

src	第一個輸入陣列。
lowerb	包含下限的陣列或標量。
upperb	包含上限的陣列或標量。
dst	與src大小相同且型別為CV_8U的輸出陣列。

此函式的呼叫圖如下

insertChannel()

void cv::insertChannel	(	InputArray	src,
		InputOutputArray	dst,
		int	coi )

Python
	cv.insertChannel(	src, dst, coi	) ->	dst

#include <opencv2/core.hpp>

將單個通道插入 dst（coi 是基於 0 的索引）

引數

src	輸入陣列
dst	輸出陣列
coi	插入通道的索引

另請參見

mixChannels, merge

此函式的呼叫圖如下

invert()

double cv::invert	(	InputArray	src,
		OutputArray	dst,
		int	flags = DECOMP_LU )

Python
	cv.invert(	src[, dst[, flags]]	) ->	retval, dst

#include <opencv2/core.hpp>

查詢矩陣的逆或偽逆。

函式 cv::invert 對矩陣 src 求逆並將結果儲存在 dst 中。當矩陣 src 是奇異或非方陣時，函式計算偽逆矩陣（dst 矩陣），使得 norm(src*dst - I) 最小，其中 I 是單位矩陣。

對於 DECOMP_LU 方法，如果成功計算了逆矩陣，函式返回非零值；如果 src 是奇異的，則返回 0。

對於 DECOMP_SVD 方法，函式返回 src 的逆條件數（最小奇異值與最大奇異值的比率），如果 src 是奇異的，則返回 0。如果 src 是奇異的，SVD 方法將計算偽逆矩陣。

類似於 DECOMP_LU，DECOMP_CHOLESKY 方法僅適用於非奇異方陣，這些方陣也應是對稱且正定的。在這種情況下，函式將逆矩陣儲存在 dst 中並返回非零值。否則，返回 0。

引數

src	輸入浮點 M x N 矩陣。
dst	N x M 大小且與 src 相同型別的輸出矩陣。
flags	求逆方法（cv::DecompTypes）

另請參見

solve, SVD

此函式的呼叫圖如下

log()

void cv::log	(	InputArray	src,
		OutputArray	dst )

Python
	cv.log(	src[, dst]	) ->	dst

#include <opencv2/core.hpp>

計算每個陣列元素的自然對數。

函式 cv::log 計算輸入陣列每個元素的自然對數

\[\texttt{dst} (I) = \log (\texttt{src}(I)) \]

對零、負值和特殊值（NaN、Inf）的輸出未定義。

引數

src	輸入陣列。
dst	與 src 大小和型別相同的輸出陣列。

另請參見

exp, cartToPolar, polarToCart, phase, pow, sqrt, magnitude

LUT()

void cv::LUT	(	InputArray	src,
		InputArray	lut,
		OutputArray	dst )

Python
	cv.LUT(	src, lut[, dst]	) ->	dst

#include <opencv2/core.hpp>

對陣列執行查詢表變換。

LUT 函式使用查詢表中的值填充輸出陣列。條目的索引取自輸入陣列。也就是說，函式按以下方式處理 src 的每個元素：

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

其中

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

引數

src	8位元素的輸入陣列。
lut	包含 256 個元素的查詢表；對於多通道輸入陣列，該表應為單通道（在這種情況下，所有通道使用相同的表）或與輸入陣列具有相同數量的通道。
dst	輸出陣列，其大小和通道數與 src 相同，深度與 lut 相同。

另請參見

convertScaleAbs, Mat::convertTo

此函式的呼叫圖如下

magnitude()

void cv::magnitude	(	InputArray	x,
		InputArray	y,
		OutputArray	magnitude )

Python
	cv.magnitude(	x, y[, magnitude]	) ->	magnitude

#include <opencv2/core.hpp>

計算二維向量的幅度。

函式 cv::magnitude 計算由 x 和 y 陣列的相應元素形成的二維向量的幅度

\[\texttt{dst} (I) = \sqrt{\texttt{x}(I)^2 + \texttt{y}(I)^2}\]

引數

x	向量的 x 座標的浮點陣列。
y	向量 y 座標的浮點陣列；其大小必須與 x 相同。
magnitude	與 x 大小和型別相同的輸出陣列。

另請參見

cartToPolar, polarToCart, phase, sqrt

此函式的呼叫圖如下

Mahalanobis()

double cv::Mahalanobis	(	InputArray	v2 ),
		InputArray	v2,
		InputArray	icovar )

Python
	cv.Mahalanobis(	v1, v2, icovar	) ->	retval

#include <opencv2/core.hpp>

計算兩個向量之間的馬哈拉諾比斯距離。

函式 cv::Mahalanobis 計算並返回兩個向量之間的加權距離

\[d( \texttt{vec1} , \texttt{vec2} )= \sqrt{\sum_{i,j}{\texttt{icovar(i,j)}\cdot(\texttt{vec1}(I)-\texttt{vec2}(I))\cdot(\texttt{vec1(j)}-\texttt{vec2(j)})} }\]

協方差矩陣可以使用 calcCovarMatrix 函式計算，然後使用 invert 函式求逆（最好使用 DECOMP_SVD 方法，因為它最準確）。

引數

v2 )	第一個一維輸入向量。
v2	第二個一維輸入向量。
icovar	逆協方差矩陣。

此函式的呼叫圖如下

max() [1/3]

void cv::max	(	const Mat &	src1,
		const Mat &	src2,
		Mat &	dst )

Python
	cv.max(	src1, src2[, dst]	) ->	dst

#include <opencv2/core.hpp>

這是一個過載成員函式，為方便起見而提供。它與上述函式的唯一區別在於其接受的引數。用於避免與 const _Tp& std::min(const _Tp&, const _Tp&, _Compare) 衝突

max() [2/3]

void cv::max	(	const UMat &	src1,
		const UMat &	src2,
		UMat &	dst )

Python
	cv.max(	src1, src2[, dst]	) ->	dst

#include <opencv2/core.hpp>

這是一個過載成員函式，為方便起見而提供。它與上述函式的唯一區別在於其接受的引數。用於避免與 const _Tp& std::min(const _Tp&, const _Tp&, _Compare) 衝突

max() [3/3]

void cv::max	(	InputArray	src1,
		InputArray	src2,
		OutputArray	dst )

Python
	cv.max(	src1, src2[, dst]	) ->	dst

#include <opencv2/core.hpp>

計算兩個陣列或陣列與標量的逐元素最大值。

函式 cv::max 計算兩個陣列的逐元素最大值

\[\texttt{dst} (I)= \max ( \texttt{src1} (I), \texttt{src2} (I))\]

或陣列與標量

\[\texttt{dst} (I)= \max ( \texttt{src1} (I), \texttt{value} )\]

引數

src1	第一個輸入陣列。
src2	第二個輸入陣列，其大小和型別與 src1 相同。
dst	與 src1 大小和型別相同的輸出陣列。

另請參見

min, compare, inRange, minMaxLoc, MatrixExpressions

mean()

Scalar cv::mean	(	InputArray	src,
		InputArray	mask = noArray() )

Python
	cv.mean(	src[, mask]	) ->	retval

#include <opencv2/core.hpp>

計算陣列元素的平均值（均值）。

函式 cv::mean 獨立地為每個通道計算陣列元素的平均值 M 並返回它

\[\begin{array}{l} N = \sum _{I: \; \texttt{mask} (I) \ne 0} 1 \\ M_c = \left ( \sum _{I: \; \texttt{mask} (I) \ne 0}{ \texttt{mtx} (I)_c} \right )/N \end{array}\]

當所有掩碼元素都為 0 時，函式返回 Scalar::all(0)。

引數

src	輸入陣列，應具有 1 到 4 個通道，以便結果可以儲存在 Scalar_ 中。
mask	可選操作掩碼。

另請參見

countNonZero, meanStdDev, norm, minMaxLoc

此函式的呼叫圖如下

meanStdDev()

void cv::meanStdDev	(	InputArray	src,
		OutputArray	mean,
		OutputArray	stddev,
		InputArray	mask = noArray() )

Python
	cv.meanStdDev(	src[, mean[, stddev[, mask]]]	) ->	mean, stddev

#include <opencv2/core.hpp>

計算陣列元素的均值和標準差。

函式 cv::meanStdDev 獨立地為每個通道計算陣列元素的平均值和標準差 M，並透過輸出引數返回它

\[\begin{array}{l} N = \sum _{I, \texttt{mask} (I) \ne 0} 1 \\ \texttt{mean} _c = \frac{\sum_{ I: \; \texttt{mask}(I) \ne 0} \texttt{src} (I)_c}{N} \\ \texttt{stddev} _c = \sqrt{\frac{\sum_{ I: \; \texttt{mask}(I) \ne 0} \left ( \texttt{src} (I)_c - \texttt{mean} _c \right )^2}{N}} \end{array}\]

當所有掩碼元素都為 0 時，函式返回 mean=stddev=Scalar::all(0)。

注意

計算出的標準差僅是完整歸一化協方差矩陣的對角線。如果需要完整的矩陣，您可以將多通道陣列 M x N 重塑為單通道陣列 M*N x mtx.channels()（僅當矩陣是連續的時才可能），然後將該矩陣傳遞給 calcCovarMatrix。

引數

src	輸入陣列，應具有 1 到 4 個通道，以便結果可以儲存在 Scalar_ 中。
mean	輸出引數：計算出的平均值。
stddev	輸出引數：計算出的標準差。
mask	可選操作掩碼。

另請參見

countNonZero, mean, norm, minMaxLoc, calcCovarMatrix

此函式的呼叫圖如下

merge() [1/2]

void cv::merge	(	const Mat *	mv,
		size_t	count,
		OutputArray	dst )

Python
	cv.merge(	mv[, dst]	) ->	dst

#include <opencv2/core.hpp>

將多個單通道數組合併為一個多通道陣列。

函式 cv::merge 將多個數組合併為一個單一的多通道陣列。也就是說，輸出陣列的每個元素將是輸入陣列元素的連線，其中第 i 個輸入陣列的元素被視為 mv[i].channels()-元素向量。

函式 cv::split 執行相反的操作。如果您需要以其他更高階的方式重新排列通道，請使用 cv::mixChannels。

以下示例展示瞭如何將 3 個單通道矩陣合併為一個 3 通道矩陣。

    Mat m1 = (Mat_<uchar>(2,2) << 1,4,7,10);
    Mat m2 = (Mat_<uchar>(2,2) << 2,5,8,11);
    Mat m3 = (Mat_<uchar>(2,2) << 3,6,9,12);
 
    Mat channels[3] = {m1, m2, m3};
    Mat m;
    merge(channels, 3, m);
    /*
m =
    [  1,   2,   3,   4,   5,   6;
       7,   8,   9,  10,  11,  12]
m.channels() = 3
    */

引數

mv	要合併的矩陣輸入陣列；mv 中的所有矩陣必須具有相同的大小和相同的深度。
count	當 mv 是普通 C 陣列時輸入矩陣的數量；它必須大於零。
dst	與 mv[0] 具有相同大小和深度的輸出陣列；通道數將等於引數 count。

另請參見

mixChannels, split, Mat::reshape

此函式的呼叫圖如下

merge() [2/2]

void cv::merge	(	InputArrayOfArrays	mv,
		OutputArray	dst )

Python
	cv.merge(	mv[, dst]	) ->	dst

#include <opencv2/core.hpp>

這是一個過載成員函式，為方便起見提供。它與上述函式的區別僅在於其接受的引數。

引數

mv	要合併的矩陣輸入向量；mv 中的所有矩陣必須具有相同的大小和相同的深度。
dst	與 mv[0] 具有相同大小和深度的輸出陣列；通道數將是矩陣陣列中的總通道數。

此函式的呼叫圖如下

min() [1/3]

void cv::min	(	const Mat &	src1,
		const Mat &	src2,
		Mat &	dst )

Python
	cv.min(	src1, src2[, dst]	) ->	dst

#include <opencv2/core.hpp>

這是一個過載成員函式，為方便起見而提供。它與上述函式的唯一區別在於其接受的引數。用於避免與 const _Tp& std::min(const _Tp&, const _Tp&, _Compare) 衝突

min() [2/3]

void cv::min	(	const UMat &	src1,
		const UMat &	src2,
		UMat &	dst )

Python
	cv.min(	src1, src2[, dst]	) ->	dst

#include <opencv2/core.hpp>

這是一個過載成員函式，為方便起見而提供。它與上述函式的唯一區別在於其接受的引數。用於避免與 const _Tp& std::min(const _Tp&, const _Tp&, _Compare) 衝突

min() [3/3]

void cv::min	(	InputArray	src1,
		InputArray	src2,
		OutputArray	dst )

Python
	cv.min(	src1, src2[, dst]	) ->	dst

#include <opencv2/core.hpp>

計算兩個陣列或陣列與標量的逐元素最小值。

函式 cv::min 計算兩個陣列的逐元素最小值

\[\texttt{dst} (I)= \min ( \texttt{src1} (I), \texttt{src2} (I))\]

或陣列與標量

\[\texttt{dst} (I)= \min ( \texttt{src1} (I), \texttt{value} )\]

引數

src1	第一個輸入陣列。
src2	與 src1 大小和型別相同的第二個輸入陣列。
dst	與 src1 大小和型別相同的輸出陣列。

另請參見

max, compare, inRange, minMaxLoc

minMaxIdx()

void cv::minMaxIdx	(	InputArray	src,
		如果傳入NULL，則假定尺度引數c為1.0。否則，指向的變數將被設定為最優尺度。	minVal,
		如果傳入NULL，則假定尺度引數c為1.0。否則，指向的變數將被設定為最優尺度。	maxVal = 0,
		int *	minIdx = 0,
		int *	maxIdx = 0,
		InputArray	mask = noArray() )

#include <opencv2/core.hpp>

查詢陣列中的全域性最小值和最大值。

函式 cv::minMaxIdx 查詢陣列中的最小值、最大值及其位置。極值搜尋範圍可以是整個陣列，或者在 mask 不為空時，搜尋指定陣列區域。對於稀疏矩陣，只在非零元素中查詢最小值。支援多通道輸入，但不帶掩碼和極值索引（應為 nullptr）。

注意

當 minIdx 不為 NULL 時，它必須至少包含 2 個元素（maxIdx 亦然），即使 src 是單行或單列矩陣。在 OpenCV 中（仿照 MATLAB），每個陣列至少有 2 個維度，即單列矩陣是 Mx1 矩陣（因此 minIdx/maxIdx 將是 (i1,0)/(i2,0)），單行矩陣是 1xN 矩陣（因此 minIdx/maxIdx 將是 (0,j1)/(0,j2)）。

引數

src	單通道輸入陣列。
minVal	指向返回的最小值的指標；如果不需要，則使用 NULL。
maxVal	指向返回的最大值的指標；如果不需要，則使用 NULL。
minIdx	指向返回的最小值位置的指標（n 維情況下）；如果不需要，則使用 NULL；否則，它必須指向一個包含 src.dims 個元素的陣列，其中按順序儲存了最小值元素在每個維度上的座標。
maxIdx	指向返回的最大值位置的指標（n 維情況下）。如果不需要，則使用 NULL。
mask	指定的陣列區域

此函式的呼叫圖如下

minMaxLoc() [1/2]

void cv::minMaxLoc	(	const SparseMat &	a,
		如果傳入NULL，則假定尺度引數c為1.0。否則，指向的變數將被設定為最優尺度。	minVal,
		如果傳入NULL，則假定尺度引數c為1.0。否則，指向的變數將被設定為最優尺度。	maxVal,
		int *	minIdx = 0,
		int *	maxIdx = 0 )

Python
	cv.minMaxLoc(	src[, mask]	) ->	minVal, maxVal, minLoc, maxLoc

#include <opencv2/core.hpp>

這是一個過載成員函式，為方便起見提供。它與上述函式的區別僅在於其接受的引數。

引數

a	單通道輸入陣列。
minVal	指向返回的最小值的指標；如果不需要，則使用 NULL。
maxVal	指向返回的最大值的指標；如果不需要，則使用 NULL。
minIdx	指向返回的最小值位置的指標（n 維情況下）；如果不需要，則使用 NULL；否則，它必須指向一個包含 src.dims 個元素的陣列，其中按順序儲存了最小值元素在每個維度上的座標。
maxIdx	指向返回的最大值位置的指標（n 維情況下）。如果不需要，則使用 NULL。

此函式的呼叫圖如下

minMaxLoc() [2/2]

void cv::minMaxLoc	(	InputArray	src,
		如果傳入NULL，則假定尺度引數c為1.0。否則，指向的變數將被設定為最優尺度。	minVal,
		如果傳入NULL，則假定尺度引數c為1.0。否則，指向的變數將被設定為最優尺度。	maxVal = 0,
		Point *	minLoc = 0,
		Point *	maxLoc = 0,
		InputArray	mask = noArray() )

Python
	cv.minMaxLoc(	src[, mask]	) ->	minVal, maxVal, minLoc, maxLoc

#include <opencv2/core.hpp>

查詢陣列中的全域性最小值和最大值。

函式 cv::minMaxLoc 查詢陣列中的最小值、最大值及其位置。極值搜尋範圍可以是整個陣列，或者在 mask 不為空時，搜尋指定陣列區域。

在 C++ 中，如果輸入是多通道的，您應該省略 minLoc、maxLoc 和 mask 引數（即分別將它們保留為 NULL、NULL 和 noArray()）。多通道輸入陣列不支援這些引數。如果處理多通道輸入且需要 minLoc、maxLoc 或 mask 引數，則應首先使用 Mat::reshape 將陣列重新解釋為單通道。或者，您可以使用 extractImageCOI、mixChannels 或 split 提取特定通道。

在 Python 中，由於繫結生成過程中的限制（無法將 minLoc 和 maxLoc 設定為 NULL），根本不支援多通道輸入。解決方法是單獨操作每個通道或使用 NumPy 實現相同的功能。

引數

src	單通道輸入陣列。
minVal	指向返回的最小值的指標；如果不需要，則使用 NULL。
maxVal	指向返回的最大值的指標；如果不需要，則使用 NULL。
minLoc (最小位置)	指向返回的最小值位置的指標（2D 情況下）；如果不需要，則使用 NULL。
maxLoc (最大位置)	指向返回的最大值位置的指標（2D 情況下）；如果不需要，則使用 NULL。
mask	用於選擇子陣列的可選掩碼。

另請參見

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

此函式的呼叫圖如下

mixChannels() [1/3]

void cv::mixChannels	(	const Mat *	src,
		size_t	nsrcs,
		Mat *	dst,
		size_t	ndsts,
		const int *	fromTo,
		size_t	npairs )

Python
	cv.mixChannels(	src, dst, fromTo	) ->	dst

#include <opencv2/core.hpp>

將指定通道從輸入陣列複製到輸出陣列的指定通道。

函式 cv::mixChannels 提供了一種高階機制，用於重新排列影像通道。

cv::split,cv::merge,cv::extractChannel,cv::insertChannel 和某些形式的 cv::cvtColor 是 cv::mixChannels 的部分情況。

在下面的示例中，程式碼將一個 4 通道 BGRA 影像分割成一個 3 通道 BGR 影像（其中 B 和 R 通道已交換）以及一個單獨的 alpha 通道影像

Mat bgra( 100, 100, CV_8UC4, Scalar(255,0,0,255) );
Mat bgr( bgra.rows, bgra.cols, CV_8UC3 );
Mat alpha( bgra.rows, bgra.cols, CV_8UC1 );
 
// 形成矩陣陣列是一個相當高效的操作，
// 因為矩陣資料不會被複制，只複製頭部
Mat out[] = { bgr, alpha };
// bgra[0] -> bgr[2], bgra[1] -> bgr[1],
// bgra[2] -> bgr[0], bgra[3] -> alpha[0]
int from_to[] = { 0,2, 1,1, 2,0, 3,3 };
mixChannels( &bgra, 1, out, 2, from_to, 4 );

注意

與 OpenCV 中許多其他新式 C++ 函式不同（參見介紹部分和 Mat::create），cv::mixChannels 要求在呼叫函式之前預先分配輸出陣列。

引數

src	輸入陣列或矩陣向量；所有矩陣必須具有相同的大小和深度。
nsrcs	src 中矩陣的數量。
dst	輸出陣列或矩陣向量；所有矩陣必須已分配；它們的大小和深度必須與 src[0] 相同。
ndsts	dst 中矩陣的數量。
fromTo	指定複製哪些通道以及複製到何處的索引對陣列；fromTo[k*2] 是 src 中輸入通道的基於 0 的索引，fromTo[k*2+1] 是 dst 中輸出通道的索引；使用連續的通道編號：第一個輸入影像通道的索引從 0 到 src[0].channels()-1，第二個輸入影像通道的索引從 src[0].channels() 到 src[0].channels() + src[1].channels()-1，依此類推，輸出影像通道也使用相同的方案；作為特殊情況，當 fromTo[k*2] 為負時，相應的輸出通道填充為零。
npairs	fromTo 中索引對的數量。

另請參見

split, merge, extractChannel, insertChannel, cvtColor

此函式的呼叫圖如下

mixChannels() [2/3]

void cv::mixChannels	(	InputArrayOfArrays	src,
		InputOutputArrayOfArrays	dst,
		const int *	fromTo,
		size_t	npairs )

Python
	cv.mixChannels(	src, dst, fromTo	) ->	dst

#include <opencv2/core.hpp>

這是一個過載成員函式，為方便起見提供。它與上述函式的區別僅在於其接受的引數。

引數

src	輸入陣列或矩陣向量；所有矩陣必須具有相同的大小和深度。
dst	輸出陣列或矩陣向量；所有矩陣必須已分配；它們的大小和深度必須與 src[0] 相同。
fromTo	指定複製哪些通道以及複製到何處的索引對陣列；fromTo[k*2] 是 src 中輸入通道的基於 0 的索引，fromTo[k*2+1] 是 dst 中輸出通道的索引；使用連續的通道編號：第一個輸入影像通道的索引從 0 到 src[0].channels()-1，第二個輸入影像通道的索引從 src[0].channels() 到 src[0].channels() + src[1].channels()-1，依此類推，輸出影像通道也使用相同的方案；作為特殊情況，當 fromTo[k*2] 為負時，相應的輸出通道填充為零。
npairs	fromTo 中索引對的數量。

此函式的呼叫圖如下

mixChannels() [3/3]

void cv::mixChannels	(	InputArrayOfArrays	src,
		InputOutputArrayOfArrays	dst,
		const std::vector< int > &	fromTo )

Python
	cv.mixChannels(	src, dst, fromTo	) ->	dst

#include <opencv2/core.hpp>

這是一個過載成員函式，為方便起見提供。它與上述函式的區別僅在於其接受的引數。

引數

src	輸入陣列或矩陣向量；所有矩陣必須具有相同的大小和深度。
dst	輸出陣列或矩陣向量；所有矩陣必須已分配；它們的大小和深度必須與 src[0] 相同。
fromTo	指定複製哪些通道以及複製到何處的索引對陣列；fromTo[k*2] 是 src 中輸入通道的基於 0 的索引，fromTo[k*2+1] 是 dst 中輸出通道的索引；使用連續的通道編號：第一個輸入影像通道的索引從 0 到 src[0].channels()-1，第二個輸入影像通道的索引從 src[0].channels() 到 src[0].channels() + src[1].channels()-1，依此類推，輸出影像通道也使用相同的方案；作為特殊情況，當 fromTo[k*2] 為負時，相應的輸出通道填充為零。

此函式的呼叫圖如下

mulSpectrums()

void cv::mulSpectrums	(	InputArray	a,
		InputArray	b,
		OutputArray	c,
		int	flags,
		bool	conjB = false )

Python
	cv.mulSpectrums(	a, b, flags[, c[, conjB]]	) ->	c

#include <opencv2/core.hpp>

執行兩個傅立葉頻譜的逐元素乘法。

函式 cv::mulSpectrums 對兩個 CCS 打包或複數矩陣進行逐元素乘法運算，這些矩陣是實數或複數傅立葉變換的結果。

該函式與 dft 和 idft 一起，可用於快速計算兩個陣列的卷積（conjB=false）或相關（conjB=true）。當陣列為複數時，它們會簡單地進行逐元素乘法運算，並可選擇對第二個陣列的元素進行共軛。當陣列為實數時，假定它們是 CCS 打包的（詳情請參閱 dft）。

引數

a	第一個輸入陣列。
b	第二個輸入陣列，其大小和型別與 src1 相同。
c	輸出陣列，其大小和型別與 src1 相同。
flags	操作標誌；目前，唯一支援的標誌是 cv::DFT_ROWS，它表示 src1 和 src2 的每一行都是獨立的 1D 傅立葉頻譜。如果您不想使用此標誌，則只需新增 0 作為值。
conjB	在乘法之前是否對第二個輸入陣列進行共軛的可選標誌（true 為共軛，false 為不共軛）。

此函式的呼叫圖如下

multiply()

void cv::multiply	(	InputArray	src1,
		InputArray	src2,
		OutputArray	dst,
		double	scale = 1,
		int	dtype = -1 )

Python
	cv.multiply(	src1, src2[, dst[, scale[, dtype]]]	) ->	dst

#include <opencv2/core.hpp>

計算兩個陣列的逐元素縮放積。

函式 multiply 計算兩個陣列的逐元素乘積

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

第一個函式還有一個 MatrixExpressions -友好的變體。請參閱 Mat::mul 。

對於非逐元素的矩陣乘積，請參見 gemm 。

注意

當輸出陣列深度為 CV_32S 時，不應用飽和。在溢位情況下，甚至可能得到不正確的符號結果。

(Python) 請注意 src1/src2 為單個數字與它們為元組/陣列時的行為差異。multiply(src,X) 意味著 multiply(src,(X,X,X,X))。multiply(src,(X,)) 意味著 multiply(src,(X,0,0,0))。

引數

src1	第一個輸入陣列。
src2	與 src1 大小和型別相同的第二個輸入陣列。
dst	與 src1 大小和型別相同的輸出陣列。
scale	可選的比例因子。
dtype	輸出陣列的可選深度

另請參見

add, subtract, divide, scaleAdd, addWeighted, accumulate, accumulateProduct, accumulateSquare, Mat::convertTo

此函式的呼叫圖如下

mulTransposed()

void cv::mulTransposed	(	InputArray	src,
		OutputArray	dst,
		bool	aTa,
		InputArray	delta = noArray(),
		double	scale = 1,
		int	dtype = -1 )

Python
	cv.mulTransposed(	src, aTa[, dst[, delta[, scale[, dtype]]]]	) ->	dst

#include <opencv2/core.hpp>

計算矩陣及其轉置的乘積。

函式 cv::mulTransposed 計算 src 及其轉置的乘積

\[\texttt{dst} = \texttt{scale} ( \texttt{src} - \texttt{delta} )^T ( \texttt{src} - \texttt{delta} )\]

如果 aTa=true，以及

\[\texttt{dst} = \texttt{scale} ( \texttt{src} - \texttt{delta} ) ( \texttt{src} - \texttt{delta} )^T\]

否則。該函式用於計算協方差矩陣。當 delta 為零時，它可以作為一般矩陣乘積 A*B（當 B=A'時）的更快替代方案。

引數

src	輸入單通道矩陣。請注意，與 gemm 不同，該函式不僅可以乘以浮點矩陣。
dst	輸出方陣。
aTa	指定乘法順序的標誌。請參閱下面的描述。
delta	在乘法之前從 src 中減去的可選 delta 矩陣。當矩陣為空（delta=noArray()）時，假定為零，即不減去任何東西。如果它與 src 具有相同的大小，則直接減去。否則，它會被“重複”（參見 repeat）以覆蓋整個 src，然後進行減法運算。當 delta 矩陣不為空時，其型別必須與建立的輸出矩陣的型別相同。請參閱下面的 dtype 引數描述。
scale	矩陣乘積的可選比例因子。
dtype	輸出矩陣的可選型別。當它為負時，輸出矩陣將與 src 具有相同的型別。否則，它的型別將是 type=CV_MAT_DEPTH(dtype)，應為 CV_32F 或 CV_64F。

另請參見

calcCovarMatrix, gemm, repeat, reduce

此函式的呼叫圖如下

norm() [1/3]

double cv::norm	(	const SparseMat &	src,
		int	normalize()

Python
	src1[, normType[, mask]]	src1, src2[, normType[, mask]]	) ->	retval
	src1[, normType[, mask]]	norm() [2/2]	) ->	retval

#include <opencv2/core.hpp>

這是一個過載成員函式，為方便起見提供。它與上述函式的區別僅在於其接受的引數。

引數

src	第一個輸入陣列。
normType	範數型別（參見 NormTypes）。

此函式的呼叫圖如下

norm() [2/3]

double cv::norm	(	InputArray	src1,
		InputArray	src2,
		int	normType = NORM_L2,
		InputArray	mask = noArray() )

Python
	src1[, normType[, mask]]	src1, src2[, normType[, mask]]	) ->	retval
	src1[, normType[, mask]]	norm() [2/2]	) ->	retval

#include <opencv2/core.hpp>

計算絕對差範數或相對差範數。

此版本的 cv::norm 計算陣列 src1 和 src2 的絕對差範數或相對差範數。要計算的範數型別使用 NormTypes 指定。

引數

src1	第一個輸入陣列。
src2	與 src1 大小和型別相同的第二個輸入陣列。
normType	範數型別（參見 NormTypes）。
mask	可選操作掩碼；它必須與 src1 具有相同的大小和 CV_8UC1 型別。

此函式的呼叫圖如下

norm() [3/3]

double cv::norm	(	InputArray	src1,
		int	normType = NORM_L2,
		InputArray	mask = noArray() )

Python
	src1[, normType[, mask]]	src1, src2[, normType[, mask]]	) ->	retval
	src1[, normType[, mask]]	norm() [2/2]	) ->	retval

#include <opencv2/core.hpp>

計算陣列的絕對範數。

此版本的 norm 計算 src1 的絕對範數。要計算的範數型別使用 NormTypes 指定。

以一個數組為例，考慮函式 \(r(x)= \begin{pmatrix} x \\ 1-x \end{pmatrix}, x \in [-1;1]\)。樣本值 \(r(-1) = \begin{pmatrix} -1 \\ 2 \end{pmatrix}\) 的 \( L_{1}, L_{2} \) 和 \( L_{\infty} \) 範數計算如下：

\begin{align*} \| r(-1) \|_{L_1} &= |-1| + |2| = 3 \\ \| r(-1) \|_{L_2} &= \sqrt{(-1)^{2} + (2)^{2}} = \sqrt{5} \\ \| r(-1) \|_{L_\infty} &= \max(|-1|,|2|) = 2 \end{align*}

對於 \(r(0.5) = \begin{pmatrix} 0.5 \\ 0.5 \end{pmatrix}\)，計算結果為：

\begin{align*} \| r(0.5) \|_{L_1} &= |0.5| + |0.5| = 1 \\ \| r(0.5) \|_{L_2} &= \sqrt{(0.5)^{2} + (0.5)^{2}} = \sqrt{0.5} \\ \| r(0.5) \|_{L_\infty} &= \max(|0.5|,|0.5|) = 0.5. \end{align*}

下圖顯示了三個範數函式 \(\| r(x) \|_{L_1}, \| r(x) \|_{L_2}\) 和 \(\| r(x) \|_{L_\infty}\) 的所有值。值得注意的是，\( L_{1} \) 範數構成了示例函式 \( r(x) \) 的上限，而 \( L_{\infty} \) 範數構成了下限。

當指定 mask 引數且不為空時，範數為

如果未指定 normType，則使用 NORM_L2。僅在掩碼指定的區域上計算。

多通道輸入陣列被視為單通道陣列，即所有通道的結果都會合並。

Hamming 範數只能使用 CV_8U 深度陣列進行計算。

引數

src1	第一個輸入陣列。
normType	範數型別（參見 NormTypes）。
mask	可選操作掩碼；它必須與 src1 具有相同的大小和 CV_8UC1 型別。

此函式的呼叫圖如下

normalize() [1/2]

void cv::normalize	(	const SparseMat &	src,
		SparseMat &	dst,
		double	alpha,
		int	normalize()

Python
	src, dst[, alpha[, beta[, norm_type[, dtype[, mask]]]]]	operator!=()	) ->	dst

#include <opencv2/core.hpp>

這是一個過載成員函式，為方便起見提供。它與上述函式的區別僅在於其接受的引數。

引數

src	輸入陣列。
dst	與 src 大小相同的輸出陣列。
alpha	歸一化的範數值或範圍歸一化情況下的下限。
normType	歸一化型別（參見 cv::NormTypes）。

此函式的呼叫圖如下

normalize() [2/2]

void cv::normalize	(	InputArray	src,
		InputOutputArray	dst,
		double	alpha = 1,
		double	beta = 0,
		int	norm_type = NORM_L2,
		int	dtype = -1,
		InputArray	mask = noArray() )

Python
	src, dst[, alpha[, beta[, norm_type[, dtype[, mask]]]]]	operator!=()	) ->	dst

#include <opencv2/core.hpp>

對陣列的範數或值範圍進行歸一化。

函式 cv::normalize 對輸入陣列元素進行歸一化縮放和移位，使得

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

(其中 p=Inf、1 或 2) 當 normType 分別為 NORM_INF、NORM_L1 或 NORM_L2 時；或者使得

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

當 normType=NORM_MINMAX 時（僅適用於密集陣列）。可選的 mask 指定要歸一化的子陣列。這意味著範數或最小-最大值是在子陣列上計算的，然後該子陣列被修改以進行歸一化。如果您只想使用 mask 來計算範數或最小-最大值，但要修改整個陣列，則可以使用 norm 和 Mat::convertTo。

對於稀疏矩陣，只分析和轉換非零值。因此，不允許對稀疏矩陣進行範圍轉換，因為它會改變零級別。

帶有一些正例資料的可能用法

vector<double> positiveData = { 2.0, 8.0, 10.0 };
vector<double> normalizedData_l1, normalizedData_l2, normalizedData_inf, normalizedData_minmax;
 
// 歸一化為機率（總計數）
// sum(numbers) = 20.0
// 2.0      0.1     (2.0/20.0)
// 8.0      0.4     (8.0/20.0)
// 10.0     0.5     (10.0/20.0)
normalize(positiveData, normalizedData_l1, 1.0, 0.0, NORM_L1);
 
// 歸一化為單位向量: ||positiveData|| = 1.0
// 2.0      0.15
// 8.0      0.62
// 10.0     0.77
normalize(positiveData, normalizedData_l2, 1.0, 0.0, NORM_L2);
 
// 歸一化為最大元素
// 2.0      0.2     (2.0/10.0)
// 8.0      0.8     (8.0/10.0)
// 10.0     1.0     (10.0/10.0)
normalize(positiveData, normalizedData_inf, 1.0, 0.0, NORM_INF);
 
// 歸一化到範圍 [0.0;1.0]
// 2.0 0.0 (左邊界偏移)
// 8.0      0.75    (6.0/8.0)
// 10.0 1.0 (右邊界偏移)
normalize(positiveData, normalizedData_minmax, 1.0, 0.0, NORM_MINMAX);

注意

由於舍入問題，最小-最大歸一化可能導致值超出提供的邊界。如果需要精確的範圍一致性，可以使用以下變通方法：

• 使用雙精度浮點（dtype = CV_64F）
• 手動裁剪值（cv::max(res, left_bound, res)、cv::min(res, right_bound, res) 或 np.clip）

引數

src	輸入陣列。
dst	與 src 大小相同的輸出陣列。
alpha	歸一化的範數值或範圍歸一化情況下的下限。
beta	範圍歸一化情況下的上限；它不用於範數歸一化。
norm_type	歸一化型別（參見 cv::NormTypes）。
dtype	當為負時，輸出陣列與 src 具有相同的型別；否則，它與 src 具有相同的通道數，並且深度 =CV_MAT_DEPTH(dtype)。
mask	可選操作掩碼。

另請參見

norm, Mat::convertTo, SparseMat::convertTo

示例

samples/cpp/pca.cpp.

此函式的呼叫圖如下

patchNaNs()

void cv::patchNaNs	(	InputOutputArray	a,
		double	val = 0 )

Python
	cv.patchNaNs(	a[, val]	) ->	a

#include <opencv2/core.hpp>

將 NaN 替換為給定數字。

引數

a	輸入/輸出矩陣（CV_32F 型別）。
val	用於轉換 NaN 的值

此函式的呼叫圖如下

PCABackProject()

void cv::PCABackProject	(	InputArray	data,
		InputArray	mean,
		InputArray	eigenvectors （特徵向量）,
		OutputArray	result )

Python
	cv.PCABackProject(	data, mean, eigenvectors[, result]	) ->	result

#include <opencv2/core.hpp>

封裝 PCA::backProject

此函式的呼叫圖如下

PCACompute() [1/4]

void cv::PCACompute	(	InputArray	data,
		InputOutputArray	mean,
		OutputArray	eigenvectors （特徵向量）,
		double	retainedVariance )

Python
	cv.PCACompute(	data, mean[, eigenvectors[, maxComponents]]	) ->	mean, eigenvectors
	cv.PCACompute(	data, mean, retainedVariance[, eigenvectors]	) ->	mean, eigenvectors
	cv.PCACompute2(	data, mean[, eigenvectors[, eigenvalues[, maxComponents]]]	) ->	mean, eigenvectors, eigenvalues
	cv.PCACompute2(	data, mean, retainedVariance[, eigenvectors[, eigenvalues]]	) ->	mean, eigenvectors, eigenvalues

#include <opencv2/core.hpp>

封裝 PCA::operator()

此函式的呼叫圖如下

PCACompute() [2/4]

void cv::PCACompute	(	InputArray	data,
		InputOutputArray	mean,
		OutputArray	eigenvectors （特徵向量）,
		int	maxComponents = 0 )

Python
	cv.PCACompute(	data, mean[, eigenvectors[, maxComponents]]	) ->	mean, eigenvectors
	cv.PCACompute(	data, mean, retainedVariance[, eigenvectors]	) ->	mean, eigenvectors
	cv.PCACompute2(	data, mean[, eigenvectors[, eigenvalues[, maxComponents]]]	) ->	mean, eigenvectors, eigenvalues
	cv.PCACompute2(	data, mean, retainedVariance[, eigenvectors[, eigenvalues]]	) ->	mean, eigenvectors, eigenvalues

#include <opencv2/core.hpp>

封裝 PCA::operator()

此函式的呼叫圖如下

PCACompute() [3/4]

void cv::PCACompute	(	InputArray	data,
		InputOutputArray	mean,
		OutputArray	eigenvectors （特徵向量）,
		OutputArray	eigenvalues （特徵值）,
		double	retainedVariance )

Python
	cv.PCACompute(	data, mean[, eigenvectors[, maxComponents]]	) ->	mean, eigenvectors
	cv.PCACompute(	data, mean, retainedVariance[, eigenvectors]	) ->	mean, eigenvectors
	cv.PCACompute2(	data, mean[, eigenvectors[, eigenvalues[, maxComponents]]]	) ->	mean, eigenvectors, eigenvalues
	cv.PCACompute2(	data, mean, retainedVariance[, eigenvectors[, eigenvalues]]	) ->	mean, eigenvectors, eigenvalues

#include <opencv2/core.hpp>

封裝 PCA::operator() 並新增特徵值輸出引數

此函式的呼叫圖如下

PCACompute() [4/4]

void cv::PCACompute	(	InputArray	data,
		InputOutputArray	mean,
		OutputArray	eigenvectors （特徵向量）,
		OutputArray	eigenvalues （特徵值）,
		int	maxComponents = 0 )

Python
	cv.PCACompute(	data, mean[, eigenvectors[, maxComponents]]	) ->	mean, eigenvectors
	cv.PCACompute(	data, mean, retainedVariance[, eigenvectors]	) ->	mean, eigenvectors
	cv.PCACompute2(	data, mean[, eigenvectors[, eigenvalues[, maxComponents]]]	) ->	mean, eigenvectors, eigenvalues
	cv.PCACompute2(	data, mean, retainedVariance[, eigenvectors[, eigenvalues]]	) ->	mean, eigenvectors, eigenvalues

#include <opencv2/core.hpp>

封裝 PCA::operator() 並新增特徵值輸出引數

此函式的呼叫圖如下

PCAProject()

void cv::PCAProject	(	InputArray	data,
		InputArray	mean,
		InputArray	eigenvectors （特徵向量）,
		OutputArray	result )

Python
	cv.PCAProject(	data, mean, eigenvectors[, result]	) ->	result

#include <opencv2/core.hpp>

封裝 PCA::project

此函式的呼叫圖如下

perspectiveTransform()

void cv::perspectiveTransform	(	InputArray	src,
		OutputArray	dst,
		InputArray	m )

Python
	cv.perspectiveTransform(	src, m[, dst]	) ->	dst

#include <opencv2/core.hpp>

執行向量的透視矩陣變換。

函式 cv::perspectiveTransform 將 src 的每個元素視為 2D 或 3D 向量，並按以下方式進行變換：

\[(x, y, z) \rightarrow (x'/w, y'/w, z'/w)\]

其中

\[(x', y', z', w') = \texttt{mat} \cdot \begin{bmatrix} x & y & z & 1 \end{bmatrix}\]

且

\[w = \fork{w'}{if \(w' \ne 0\)}{\infty}{otherwise}\]

這裡展示了 3D 向量變換。對於 2D 向量變換，z 分量被省略。

注意

該函式變換稀疏的 2D 或 3D 向量集。如果您想使用透視變換來變換影像，請使用 warpPerspective。如果您遇到逆問題，即想從幾對對應點中計算出最可能的透視變換，則可以使用 getPerspectiveTransform 或 findHomography。

引數

src	輸入雙通道或三通道浮點陣列；每個元素都是要變換的 2D/3D 向量。
dst	與 `src` 相同大小和型別的輸出陣列。
m	3x3 或 4x4 浮點變換矩陣。

另請參見

transform, warpPerspective, getPerspectiveTransform, findHomography

此函式的呼叫圖如下

phase()

void cv::phase	(	InputArray	x,
		InputArray	y,
		OutputArray	angle,
		bool	angleInDegrees = false )

Python
	cv.phase(	x, y[, angle[, angleInDegrees]]	) ->	angle

#include <opencv2/core.hpp>

計算二維向量的旋轉角度。

函式 cv::phase 計算由 x 和 y 的相應元素形成的每個 2D 向量的旋轉角度

\[\texttt{angle} (I) = \texttt{atan2} ( \texttt{y} (I), \texttt{x} (I))\]

角度估計精度約為 0.3 度。當 x(I)=y(I)=0 時，相應的 angle(I) 設定為 0。

引數

x	輸入的二維向量 x 座標浮點陣列。
y	2D 向量 y 座標的輸入陣列；它必須與 x 具有相同的大小和型別。
angle	向量角度的輸出陣列；它與 x 具有相同的大小和型別。
angleInDegrees	當為 true 時，函式以度為單位計算角度，否則以弧度為單位計算。

此函式的呼叫圖如下

polarToCart()

void cv::polarToCart	(	InputArray	magnitude,
		InputArray	angle,
		OutputArray	x,
		OutputArray	y,
		bool	angleInDegrees = false )

Python
	cv.polarToCart(	magnitude, angle[, x[, y[, angleInDegrees]]]	) ->	x, y

#include <opencv2/core.hpp>

根據二維向量的幅度和角度計算其 x 和 y 座標。

函式 cv::polarToCart 計算由幅度和角度的相應元素表示的每個 2D 向量的笛卡爾座標

\[\begin{array}{l} \texttt{x} (I) = \texttt{magnitude} (I) \cos ( \texttt{angle} (I)) \\ \texttt{y} (I) = \texttt{magnitude} (I) \sin ( \texttt{angle} (I)) \\ \end{array}\]

估計座標的相對精度約為 1e-6。

引數

magnitude	2D 向量幅度的浮點輸入陣列；它可以是一個空矩陣（=Mat()），在這種情況下，函式假定所有幅度都等於 1；如果它不為空，則它必須與 angle 具有相同的大小和型別。
angle	2D 向量角度的浮點輸入陣列。
x	2D 向量 x 座標的輸出陣列；它與 angle 具有相同的大小和型別。
y	2D 向量 y 座標的輸出陣列；它與 angle 具有相同的大小和型別。
angleInDegrees	當為 true 時，輸入角度以度為單位測量，否則以弧度為單位測量。

另請參見

cartToPolar, magnitude, phase, exp, log, pow, sqrt

此函式的呼叫圖如下

pow()

void cv::pow	(	InputArray	src,
		double	power,
		OutputArray	dst )

Python
	cv.pow(	src, power[, dst]	) ->	dst

#include <opencv2/core.hpp>

將每個陣列元素提升到指定冪。

函式 cv::pow 將輸入陣列的每個元素提升到指定冪

\[\texttt{dst} (I) = \fork{\texttt{src}(I)^{power}}{if \(\texttt{power}\) is integer}{|\texttt{src}(I)|^{power}}{otherwise}\]

因此，對於非整數冪指數，使用輸入陣列元素的絕對值。但是，透過一些額外的操作，可以獲得負值的真實值。在下面的示例中，計算陣列 src 的 5 次方根顯示：

Mat mask = src < 0;
pow(src, 1./5, dst);
subtract(Scalar::all(0), dst, dst, mask);

對於某些冪值，例如整數值、0.5 和 -0.5，會使用專門的更快速的演算法。

特殊值（NaN、Inf）不予處理。

引數

src	輸入陣列。
power	冪的指數。
dst	與 `src` 相同大小和型別的輸出陣列。

另請參見

sqrt, exp, log, cartToPolar, polarToCart

PSNR()

double cv::PSNR	(	InputArray	src1,
		InputArray	src2,
		double	R = 255. )

Python
	cv.PSNR(	src1, src2[, R]	) ->	retval

#include <opencv2/core.hpp>

計算峰值信噪比（PSNR）影像質量指標。

此函式計算兩個輸入陣列 src1 和 src2 之間的峰值信噪比（PSNR）影像質量指標，以分貝（dB）為單位。陣列必須具有相同的型別。

PSNR 計算如下：

\[ \texttt{PSNR} = 10 \cdot \log_{10}{\left( \frac{R^2}{MSE} \right) } \]

其中 R 是深度的最大整數值（例如 CV_8U 資料的情況下為 255），MSE 是兩個陣列之間的均方誤差。

引數

src1	第一個輸入陣列。
src2	與 src1 大小相同的第二個輸入陣列。
R	最大畫素值（預設為 255）

此函式的呼叫圖如下

randn()

void cv::randn	(	InputOutputArray	dst,
		InputArray	mean,
		InputArray	stddev )

Python
	cv.randn(	dst, mean, stddev	) ->	dst

#include <opencv2/core.hpp>

用正態分佈的隨機數填充陣列。

函式 cv::randn 用指定均值向量和標準差矩陣的正態分佈隨機數填充矩陣 dst。生成的隨機數會被裁剪以適應輸出陣列資料型別的值範圍。

引數

dst	隨機數的輸出陣列；該陣列必須預先分配並具有 1 到 4 個通道。
mean	生成的隨機數的平均值（期望）。
stddev	生成的隨機數的標準差；它可以是向量（在這種情況下，假定為對角標準差矩陣）或方陣。

另請參見

RNG, randu

此函式的呼叫圖如下

randShuffle()

void cv::randShuffle	(	InputOutputArray	dst,
		double	iterFactor = 1.,
		RNG *	rng = 0 )

Python
	cv.randShuffle(	dst[, iterFactor]	) ->	dst

#include <opencv2/core.hpp>

隨機打亂陣列元素。

函式 cv::randShuffle 透過隨機選擇元素對並交換它們來打亂指定的 1D 陣列。此類交換操作的數量將是 dst.rows*dst.cols*iterFactor。

引數

dst	輸入/輸出數值 1D 陣列。
iterFactor	確定隨機交換運算元量的比例因子（參見下面的詳細資訊）。
rng	用於打亂的可選隨機數生成器；如果為零，則改用 theRNG()。

另請參見

RNG, sort

示例

modules/shape/samples/shape_example.cpp.

此函式的呼叫圖如下

randu()

void cv::randu	(	InputOutputArray	dst,
		InputArray	low,
		InputArray	high )

Python
	cv.randu(	dst, low, high	) ->	dst

#include <opencv2/core.hpp>

生成單個均勻分佈的隨機數或隨機數陣列。

該函式的非模板變體使用指定範圍內的均勻分佈隨機數填充矩陣 dst

\[\texttt{low} _c \leq \texttt{dst} (I)_c < \texttt{high} _c\]

引數

dst	隨機數的輸出陣列；該陣列必須預先分配。
low	生成的隨機數的包含下限。
high	生成的隨機數的獨佔上限。

另請參見

RNG, randn, theRNG

此函式的呼叫圖如下

reduce()

void cv::reduce	(	InputArray	src,
		OutputArray	dst,
		int	dim,
		int	rtype,
		int	dtype = -1 )

Python
	cv.reduce(	src, dim, rtype[, dst[, dtype]]	) ->	dst

#include <opencv2/core.hpp>

將矩陣降維為向量。

函式 reduce 透過將矩陣行/列視為一組 1D 向量並對這些向量執行指定操作，直到獲得單個行/列，從而將矩陣降維為向量。例如，該函式可用於計算柵格影像的水平和垂直投影。在 REDUCE_MAX 和 REDUCE_MIN 的情況下，輸出影像應與源影像具有相同的型別。在 REDUCE_SUM、REDUCE_SUM2 和 REDUCE_AVG 的情況下，輸出可能具有更大的元素位深度以保持精度。多通道陣列也支援這兩種縮減模式。

以下程式碼演示了它在單通道矩陣上的用法。

        Mat m = (Mat_<uchar>(3,2) << 1,2,3,4,5,6);
        Mat col_sum, row_sum;
 
        reduce(m, col_sum, 0, REDUCE_SUM, CV_32F);
        reduce(m, row_sum, 1, REDUCE_SUM, CV_32F);
        /*
m =
        [  1,   2;
           3,   4;
           5,   6]
col_sum =
        [9, 12]
row_sum =
        [3;
         7;
         11]
         */

以下程式碼演示了它在雙通道矩陣上的用法。

        // 兩個通道
        char d[] = {1,2,3,4,5,6};
        Mat m(3, 1, CV_8UC2, d);
        Mat col_sum_per_channel;
        reduce(m, col_sum_per_channel, 0, REDUCE_SUM, CV_32F);
        /*
col_sum_per_channel =
        [9, 12]
        */

引數

src	輸入 2D 矩陣。
dst	輸出向量。其大小和型別由 dim 和 dtype 引數定義。
dim	矩陣沿其縮減的維度索引。0 表示將矩陣縮減為單行。1 表示將矩陣縮減為單列。
rtype	縮減操作，可以是 ReduceTypes 之一
dtype	當為負時，輸出向量將與輸入矩陣具有相同的型別，否則，其型別將為 CV_MAKE_TYPE(CV_MAT_DEPTH(dtype), src.channels())。

另請參見

repeat, reduceArgMin, reduceArgMax

此函式的呼叫圖如下

reduceArgMax()

void cv::reduceArgMax	(	InputArray	src,
		OutputArray	dst,
		int	axis（軸）,
		bool	lastIndex = false )

Python
	cv.reduceArgMax(	src, axis[, dst[, lastIndex]]	) ->	dst

#include <opencv2/core.hpp>

沿給定軸查詢最大元素的索引。

注意

• 如果輸入或輸出陣列不是連續的，此函式將建立一個內部副本。
• NaN 處理未明確指定，請參見 patchNaNs()。
• 返回的索引始終在輸入矩陣的邊界內。

引數

src	單通道輸入陣列。
dst	型別為 CV_32SC1 的輸出陣列，與 src 具有相同的維度，除了被縮減的軸——它應設定為 1。
lastIndex	獲取最大值的第一個或最後一個出現位置的索引。
axis（軸）	要沿其縮減的軸。

另請參見

reduceArgMin, minMaxLoc, min, max, compare, reduce

此函式的呼叫圖如下

reduceArgMin()

void cv::reduceArgMin	(	InputArray	src,
		OutputArray	dst,
		int	axis（軸）,
		bool	lastIndex = false )

Python
	cv.reduceArgMin(	src, axis[, dst[, lastIndex]]	) ->	dst

#include <opencv2/core.hpp>

沿給定軸查詢最小元素的索引。

注意

• 如果輸入或輸出陣列不是連續的，此函式將建立一個內部副本。
• NaN 處理未明確指定，請參見 patchNaNs()。
• 返回的索引始終在輸入矩陣的邊界內。

引數

src	單通道輸入陣列。
dst	型別為 CV_32SC1 的輸出陣列，與 src 具有相同的維度，除了被縮減的軸——它應設定為 1。
lastIndex	獲取最小值的第一個或最後一個出現位置的索引。
axis（軸）	要沿其縮減的軸。

另請參見

reduceArgMax, minMaxLoc, min, max, compare, reduce

此函式的呼叫圖如下

repeat() [1/2]

Mat cv::repeat	(	const Mat &	src,
		int	ny,
		int	nx )

Python
	cv.repeat(	src, ny, nx[, dst]	) ->	dst

#include <opencv2/core.hpp>

這是一個過載成員函式，為方便起見提供。它與上述函式的區別僅在於其接受的引數。

引數

src	要複製的輸入陣列。
ny	指定 src 沿垂直軸重複次數的標誌。
nx	指定 src 沿水平軸重複次數的標誌。

此函式的呼叫圖如下

repeat() [2/2]

void cv::repeat	(	InputArray	src,
		int	ny,
		int	nx,
		OutputArray	dst )

Python
	cv.repeat(	src, ny, nx[, dst]	) ->	dst

#include <opencv2/core.hpp>

用輸入陣列的重複副本填充輸出陣列。

函式 cv::repeat 沿兩個軸中的每個軸重複輸入陣列一次或多次

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

該函式的第二個變體更方便與 MatrixExpressions 一起使用。

引數

src	要複製的輸入陣列。
ny	指定 src 沿垂直軸重複次數的標誌。
nx	指定 src 沿水平軸重複次數的標誌。
dst	與 src 型別相同的輸出陣列。

另請參見

cv::reduce

此函式的呼叫圖如下

rotate()

void cv::rotate	(	InputArray	src,
		OutputArray	dst,
		int	rotateCode )

Python
	cv.rotate(	src, rotateCode[, dst]	) ->	dst

#include <opencv2/core.hpp>

將二維陣列旋轉 90 度的倍數。函式 cv::rotate 以三種不同方式之一旋轉陣列：順時針旋轉 90 度 (rotateCode = ROTATE_90_CLOCKWISE)。順時針旋轉 180 度 (rotateCode = ROTATE_180)。順時針旋轉 270 度 (rotateCode = ROTATE_90_COUNTERCLOCKWISE)。

引數

src	輸入陣列。
dst	與 src 型別相同的輸出陣列。對於 ROTATE_180，大小相同，而對於 ROTATE_90_CLOCKWISE 和 ROTATE_90_COUNTERCLOCKWISE，行和列會互換。
rotateCode	一個列舉，用於指定如何旋轉陣列；參見列舉 RotateFlags

另請參見

transpose, repeat, completeSymm, flip, RotateFlags

此函式的呼叫圖如下

scaleAdd()

void cv::scaleAdd	(	InputArray	src1,
		double	alpha,
		InputArray	src2,
		OutputArray	dst )

Python
	cv.scaleAdd(	src1, alpha, src2[, dst]	) ->	dst

#include <opencv2/core.hpp>

計算縮放陣列與另一個數組的和。

函式 scaleAdd 是經典的基本線性代數運算之一，在 BLAS 中稱為 DAXPY 或 SAXPY。它計算一個縮放陣列與另一個數組的和

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

該函式也可以透過矩陣表示式模擬，例如

Mat A(3, 3, CV_64F);
...
A.row(0) = A.row(1)*2 + A.row(2);

引數

src1	第一個輸入陣列。
alpha	第一個陣列的比例因子。
src2	與 src1 大小和型別相同的第二個輸入陣列。
dst	與 src1 大小和型別相同的輸出陣列。

另請參見

add, addWeighted, subtract, Mat::dot, Mat::convertTo

此函式的呼叫圖如下

setIdentity()

void cv::setIdentity	(	InputOutputArray	makePtr(),
		const Scalar &	s = Scalar(1) )

Python
	cv.setIdentity(	mtx[, s]	) ->	makePtr()

#include <opencv2/core.hpp>

初始化一個縮放的單位矩陣。

函式 cv::setIdentity 初始化一個縮放的單位矩陣

\[\texttt{mtx} (i,j)= \fork{\texttt{value}}{ if \(i=j\)}{0}{otherwise}\]

該函式也可以使用矩陣初始化器和矩陣表示式模擬

Mat A = Mat::eye(4, 3, CV_32F)*5;
// A 將被設定為 [[5, 0, 0], [0, 5, 0], [0, 0, 5], [0, 0, 0]]

引數

makePtr()	要初始化的矩陣（不一定是方陣）。
s	賦給對角線元素的值。

另請參見

Mat::zeros, Mat::ones, Mat::setTo, Mat::operator=

此函式的呼叫圖如下

setRNGSeed()

void cv::setRNGSeed

(

int

seed

)

Python
	cv.setRNGSeed(	seed	) ->	無

#include <opencv2/core.hpp>

設定預設隨機數生成器的狀態。

函式 cv::setRNGSeed 將預設隨機數生成器的狀態設定為自定義值。

引數

seed	預設隨機數生成器的新狀態

另請參見

RNG, randu, randn

此函式的呼叫圖如下

solve()

bool cv::solve	(	InputArray	src1,
		InputArray	src2,
		OutputArray	dst,
		int	flags = DECOMP_LU )

Python
	cv.solve(	src1, src2[, dst[, flags]]	) ->	retval, dst

#include <opencv2/core.hpp>

求解一個或多個線性系統或最小二乘問題。

函式 cv::solve 解決線性系統或最小二乘問題（後者可透過 SVD 或 QR 方法，或透過指定標誌 DECOMP_NORMAL 來實現）

\[\texttt{dst} = \arg \min _X \| \texttt{src1} \cdot \texttt{X} - \texttt{src2} \|\]

如果使用 DECOMP_LU 或 DECOMP_CHOLESKY 方法，則當 src1 (或 \(\texttt{src1}^T\texttt{src1}\) ) 非奇異時，函式返回 1。否則，返回 0。在這種情況下，dst 無效。其他方法在左側部分奇異的情況下找到偽解。

注意

如果您想找到欠定奇異系統 \(\texttt{src1}\cdot\texttt{dst}=0\) 的單位範數解，則 solve 函式無法完成此工作。請改用 SVD::solveZ。

引數

src1	系統左側的輸入矩陣。
src2	系統右側的輸入矩陣。
dst	輸出解。
flags	解（矩陣求逆）方法（DecompTypes）

另請參見

invert, SVD, eigen

此函式的呼叫圖如下

solveCubic()

int cv::solveCubic	(	InputArray	coeffs,
		OutputArray	roots )

Python
	cv.solveCubic(	coeffs[, roots]	) ->	retval, roots

#include <opencv2/core.hpp>

查詢三次方程的實根。

函式 solveCubic 查詢三次方程的實數根

• 如果 coeffs 是一個 4 元素向量

  \[\texttt{coeffs} [0] x^3 + \texttt{coeffs} [1] x^2 + \texttt{coeffs} [2] x + \texttt{coeffs} [3] = 0\]

• 如果 coeffs 是一個 3 元素向量

  \[x^3 + \texttt{coeffs} [0] x^2 + \texttt{coeffs} [1] x + \texttt{coeffs} [2] = 0\]

根儲存在roots陣列中。

引數

coeffs	方程係數，一個包含 3 或 4 個元素的陣列。
roots	實數根的輸出陣列，包含 0、1、2 或 3 個元素。

返回

實數根的數量。它可以是 -1（所有實數）、0、1、2 或 3。

此函式的呼叫圖如下

solvePoly()

double cv::solvePoly	(	InputArray	coeffs,
		OutputArray	roots,
		int	maxIters = 300 )

Python
	cv.solvePoly(	coeffs[, roots[, maxIters]]	) ->	retval, roots

#include <opencv2/core.hpp>

查詢多項式方程的實根或復根。

函式 cv::solvePoly 查詢多項式方程的實數根和複數根

\[\texttt{coeffs} [n] x^{n} + \texttt{coeffs} [n-1] x^{n-1} + ... + \texttt{coeffs} [1] x + \texttt{coeffs} [0] = 0\]

引數

coeffs	多項式係數陣列。
roots	（複數）根的輸出陣列。
maxIters	演算法執行的最大迭代次數。

此函式的呼叫圖如下

sort()

void cv::sort	(	InputArray	src,
		OutputArray	dst,
		int	flags )

Python
	cv.sort(	src, flags[, dst]	) ->	dst

#include <opencv2/core.hpp>

對矩陣的每行或每列進行排序。

函式 cv::sort 對矩陣的每一行或每一列進行升序或降序排序。因此，您應該傳遞兩個操作標誌以獲得所需行為。如果您想按字典順序對矩陣行或列進行排序，可以使用帶有適當比較謂詞的 STL std::sort 泛型函式。

引數

src	單通道輸入陣列。
dst	與 `src` 相同大小和型別的輸出陣列。
flags	操作標誌，是 SortFlags 的組合

另請參見

sortIdx, randShuffle

此函式的呼叫圖如下

sortIdx()

void cv::sortIdx	(	InputArray	src,
		OutputArray	dst,
		int	flags )

Python
	cv.sortIdx(	src, flags[, dst]	) ->	dst

#include <opencv2/core.hpp>

對矩陣的每行或每列進行排序。

函式 cv::sortIdx 對矩陣的每一行或每一列進行升序或降序排序。因此，您應該傳遞兩個操作標誌以獲得所需行為。它不是重新排列元素本身，而是將排序元素的索引儲存在輸出陣列中。例如

Mat A = Mat::eye(3,3,CV_32F), B;
sortIdx(A, B, SORT_EVERY_ROW + SORT_ASCENDING);
// B 將可能包含
// (由於 A 中元素相等，可能存在一些排列)
// [[1, 2, 0], [0, 2, 1], [0, 1, 2]]

引數

src	單通道輸入陣列。
dst	與 src 大小相同的整數輸出陣列。
flags	操作標誌，可以是 cv::SortFlags 的組合

另請參見

sort, randShuffle

此函式的呼叫圖如下

split() [1/2]

void cv::split	(	const Mat &	src,
		Mat *	mvbegin )

Python
	cv.split(	m[, mv]	) ->	mv

#include <opencv2/core.hpp>

將多通道陣列分割為多個單通道陣列。

函式 cv::split 將多通道陣列分割成單獨的單通道陣列

\[\texttt{mv} [c](I) = \texttt{src} (I)_c\]

如果您需要提取單個通道或進行其他複雜的通道置換，請使用 mixChannels。

以下示例演示如何將 3 通道矩陣分割成 3 個單通道矩陣。

    char d[] = {1,2,3,4,5,6,7,8,9,10,11,12};
    Mat m(2, 2, CV_8UC3, d);
    Mat channels[3];
    split(m, channels);
 
    /*
channels[0] =
    [  1,   4;
       7,  10]
channels[1] =
    [  2,   5;
       8,  11]
channels[2] =
    [  3,   6;
       9,  12]
    */

引數

src	輸入多通道陣列。
mvbegin	輸出陣列；陣列數量必須與 src.channels() 匹配；如果需要，陣列本身會被重新分配。

另請參見

merge, mixChannels, cvtColor

此函式的呼叫圖如下

split() [2/2]

void cv::split	(	InputArray	m,
		OutputArrayOfArrays	mv )

Python
	cv.split(	m[, mv]	) ->	mv

#include <opencv2/core.hpp>

這是一個過載成員函式，為方便起見提供。它與上述函式的區別僅在於其接受的引數。

引數

m	輸入多通道陣列。
mv	輸出陣列向量；如果需要，陣列本身會被重新分配。

此函式的呼叫圖如下

sqrt()

void cv::sqrt	(	InputArray	src,
		OutputArray	dst )

Python
	cv.sqrt(	src[, dst]	) ->	dst

#include <opencv2/core.hpp>

計算陣列元素的平方根。

函式 cv::sqrt 計算輸入陣列每個元素的平方根。對於多通道陣列，每個通道獨立處理。精度與內建的 std::sqrt 大致相同。

引數

src	輸入浮點陣列。
dst	與 `src` 相同大小和型別的輸出陣列。

subtract()

void cv::subtract	(	InputArray	src1,
		InputArray	src2,
		OutputArray	dst,
		InputArray	mask = noArray(),
		int	dtype = -1 )

Python
	cv.subtract(	src1, src2[, dst[, mask[, dtype]]]	) ->	dst

#include <opencv2/core.hpp>

計算兩個陣列或陣列與標量之間的逐元素差。

函式 subtract 計算

• 兩個陣列之間的差，當兩個輸入陣列具有相同大小和相同通道數時

  \[\texttt{dst}(I) = \texttt{saturate} ( \texttt{src1}(I) - \texttt{src2}(I)) \quad \texttt{if mask}(I) \ne0\]

• 陣列與標量之間的差，當 src2 由 Scalar 構造或具有與 src1.channels() 相同數量的元素時

  \[\texttt{dst}(I) = \texttt{saturate} ( \texttt{src1}(I) - \texttt{src2} ) \quad \texttt{if mask}(I) \ne0\]

• 標量與陣列之間的差，當 src1 由 Scalar 構造或具有與 src2.channels() 相同數量的元素時

  \[\texttt{dst}(I) = \texttt{saturate} ( \texttt{src1} - \texttt{src2}(I) ) \quad \texttt{if mask}(I) \ne0\]

• 在 SubRS 的情況下，標量與陣列之間的反向差

  \[\texttt{dst}(I) = \texttt{saturate} ( \texttt{src2} - \texttt{src1}(I) ) \quad \texttt{if mask}(I) \ne0\]

  其中 I 是陣列元素的（多維）索引。在多通道陣列的情況下，每個通道獨立處理。

列表中第一個函式可以用矩陣表示式替換

dst = src1 - src2;
dst -= src1; // 等同於 subtract(dst, src1, dst);

輸入陣列和輸出陣列可以具有相同或不同的深度。例如，您可以將 8 位無符號陣列相減並將差值儲存在 16 位有符號陣列中。輸出陣列的深度由 dtype 引數決定。在上述第二種和第三種情況以及第一種情況中，當 src1.depth() == src2.depth() 時，dtype 可以設定為預設值 -1。在這種情況下，輸出陣列將與輸入陣列（無論是 src1、src2 還是兩者）具有相同的深度。

注意

當輸出陣列深度為 CV_32S 時，不應用飽和。在溢位情況下，甚至可能得到不正確的符號結果。

(Python) 請注意 src1/src2 為單個數字與它們為元組/陣列時的行為差異。subtract(src,X) 意味著 subtract(src,(X,X,X,X))。subtract(src,(X,)) 意味著 subtract(src,(X,0,0,0))。

引數

src1	第一個輸入陣列或標量。
src2	第二個輸入陣列或標量。
dst	與輸入陣列具有相同大小和相同通道數的輸出陣列。
mask	可選操作掩碼；這是一個 8 位單通道陣列，用於指定要更改的輸出陣列元素。
dtype	輸出陣列的可選深度

另請參見

add, addWeighted, scaleAdd, Mat::convertTo

此函式的呼叫圖如下

sum()

Scalar cv::sum

(

InputArray

src

)

Python
	cv.sumElems(	src	) ->	retval

#include <opencv2/core.hpp>

計算陣列元素的和。

函式 cv::sum 計算並返回陣列元素的總和，每個通道獨立計算。

引數

src	輸入陣列，必須有 1 到 4 個通道。

另請參見

countNonZero, mean, meanStdDev, norm, minMaxLoc, reduce

示例

samples/dnn/classification.cpp.

此函式的呼叫圖如下

SVBackSubst()

void cv::SVBackSubst	(	InputArray	w,
		InputArray	u,
		InputArray	vt,
		InputArray	rhs,
		OutputArray	dst )

Python
	cv.SVBackSubst(	w, u, vt, rhs[, dst]	) ->	dst

#include <opencv2/core.hpp>

wrap SVD::backSubst

此函式的呼叫圖如下

SVDecomp()

void cv::SVDecomp	(	InputArray	src,
		OutputArray	w,
		OutputArray	u,
		OutputArray	vt,
		int	flags = 0 )

Python
	cv.SVDecomp(	src[, w[, u[, vt[, flags]]]]	) ->	w, u, vt

#include <opencv2/core.hpp>

wrap SVD::compute

此函式的呼叫圖如下

swap() [1/2]

void cv::swap	(	Mat &	a,
		Mat &	b )

#include <opencv2/core.hpp>

交換兩個矩陣。

示例

samples/cpp/lkdemo.cpp.

swap() [2/2]

void cv::swap	(	UMat &	a,
		UMat &	b )

#include <opencv2/core.hpp>

這是一個過載成員函式，為方便起見提供。它與上述函式的區別僅在於其接受的引數。

theRNG()

RNG & cv::theRNG

(

)

#include <opencv2/core.hpp>

返回預設的隨機數生成器。

函式 cv::theRNG 返回預設的隨機數生成器。每個執行緒都有一個獨立的隨機數生成器，因此您可以在多執行緒環境中安全地使用此函式。如果您只需要使用此生成器獲取單個隨機數或初始化陣列，可以使用 randu 或 randn 代替。但是，如果您打算在迴圈中生成許多隨機數，則使用此函式檢索生成器，然後使用 RNG::operator _Tp() 會快得多。

另請參見

RNG, randu, randn

此函式的呼叫圖如下

trace()

Scalar cv::trace

(

InputArray

makePtr()

)

Python
	由  1.12.0 生成於 2025年7月3日 星期四 12:14:36，面向 OpenCV	makePtr()	) ->	retval

#include <opencv2/core.hpp>

返回矩陣的跡。

函式 cv::trace 返回矩陣 mtx 對角線元素的和。

\[\mathrm{tr} ( \texttt{mtx} ) = \sum _i \texttt{mtx} (i,i)\]

引數

makePtr()

輸入矩陣。

此函式的呼叫圖如下

transform()

void cv::transform	(	InputArray	src,
		OutputArray	dst,
		InputArray	m )

Python
	cv.transform(	src, m[, dst]	) ->	dst

#include <opencv2/core.hpp>

對每個陣列元素執行矩陣變換。

函式 cv::transform 對陣列 src 的每個元素執行矩陣變換，並將結果儲存在 dst 中

\[\texttt{dst} (I) = \texttt{m} \cdot \texttt{src} (I)\]

（當 m.cols=src.channels() 時），或

\[\texttt{dst} (I) = \texttt{m} \cdot [ \texttt{src} (I); 1]\]

（當 m.cols=src.channels()+1 時）

N通道陣列 src 的每個元素都被解釋為 N 元素向量，該向量使用 M x N 或 M x (N+1) 矩陣 m 變換為 M 元素向量——即輸出陣列 dst 的相應元素。

該函式可用於 N 維點的幾何變換、任意線性色彩空間變換（例如各種 RGB 到 YUV 變換）、影像通道的重排等等。

引數

src	輸入陣列，其通道數（1 到 4）必須與 m.cols 或 m.cols-1 相同。
dst	輸出陣列，與 src 具有相同的大小和深度；其通道數與 m.rows 相同。
m	變換矩陣，2x2 或 2x3 浮點矩陣。

另請參見

perspectiveTransform, getAffineTransform, estimateAffine2D, warpAffine, warpPerspective

此函式的呼叫圖如下

transpose()

void cv::transpose	(	InputArray	src,
		OutputArray	dst )

Python
	cv.transpose(	src[, dst]	) ->	dst

#include <opencv2/core.hpp>

轉置矩陣。

函式 cv::transpose 轉置矩陣 src

\[\texttt{dst} (i,j) = \texttt{src} (j,i)\]

注意

對於複數矩陣，不執行復共軛。如果需要，應單獨執行。

引數

src	輸入陣列。
dst	與 src 相同型別的輸出陣列。

此函式的呼叫圖如下

transposeND()

void cv::transposeND	(	InputArray	src,
		const std::vector< int > &	order,
		OutputArray	dst )

Python
	cv.transposeND(	src, order[, dst]	) ->	dst

#include <opencv2/core.hpp>

n維矩陣的轉置。

注意

輸入應為連續的單通道矩陣。

引數

src	輸入陣列。
order	一個 [0,1,..,N-1] 的排列，其中 N 是 src 的軸數。dst 的第 i 個軸將對應於輸入的 order[i] 編號的軸。
dst	與 src 相同型別的輸出陣列。

此函式的呼叫圖如下

vconcat() [1/3]

void cv::vconcat	(	const Mat *	src,
		size_t	nsrc,
		OutputArray	dst )

Python
	cv.vconcat(	src[, dst]	) ->	dst

#include <opencv2/core.hpp>

對給定矩陣執行垂直連線。

此函式將兩個或更多 cv::Mat 矩陣垂直連線（它們必須具有相同的列數）。

cv::Mat matArray[] = { cv::Mat(1, 4, CV_8UC1, cv::Scalar(1)),
                       cv::Mat(1, 4, CV_8UC1, cv::Scalar(2)),
                       cv::Mat(1, 4, CV_8UC1, cv::Scalar(3)),};
 
cv::Mat out;
cv::vconcat( matArray, 3, out );
// 輸出
//[1,   1,   1,   1;
// 2,   2,   2,   2;
// 3,   3,   3,   3]

引數

src	輸入陣列或矩陣向量。所有矩陣必須具有相同的列數和相同的深度。
nsrc	src 中的矩陣數量。
dst	輸出陣列。它與 src 具有相同的列數和深度，行數是 src 的行數之和。

另請參見

cv::hconcat(const Mat*, size_t, OutputArray),

cv::hconcat(InputArrayOfArrays, OutputArray) 和

cv::hconcat(InputArray, InputArray, OutputArray)

此函式的呼叫圖如下

vconcat() [2/3]

void cv::vconcat	(	InputArray	src1,
		InputArray	src2,
		OutputArray	dst )

Python
	cv.vconcat(	src[, dst]	) ->	dst

#include <opencv2/core.hpp>

這是一個過載成員函式，為方便起見提供。它與上述函式的區別僅在於其接受的引數。

cv::Mat_<float> A = (cv::Mat_<float>(3, 2) << 1, 7,
                                              2, 8,
                                              3, 9);
cv::Mat_<float> B = (cv::Mat_<float>(3, 2) << 4, 10,
                                              5, 11,
                                              6, 12);
 
cv::Mat C;
cv::vconcat(A, B, C);
//C
//[1, 7;
// 2, 8;
// 3, 9;
// 4, 10;
// 5, 11;
// 6, 12]

引數

src1	第一個用於垂直連線的輸入陣列。
src2	第二個用於垂直連線的輸入陣列。
dst	輸出陣列。它與 src1 和 src2 具有相同的列數和深度，行數是 src1 和 src2 行數之和。

此函式的呼叫圖如下

vconcat() [3/3]

void cv::vconcat	(	InputArrayOfArrays	src,
		OutputArray	dst )

Python
	cv.vconcat(	src[, dst]	) ->	dst

#include <opencv2/core.hpp>

這是一個過載成員函式，為方便起見提供。它與上述函式的區別僅在於其接受的引數。

std::vector<cv::Mat> matrices = { cv::Mat(1, 4, CV_8UC1, cv::Scalar(1)),
                                  cv::Mat(1, 4, CV_8UC1, cv::Scalar(2)),
                                  cv::Mat(1, 4, CV_8UC1, cv::Scalar(3)),};
 
cv::Mat out;
cv::vconcat( matrices, out );
// 輸出
//[1,   1,   1,   1;
// 2,   2,   2,   2;
// 3,   3,   3,   3]

引數

src	輸入陣列或矩陣向量。所有矩陣必須具有相同的列數和相同的深度。
dst	輸出陣列。它與 src 具有相同的列數和深度，行數是 src 的行數之和。深度相同。

此函式的呼叫圖如下