OpenCV 4.11.0
开源计算机视觉库
加载中…
搜索中…
未找到匹配项
函数
逐元素操作
CUDA 加速计算机视觉 » 矩阵运算

详细描述

函数

void cv::cuda::abs (InputArray src, OutputArray dst, Stream &stream=Stream::Null())
 计算每个矩阵元素的绝对值。
 
void cv::cuda::absdiff (InputArray src1, InputArray src2, OutputArray dst, Stream &stream=Stream::Null())
 计算两个矩阵（或矩阵和标量）的逐元素绝对差。
 
void cv::cuda::absdiffWithScalar (InputArray src1, Scalar src2, OutputArray dst, Stream &stream=Stream::Null())
 计算矩阵和标量的逐元素绝对差。
 
void cv::cuda::add (InputArray src1, InputArray src2, OutputArray dst, InputArray mask=noArray(), int dtype=-1, Stream &stream=Stream::Null())
 计算矩阵-矩阵或矩阵-标量的和。
 
void cv::cuda::addWeighted (InputArray src1, double alpha, InputArray src2, double beta, double gamma, OutputArray dst, int dtype=-1, Stream &stream=Stream::Null())
 计算两个数组的加权和。
 
void cv::cuda::addWithScalar (InputArray src1, Scalar src2, OutputArray dst, InputArray mask=noArray(), int dtype=-1, Stream &stream=Stream::Null())
 计算矩阵-标量的和。
 
void cv::cuda::bitwise_and (InputArray src1, InputArray src2, OutputArray dst, InputArray mask=noArray(), Stream &stream=Stream::Null())
 执行两个矩阵（或矩阵和标量）的逐元素按位与运算。
 
void cv::cuda::bitwise_and_with_scalar (InputArray src1, Scalar src2, OutputArray dst, InputArray mask=noArray(), Stream &stream=Stream::Null())
 执行矩阵和标量的逐元素按位与运算。
 
void cv::cuda::bitwise_not (InputArray src, OutputArray dst, InputArray mask=noArray(), Stream &stream=Stream::Null())
 执行逐元素按位非运算。
 
void cv::cuda::bitwise_or (InputArray src1, InputArray src2, OutputArray dst, InputArray mask=noArray(), Stream &stream=Stream::Null())
 执行两个矩阵（或矩阵和标量）的逐元素按位或运算。
 
void cv::cuda::bitwise_or_with_scalar (InputArray src1, Scalar src2, OutputArray dst, InputArray mask=noArray(), Stream &stream=Stream::Null())
 执行矩阵和标量的逐元素按位或运算。
 
void cv::cuda::bitwise_xor (InputArray src1, InputArray src2, OutputArray dst, InputArray mask=noArray(), Stream &stream=Stream::Null())
 执行两个矩阵（或矩阵和标量）的逐元素按位异或运算。
 
void cv::cuda::bitwise_xor_with_scalar (InputArray src1, Scalar src2, OutputArray dst, InputArray mask=noArray(), Stream &stream=Stream::Null())
 执行矩阵和标量的逐元素按位异或运算。
 
void cv::cuda::cartToPolar (InputArray x, InputArray y, OutputArray magnitude, OutputArray angle, bool angleInDegrees=false, Stream &stream=Stream::Null())
 将笛卡尔坐标转换为极坐标。
 
void cv::cuda::cartToPolar (InputArray xy, OutputArray magnitude, OutputArray angle, bool angleInDegrees=false, Stream &stream=Stream::Null())
 将笛卡尔坐标转换为极坐标。
 
void cv::cuda::cartToPolar (InputArray xy, OutputArray magnitudeAngle, bool angleInDegrees=false, Stream &stream=Stream::Null())
 将笛卡尔坐标转换为极坐标。
 
void cv::cuda::compare (InputArray src1, InputArray src2, OutputArray dst, int cmpop, Stream &stream=Stream::Null())
 比较两个矩阵（或一个矩阵和一个标量）的元素。
 
void cv::cuda::compareWithScalar (InputArray src1, Scalar src2, OutputArray dst, int cmpop, Stream &stream=Stream::Null())
 比较矩阵和标量的元素。
 
void cv::cuda::divide (InputArray src1, InputArray src2, OutputArray dst, double scale=1, int dtype=-1, Stream &stream=Stream::Null())
 计算矩阵-矩阵或矩阵-标量的除法。
 
void cv::cuda::divideWithScalar (InputArray src1, Scalar src2, OutputArray dst, double scale=1, int dtype=-1, Stream &stream=Stream::Null())
 计算矩阵-标量的除法。
 
void cv::cuda::exp (InputArray src, OutputArray dst, Stream &stream=Stream::Null())
 计算每个矩阵元素的指数。
 
void cv::cuda::inRange (InputArray src, const Scalar &lowerb, const Scalar &upperb, OutputArray dst, Stream &stream=Stream::Null())
 检查数组元素是否位于两个标量之间。
 
void cv::cuda::log (InputArray src, OutputArray dst, Stream &stream=Stream::Null())
 计算每个矩阵元素绝对值的自然对数。
 
void cv::cuda::lshift (InputArray src, Scalar val, OutputArray dst, Stream &stream=Stream::Null())
 
void cv::cuda::lshift (InputArray src, Scalar_< int > val, OutputArray dst, Stream &stream=Stream::Null())
 逐像素地将图像左移一个常数值。
 
void cv::cuda::magnitude (InputArray x, InputArray y, OutputArray magnitude, Stream &stream=Stream::Null())
 
void cv::cuda::magnitude (InputArray xy, OutputArray magnitude, Stream &stream=Stream::Null())
 计算复矩阵元素的幅度。
 
void cv::cuda::magnitudeSqr (InputArray x, InputArray y, OutputArray magnitude, Stream &stream=Stream::Null())
 
void cv::cuda::magnitudeSqr (InputArray xy, OutputArray magnitude, Stream &stream=Stream::Null())
 计算复矩阵元素的幅度平方。
 
void cv::cuda::max (InputArray src1, InputArray src2, OutputArray dst, Stream &stream=Stream::Null())
 计算两个矩阵（或一个矩阵和一个标量）的逐元素最大值。
 
void cv::cuda::maxWithScalar (InputArray src1, Scalar src2, OutputArray dst, Stream &stream=Stream::Null())
 计算一个矩阵和一个标量的逐元素最大值。
 
void cv::cuda::min (InputArray src1, InputArray src2, OutputArray dst, Stream &stream=Stream::Null())
 计算两个矩阵（或一个矩阵和一个标量）的逐元素最小值。
 
void cv::cuda::minWithScalar (InputArray src1, Scalar src2, OutputArray dst, Stream &stream=Stream::Null())
 计算一个矩阵和一个标量的逐元素最小值。
 
void cv::cuda::multiply (InputArray src1, InputArray src2, OutputArray dst, double scale=1, int dtype=-1, Stream &stream=Stream::Null())
 计算矩阵-矩阵或矩阵-标量的逐元素乘积。
 
void cv::cuda::multiplyWithScalar (InputArray src1, Scalar src2, OutputArray dst, double scale=1, int dtype=-1, Stream &stream=Stream::Null())
 计算矩阵-标量的逐元素乘积。
 
void cv::cuda::phase (InputArray x, InputArray y, OutputArray angle, bool angleInDegrees=false, Stream &stream=Stream::Null())
 计算复数矩阵元素的极角。
 
void cv::cuda::phase (InputArray xy, OutputArray angle, bool angleInDegrees=false, Stream &stream=Stream::Null())
 计算复数矩阵元素的极角。
 
void cv::cuda::polarToCart (InputArray magnitude, InputArray angle, OutputArray x, OutputArray y, bool angleInDegrees=false, Stream &stream=Stream::Null())
 将极坐标转换为笛卡尔坐标。
 
void cv::cuda::polarToCart (InputArray magnitude, InputArray angle, OutputArray xy, bool angleInDegrees=false, Stream &stream=Stream::Null())
 将极坐标转换为笛卡尔坐标。
 
void cv::cuda::polarToCart (InputArray magnitudeAngle, OutputArray xy, bool angleInDegrees=false, Stream &stream=Stream::Null())
 将极坐标转换为笛卡尔坐标。
 
void cv::cuda::pow (InputArray src, double power, OutputArray dst, Stream &stream=Stream::Null())
 将每个矩阵元素提高到一个幂。
 
void cv::cuda::rshift (InputArray src, Scalar val, OutputArray dst, Stream &stream=Stream::Null())
 
void cv::cuda::rshift (InputArray src, Scalar_< int > val, OutputArray dst, Stream &stream=Stream::Null())
 对图像执行逐像素右移，移动的常数值。
 
静态 void cv::cuda::scaleAdd (InputArray src1, double alpha, InputArray src2, OutputArray dst, Stream &stream=Stream::Null())
 将缩放后的数组添加到另一个数组 (dst = alpha*src1 + src2)
 
void cv::cuda::sqr (InputArray src, OutputArray dst, Stream &stream=Stream::Null())
 计算每个矩阵元素的平方值。
 
void cv::cuda::sqrt (InputArray src, OutputArray dst, Stream &stream=Stream::Null())
 计算每个矩阵元素的平方根。
 
void cv::cuda::subtract (InputArray src1, InputArray src2, OutputArray dst, InputArray mask=noArray(), int dtype=-1, Stream &stream=Stream::Null())
 计算矩阵与矩阵或矩阵与标量的差。
 
void cv::cuda::subtractWithScalar (InputArray src1, Scalar src2, OutputArray dst, InputArray mask=noArray(), int dtype=-1, Stream &stream=Stream::Null())
 计算矩阵与标量的差。
 
double cv::cuda::threshold (InputArray src, OutputArray dst, double thresh, double maxval, int type, Stream &stream=Stream::Null())
 对每个数组元素应用固定级别的阈值。
 

函数文档

◆ abs()

void cv::cuda::abs ( InputArray src,
OutputArray dst,
Stream & stream = Stream::Null() )

#include <opencv2/cudaarithm.hpp>

计算每个矩阵元素的绝对值。

参数
src源矩阵。
dst与src大小和类型相同的目标矩阵。
stream异步版本的流。Stream
另请参阅
abs

◆ absdiff()

void cv::cuda::absdiff ( InputArray src1,
InputArray src2,
OutputArray dst,
Stream & stream = Stream::Null() )

#include <opencv2/cudaarithm.hpp>

计算两个矩阵（或矩阵和标量）的逐元素绝对差。

参数
src1第一个源矩阵或标量。
src2第二个源矩阵或标量。
dst与输入数组大小和类型相同的目标矩阵。
stream异步版本的流。Stream
警告
在Python中，src1和src2都必须是矩阵，有关标量重载，请参阅absdiffWithScalar。
另请参阅
cv::absdiff, absdiffWithScalar

◆ absdiffWithScalar()

void cv::cuda::absdiffWithScalar ( InputArray src1,
Scalar src2,
OutputArray dst,
Stream & stream = Stream::Null() )
inline

#include <opencv2/cudaarithm.hpp>

计算矩阵和标量的逐元素绝对差。

参数
src1第一个源矩阵。
src2第二个源标量。
dst与输入数组大小和类型相同的目标矩阵。
stream异步版本的流。Stream
另请参阅
absdiff
此函数的调用图

◆ add()

void cv::cuda::add ( InputArray src1,
InputArray src2,
OutputArray dst,
InputArray mask = noArray(),
int dtype = -1,
Stream & stream = Stream::Null() )

#include <opencv2/cudaarithm.hpp>

计算矩阵-矩阵或矩阵-标量的和。

参数
src1第一个源矩阵或标量。
src2第二个源矩阵或标量。矩阵应与src1大小和类型相同。
dst与输入数组大小和通道数相同的目标矩阵。深度由dtype或src1深度定义。
mask可选操作掩码，8位单通道数组，指定要更改的目标数组的元素。掩码只能与单通道图像一起使用。
dtype输出数组的可选深度。
stream异步版本的流。Stream
警告
在Python中，src1和src2都必须是矩阵，有关标量重载，请参阅addWithScalar。
另请参阅
cv::add, addWithScalar

◆ addWeighted()

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

#include <opencv2/cudaarithm.hpp>

计算两个数组的加权和。

参数
src1第一个源数组。
alpha第一个数组元素的权重。
src2与src1大小和通道数相同的第二个源数组。
beta第二个数组元素的权重。
dst与输入数组大小和通道数相同的目标数组。
gamma添加到每个总和的标量。
dtype目标数组的可选深度。当两个输入数组具有相同的深度时，dtype可以设置为-1，这将等效于src1.depth()。
stream异步版本的流。Stream

addWeighted函数计算两个数组的加权和，如下所示

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

其中I是数组元素的多维索引。对于多通道数组，每个通道都独立处理。

另请参阅
addWeighted

◆ addWithScalar()

void cv::cuda::addWithScalar ( InputArray src1,
Scalar src2,
OutputArray dst,
InputArray mask = noArray(),
int dtype = -1,
Stream & stream = Stream::Null() )
inline

#include <opencv2/cudaarithm.hpp>

计算矩阵-标量的和。

参数
src1第一个源矩阵。
src2第二个源标量。
dst与输入数组大小和通道数相同的目标矩阵。深度由dtype或src1深度定义。
mask可选操作掩码，8位单通道数组，指定要更改的目标数组的元素。掩码只能与单通道图像一起使用。
dtype输出数组的可选深度。
stream异步版本的流。Stream
另请参阅
add
此函数的调用图

◆ bitwise_and()

void cv::cuda::bitwise_and ( InputArray src1,
InputArray src2,
OutputArray dst,
InputArray mask = noArray(),
Stream & stream = Stream::Null() )

#include <opencv2/cudaarithm.hpp>

执行两个矩阵（或矩阵和标量）的逐元素按位与运算。

参数
src1第一个源矩阵或标量。
src2第二个源矩阵或标量。
dst与输入数组大小和类型相同的目标矩阵。
mask可选操作掩码，8位单通道数组，指定要更改的目标数组的元素。掩码只能与单通道图像一起使用。
stream异步版本的流。Stream
警告
在Python中，src1和src2都必须是矩阵，有关标量重载，请参阅bitwise_and_with_scalar。
另请参阅
bitwise_and_with_scalar

◆ bitwise_and_with_scalar()

void cv::cuda::bitwise_and_with_scalar ( InputArray src1,
Scalar src2,
OutputArray dst,
InputArray mask = noArray(),
Stream & stream = Stream::Null() )
inline

#include <opencv2/cudaarithm.hpp>

执行矩阵和标量的逐元素按位与运算。

参数
src1第一个源矩阵。
src2第二个源标量。
dst与输入数组大小和类型相同的目标矩阵。
mask可选操作掩码，8位单通道数组，指定要更改的目标数组的元素。掩码只能与单通道图像一起使用。
stream异步版本的流。Stream
另请参阅
bitwise_and
此函数的调用图

◆ bitwise_not()

void cv::cuda::bitwise_not ( InputArray src,
OutputArray dst,
InputArray mask = noArray(),
Stream & stream = Stream::Null() )

#include <opencv2/cudaarithm.hpp>

执行逐元素按位非运算。

参数
src源矩阵。
dst与src大小和类型相同的目标矩阵。
mask可选操作掩码，8位单通道数组，指定要更改的目标数组的元素。掩码只能与单通道图像一起使用。
stream异步版本的流。Stream

◆ bitwise_or()

void cv::cuda::bitwise_or ( InputArray src1,
InputArray src2,
OutputArray dst,
InputArray mask = noArray(),
Stream & stream = Stream::Null() )

#include <opencv2/cudaarithm.hpp>

执行两个矩阵（或矩阵和标量）的逐元素按位或运算。

参数
src1第一个源矩阵或标量。
src2第二个源矩阵或标量。
dst与输入数组大小和类型相同的目标矩阵。
mask可选操作掩码，8位单通道数组，指定要更改的目标数组的元素。掩码只能与单通道图像一起使用。
stream异步版本的流。Stream
警告
在Python中，src1和src2必须都是矩阵，参见bitwise_or_with_scalar了解标量重载。
另请参阅
cv::bitwise_or，bitwise_or_with_scalar

◆ bitwise_or_with_scalar()

void cv::cuda::bitwise_or_with_scalar ( InputArray src1,
Scalar src2,
OutputArray dst,
InputArray mask = noArray(),
Stream & stream = Stream::Null() )
inline

#include <opencv2/cudaarithm.hpp>

执行矩阵和标量的逐元素按位或运算。

参数
src1第一个源矩阵。
src2第二个源标量。
dst与输入数组大小和类型相同的目标矩阵。
mask可选操作掩码，8位单通道数组，指定要更改的目标数组的元素。掩码只能与单通道图像一起使用。
stream异步版本的流。Stream
另请参阅
bitwise_or
此函数的调用图

◆ bitwise_xor()

void cv::cuda::bitwise_xor ( InputArray src1,
InputArray src2,
OutputArray dst,
InputArray mask = noArray(),
Stream & stream = Stream::Null() )

#include <opencv2/cudaarithm.hpp>

执行两个矩阵（或矩阵和标量）的逐元素按位异或运算。

参数
src1第一个源矩阵或标量。
src2第二个源矩阵或标量。
dst与输入数组大小和类型相同的目标矩阵。
mask可选操作掩码，8位单通道数组，指定要更改的目标数组的元素。掩码只能与单通道图像一起使用。
stream异步版本的流。Stream
警告
在Python中，src1和src2必须都是矩阵，参见bitwise_xor_with_scalar了解标量重载。
另请参阅
cv::bitwise_xor，bitwise_xor_with_scalar

◆ bitwise_xor_with_scalar()

void cv::cuda::bitwise_xor_with_scalar ( InputArray src1,
Scalar src2,
OutputArray dst,
InputArray mask = noArray(),
Stream & stream = Stream::Null() )
inline

#include <opencv2/cudaarithm.hpp>

执行矩阵和标量的逐元素按位异或运算。

参数
src1第一个源矩阵。
src2第二个源标量。
dst与输入数组大小和类型相同的目标矩阵。
mask可选操作掩码，8位单通道数组，指定要更改的目标数组的元素。掩码只能与单通道图像一起使用。
stream异步版本的流。Stream
另请参阅
bitwise_xor
此函数的调用图

◆ cartToPolar() [1/3]

void cv::cuda::cartToPolar ( InputArray x,
InputArray y,
OutputArray 幅值,
OutputArray 角度,
bool angleInDegrees = false,
Stream & stream = Stream::Null() )

#include <opencv2/cudaarithm.hpp>

将笛卡尔坐标转换为极坐标。

参数
x包含实数部分的源矩阵 (CV_32FC1)。
y包含虚数部分的源矩阵 (CV_32FC1)。
幅值浮点幅值的目标矩阵 (CV_32FC1)。
角度角度的目标矩阵 (CV_32FC1)。
angleInDegrees用于必须以度为单位计算角度的标志。
stream异步版本的流。Stream
另请参阅
cartToPolar

◆ cartToPolar() [2/3]

void cv::cuda::cartToPolar ( InputArray xy,
OutputArray 幅值,
OutputArray 角度,
bool angleInDegrees = false,
Stream & stream = Stream::Null() )

#include <opencv2/cudaarithm.hpp>

将笛卡尔坐标转换为极坐标。

参数
xy包含实数和虚数部分的源矩阵 (CV_32FC2)。
幅值浮点幅值的目标矩阵 (CV_32FC1)。
角度角度的目标矩阵 (CV_32FC1)。
angleInDegrees用于必须以度为单位计算角度的标志。
stream异步版本的流。Stream
另请参阅
cartToPolar

◆ cartToPolar() [3/3]

void cv::cuda::cartToPolar ( InputArray xy,
OutputArray magnitudeAngle,
bool angleInDegrees = false,
Stream & stream = Stream::Null() )

#include <opencv2/cudaarithm.hpp>

将笛卡尔坐标转换为极坐标。

参数
xy包含实数和虚数部分的源矩阵 (CV_32FC2)。
magnitudeAngle浮点幅值和角度的目标矩阵 (CV_32FC2)。
angleInDegrees用于必须以度为单位计算角度的标志。
stream异步版本的流。Stream
另请参阅
cartToPolar

◆ compare()

void cv::cuda::compare ( InputArray src1,
InputArray src2,
OutputArray dst,
int cmpop,
Stream & stream = Stream::Null() )

#include <opencv2/cudaarithm.hpp>

比较两个矩阵（或一个矩阵和一个标量）的元素。

参数
src1第一个源矩阵或标量。
src2第二个源矩阵或标量。
dst与输入数组大小相同且类型为CV_8U的目标矩阵。
cmpop指定要检查的元素之间关系的标志
  • CMP_EQ: a(.) == b(.)
  • CMP_GT: a(.) > b(.)
  • CMP_GE: a(.) >= b(.)
  • CMP_LT: a(.) < b(.)
  • CMP_LE: a(.) <= b(.)
  • CMP_NE: a(.) != b(.)
stream异步版本的流。Stream
警告
在Python中，src1和src2必须都是矩阵，参见compareWithScalar了解标量重载。
另请参阅
cv::compare，compareWithScalar

◆ compareWithScalar()

void cv::cuda::compareWithScalar ( InputArray src1,
Scalar src2,
OutputArray dst,
int cmpop,
Stream & stream = Stream::Null() )
inline

#include <opencv2/cudaarithm.hpp>

比较矩阵和标量的元素。

参数
src1第一个源矩阵。
src2第二个源标量。
dst与输入数组大小相同且类型为CV_8U的目标矩阵。
cmpop指定要检查的元素之间关系的标志
  • CMP_EQ: a(.) == b(.)
  • CMP_GT: a(.) > b(.)
  • CMP_GE: a(.) >= b(.)
  • CMP_LT: a(.) < b(.)
  • CMP_LE: a(.) <= b(.)
  • CMP_NE: a(.) != b(.)
stream异步版本的流。Stream
另请参阅
compare
此函数的调用图

◆ divide()

void cv::cuda::divide ( InputArray src1,
InputArray src2,
OutputArray dst,
double scale = 1,
int dtype = -1,
Stream & stream = Stream::Null() )

#include <opencv2/cudaarithm.hpp>

计算矩阵-矩阵或矩阵-标量的除法。

参数
src1第一个源矩阵或标量。
src2第二个源矩阵或标量。
dst与输入数组大小和通道数相同的目标矩阵。深度由dtype或src1深度定义。
scale可选比例因子。
dtype输出数组的可选深度。
stream异步版本的流。Stream

与divide函数相反，此函数使用向下舍入模式。

警告
在Python中，src1和src2必须都是矩阵，参见divideWithScalar了解标量重载。
另请参阅
cv::divide，divideWithScalar

◆ divideWithScalar()

void cv::cuda::divideWithScalar ( InputArray src1,
Scalar src2,
OutputArray dst,
double scale = 1,
int dtype = -1,
Stream & stream = Stream::Null() )
inline

#include <opencv2/cudaarithm.hpp>

计算矩阵-标量的除法。

参数
src1第一个源矩阵。
src2第二个源标量。
dst与输入数组大小和通道数相同的目标矩阵。深度由dtype或src1深度定义。
scale可选比例因子。
dtype输出数组的可选深度。
stream异步版本的流。Stream

与divide函数相反，此函数使用向下舍入模式。

另请参阅
divide
此函数的调用图

◆ exp()

void cv::cuda::exp ( InputArray src,
OutputArray dst,
Stream & stream = Stream::Null() )

#include <opencv2/cudaarithm.hpp>

计算每个矩阵元素的指数。

参数
src源矩阵。
dst与src大小和类型相同的目标矩阵。
stream异步版本的流。Stream
另请参阅
exp

◆ inRange()

void cv::cuda::inRange ( InputArray src,
const Scalar & 下界,
const Scalar & 上界,
OutputArray dst,
Stream & stream = Stream::Null() )

#include <opencv2/cudaarithm.hpp>

检查数组元素是否位于两个标量之间。

函数检查范围如下

  • 对于单通道输入数组的每个元素

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

  • 对于双通道数组

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

  • 等等。

也就是说，如果src(I)在指定的1D、2D、3D……范围内，则dst(I)设置为255（所有1位），否则设置为0。

请注意，与CPU inRange不同，此函数不接受下界或上界的数组，只接受cv::Scalar。

参数
src第一个输入数组。
下界包含下界 cv::Scalar。
上界包含上界 cv::Scalar。
dst与src大小相同且类型为CV_8U的输出数组。
stream异步版本的流。Stream
另请参阅
cv::inRange

◆ log()

void cv::cuda::log ( InputArray src,
OutputArray dst,
Stream & stream = Stream::Null() )

#include <opencv2/cudaarithm.hpp>

计算每个矩阵元素绝对值的自然对数。

参数
src源矩阵。
dst与src大小和类型相同的目标矩阵。
stream异步版本的流。Stream
另请参阅
log

◆ lshift() [1/2]

void cv::cuda::lshift ( InputArray src,
Scalar val,
OutputArray dst,
Stream & stream = Stream::Null() )
inline

#include <opencv2/cudaarithm.hpp>

此函数的调用图

◆ lshift() [2/2]

void cv::cuda::lshift ( InputArray src,
Scalar_< int > val,
OutputArray dst,
Stream & stream = Stream::Null() )

#include <opencv2/cudaarithm.hpp>

逐像素地将图像左移一个常数值。

参数
src源矩阵。支持深度为CV_8U、CV_16U或CV_32S的1、3和4通道图像。
val常量值，每个通道一个。
dst与src大小和类型相同的目标矩阵。
stream异步版本的流。Stream

◆ magnitude() [1/2]

void cv::cuda::magnitude ( InputArray x,
InputArray y,
OutputArray 幅值,
Stream & stream = Stream::Null() )

#include <opencv2/cudaarithm.hpp>

这是一个重载的成员函数，为了方便使用。它与上面的函数的区别仅仅在于它接受的参数。计算每个(x(i), y(i))向量的幅值，只支持浮点型源。

参数
x包含实数部分的源矩阵 (CV_32FC1)。
y包含虚数部分的源矩阵 (CV_32FC1)。
幅值浮点幅值的目标矩阵 (CV_32FC1)。
stream异步版本的流。Stream

◆ magnitude() [2/2]

void cv::cuda::magnitude ( InputArray xy,
OutputArray 幅值,
Stream & stream = Stream::Null() )

#include <opencv2/cudaarithm.hpp>

计算复矩阵元素的幅度。

参数
xy交错格式的源复数矩阵 (CV_32FC2)。
幅值浮点幅值的目标矩阵 (CV_32FC1)。
stream异步版本的流。Stream
另请参阅
幅值

◆ magnitudeSqr() [1/2]

void cv::cuda::magnitudeSqr ( InputArray x,
InputArray y,
OutputArray 幅值,
Stream & stream = Stream::Null() )

#include <opencv2/cudaarithm.hpp>

这是一个重载的成员函数，为了方便使用。它与上面的函数的区别仅仅在于它接受的参数。计算每个(x(i), y(i))向量的平方幅值，只支持浮点型源。

参数
x包含实数部分的源矩阵 (CV_32FC1)。
y包含虚数部分的源矩阵 (CV_32FC1)。
幅值浮点平方幅值的目标矩阵 (CV_32FC1)。
stream异步版本的流。Stream

◆ magnitudeSqr() [2/2]

void cv::cuda::magnitudeSqr ( InputArray xy,
OutputArray 幅值,
Stream & stream = Stream::Null() )

#include <opencv2/cudaarithm.hpp>

计算复矩阵元素的幅度平方。

参数
xy交错格式的源复数矩阵 (CV_32FC2)。
幅值浮点平方幅值的目标矩阵 (CV_32FC1)。
stream异步版本的流。Stream

◆ max()

void cv::cuda::max ( InputArray src1,
InputArray src2,
OutputArray dst,
Stream & stream = Stream::Null() )

#include <opencv2/cudaarithm.hpp>

计算两个矩阵（或一个矩阵和一个标量）的逐元素最大值。

参数
src1第一个源矩阵或标量。
src2第二个源矩阵或标量。
dst与输入数组大小和类型相同的目标矩阵。
stream异步版本的流。Stream
警告
在Python中，src1和src2必须都是矩阵，参见maxWithScalar了解标量重载。
另请参阅
cv::max, maxWithScalar

◆ maxWithScalar()

void cv::cuda::maxWithScalar ( InputArray src1,
Scalar src2,
OutputArray dst,
Stream & stream = Stream::Null() )
inline

#include <opencv2/cudaarithm.hpp>

计算一个矩阵和一个标量的逐元素最大值。

参数
src1第一个源矩阵。
src2第二个源标量。
dst与输入数组大小和类型相同的目标矩阵。
stream异步版本的流。Stream
另请参阅
max
此函数的调用图

◆ min()

void cv::cuda::min ( InputArray src1,
InputArray src2,
OutputArray dst,
Stream & stream = Stream::Null() )

#include <opencv2/cudaarithm.hpp>

计算两个矩阵（或一个矩阵和一个标量）的逐元素最小值。

参数
src1第一个源矩阵或标量。
src2第二个源矩阵或标量。
dst与输入数组大小和类型相同的目标矩阵。
stream异步版本的流。Stream
警告
在Python中，src1和src2必须都是矩阵，参见minWithScalar了解标量重载。
另请参阅
cv::min, minWithScalar

◆ minWithScalar()

void cv::cuda::minWithScalar ( InputArray src1,
Scalar src2,
OutputArray dst,
Stream & stream = Stream::Null() )
inline

#include <opencv2/cudaarithm.hpp>

计算一个矩阵和一个标量的逐元素最小值。

参数
src1第一个源矩阵。
src2第二个源标量。
dst与输入数组大小和类型相同的目标矩阵。
stream异步版本的流。Stream
另请参阅
min
此函数的调用图

◆ multiply()

void cv::cuda::multiply ( InputArray src1,
InputArray src2,
OutputArray dst,
double scale = 1,
int dtype = -1,
Stream & stream = Stream::Null() )

#include <opencv2/cudaarithm.hpp>

计算矩阵-矩阵或矩阵-标量的逐元素乘积。

参数
src1第一个源矩阵或标量。
src2第二个源矩阵或标量。
dst与输入数组大小和通道数相同的目标矩阵。深度由dtype或src1深度定义。
scale可选比例因子。
dtype输出数组的可选深度。
stream异步版本的流。Stream
警告
在Python中，src1和src2必须都是矩阵，参见multiplyWithScalar了解标量重载。
另请参阅
cv::multiply, multiplyWithScalar

◆ multiplyWithScalar()

void cv::cuda::multiplyWithScalar ( InputArray src1,
Scalar src2,
OutputArray dst,
double scale = 1,
int dtype = -1,
Stream & stream = Stream::Null() )
inline

#include <opencv2/cudaarithm.hpp>

计算矩阵-标量的逐元素乘积。

参数
src1第一个源矩阵。
src2第二个源标量。
dst与输入数组大小和通道数相同的目标矩阵。深度由dtype或src1深度定义。
scale可选比例因子。
dtype输出数组的可选深度。
stream异步版本的流。Stream
另请参阅
multiply
此函数的调用图

◆ phase() [1/2]

void cv::cuda::phase ( InputArray x,
InputArray y,
OutputArray 角度,
bool angleInDegrees = false,
Stream & stream = Stream::Null() )

#include <opencv2/cudaarithm.hpp>

计算复数矩阵元素的极角。

参数
x包含实数部分的源矩阵 (CV_32FC1)。
y包含虚数部分的源矩阵 (CV_32FC1)。
角度角度的目标矩阵 (CV_32FC1)。
angleInDegrees用于必须以度为单位计算角度的标志。
stream异步版本的流。Stream
另请参阅
phase

◆ phase() [2/2]

void cv::cuda::phase ( InputArray xy,
OutputArray 角度,
bool angleInDegrees = false,
Stream & stream = Stream::Null() )

#include <opencv2/cudaarithm.hpp>

计算复数矩阵元素的极角。

参数
xy包含实数和虚数部分的源矩阵 (CV_32FC2)。
角度角度的目标矩阵 (CV_32FC1)。
angleInDegrees用于必须以度为单位计算角度的标志。
stream异步版本的流。Stream
另请参阅
phase

◆ polarToCart() [1/3]

void cv::cuda::polarToCart ( InputArray 幅值,
InputArray 角度,
OutputArray x,
OutputArray y,
bool angleInDegrees = false,
Stream & stream = Stream::Null() )

#include <opencv2/cudaarithm.hpp>

将极坐标转换为笛卡尔坐标。

参数
幅值包含幅度的源矩阵（CV_32FC1 或 CV_64FC1）。
角度包含角度的源矩阵（与幅度类型相同）。
x实数分量的目标矩阵（与幅度类型相同）。
y虚数分量的目标矩阵（与幅度类型相同）。
angleInDegrees指示角度是否为度的标志。
stream异步版本的流。Stream

◆ polarToCart() [2/3]

void cv::cuda::polarToCart ( InputArray 幅值,
InputArray 角度,
OutputArray xy,
bool angleInDegrees = false,
Stream & stream = Stream::Null() )

#include <opencv2/cudaarithm.hpp>

将极坐标转换为笛卡尔坐标。

参数
幅值包含幅度的源矩阵（CV_32FC1 或 CV_64FC1）。
角度包含角度的源矩阵（与幅度类型相同）。
xy实数和虚数分量的目标矩阵（与幅度的深度相同，即 CV_32FC2 或 CV_64FC2）。
angleInDegrees指示角度是否为度的标志。
stream异步版本的流。Stream

◆ polarToCart() [3/3]

void cv::cuda::polarToCart ( InputArray magnitudeAngle,
OutputArray xy,
bool angleInDegrees = false,
Stream & stream = Stream::Null() )

#include <opencv2/cudaarithm.hpp>

将极坐标转换为笛卡尔坐标。

参数
magnitudeAngle包含幅度和角度的源矩阵（CV_32FC2 或 CV_64FC2）。
xy实数和虚数分量的目标矩阵（与源矩阵的深度相同）。
angleInDegrees指示角度是否为度的标志。
stream异步版本的流。Stream

◆ pow()

void cv::cuda::pow ( InputArray src,
double 幂,
OutputArray dst,
Stream & stream = Stream::Null() )

#include <opencv2/cudaarithm.hpp>

将每个矩阵元素提高到一个幂。

参数
src源矩阵。
幂幂指数。
dst与src大小和类型相同的目标矩阵。
stream异步版本的流。Stream

pow 函数将输入矩阵的每个元素都提升到 power 次幂

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

另请参阅
pow

◆ rshift() [1/2]

void cv::cuda::rshift ( InputArray src,
Scalar val,
OutputArray dst,
Stream & stream = Stream::Null() )
inline

#include <opencv2/cudaarithm.hpp>

此函数的调用图

◆ rshift() [2/2]

void cv::cuda::rshift ( InputArray src,
Scalar_< int > val,
OutputArray dst,
Stream & stream = Stream::Null() )

#include <opencv2/cudaarithm.hpp>

对图像执行逐像素右移，移动的常数值。

参数
src源矩阵。支持具有整数元素的 1、3 和 4 通道图像。
val常量值，每个通道一个。
dst与src大小和类型相同的目标矩阵。
stream异步版本的流。Stream

◆ scaleAdd()

static void cv::cuda::scaleAdd ( InputArray src1,
double alpha,
InputArray src2,
OutputArray dst,
Stream & stream = Stream::Null() )
inlinestatic

#include <opencv2/cudaarithm.hpp>

将缩放后的数组添加到另一个数组 (dst = alpha*src1 + src2)

此函数的调用图

◆ sqr()

void cv::cuda::sqr ( InputArray src,
OutputArray dst,
Stream & stream = Stream::Null() )

#include <opencv2/cudaarithm.hpp>

计算每个矩阵元素的平方值。

参数
src源矩阵。
dst与src大小和类型相同的目标矩阵。
stream异步版本的流。Stream

◆ sqrt()

void cv::cuda::sqrt ( InputArray src,
OutputArray dst,
Stream & stream = Stream::Null() )

#include <opencv2/cudaarithm.hpp>

计算每个矩阵元素的平方根。

参数
src源矩阵。
dst与src大小和类型相同的目标矩阵。
stream异步版本的流。Stream
另请参阅
sqrt

◆ subtract()

void cv::cuda::subtract ( InputArray src1,
InputArray src2,
OutputArray dst,
InputArray mask = noArray(),
int dtype = -1,
Stream & stream = Stream::Null() )

#include <opencv2/cudaarithm.hpp>

计算矩阵与矩阵或矩阵与标量的差。

参数
src1第一个源矩阵或标量。
src2第二个源矩阵或标量。矩阵的大小和类型应与src1相同。
dst与输入数组大小和通道数相同的目标矩阵。深度由dtype或src1深度定义。
mask可选操作掩码，8位单通道数组，指定要更改的目标数组的元素。掩码只能与单通道图像一起使用。
dtype输出数组的可选深度。
stream异步版本的流。Stream
警告
在Python中，src1和src2必须都是矩阵，参见subtractWithScalar了解标量重载。
另请参阅
cv::subtract, subtractWithScalar

◆ subtractWithScalar()

void cv::cuda::subtractWithScalar ( InputArray src1,
Scalar src2,
OutputArray dst,
InputArray mask = noArray(),
int dtype = -1,
Stream & stream = Stream::Null() )
inline

#include <opencv2/cudaarithm.hpp>

计算矩阵与标量的差。

参数
src1第一个源矩阵。
src2第二个源标量。
dst与输入数组大小和通道数相同的目标矩阵。深度由dtype或src1深度定义。
mask可选操作掩码，8位单通道数组，指定要更改的目标数组的元素。掩码只能与单通道图像一起使用。
dtype输出数组的可选深度。
stream异步版本的流。Stream
另请参阅
cv::subtract
此函数的调用图

◆ threshold()

double cv::cuda::threshold ( InputArray src,
OutputArray dst,
double 阈值,
double 最大值,
int 类型,
Stream & stream = Stream::Null() )

#include <opencv2/cudaarithm.hpp>

对每个数组元素应用固定级别的阈值。

参数
src源数组（单通道）。
dst与 src 大小和类型相同的目标数组。
阈值阈值。
最大值与 THRESH_BINARY 和 THRESH_BINARY_INV 阈值类型一起使用的最大值。
类型阈值类型。详情请参见 threshold 。不支持 THRESH_OTSU 和 THRESH_TRIANGLE 阈值类型。
stream异步版本的流。Stream
另请参阅
threshold
2025年1月8日星期三16:06:36 为OpenCV生成的文档，由 doxygen 1.12.0提供。