OpenCV 4.12.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())
 逐像素对图像进行常数值右移操作。
 
static 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具有相同的大小和类型。
流用于异步版本的流。
另请参见
abs

◆ absdiff()

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

#include <opencv2/cudaarithm.hpp>

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

参数
src1第一个源矩阵或标量。
src2第二个源矩阵或标量。
dst目标矩阵，与输入数组(们)具有相同的大小和类型。
流用于异步版本的流。
警告
在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目标矩阵，与输入数组具有相同的大小和类型。
流用于异步版本的流。
另请参见
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输出数组的可选深度。
流用于异步版本的流。
警告
在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()。
流用于异步版本的流。

函数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输出数组的可选深度。
流用于异步版本的流。
另请参见
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位单通道数组，指定要更改的目标数组的元素。此掩码只能用于单通道图像。
流用于异步版本的流。
警告
在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位单通道数组，指定要更改的目标数组的元素。此掩码只能用于单通道图像。
流用于异步版本的流。
另请参见
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位单通道数组，指定要更改的目标数组的元素。此掩码只能用于单通道图像。
流用于异步版本的流。

◆ 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位单通道数组，指定要更改的目标数组的元素。此掩码只能用于单通道图像。
流用于异步版本的流。
警告
在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位单通道数组，指定要更改的目标数组的元素。此掩码只能用于单通道图像。
流用于异步版本的流。
另请参见
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位单通道数组，指定要更改的目标数组的元素。此掩码只能用于单通道图像。
流用于异步版本的流。
警告
在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位单通道数组，指定要更改的目标数组的元素。此掩码只能用于单通道图像。
流用于异步版本的流。
另请参见
bitwise_xor
此函数的调用图如下

◆ cartToPolar() [1/3]

void cv::cuda::cartToPolar ( InputArray x,
InputArray y,
OutputArray magnitude,
OutputArray angle,
bool angleInDegrees = false，
Stream & stream = Stream::Null() )

#include <opencv2/cudaarithm.hpp>

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

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

◆ cartToPolar() [2/3]

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

#include <opencv2/cudaarithm.hpp>

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

参数
xy包含实部和虚部分量的源矩阵 (CV_32FC2)。
magnitude浮点幅值目标矩阵 (CV_32FC1)。
angle角度目标矩阵 (CV_32FC1)。
angleInDegrees表示角度必须以度为单位计算的标志。
流用于异步版本的流。
另请参见
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表示角度必须以度为单位计算的标志。
流用于异步版本的流。
另请参见
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(.)
流用于异步版本的流。
警告
在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(.)
流用于异步版本的流。
另请参见
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输出数组的可选深度。
流用于异步版本的流。

与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输出数组的可选深度。
流用于异步版本的流。

与divide函数不同，此函数使用向下取整的舍入模式。

另请参见
divide
此函数的调用图如下

◆ exp()

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

#include <opencv2/cudaarithm.hpp>

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

参数
src源矩阵。
dst目标矩阵，与src具有相同的大小和类型。
流用于异步版本的流。
另请参见
exp

◆ inRange()

void cv::cuda::inRange ( InputArray src,
const Scalar & lowerb,
const Scalar & upperb,
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不同，此函数不接受`lowerb`或`upperb`的数组，只接受cv::Scalar。

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

◆ log()

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

#include <opencv2/cudaarithm.hpp>

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

参数
src源矩阵。
dst目标矩阵，与src具有相同的大小和类型。
流用于异步版本的流。
另请参见
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源矩阵。支持1、3和4通道图像，深度为CV_8U、CV_16U或CV_32S。
val常数值，每个通道一个。
dst目标矩阵，与src具有相同的大小和类型。
流用于异步版本的流。

◆ magnitude() [1/2]

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

#include <opencv2/cudaarithm.hpp>

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

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

◆ magnitude() [2/2]

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

#include <opencv2/cudaarithm.hpp>

计算复杂矩阵元素的幅值。

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

◆ magnitudeSqr() [1/2]

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

#include <opencv2/cudaarithm.hpp>

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

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

◆ magnitudeSqr() [2/2]

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

#include <opencv2/cudaarithm.hpp>

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

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

◆ max()

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

#include <opencv2/cudaarithm.hpp>

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

参数
src1第一个源矩阵或标量。
src2第二个源矩阵或标量。
dst目标矩阵，与输入数组(们)具有相同的大小和类型。
流用于异步版本的流。
警告
在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目标矩阵，与输入数组具有相同的大小和类型。
流用于异步版本的流。
另请参见
max
此函数的调用图如下

◆ min()

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

#include <opencv2/cudaarithm.hpp>

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

参数
src1第一个源矩阵或标量。
src2第二个源矩阵或标量。
dst目标矩阵，与输入数组(们)具有相同的大小和类型。
流用于异步版本的流。
警告
在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目标矩阵，与输入数组具有相同的大小和类型。
流用于异步版本的流。
另请参见
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输出数组的可选深度。
流用于异步版本的流。
警告
在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输出数组的可选深度。
流用于异步版本的流。
另请参见
multiply
此函数的调用图如下

◆ phase() [1/2]

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

#include <opencv2/cudaarithm.hpp>

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

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

◆ phase() [2/2]

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

#include <opencv2/cudaarithm.hpp>

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

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

◆ polarToCart() [1/3]

void cv::cuda::polarToCart ( InputArray magnitude,
InputArray angle,
OutputArray x,
OutputArray y,
bool angleInDegrees = false，
Stream & stream = Stream::Null() )

#include <opencv2/cudaarithm.hpp>

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

参数
magnitude包含幅值的源矩阵 (CV_32FC1 或 CV_64FC1)。
angle包含角度的源矩阵（与幅值类型相同）。
x实部分量目标矩阵（与幅值类型相同）。
y虚部分量目标矩阵（与幅值类型相同）。
angleInDegrees指示角度以度为单位的标志。
流用于异步版本的流。

◆ polarToCart() [2/3]

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

#include <opencv2/cudaarithm.hpp>

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

参数
magnitude包含幅值的源矩阵 (CV_32FC1 或 CV_64FC1)。
angle包含角度的源矩阵（与幅值类型相同）。
xy实部和虚部分量目标矩阵（与幅值深度相同，即CV_32FC2 或 CV_64FC2）。
angleInDegrees指示角度以度为单位的标志。
流用于异步版本的流。

◆ 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指示角度以度为单位的标志。
流用于异步版本的流。

◆ pow()

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

#include <opencv2/cudaarithm.hpp>

将每个矩阵元素提升到指定幂。

参数
src源矩阵。
power幂指数。
dst目标矩阵，与src具有相同的大小和类型。
流用于异步版本的流。

函数pow将输入矩阵的每个元素提升到指定幂次方。

\[\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具有相同的大小和类型。
流用于异步版本的流。

◆ 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具有相同的大小和类型。
流用于异步版本的流。

◆ sqrt()

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

#include <opencv2/cudaarithm.hpp>

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

参数
src源矩阵。
dst目标矩阵，与src具有相同的大小和类型。
流用于异步版本的流。
另请参见
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输出数组的可选深度。
流用于异步版本的流。
警告
在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输出数组的可选深度。
流用于异步版本的流。
另请参见
cv::subtract
此函数的调用图如下

◆ threshold()

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

#include <opencv2/cudaarithm.hpp>

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

特殊值cv::THRESH_OTSU可以与其他类型结合使用。在这种情况下，函数使用Otsu算法确定最佳阈值，并将其用于代替指定阈值。函数除了返回阈值化矩阵外，还返回计算出的阈值。Otsu方法仅适用于8位矩阵。

参数
src源数组（单通道）。
dst目标数组，与src具有相同的大小和类型。
thresh阈值。
最大值与`THRESH_BINARY`和`THRESH_BINARY_INV`阈值类型一起使用的最大值。
type阈值类型。详情请参阅threshold。不支持`THRESH_TRIANGLE`阈值类型。
流用于异步版本的流。
另请参见
RANSAC参数。它是点到像素中对极线的最大距离，超过此距离的点将被视为异常值，不用于计算最终的基本矩阵。它可以设置为1-3左右，具体取决于点定位的精度、图像分辨率和图像噪声。
生成于2025年7月3日星期四12:14:36，为OpenCV生成，由 doxygen 1.12.0