陣列操作

詳細說明

類
類	cv::LDA
	線性判別分析。 更多...
類	cv::PCA
	主成分分析。 更多...
類	cv::RNG
	隨機數生成器。 更多...
類	cv::RNG_MT19937
	梅森旋轉演算法隨機數生成器。 更多...
類	cv::SVD
	奇異值分解。 更多...

列舉
enum	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 }
enum	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 }
	比較型別 更多...
enum	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 }
	協方差標誌。 更多...
enum	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 }
	矩陣分解型別 更多...
enum	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 }
enum	cv::GemmFlags {   cv::GEMM_1_T = 1 ,   cv::GEMM_2_T = 2 ,   cv::GEMM_3_T = 4 }
	廣義矩陣乘法標誌 更多...
enum	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 }
enum	cv::ReduceTypes {   cv::REDUCE_SUM = 0 ,   cv::REDUCE_AVG = 1 ,   cv::REDUCE_MAX = 2 ,   cv::REDUCE_MIN = 3 ,   cv::REDUCE_SUM2 = 4 }
enum	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)
	計算二維向量的幅值和角度。
bool	cv::checkRange (InputArray a, bool quiet=true, Point *pos=0, double minVal=-DBL_MAX, double maxVal=DBL_MAX)
	檢查輸入陣列中的每個元素是否含有無效值。
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)
	將陣列轉換為半精度浮點數。
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())
	在影像周圍形成邊框。
void	cv::copyTo (InputArray src, OutputArray dst, InputArray mask)
	這是一個過載的成員函式，為了方便 (python) 提供。將矩陣複製到另一個矩陣。指定操作掩碼時，如果上述 Mat::create 呼叫重新分配了矩陣，則新分配的矩陣在複製資料前會被初始化為全零。
int	cv::countNonZero (InputArray src)
	統計非零陣列元素的數量。
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)
	沿垂直軸、水平軸或雙軸翻轉二維陣列。
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)

列舉型別文件 (Enumeration Type Documentation)

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

列舉值 (Enumerator)
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>

比較型別

列舉值 (Enumerator)
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>

協方差標誌。

列舉值 (Enumerator)
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（例如，用於人臉識別的特徵臉技術）。該“打亂”矩陣的特徵值與真實協方差矩陣的特徵值相匹配。可以透過“打亂”協方差矩陣的特徵向量輕鬆計算出“真實”特徵向量。
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 將是一個方陣，其大小與每個輸入向量中的元素總數相同。必須指定 COVAR_SCRAMBLED 或 COVAR_NORMAL 中的一種且僅能指定一種。
COVAR_USE_AVG  Python: cv.COVAR_USE_AVG	如果指定該標誌，函式將不從輸入向量計算均值，而是使用傳入的均值向量。如果均值已預先計算、已知，或者需要分批計算協方差矩陣，這將非常有用。在這種情況下，mean 不是輸入向量子集的均值向量，而是整個集合的均值向量。
COVAR_SCALE  Python: cv.COVAR_SCALE	如果指定該標誌，協方差矩陣將被縮放。在“普通”模式下，scale 為 1./nsamples。在“打亂”模式下，scale 為每個輸入向量中元素總數的倒數。預設情況下（如果不指定該標誌），協方差矩陣不進行縮放 (scale=1)。
COVAR_ROWS  Python: cv.COVAR_ROWS	如果指定該標誌，所有輸入向量都作為 samples 矩陣的行儲存。在這種情況下，mean 應該是一個單行向量。
COVAR_COLS  Python: cv.COVAR_COLS	如果指定該標誌，所有輸入向量都作為 samples 矩陣的列儲存。在這種情況下，mean 應該是一個單列向量。

DecompTypes

列舉 cv::DecompTypes

#include <opencv2/core/base.hpp>

矩陣分解型別

列舉值 (Enumerator)
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>

列舉值 (Enumerator)
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>

廣義矩陣乘法標誌

列舉值 (Enumerator)
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 表示輸入陣列。

列舉值 (Enumerator)
NORM_INF  Python: cv.NORM_INF	\[ norm = \forkthree {\|\texttt{src1}\|_{L_{\infty}} = \max _I | \texttt{src1} (I)|}{如果 \(\texttt{normType} = \texttt{NORM_INF}\) } {\|\texttt{src1}-\texttt{src2}\|_{L_{\infty}} = \max _I | \texttt{src1} (I) - \texttt{src2} (I)|}{如果 \(\texttt{normType} = \texttt{NORM_INF}\) } {\frac{\|\texttt{src1}-\texttt{src2}\|_{L_{\infty}} }{\|\texttt{src2}\|_{L_{\infty}} }}{如果 \(\texttt{normType} = \texttt{NORM_RELATIVE | NORM_INF}\) } \]
NORM_L1  Python: cv.NORM_L1	\[ norm = \forkthree {\| \texttt{src1} \| _{L_1} = \sum _I | \texttt{src1} (I)|}{如果 \(\texttt{normType} = \texttt{NORM_L1}\)} { \| \texttt{src1} - \texttt{src2} \| _{L_1} = \sum _I | \texttt{src1} (I) - \texttt{src2} (I)|}{如果 \(\texttt{normType} = \texttt{NORM_L1}\) } { \frac{\|\texttt{src1}-\texttt{src2}\|_{L_1} }{\|\texttt{src2}\|_{L_1}} }{如果 \(\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} }{如果 \(\texttt{normType} = \texttt{NORM_L2}\) } { \| \texttt{src1} - \texttt{src2} \| _{L_2} = \sqrt{\sum_I (\texttt{src1}(I) - \texttt{src2}(I))^2} }{如果 \(\texttt{normType} = \texttt{NORM_L2}\) } { \frac{\|\texttt{src1}-\texttt{src2}\|_{L_2} }{\|\texttt{src2}\|_{L_2}} }{如果 \(\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} {如果 \(\texttt{normType} = \texttt{NORM_L2SQR}\)} { \| \texttt{src1} - \texttt{src2} \| _{L_2} ^{2} = \sum_I (\texttt{src1}(I) - \texttt{src2}(I))^2 }{如果 \(\texttt{normType} = \texttt{NORM_L2SQR}\) } { \left(\frac{\|\texttt{src1}-\texttt{src2}\|_{L_2} }{\|\texttt{src2}\|_{L_2}}\right)^2 }{如果 \(\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	標誌
NORM_MINMAX  Python: cv.NORM_MINMAX	標誌

ReduceTypes

列舉 cv::ReduceTypes

#include <opencv2/core.hpp>

列舉值 (Enumerator)
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>

列舉值 (Enumerator)
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 度。

函式文件 (Function Documentation)

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)|)\]

當第二個陣列由標量構造，或者其元素數量與 src1 的通道數相同時，計算陣列與標量之間的絕對差值

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

當第一個陣列由標量構造，或者其元素數量與 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{如果 mask}(I) \ne0\]

• 當 src2 由標量構造，或者其元素數量與 src1.channels() 相同時，計算陣列與標量之和

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

• 當 src1 由標量構造，或者其元素數量與 src2.channels() 相同時，計算標量與陣列之和

  \[\texttt{dst}(I) = \texttt{saturate} ( \texttt{src1} + \texttt{src2}(I) ) \quad \texttt{如果 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	距離,
		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

待辦

文件

此函式的呼叫圖

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）。
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）。
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>

計算二維向量的幅值和角度。

函式 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>

檢查輸入陣列中的每個元素是否含有無效值。

函式 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)\]

當比較結果為 true 時，輸出陣列的相應元素設定為 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 將方陣的下半部分或上半部分複製到另一半。矩陣對角線保持不變

• 如果 lowerToUpper=false，則對於 \(i > j\)，\(\texttt{m}_{ij}=\texttt{m}_{ji}\)
• 如果 lowerToUpper=true，則對於 \(i < j\)，\(\texttt{m}_{ij}=\texttt{m}_{ji}\)

引數

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

另請參閱

flip, transpose

此函式的呼叫圖

convertFp16()

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

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

#include <opencv2/core.hpp>

將陣列轉換為半精度浮點數。

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

引數

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

已棄用

請改用帶 CV_16F 的 Mat::convertTo。

此函式的呼叫圖

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) 也能完成任務，
// 但它會分配一個臨時矩陣

引數

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

另請參閱

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

此函式的呼叫圖

copyMakeBorder()

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

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

#include <opencv2/core.hpp>

在影像周圍形成邊框。

該函式將源影像複製到目標影像的中間。複製後的源影像左側、右側、上方和下方的區域將用外推畫素填充。這與基於它的濾波函式所做的不同（它們是動態外推畫素），但其他更復雜的函式（包括你自己的函式）可能會這樣做，以簡化影像邊界處理。

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

// 假設所有方向的邊界都相同
int border=2;
// 構建一個更大的影像以容納影像和邊界
Mat gray_buf(rgb.rows + border*2, rgb.cols + border*2, rgb.depth());
// 選擇其中的中間部分而不復制資料
Mat gray(gray_canvas, Rect(border, border, rgb.cols, rgb.rows));
// 將影像從 RGB 轉換為灰度
cvtColor(rgb, gray, COLOR_RGB2GRAY);
// 就地形成邊界
copyMakeBorder(gray, gray_buf, border, border,
border, border, BORDER_REPLICATE);
// 現在進行一些自定義濾波 ...
...

注意

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

引數

src	源影像。
dst	與 src 型別相同且大小為 Size(src.cols+left+right, src.rows+top+bottom) 的目標影像。
top (上)	頂部畫素
bottom (下)	底部畫素
left (左)	左側畫素
right (右)	指定在源影像矩形的每個方向上外推多少個畫素的引數。例如，top=1, bottom=1, left=1, right=1 意味著需要構建 1 畫素寬的邊界。
borderType	邊界型別。詳情請參閱 borderInterpolate。
value (值)	如果 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 型別，並且可以有一個或多個通道。

此函式的呼叫圖

countNonZero()

int cv::countNonZero

(

InputArray

src

)

Python
	cv.countNonZero(	src	) ->	retval

#include <opencv2/core.hpp>

統計非零陣列元素的數量。

該函式返回 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 )\]

  且當 j > 0 時，\(\alpha_0=1\)，\(\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

mtx (矩陣)

)

Python
	cv.determinant(	mtx (矩陣)	) ->	retval

#include <opencv2/core.hpp>

返回浮點方陣的行列式。

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

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

引數

mtx (矩陣)

輸入矩陣，必須具有 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 中實現。因此，透過使用它們，您可以獲得比上述理論上最佳實現更好的效能。雖然這兩個函式實際上計算的是互相關（cross-correlation），而不是卷積，所以您需要使用 flip 將第二個卷積運算元 B 垂直和水平翻轉。

注意

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

引數

src	輸入陣列，可以是實數或複數。
dst	輸出陣列，其大小和型別取決於標誌。
flags (標誌)	變換標誌，代表 DftFlags 的組合
nonzeroRows (非零行數)	當該引數不為零時，函式假定只有輸入陣列的前 nonzeroRows 行（未設定 DFT_INVERSE）或只有輸出陣列的前 nonzeroRows 行（設定了 DFT_INVERSE）包含非零值，因此，函式可以更高效地處理其餘行並節省時間；這種技術對於使用 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>

沿垂直軸、水平軸或雙軸翻轉二維陣列。

函式 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* OS 上影片處理中的典型操作。水平翻轉影像，隨後進行水平位移和絕對差計算，以檢查垂直軸對稱性（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 第 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 的冪 (2, 4, 8, 16, 32, ...) 的陣列處理速度最快。此外，大小為 2、3 和 5 的乘積（例如 300 = 5*5*3*2*2）的陣列處理效率也相當高。

函式 cv::getOptimalDFTSize 返回大於或等於 vecsize 的最小整數 N，以便能高效處理大小為 N 的向量的 DFT。在當前實現中，對於某些整數 p, q, r，N = 2 ^p^ * 3 ^q^ * 5 ^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 );
//輸出 (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) 以及

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 );
//輸出 (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 或 idft 之一傳遞 DFT_SCALE，以使這些變換互為逆變換。

另請參閱

dft, dct, idct, mulSpectrums, getOptimalDFTSize

引數

src	輸入浮點型實數或複數陣列。
dst	輸出陣列，其尺寸和型別取決於標誌（flags）。
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) 在指定的 1D, 2D, 3D, ... 盒子內，則 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 = \forkthree{0}{如果 \(\texttt{src}\) 深度為 \(\texttt{CV_8U}\) 或 \(\texttt{CV_16U}\)}{128}{如果 \(\texttt{src}\) 深度為 \(\texttt{CV_8S}\)}{32768}{如果 \(\texttt{src}\) 深度為 \(\texttt{CV_16S}\)}\]

引數

src	8位或16位整數元素的輸入陣列。
lut	具有 256 個元素（如果 src 深度為 CV_8U 或 CV_8S）或 65536 個元素（如果 src 深度為 CV_16U 或 CV_16S）的查詢表；如果是多通道輸入陣列，該表應為單通道（此時所有通道使用同一張表）或與輸入陣列具有相同數量的通道。
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	v1,
		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 方法，因為它是最準確的）。

引數

v1	第一個一維輸入向量。
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,
		double *	minVal,
		double *	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	指向返回最小值位置（nD 情況下）的指標；如果不需要則使用 NULL；否則，它必須指向一個具有 src.dims 個元素的陣列，每個維度中最小元素的座標將按順序儲存在那裡。
maxIdx	指向返回最大值位置（nD 情況下）的指標。如果不需要則使用 NULL。
mask	指定的陣列區域

此函式的呼叫圖

minMaxLoc() [1/2]

void cv::minMaxLoc	(	const SparseMat &	a,
		double *	minVal,
		double *	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	指向返回最小值位置（nD 情況下）的指標；如果不需要則使用 NULL；否則，它必須指向一個具有 src.dims 個元素的陣列，每個維度中最小元素的座標將按順序儲存在那裡。
maxIdx	指向返回最大值位置（nD 情況下）的指標。如果不需要則使用 NULL。

此函式的呼叫圖

minMaxLoc() [2/2]

void cv::minMaxLoc	(	InputArray	src,
		double *	minVal,
		double *	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 格式包（CCS-packed）或複數矩陣執行逐元素乘法，這些矩陣是實數或複數傅立葉變換的結果。

該函式與 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 為零時，它可以作為當 B=A' 時通用矩陣乘積 A*B 的更快替代方案。

引數

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

Python
	cv.norm(	src1[, normType[, mask]]	) ->	retval
	cv.norm(	src1, src2[, normType[, mask]]	) ->	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
	cv.norm(	src1[, normType[, mask]]	) ->	retval
	cv.norm(	src1, src2[, normType[, mask]]	) ->	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
	cv.norm(	src1[, normType[, mask]]	) ->	retval
	cv.norm(	src1, src2[, normType[, mask]]	) ->	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}\) 的所有值。值得注意的是，對於示例函式 \( r(x) \)，\( L_{1} \) 範數形成了上限，而 \( 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	normType )

Python
	cv.normalize(	src, dst[, alpha[, beta[, norm_type[, dtype[, mask]]]]]	) ->	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
	cv.normalize(	src, dst[, alpha[, beta[, norm_type[, dtype[, mask]]]]]	) ->	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 指定要歸一化的子陣列。這意味著範數或最小值/最大值是根據該子陣列計算的，然後修改該子陣列以進行歸一化。如果您只想使用掩碼來計算範數或最小最大值，但修改整個陣列，您可以使用 norm 和 Mat::convertTo。

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

使用一些正數示例資料的可能用法

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（非數字值）替換為指定值。

此函式原位（in-place）修改輸入矩陣。輸入矩陣必須是 CV_32F 或 CV_64F 型別；不支援其他型別。

引數

a	輸入/輸出矩陣 (CV_32F 或 CV_64F 型別)。
val	用於替換 NaN 的值（預設為 0）。

此函式的呼叫圖

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() 並增加 eigenvalues 輸出引數

此函式的呼叫圖

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() 並增加 eigenvalues 輸出引數

此函式的呼叫圖

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'}{如果 \(w' \ne 0\)}{\infty}{否則}\]

此處顯示的是 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 對應元素構成的每個二維向量的旋轉角度

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

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

引數

x	二維向量 x 座標的輸入浮點陣列。
y	二維向量 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 計算由對應 magnitude 和 angle 元素表示的每個二維向量的笛卡爾座標

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

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

引數

magnitude (幅度)	二維向量幅值的輸入浮點陣列；它可以是一個空矩陣 (=Mat())，在這種情況下，函式假設所有幅值均為 1；如果不為空，它必須與 angle 具有相同的尺寸和型別。
angle (角度)	二維向量角度的輸入浮點陣列。
x	二維向量 x 座標的輸出陣列；它與 angle 具有相同的尺寸和型別。
y	二維向量 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}}{如果 \(\texttt{power}\) 是整數}{|\texttt{src}(I)|^{power}}{否則}\]

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

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

對於某些 power 值，如整數、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) } \text{ (dB)} \]

其中 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 透過隨機選擇元素對並交換它們來打亂指定的一維陣列。此類交換操作的數量將為 dst.rows*dst.cols*iterFactor。

引數

dst	輸入/輸出數值型一維陣列。
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 透過將矩陣行/列視為一組一維向量，並在這些向量上執行指定操作，直到獲得單行/列，從而將矩陣歸約為向量。例如，該函式可用於計算光柵影像的水平和垂直投影。在 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 相同的維數，除了被縮減的軸（axis）——該軸應設定為 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 相同的維數，除了被縮減的軸（axis）——該軸應設定為 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	mtx (矩陣),
		const Scalar &	s = Scalar(1) )

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

#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]]

引數

mtx (矩陣)	待初始化的矩陣（不一定是方陣）。
s	分配給對角線元素的值。

另請參閱

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

此函式的呼叫圖

setRNGSeed()

void cv::setRNGSeed

(

int

seed

)

Python
	cv.setRNGSeed(	seed	) ->	None

#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>

包裝 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>

包裝 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

mtx (矩陣)

)

Python
	cv.trace(	mtx (矩陣)	) ->	retval

#include <opencv2/core.hpp>

返回矩陣的跡。

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

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

引數

mtx (矩陣)

輸入矩陣。

此函式的呼叫圖

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 );
//輸出 (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 );
//輸出 (out)
//[1,   1,   1,   1;
// 2,   2,   2,   2;
// 3,   3,   3,   3]

引數

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

此函式的呼叫圖