OpenCV 4.13.0
开源计算机视觉库 (Open Source Computer Vision)
正在加载...
正在搜索...
未找到匹配项
函数
逐元素操作
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())
 对数组的每个元素应用固定阈值操作。
 

函数文档 (Function Documentation)

◆ abs()

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

#include <opencv2/cudaarithm.hpp>

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

参数
src源矩阵。
dst与 src 具有相同大小和类型的目标矩阵。
流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 用于异步版本。
警告
在 Python 中，src1 和 src2 都必须是矩阵，标量重载请参见 absdiffWithScalar。
另请参阅
cv::absdiff, absdiffWithScalar

◆ absdiffWithScalar()

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

#include <opencv2/cudaarithm.hpp>

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

参数
src1第一个源矩阵。
src2第二个源标量。
dst与输入数组具有相同大小和类型的目标矩阵。
流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 用于异步版本。
警告
在 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 用于异步版本。

函数 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() )
内联

#include <opencv2/cudaarithm.hpp>

计算矩阵-标量的和。

参数
src1第一个源矩阵。
src2第二个源标量。
dst与输入数组具有相同大小和通道数的目标矩阵。深度由 dtype 或 src1 深度定义。
mask可选的操作掩码，8 位单通道数组，指定要更改的目标数组元素。掩码仅可用于单通道图像。
dtype输出数组的可选深度。
流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 用于异步版本。
警告
在 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() )
内联

#include <opencv2/cudaarithm.hpp>

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

参数
src1第一个源矩阵。
src2第二个源标量。
dst与输入数组具有相同大小和类型的目标矩阵。
mask可选的操作掩码，8 位单通道数组，指定要更改的目标数组元素。掩码仅可用于单通道图像。
流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 用于异步版本。

◆ 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 用于异步版本。
警告
在 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() )
内联

#include <opencv2/cudaarithm.hpp>

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

参数
src1第一个源矩阵。
src2第二个源标量。
dst与输入数组具有相同大小和类型的目标矩阵。
mask可选的操作掩码，8 位单通道数组，指定要更改的目标数组元素。掩码仅可用于单通道图像。
流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 用于异步版本。
警告
在 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() )
内联

#include <opencv2/cudaarithm.hpp>

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

参数
src1第一个源矩阵。
src2第二个源标量。
dst与输入数组具有相同大小和类型的目标矩阵。
mask可选的操作掩码，8 位单通道数组，指定要更改的目标数组元素。掩码仅可用于单通道图像。
流Stream 用于异步版本。
另请参阅
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 (幅度)float 型幅值的目标矩阵 ( CV_32FC1 )。
angle (角度)角度的目标矩阵 ( CV_32FC1 )。
angleInDegrees标志位，指示角度是否必须以度为单位进行计算。
流Stream 用于异步版本。
另请参阅
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 (幅度)float 型幅值的目标矩阵 ( CV_32FC1 )。
angle (角度)角度的目标矩阵 ( CV_32FC1 )。
angleInDegrees标志位，指示角度是否必须以度为单位进行计算。
流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 )。
magnitudeAnglefloat 型幅值和角度的目标矩阵 ( CV_32FC2 )。
angleInDegrees标志位，指示角度是否必须以度为单位进行计算。
流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 用于异步版本。
警告
在 Python 中，src1 和 src2 都必须是矩阵，标量重载请参见 compareWithScalar。
另请参阅
cv::compare, compareWithScalar

◆ compareWithScalar()

void cv::cuda::compareWithScalar ( InputArray src1,
Scalar 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 用于异步版本。
另请参阅
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 用于异步版本。

与 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() )
内联

#include <opencv2/cudaarithm.hpp>

计算矩阵-标量的除法。

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

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

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

◆ exp()

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

#include <opencv2/cudaarithm.hpp>

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

参数
src源矩阵。
dst与 src 具有相同大小和类型的目标矩阵。
流Stream 用于异步版本。
另请参阅
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 的输出数组。
流Stream 用于异步版本。
另请参阅
cv::inRange

◆ log()

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

#include <opencv2/cudaarithm.hpp>

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

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

◆ lshift() [1/2]

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

#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 用于异步版本。

◆ 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 (幅度)float 型幅值的目标矩阵 ( CV_32FC1 )。
流Stream 用于异步版本。

◆ magnitude() [2/2]

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

#include <opencv2/cudaarithm.hpp>

计算复矩阵元素的幅值。

参数
xy交织格式的源复数矩阵 ( CV_32FC2 )。
magnitude (幅度)float 型幅值的目标矩阵 ( CV_32FC1 )。
流Stream 用于异步版本。
另请参阅
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 (幅度)float 型平方幅值的目标矩阵 ( CV_32FC1 )。
流Stream 用于异步版本。

◆ magnitudeSqr() [2/2]

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

#include <opencv2/cudaarithm.hpp>

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

参数
xy交织格式的源复数矩阵 ( CV_32FC2 )。
magnitude (幅度)float 型平方幅值的目标矩阵 ( CV_32FC1 )。
流Stream 用于异步版本。

◆ max()

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

#include <opencv2/cudaarithm.hpp>

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

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

◆ maxWithScalar()

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

#include <opencv2/cudaarithm.hpp>

计算矩阵与标量的逐元素最大值。

参数
src1第一个源矩阵。
src2第二个源标量。
dst与输入数组具有相同大小和类型的目标矩阵。
流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 用于异步版本。
警告
在 Python 中，src1 和 src2 都必须是矩阵，标量重载请参见 minWithScalar。
另请参阅
cv::min, minWithScalar

◆ minWithScalar()

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

#include <opencv2/cudaarithm.hpp>

计算矩阵与标量的逐元素最小值。

参数
src1第一个源矩阵。
src2第二个源标量。
dst与输入数组具有相同大小和类型的目标矩阵。
流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 用于异步版本。
警告
在 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() )
内联

#include <opencv2/cudaarithm.hpp>

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

参数
src1第一个源矩阵。
src2第二个源标量。
dst与输入数组具有相同大小和通道数的目标矩阵。深度由 dtype 或 src1 深度定义。
scale可选的比例因子。
dtype输出数组的可选深度。
流Stream 用于异步版本。
另请参阅
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标志位，指示角度是否必须以度为单位进行计算。
流Stream 用于异步版本。
另请参阅
相位 (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标志位，指示角度是否必须以度为单位进行计算。
流Stream 用于异步版本。
另请参阅
相位 (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 (角度)包含角度的源矩阵（与 magnitude 类型相同）。
x包含实部组件的目标矩阵（与 magnitude 类型相同）。
y包含虚部组件的目标矩阵（与 magnitude 类型相同）。
angleInDegrees指示角度是否以度为单位的标志。
流Stream 用于异步版本。

◆ 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 (角度)包含角度的源矩阵（与 magnitude 类型相同）。
xy包含实部和虚部组件的目标矩阵（与 magnitude 深度相同，即 CV_32FC2 或 CV_64FC2）。
angleInDegrees指示角度是否以度为单位的标志。
流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 用于异步版本。

◆ pow()

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

#include <opencv2/cudaarithm.hpp>

计算每个矩阵元素的幂。

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

函数 pow 将输入矩阵的每个元素求 power 次幂

\[\texttt{dst} (I) = \fork{\texttt{src}(I)^power}{如果 \texttt{power} 是整数}{|\texttt{src}(I)|^power}{否则}\]

另请参阅
pow

◆ rshift() [1/2]

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

#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 用于异步版本。

◆ 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 用于异步版本。

◆ sqrt()

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

#include <opencv2/cudaarithm.hpp>

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

参数
src源矩阵。
dst与 src 具有相同大小和类型的目标矩阵。
流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 用于异步版本。
警告
在 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() )
内联

#include <opencv2/cudaarithm.hpp>

计算矩阵-标量的差值。

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

◆ threshold()

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

#include <opencv2/cudaarithm.hpp>

对数组的每个元素应用固定阈值操作。

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

参数
src源数组（单通道）。
dst与 src 大小和类型相同的目标数组。
thresh阈值。
最大值 (maxval)用于 THRESH_BINARY 和 THRESH_BINARY_INV 阈值类型的最大值。
type阈值类型。详情请参阅 threshold。不支持 THRESH_TRIANGLE 阈值类型。
流Stream 用于异步版本。
另请参阅
阈值 (threshold)
生成于 2025年12月31日 星期三 07:26:23，为 OpenCV 生成，由 doxygen 1.12.0