詳細説明

関数
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())
	2つの行列(または行列とスカラー)の要素ごとの絶対差を計算する。

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())
	2つの配列の加重和を計算する。

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())
	2つの行列(または行列とスカラー)の要素ごとのビット単位論理積を実行する。

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())
	2つの行列(または行列とスカラー)の要素ごとのビット単位論理和を実行する。

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())
	2つの行列(または行列とスカラー)の要素ごとのビット単位排他的論理和を実行する。

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())
	2つの行列(または行列とスカラー)の要素を比較する。

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())
	配列の要素が2つのスカラの間にあるかを確認する。

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())
	複素数行列要素の大きさ（マグニチュード）の2乗を計算する。

void	cv::cuda::max (InputArray src1, InputArray src2, OutputArray dst, Stream &stream=Stream::Null())
	2つの行列（または行列とスカラ）の要素ごとの最大値を計算する。

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())
	2つの行列（または行列とスカラ）の要素ごとの最小値を計算する。

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())
	各行列要素の2乗を計算する。

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>

2つの行列（または行列とスカラ）の要素ごとの絶対差を計算する。

引数

src1	1つ目の入力行列またはスカラー。
src2	2つ目の入力行列またはスカラー。
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	1つ目の入力行列。
src2	2番目の入力スカラ。
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	1つ目の入力行列またはスカラー。
src2	2つ目の入力行列またはスカラー。行列は 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>

2つの配列の重み付き和を計算する。

引数

src1	1つ目の入力配列。
alpha	1つ目の配列の要素に対する重み。
src2	src1 と同じサイズおよびチャンネル数を持つ2つ目の入力配列。
beta	2つ目の配列の要素に対する重み。
dst	入力配列と同じサイズおよびチャンネル数を持つ出力配列。
gamma	各合計に加算されるスカラー。
dtype	出力配列の省略可能なビット深度。両方の入力配列が同じビット深度を持つ場合、dtype を -1 に設定でき、これは src1.depth() と同等になる。
stream	非同期版のための Stream。

関数 addWeighted は2つの配列の重み付き和を次のように計算する。

\[\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	1つ目の入力行列。
src2	2番目の入力スカラ。
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>

2つの行列（または行列とスカラー）の要素ごとのビット単位の論理積を実行する。

引数

src1	1つ目の入力行列またはスカラー。
src2	2つ目の入力行列またはスカラー。
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	1つ目の入力行列。
src2	2番目の入力スカラ。
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>

2つの行列（または行列とスカラー）の要素ごとのビット単位の論理和を実行する。

引数

src1	1つ目の入力行列またはスカラー。
src2	2つ目の入力行列またはスカラー。
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	1つ目の入力行列。
src2	2番目の入力スカラ。
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>

2つの行列（または行列とスカラー）の要素ごとのビット単位の排他的論理和演算を実行する。

引数

src1	1つ目の入力行列またはスカラー。
src2	2つ目の入力行列またはスカラー。
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	1つ目の入力行列。
src2	2番目の入力スカラ。
dst	入力配列と同じサイズおよび型を持つ出力行列。
mask	省略可能な演算マスク。8ビットのシングルチャンネル配列で、変更される出力配列の要素を指定する。マスクはシングルチャンネル画像でのみ使用できる。
stream	非同期版のための 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	浮動小数点の大きさを格納する出力行列 ( CV_32FC1 )。
angle	角度を格納する出力行列 ( CV_32FC1 )。
angleInDegrees	角度を度単位で評価する必要があることを示すフラグ。
stream	非同期版のための 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	浮動小数点の大きさを格納する出力行列 ( CV_32FC1 )。
angle	角度を格納する出力行列 ( 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>

2つの行列（または行列とスカラ）の要素を比較する。

引数

src1	1つ目の入力行列またはスカラー。
src2	2つ目の入力行列またはスカラー。
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	1つ目の入力行列。
src2	2番目の入力スカラ。
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	1つ目の入力行列またはスカラー。
src2	2つ目の入力行列またはスカラー。
dst	入力配列と同じサイズおよびチャンネル数を持つ出力行列。ビット深度は dtype または `src1` のビット深度によって決まる。
scale	省略可能なスケール係数。
dtype	出力配列の省略可能なビット深度。
stream	非同期版のための Stream。

この関数は、divideと異なり、切り捨て(round-down)の丸めモードを使用する。

警告: 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	1つ目の入力行列。
src2	2番目の入力スカラ。
dst	入力配列と同じサイズおよびチャンネル数を持つ出力行列。ビット深度は dtype または `src1` のビット深度によって決まる。
scale	省略可能なスケール係数。
dtype	出力配列の省略可能なビット深度。
stream	非同期版のための Stream。

この関数は、divideと異なり、切り捨て(round-down)の丸めモードを使用する。

参照: 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 &	lowerb,
		const Scalar &	upperb,
		OutputArray	dst,
		Stream &	stream = Stream::Null() )

#include <opencv2/cudaarithm.hpp>

配列の要素が2つのスカラーの間にあるかを調べる。

この関数は次のように範囲を調べる。

For every element of a single-channel input array:
\[\texttt{dst} (I)= \texttt{lowerb}_0 \leq \texttt{src} (I)_0 \leq \texttt{upperb}_0\]
For two-channel arrays:
\[\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) が指定された1次元、2次元、3次元、... のボックス内にある場合、dst (I) は255（すべて 1 のビット）に設定され、そうでない場合は0に設定される。

CPU版のinRangeと異なり、これはlowerbやupperbに配列を受け付けず、cv::Scalarのみを受け付けることに注意。

引数

src	1番目の入力配列。
lowerb	下限（境界を含む） cv::Scalar。
upperb	上限（境界を含む） 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	定数値（チャンネルごとに1つ）。
dst	src と同じサイズおよび型を持つ出力行列。
stream	非同期版のための 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	浮動小数点の大きさを格納する出力行列 ( CV_32FC1 )。
stream	非同期版のための Stream。

◆ 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 )。
stream	非同期版のための 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))ベクトルの大きさの2乗を計算する。浮動小数点のソースのみをサポートする。

引数

x	実部成分を含む入力行列 ( CV_32FC1 )。
y	虚部成分を含む入力行列 ( CV_32FC1 )。
magnitude	浮動小数点の大きさの二乗を格納する出力行列 ( CV_32FC1 )。
stream	非同期版のための Stream。

◆ magnitudeSqr() [2/2]

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

#include <opencv2/cudaarithm.hpp>

複素行列要素の大きさの2乗を計算する。

引数

xy	インターリーブ形式の複素数入力行列 ( CV_32FC2 )。
magnitude	浮動小数点の大きさの二乗を格納する出力行列 ( CV_32FC1 )。
stream	非同期版のための Stream。

◆ max()

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

#include <opencv2/cudaarithm.hpp>

2つの行列(または行列とスカラー)の要素ごとの最大値を計算する。

引数

src1	1つ目の入力行列またはスカラー。
src2	2つ目の入力行列またはスカラー。
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	1つ目の入力行列。
src2	2番目の入力スカラ。
dst	入力配列と同じサイズおよび型を持つ出力行列。
stream	非同期版のための Stream。

参照: max

この関数の呼び出しグラフ:

◆ min()

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

#include <opencv2/cudaarithm.hpp>

2つの行列(または行列とスカラー)の要素ごとの最小値を計算する。

引数

src1	1つ目の入力行列またはスカラー。
src2	2つ目の入力行列またはスカラー。
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	1つ目の入力行列。
src2	2番目の入力スカラ。
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	1つ目の入力行列またはスカラー。
src2	2つ目の入力行列またはスカラー。
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	1つ目の入力行列。
src2	2番目の入力スカラ。
dst	入力配列と同じサイズおよびチャンネル数を持つ出力行列。ビット深度は dtype または `src1` のビット深度によって決まる。
scale	省略可能なスケール係数。
dtype	出力配列の省略可能なビット深度。
stream	非同期版のための 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	非同期版のための 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	非同期版のための 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	非同期版のための 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	非同期版のための 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	power,
		OutputArray	dst,
		Stream &	stream = Stream::Null() )

#include <opencv2/cudaarithm.hpp>

各行列要素をべき乗する。

引数

src	入力行列。
power	べき乗の指数。
dst	src と同じサイズおよび型を持つ出力行列。
stream	非同期版のための Stream。

関数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	定数値（チャンネルごとに1つ）。
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>

各行列要素の2乗値を計算する。

引数

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	1つ目の入力行列またはスカラー。
src2	2番目の入力行列またはスカラ。行列は `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	1つ目の入力行列。
src2	2番目の入力スカラ。
dst	入力配列と同じサイズおよびチャンネル数を持つ出力行列。ビット深度は dtype または `src1` のビット深度によって決まる。
mask	省略可能な演算マスク。8ビットのシングルチャンネル配列で、変更される出力配列の要素を指定する。マスクはシングルチャンネル画像でのみ使用できる。
dtype	出力配列の省略可能なビット深度。
stream	非同期版のための 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は、他の型のいずれかと組み合わせることができる。この場合、関数は大津の方法を用いて最適なしきい値を決定し、指定されたしきい値の代わりにそれを使用する。関数は、しきい値処理した行列に加えて、計算されたしきい値を返す。大津の方法は8ビット行列に対してのみ実装されている。

引数

src	入力配列（シングルチャンネル）。
dst	src と同じサイズおよび型を持つ出力配列。
thresh	しきい値。
maxval	THRESH_BINARY および THRESH_BINARY_INV のしきい値処理タイプで使用する最大値。
type	しきい値の種類。詳細は threshold を参照。THRESH_TRIANGLE のしきい値の種類はサポートされていない。
stream	非同期版のための Stream。

参照: threshold