基本構造体

詳細説明

名前空間
namespace	cv::traits

クラス
class	cv::_InputArray
	読み取り専用の入力配列を OpenCV 関数へ渡すためのプロキシクラス。続き...
class	cv::_InputOutputArray
class	cv::_OutputArray
	この型は InputArray と非常によく似ているが、入出力および出力の関数引数に使用される点が異なる。続き...
class	cv::Algorithm
	OpenCVにおける、多かれ少なかれ複雑なすべてのアルゴリズムの基底クラス。 詳細...
class	cv::Complex< _Tp >
	複素数クラス。 続きを読む...
class	cv::DataDepth< _Tp >
	cv::DataTypeのためのヘルパークラス。 続きを読む...
class	cv::DataType< _Tp >
	OpenCVのプリミティブデータ型のためのテンプレート「トレイト」クラス。 続きを読む...
class	cv::DMatch
	キーポイント記述子をマッチングするためのクラス。 続きを読む...
class	cv::Formatted
class	cv::Formatter
class	cv::KeyPoint
	顕著点検出器のためのデータ構造。 続きを読む...
class	cv::Mat
	カンマ区切りの行列初期化子。 続きを読む...
class	cv::Mat_< _Tp >
	Mat から派生したテンプレート行列クラス。 続きを読む...
class	cv::MatAllocator
	カスタム配列アロケータ。 続きを読む...
class	cv::MatConstIterator
class	cv::MatConstIterator_< _Tp >
	行列の読み取り専用イテレータ。 続きを読む...
class	cv::MatExpr
	行列式の表現 これは任意の複雑な式の中で組み合わせられる、実装済みの行列演算の一覧である（ここで A, B は行列 ( cv::Mat )、s は cv::Scalar、alpha は実数値スカラー ( double ) を表す）: 続きを読む...
class	cv::MatIterator_< _Tp >
	行列の読み書きイテレータ。 続きを読む...
class	cv::MatOp
struct	cv::MatShape
	行列/テンソルの形状を表す。以前は MatShape は std::vector<int> のエイリアスとして定義されていたが、現在はいくつかの追加の利点を提供する特別な構造体を使用している: 続きを読む...
class	cv::Matx< _Tp, m, n >
	型とサイズがコンパイル時に既知である小行列のためのテンプレートクラス。 続きを読む...
class	cv::NAryMatIterator
	n項の多次元配列イテレータ。 続きを読む...
struct	cv::ParamType< _Tp, _EnumTp >
struct	cv::ParamType< _Tp, typename std::enable_if< std::is_enum< _Tp >::value >::type >
struct	cv::ParamType< Algorithm >
struct	cv::ParamType< bool >
struct	cv::ParamType< double >
struct	cv::ParamType< float >
struct	cv::ParamType< Mat >
struct	cv::ParamType< Scalar >
struct	cv::ParamType< std::vector< Mat > >
struct	cv::ParamType< String >
struct	cv::ParamType< uchar >
struct	cv::ParamType< uint64 >
struct	cv::ParamType< unsigned >
class	cv::Point3_< _Tp >
	座標x, y, zで指定される3D点のためのテンプレートクラス。 続きを読む...
class	cv::Point_< _Tp >
	座標xおよびyで指定される2D点のためのテンプレートクラス。 続きを読む...
class	cv::Range
	シーケンスの連続した部分シーケンス（スライス）を指定するテンプレートクラス。 続きを読む...
class	cv::Rect_< _Tp >
	2D矩形のためのテンプレートクラス。 続きを読む...
class	cv::RotatedRect
	このクラスは、平面上の回転した（すなわち直立していない）矩形を表す。 続きを読む...
class	cv::Scalar_< _Tp >
	Vecから派生した4要素ベクトルのためのテンプレートクラス。 続きを読む...
class	cv::Size_< _Tp >
	画像または矩形のサイズを指定するためのテンプレートクラス。 続きを読む...
class	cv::SparseMat
	SparseMatクラスは、多次元の疎な数値配列を表す。 続きを読む...
class	cv::SparseMat_< _Tp >
	SparseMatから派生したテンプレートの疎なn次元配列クラス。 続きを読む...
class	cv::SparseMatConstIterator
	読み取り専用の疎行列イテレータ。 続きを読む...
class	cv::SparseMatConstIterator_< _Tp >
	テンプレートの読み取り専用疎行列イテレータクラス。 続きを読む...
class	cv::SparseMatIterator
	読み書き可能な疎行列イテレータ。 詳細...
class	cv::SparseMatIterator_< _Tp >
	テンプレート版の読み書き可能な疎行列イテレータクラス。 詳細...
class	cv::TermCriteria
	反復アルゴリズムの終了条件を定義するクラス。 詳細...
class	cv::UMat
class	cv::Vec< _Tp, cn >
	短い数値ベクトル用のテンプレートクラスであり、Matx の部分的な特殊ケースである。 詳細...

型定義
typedef Complex< double >	cv::Complexd
typedef Complex< float >	cv::Complexf
typedef const _InputArray &	cv::InputArray
typedef InputArray	cv::InputArrayOfArrays
typedef const _InputOutputArray &	cv::InputOutputArray
typedef InputOutputArray	cv::InputOutputArrayOfArrays
typedef Mat_< uchar >	cv::Mat1b
typedef Mat_< double >	cv::Mat1d
typedef Mat_< float >	cv::Mat1f
typedef Mat_< int >	cv::Mat1i
typedef Mat_< short >	cv::Mat1s
typedef Mat_< ushort >	cv::Mat1w
typedef Mat_< Vec2b >	cv::Mat2b
typedef Mat_< Vec2d >	cv::Mat2d
typedef Mat_< Vec2f >	cv::Mat2f
typedef Mat_< Vec2i >	cv::Mat2i
typedef Mat_< Vec2s >	cv::Mat2s
typedef Mat_< Vec2w >	cv::Mat2w
typedef Mat_< Vec3b >	cv::Mat3b
typedef Mat_< Vec3d >	cv::Mat3d
typedef Mat_< Vec3f >	cv::Mat3f
typedef Mat_< Vec3i >	cv::Mat3i
typedef Mat_< Vec3s >	cv::Mat3s
typedef Mat_< Vec3w >	cv::Mat3w
typedef Mat_< Vec4b >	cv::Mat4b
typedef Mat_< Vec4d >	cv::Mat4d
typedef Mat_< Vec4f >	cv::Mat4f
typedef Mat_< Vec4i >	cv::Mat4i
typedef Mat_< Vec4s >	cv::Mat4s
typedef Mat_< Vec4w >	cv::Mat4w
typedef Matx< double, 1, 2 >	cv::Matx12d
typedef Matx< float, 1, 2 >	cv::Matx12f
typedef Matx< double, 1, 3 >	cv::Matx13d
typedef Matx< float, 1, 3 >	cv::Matx13f
typedef Matx< double, 1, 4 >	cv::Matx14d
typedef Matx< float, 1, 4 >	cv::Matx14f
typedef Matx< double, 1, 6 >	cv::Matx16d
typedef Matx< float, 1, 6 >	cv::Matx16f
typedef Matx< double, 2, 1 >	cv::Matx21d
typedef Matx< float, 2, 1 >	cv::Matx21f
typedef Matx< double, 2, 2 >	cv::Matx22d
typedef Matx< float, 2, 2 >	cv::Matx22f
typedef Matx< double, 2, 3 >	cv::Matx23d
typedef Matx< float, 2, 3 >	cv::Matx23f
typedef Matx< double, 3, 1 >	cv::Matx31d
typedef Matx< float, 3, 1 >	cv::Matx31f
typedef Matx< double, 3, 2 >	cv::Matx32d
typedef Matx< float, 3, 2 >	cv::Matx32f
typedef Matx< double, 3, 3 >	cv::Matx33d
typedef Matx< float, 3, 3 >	cv::Matx33f
typedef Matx< double, 3, 4 >	cv::Matx34d
typedef Matx< float, 3, 4 >	cv::Matx34f
typedef Matx< double, 4, 1 >	cv::Matx41d
typedef Matx< float, 4, 1 >	cv::Matx41f
typedef Matx< double, 4, 3 >	cv::Matx43d
typedef Matx< float, 4, 3 >	cv::Matx43f
typedef Matx< double, 4, 4 >	cv::Matx44d
typedef Matx< float, 4, 4 >	cv::Matx44f
typedef Matx< double, 6, 1 >	cv::Matx61d
typedef Matx< float, 6, 1 >	cv::Matx61f
typedef Matx< double, 6, 6 >	cv::Matx66d
typedef Matx< float, 6, 6 >	cv::Matx66f
typedef const _OutputArray &	cv::OutputArray
typedef OutputArray	cv::OutputArrayOfArrays
typedef Point2i	cv::Point
typedef Point_< double >	cv::Point2d
typedef Point_< float >	cv::Point2f
typedef Point_< int >	cv::Point2i
typedef Point_< int64 >	cv::Point2l
typedef Point3_< double >	cv::Point3d
typedef Point3_< float >	cv::Point3f
typedef Point3_< int >	cv::Point3i
template<typename _Tp >
using	cv::Ptr = std::shared_ptr<_Tp>
typedef Rect2i	cv::Rect
typedef Rect_< double >	cv::Rect2d
typedef Rect_< float >	cv::Rect2f
typedef Rect_< int >	cv::Rect2i
typedef Scalar_< double >	cv::Scalar
typedef Size2i	cv::Size
typedef Size_< double >	cv::Size2d
typedef Size_< float >	cv::Size2f
typedef Size_< int >	cv::Size2i
typedef Size_< int64 >	cv::Size2l
typedef std::string	cv::String

列挙型
enum	cv::AccessFlag {   cv::ACCESS_READ =1<<24 ,   cv::ACCESS_WRITE =1<<25 ,   cv::ACCESS_RW =3<<24 ,   cv::ACCESS_MASK =ACCESS_RW ,   cv::ACCESS_FAST =1<<26 }
enum	cv::DataLayout {   cv::DATA_LAYOUT_UNKNOWN = 0 ,   cv::DATA_LAYOUT_ND = 1 ,   cv::DATA_LAYOUT_NCHW = 2 ,   cv::DATA_LAYOUT_NCDHW = 3 ,   cv::DATA_LAYOUT_NHWC = 4 ,   cv::DATA_LAYOUT_NDHWC = 5 ,   cv::DATA_LAYOUT_PLANAR = 6 ,   cv::DATA_LAYOUT_BLOCK = 7 ,   cv::DNN_LAYOUT_UNKNOWN = 0 ,   cv::DNN_LAYOUT_ND = 1 ,   cv::DNN_LAYOUT_NCHW = 2 ,   cv::DNN_LAYOUT_NCDHW = 3 ,   cv::DNN_LAYOUT_NHWC = 4 ,   cv::DNN_LAYOUT_NDHWC = 5 ,   cv::DNN_LAYOUT_PLANAR = 6 ,   cv::DNN_LAYOUT_BLOCK = 7 }
	モデル推論におけるデータレイアウトのEnum。 続きを読む...
enum struct	cv::Param {   cv::Param::INT =0 ,   cv::Param::BOOLEAN =1 ,   cv::Param::REAL =2 ,   cv::Param::STRING =3 ,   cv::Param::MAT =4 ,   cv::Param::MAT_VECTOR =5 ,   cv::Param::ALGORITHM =6 ,   cv::Param::FLOAT =7 ,   cv::Param::UNSIGNED_INT =8 ,   cv::Param::UINT64 =9 ,   cv::Param::UCHAR =11 ,   cv::Param::SCALAR =12 }
enum	cv::UMatUsageFlags {   cv::USAGE_DEFAULT = 0 ,   cv::USAGE_ALLOCATE_HOST_MEMORY = 1 << 0 ,   cv::USAGE_ALLOCATE_DEVICE_MEMORY = 1 << 1 ,   cv::USAGE_ALLOCATE_SHARED_MEMORY = 1 << 2 ,   cv::__UMAT_USAGE_FLAGS_32BIT = 0x7fffffff }
	アロケータのための使用法フラグ。 続きを読む...

関数
template<typename _Tp , int m>
static double	cv::determinant (const Matx< _Tp, m, m > &a)
std::string	cv::layoutToString (DataLayout layout)
template<typename _Tp , typename ... A1>
static Ptr< _Tp >	cv::makePtr (const A1 &... a1)
InputOutputArray	cv::noArray ()
	空のInputArrayまたはOutputArrayを返す。
template<typename _Tp , int m, int n>
static double	cv::norm (const Matx< _Tp, m, n > &M)
template<typename _Tp , int m, int n>
static double	cv::norm (const Matx< _Tp, m, n > &M, int normType)
template<typename _Tp , int cn>
Vec< _Tp, cn >	cv::normalize (const Vec< _Tp, cn > &v)
bool	cv::operator!= (const MatShape &shape1, const MatShape &shape2)
template<typename _Tp , int m, int n>
static bool	cv::operator!= (const Matx< _Tp, m, n > &a, const Matx< _Tp, m, n > &b)
template<typename _Tp , int m, int n, int l>
static Matx< _Tp, m, n >	cv::operator* (const Matx< _Tp, m, l > &a, const Matx< _Tp, l, n > &b)
template<typename _Tp , int m, int n>
static Vec< _Tp, m >	cv::operator* (const Matx< _Tp, m, n > &a, const Vec< _Tp, n > &b)
template<typename _Tp , int m, int n>
static Matx< _Tp, m, n >	cv::operator* (const Matx< _Tp, m, n > &a, double alpha)
template<typename _Tp , int m, int n>
static Matx< _Tp, m, n >	cv::operator* (const Matx< _Tp, m, n > &a, float alpha)
template<typename _Tp , int m, int n>
static Matx< _Tp, m, n >	cv::operator* (const Matx< _Tp, m, n > &a, int alpha)
template<typename _Tp >
Vec< _Tp, 4 >	cv::operator* (const Vec< _Tp, 4 > &v1, const Vec< _Tp, 4 > &v2)
template<typename _Tp , int cn>
static Vec< _Tp, cn >	cv::operator* (const Vec< _Tp, cn > &a, double alpha)
template<typename _Tp , int cn>
static Vec< _Tp, cn >	cv::operator* (const Vec< _Tp, cn > &a, float alpha)
template<typename _Tp , int cn>
static Vec< _Tp, cn >	cv::operator* (const Vec< _Tp, cn > &a, int alpha)
template<typename _Tp , int m, int n>
static Matx< _Tp, m, n >	cv::operator* (double alpha, const Matx< _Tp, m, n > &a)
template<typename _Tp , int cn>
static Vec< _Tp, cn >	cv::operator* (double alpha, const Vec< _Tp, cn > &a)
template<typename _Tp , int m, int n>
static Matx< _Tp, m, n >	cv::operator* (float alpha, const Matx< _Tp, m, n > &a)
template<typename _Tp , int cn>
static Vec< _Tp, cn >	cv::operator* (float alpha, const Vec< _Tp, cn > &a)
template<typename _Tp , int m, int n>
static Matx< _Tp, m, n >	cv::operator* (int alpha, const Matx< _Tp, m, n > &a)
template<typename _Tp , int cn>
static Vec< _Tp, cn >	cv::operator* (int alpha, const Vec< _Tp, cn > &a)
template<typename _Tp , int m, int n>
static Matx< _Tp, m, n > &	cv::operator*= (Matx< _Tp, m, n > &a, double alpha)
template<typename _Tp , int m, int n>
static Matx< _Tp, m, n > &	cv::operator*= (Matx< _Tp, m, n > &a, float alpha)
template<typename _Tp , int m, int n>
static Matx< _Tp, m, n > &	cv::operator*= (Matx< _Tp, m, n > &a, int alpha)
template<typename _Tp >
Vec< _Tp, 4 > &	cv::operator*= (Vec< _Tp, 4 > &v1, const Vec< _Tp, 4 > &v2)
template<typename _Tp , int cn>
static Vec< _Tp, cn > &	cv::operator*= (Vec< _Tp, cn > &a, double alpha)
template<typename _Tp , int cn>
static Vec< _Tp, cn > &	cv::operator*= (Vec< _Tp, cn > &a, float alpha)
template<typename _Tp , int cn>
static Vec< _Tp, cn > &	cv::operator*= (Vec< _Tp, cn > &a, int alpha)
template<typename _Tp , int m, int n>
static Matx< _Tp, m, n >	cv::operator+ (const Matx< _Tp, m, n > &a, const Matx< _Tp, m, n > &b)
template<typename _Tp , int cn>
static Vec< _Tp, cn >	cv::operator+ (const Vec< _Tp, cn > &a, const Vec< _Tp, cn > &b)
template<typename _Tp1 , typename _Tp2 , int m, int n>
static Matx< _Tp1, m, n > &	cv::operator+= (Matx< _Tp1, m, n > &a, const Matx< _Tp2, m, n > &b)
template<typename _Tp1 , typename _Tp2 , int cn>
static Vec< _Tp1, cn > &	cv::operator+= (Vec< _Tp1, cn > &a, const Vec< _Tp2, cn > &b)
template<typename _Tp , int m, int n>
static Matx< _Tp, m, n >	cv::operator- (const Matx< _Tp, m, n > &a)
template<typename _Tp , int m, int n>
static Matx< _Tp, m, n >	cv::operator- (const Matx< _Tp, m, n > &a, const Matx< _Tp, m, n > &b)
template<typename _Tp , int cn>
static Vec< _Tp, cn >	cv::operator- (const Vec< _Tp, cn > &a)
template<typename _Tp , int cn>
static Vec< _Tp, cn >	cv::operator- (const Vec< _Tp, cn > &a, const Vec< _Tp, cn > &b)
template<typename _Tp1 , typename _Tp2 , int m, int n>
static Matx< _Tp1, m, n > &	cv::operator-= (Matx< _Tp1, m, n > &a, const Matx< _Tp2, m, n > &b)
template<typename _Tp1 , typename _Tp2 , int cn>
static Vec< _Tp1, cn > &	cv::operator-= (Vec< _Tp1, cn > &a, const Vec< _Tp2, cn > &b)
template<typename _Tp , int m, int n>
static Matx< _Tp, m, n >	cv::operator/ (const Matx< _Tp, m, n > &a, double alpha)
template<typename _Tp , int m, int n>
static Matx< _Tp, m, n >	cv::operator/ (const Matx< _Tp, m, n > &a, float alpha)
template<typename _Tp , int cn>
static Vec< _Tp, cn >	cv::operator/ (const Vec< _Tp, cn > &a, double alpha)
template<typename _Tp , int cn>
static Vec< _Tp, cn >	cv::operator/ (const Vec< _Tp, cn > &a, float alpha)
template<typename _Tp , int cn>
static Vec< _Tp, cn >	cv::operator/ (const Vec< _Tp, cn > &a, int alpha)
template<typename _Tp , int m, int n>
static Matx< _Tp, m, n > &	cv::operator/= (Matx< _Tp, m, n > &a, double alpha)
template<typename _Tp , int m, int n>
static Matx< _Tp, m, n > &	cv::operator/= (Matx< _Tp, m, n > &a, float alpha)
template<typename _Tp , int cn>
static Vec< _Tp, cn > &	cv::operator/= (Vec< _Tp, cn > &a, double alpha)
template<typename _Tp , int cn>
static Vec< _Tp, cn > &	cv::operator/= (Vec< _Tp, cn > &a, float alpha)
template<typename _Tp , int cn>
static Vec< _Tp, cn > &	cv::operator/= (Vec< _Tp, cn > &a, int alpha)
static String &	cv::operator<< (String &out, const Mat &mtx)
static String &	cv::operator<< (String &out, Ptr< Formatted > fmtd)
bool	cv::operator== (const MatShape &shape1, const MatShape &shape2)
template<typename _Tp , int m, int n>
static bool	cv::operator== (const Matx< _Tp, m, n > &a, const Matx< _Tp, m, n > &b)
template<typename _Tp >
static _InputArray	cv::rawIn (_Tp &v)
template<typename _Tp >
static _InputOutputArray	cv::rawInOut (_Tp &v)
template<typename _Tp >
static _OutputArray	cv::rawOut (_Tp &v)
static std::string	cv::toLowerCase (const std::string &str)
static std::string	cv::toUpperCase (const std::string &str)
template<typename _Tp , int m, int n>
static double	cv::trace (const Matx< _Tp, m, n > &a)

Shorter aliases for the most popular specializations of Vec<T,n>
typedef Vec< uchar, 2 >	cv::Vec2b
typedef Vec< uchar, 3 >	cv::Vec3b
typedef Vec< uchar, 4 >	cv::Vec4b
typedef Vec< short, 2 >	cv::Vec2s
typedef Vec< short, 3 >	cv::Vec3s
typedef Vec< short, 4 >	cv::Vec4s
typedef Vec< ushort, 2 >	cv::Vec2w
typedef Vec< ushort, 3 >	cv::Vec3w
typedef Vec< ushort, 4 >	cv::Vec4w
typedef Vec< int, 2 >	cv::Vec2i
typedef Vec< int, 3 >	cv::Vec3i
typedef Vec< int, 4 >	cv::Vec4i
typedef Vec< int, 6 >	cv::Vec6i
typedef Vec< int, 8 >	cv::Vec8i
typedef Vec< int64_t, 2 >	cv::Vec2l
typedef Vec< int64_t, 3 >	cv::Vec3l
typedef Vec< int64_t, 4 >	cv::Vec4l
typedef Vec< int64_t, 6 >	cv::Vec6l
typedef Vec< int64_t, 8 >	cv::Vec8l
typedef Vec< float, 2 >	cv::Vec2f
typedef Vec< float, 3 >	cv::Vec3f
typedef Vec< float, 4 >	cv::Vec4f
typedef Vec< float, 6 >	cv::Vec6f
typedef Vec< double, 2 >	cv::Vec2d
typedef Vec< double, 3 >	cv::Vec3d
typedef Vec< double, 4 >	cv::Vec4d
typedef Vec< double, 6 >	cv::Vec6d

型定義詳解

Complexd

typedef Complex<double> cv::Complexd

#include <opencv2/core/types.hpp>

Complexf

typedef Complex<float> cv::Complexf

#include <opencv2/core/types.hpp>

InputArray

typedef const _InputArray& cv::InputArray

#include <opencv2/core/mat.hpp>

InputArrayOfArrays

typedef InputArray cv::InputArrayOfArrays

#include <opencv2/core/mat.hpp>

InputOutputArray

typedef const _InputOutputArray& cv::InputOutputArray

#include <opencv2/core/mat.hpp>

InputOutputArrayOfArrays

typedef InputOutputArray cv::InputOutputArrayOfArrays

#include <opencv2/core/mat.hpp>

Mat1b

typedef Mat_<uchar> cv::Mat1b

#include <opencv2/core/mat.hpp>

Mat1d

typedef Mat_<double> cv::Mat1d

#include <opencv2/core/mat.hpp>

Mat1f

typedef Mat_<float> cv::Mat1f

#include <opencv2/core/mat.hpp>

Mat1i

typedef Mat_<int> cv::Mat1i

#include <opencv2/core/mat.hpp>

Mat1s

typedef Mat_<short> cv::Mat1s

#include <opencv2/core/mat.hpp>

Mat1w

typedef Mat_<ushort> cv::Mat1w

#include <opencv2/core/mat.hpp>

Mat2b

typedef Mat_<Vec2b> cv::Mat2b

#include <opencv2/core/mat.hpp>

Mat2d

typedef Mat_<Vec2d> cv::Mat2d

#include <opencv2/core/mat.hpp>

Mat2f

typedef Mat_<Vec2f> cv::Mat2f

#include <opencv2/core/mat.hpp>

Mat2i

typedef Mat_<Vec2i> cv::Mat2i

#include <opencv2/core/mat.hpp>

Mat2s

typedef Mat_<Vec2s> cv::Mat2s

#include <opencv2/core/mat.hpp>

Mat2w

typedef Mat_<Vec2w> cv::Mat2w

#include <opencv2/core/mat.hpp>

Mat3b

typedef Mat_<Vec3b> cv::Mat3b

#include <opencv2/core/mat.hpp>

Mat3d

typedef Mat_<Vec3d> cv::Mat3d

#include <opencv2/core/mat.hpp>

Mat3f

typedef Mat_<Vec3f> cv::Mat3f

#include <opencv2/core/mat.hpp>

Mat3i

typedef Mat_<Vec3i> cv::Mat3i

#include <opencv2/core/mat.hpp>

Mat3s

typedef Mat_<Vec3s> cv::Mat3s

#include <opencv2/core/mat.hpp>

Mat3w

typedef Mat_<Vec3w> cv::Mat3w

#include <opencv2/core/mat.hpp>

Mat4b

typedef Mat_<Vec4b> cv::Mat4b

#include <opencv2/core/mat.hpp>

Mat4d

typedef Mat_<Vec4d> cv::Mat4d

#include <opencv2/core/mat.hpp>

Mat4f

typedef Mat_<Vec4f> cv::Mat4f

#include <opencv2/core/mat.hpp>

Mat4i

typedef Mat_<Vec4i> cv::Mat4i

#include <opencv2/core/mat.hpp>

Mat4s

typedef Mat_<Vec4s> cv::Mat4s

#include <opencv2/core/mat.hpp>

Mat4w

typedef Mat_<Vec4w> cv::Mat4w

#include <opencv2/core/mat.hpp>

Matx12d

typedef Matx<double, 1, 2> cv::Matx12d

#include <opencv2/core/matx.hpp>

Matx12f

typedef Matx<float, 1, 2> cv::Matx12f

#include <opencv2/core/matx.hpp>

Matx13d

typedef Matx<double, 1, 3> cv::Matx13d

#include <opencv2/core/matx.hpp>

Matx13f

typedef Matx<float, 1, 3> cv::Matx13f

#include <opencv2/core/matx.hpp>

Matx14d

typedef Matx<double, 1, 4> cv::Matx14d

#include <opencv2/core/matx.hpp>

Matx14f

typedef Matx<float, 1, 4> cv::Matx14f

#include <opencv2/core/matx.hpp>

Matx16d

typedef Matx<double, 1, 6> cv::Matx16d

#include <opencv2/core/matx.hpp>

Matx16f

typedef Matx<float, 1, 6> cv::Matx16f

#include <opencv2/core/matx.hpp>

Matx21d

typedef Matx<double, 2, 1> cv::Matx21d

#include <opencv2/core/matx.hpp>

Matx21f

typedef Matx<float, 2, 1> cv::Matx21f

#include <opencv2/core/matx.hpp>

Matx22d

typedef Matx<double, 2, 2> cv::Matx22d

#include <opencv2/core/matx.hpp>

Matx22f

typedef Matx<float, 2, 2> cv::Matx22f

#include <opencv2/core/matx.hpp>

Matx23d

typedef Matx<double, 2, 3> cv::Matx23d

#include <opencv2/core/matx.hpp>

Matx23f

typedef Matx<float, 2, 3> cv::Matx23f

#include <opencv2/core/matx.hpp>

Matx31d

typedef Matx<double, 3, 1> cv::Matx31d

#include <opencv2/core/matx.hpp>

Matx31f

typedef Matx<float, 3, 1> cv::Matx31f

#include <opencv2/core/matx.hpp>

Matx32d

typedef Matx<double, 3, 2> cv::Matx32d

#include <opencv2/core/matx.hpp>

Matx32f

typedef Matx<float, 3, 2> cv::Matx32f

#include <opencv2/core/matx.hpp>

Matx33d

typedef Matx<double, 3, 3> cv::Matx33d

#include <opencv2/core/matx.hpp>

Matx33f

typedef Matx<float, 3, 3> cv::Matx33f

#include <opencv2/core/matx.hpp>

Matx34d

typedef Matx<double, 3, 4> cv::Matx34d

#include <opencv2/core/matx.hpp>

Matx34f

typedef Matx<float, 3, 4> cv::Matx34f

#include <opencv2/core/matx.hpp>

Matx41d

typedef Matx<double, 4, 1> cv::Matx41d

#include <opencv2/core/matx.hpp>

Matx41f

typedef Matx<float, 4, 1> cv::Matx41f

#include <opencv2/core/matx.hpp>

Matx43d

typedef Matx<double, 4, 3> cv::Matx43d

#include <opencv2/core/matx.hpp>

Matx43f

typedef Matx<float, 4, 3> cv::Matx43f

#include <opencv2/core/matx.hpp>

Matx44d

typedef Matx<double, 4, 4> cv::Matx44d

#include <opencv2/core/matx.hpp>

Matx44f

typedef Matx<float, 4, 4> cv::Matx44f

#include <opencv2/core/matx.hpp>

Matx61d

typedef Matx<double, 6, 1> cv::Matx61d

#include <opencv2/core/matx.hpp>

Matx61f

typedef Matx<float, 6, 1> cv::Matx61f

#include <opencv2/core/matx.hpp>

Matx66d

typedef Matx<double, 6, 6> cv::Matx66d

#include <opencv2/core/matx.hpp>

Matx66f

typedef Matx<float, 6, 6> cv::Matx66f

#include <opencv2/core/matx.hpp>

OutputArray

typedef const _OutputArray& cv::OutputArray

#include <opencv2/core/mat.hpp>

OutputArrayOfArrays

typedef OutputArray cv::OutputArrayOfArrays

#include <opencv2/core/mat.hpp>

Point

typedef Point2i cv::Point

#include <opencv2/core/types.hpp>

Point2d

typedef Point_<double> cv::Point2d

#include <opencv2/core/types.hpp>

Point2f

typedef Point_<float> cv::Point2f

#include <opencv2/core/types.hpp>

Point2i

typedef Point_<int> cv::Point2i

#include <opencv2/core/types.hpp>

Point2l

typedef Point_<int64> cv::Point2l

#include <opencv2/core/types.hpp>

Point3d

typedef Point3_<double> cv::Point3d

#include <opencv2/core/types.hpp>

Point3f

typedef Point3_<float> cv::Point3f

#include <opencv2/core/types.hpp>

Point3i

typedef Point3_<int> cv::Point3i

#include <opencv2/core/types.hpp>

Ptr

template<typename _Tp >

using cv::Ptr = std::shared_ptr<_Tp>

#include <opencv2/core/cvstd_wrapper.hpp>

例

modules/shape/samples/shape_example.cpp.

Rect

typedef Rect2i cv::Rect

#include <opencv2/core/types.hpp>

Rect2d

typedef Rect_<double> cv::Rect2d

#include <opencv2/core/types.hpp>

Rect2f

typedef Rect_<float> cv::Rect2f

#include <opencv2/core/types.hpp>

Rect2i

typedef Rect_<int> cv::Rect2i

#include <opencv2/core/types.hpp>

Scalar

typedef Scalar_<double> cv::Scalar

#include <opencv2/core/types.hpp>

Size

typedef Size2i cv::Size

#include <opencv2/core/types.hpp>

Size2d

typedef Size_<double> cv::Size2d

#include <opencv2/core/types.hpp>

Size2f

typedef Size_<float> cv::Size2f

#include <opencv2/core/types.hpp>

Size2i

typedef Size_<int> cv::Size2i

#include <opencv2/core/types.hpp>

Size2l

typedef Size_<int64> cv::Size2l

#include <opencv2/core/types.hpp>

String

typedef std::string cv::String

#include <opencv2/core/cvstd.hpp>

Vec2b

typedef Vec<uchar, 2> cv::Vec2b

#include <opencv2/core/matx.hpp>

Vec2d

typedef Vec<double, 2> cv::Vec2d

#include <opencv2/core/matx.hpp>

Vec2f

typedef Vec<float, 2> cv::Vec2f

#include <opencv2/core/matx.hpp>

Vec2i

typedef Vec<int, 2> cv::Vec2i

#include <opencv2/core/matx.hpp>

Vec2l

typedef Vec<int64_t, 2> cv::Vec2l

#include <opencv2/core/matx.hpp>

Vec2s

typedef Vec<short, 2> cv::Vec2s

#include <opencv2/core/matx.hpp>

Vec2w

typedef Vec<ushort, 2> cv::Vec2w

#include <opencv2/core/matx.hpp>

Vec3b

typedef Vec<uchar, 3> cv::Vec3b

#include <opencv2/core/matx.hpp>

Vec3d

typedef Vec<double, 3> cv::Vec3d

#include <opencv2/core/matx.hpp>

Vec3f

typedef Vec<float, 3> cv::Vec3f

#include <opencv2/core/matx.hpp>

Vec3i

typedef Vec<int, 3> cv::Vec3i

#include <opencv2/core/matx.hpp>

Vec3l

typedef Vec<int64_t, 3> cv::Vec3l

#include <opencv2/core/matx.hpp>

Vec3s

typedef Vec<short, 3> cv::Vec3s

#include <opencv2/core/matx.hpp>

Vec3w

typedef Vec<ushort, 3> cv::Vec3w

#include <opencv2/core/matx.hpp>

Vec4b

typedef Vec<uchar, 4> cv::Vec4b

#include <opencv2/core/matx.hpp>

Vec4d

typedef Vec<double, 4> cv::Vec4d

#include <opencv2/core/matx.hpp>

Vec4f

typedef Vec<float, 4> cv::Vec4f

#include <opencv2/core/matx.hpp>

Vec4i

typedef Vec<int, 4> cv::Vec4i

#include <opencv2/core/matx.hpp>

Vec4l

typedef Vec<int64_t, 4> cv::Vec4l

#include <opencv2/core/matx.hpp>

Vec4s

typedef Vec<short, 4> cv::Vec4s

#include <opencv2/core/matx.hpp>

Vec4w

typedef Vec<ushort, 4> cv::Vec4w

#include <opencv2/core/matx.hpp>

Vec6d

typedef Vec<double, 6> cv::Vec6d

#include <opencv2/core/matx.hpp>

Vec6f

typedef Vec<float, 6> cv::Vec6f

#include <opencv2/core/matx.hpp>

Vec6i

typedef Vec<int, 6> cv::Vec6i

#include <opencv2/core/matx.hpp>

Vec6l

typedef Vec<int64_t, 6> cv::Vec6l

#include <opencv2/core/matx.hpp>

Vec8i

typedef Vec<int, 8> cv::Vec8i

#include <opencv2/core/matx.hpp>

Vec8l

typedef Vec<int64_t, 8> cv::Vec8l

#include <opencv2/core/matx.hpp>

列挙型詳解

AccessFlag

enum cv::AccessFlag

#include <opencv2/core/mat.hpp>

列挙値
ACCESS_READ  Python: cv.ACCESS_READ
ACCESS_WRITE  Python: cv.ACCESS_WRITE
ACCESS_RW  Python: cv.ACCESS_RW
ACCESS_MASK  Python: cv.ACCESS_MASK
ACCESS_FAST  Python: cv.ACCESS_FAST

DataLayout

enum cv::DataLayout

#include <opencv2/core/mat.hpp>

モデル推論のためのデータレイアウトのenum。

参照

Image2BlobParams

列挙値
DATA_LAYOUT_UNKNOWN  Python: cv.DATA_LAYOUT_UNKNOWN
DATA_LAYOUT_ND  Python: cv.DATA_LAYOUT_ND	2DデータのためのOpenCVデータレイアウト。
DATA_LAYOUT_NCHW  Python: cv.DATA_LAYOUT_NCHW	4DデータのためのOpenCVデータレイアウト。
DATA_LAYOUT_NCDHW  Python: cv.DATA_LAYOUT_NCDHW	5DデータのためのOpenCVデータレイアウト。
DATA_LAYOUT_NHWC  Python: cv.DATA_LAYOUT_NHWC	4DデータのためのTensorflow風データレイアウト。
DATA_LAYOUT_NDHWC  Python: cv.DATA_LAYOUT_NDHWC	5DデータのためのTensorflow風データレイアウト。
DATA_LAYOUT_PLANAR  Python: cv.DATA_LAYOUT_PLANAR	Tensorflow風データレイアウト。tfまたはtfliteモデルの解析時にのみ使用すべきである。
DATA_LAYOUT_BLOCK  Python: cv.DATA_LAYOUT_BLOCK	ブロックレイアウト（'NC1HWC0' とも呼ばれる）。一部のアクセラレータで必要とされ、CPU上でもより高い性能が得られる場合がある。
DNN_LAYOUT_UNKNOWN  Python: cv.DNN_LAYOUT_UNKNOWN
DNN_LAYOUT_ND  Python: cv.DNN_LAYOUT_ND	2DデータのためのOpenCVデータレイアウト。
DNN_LAYOUT_NCHW  Python: cv.DNN_LAYOUT_NCHW	4DデータのためのOpenCVデータレイアウト。
DNN_LAYOUT_NCDHW  Python: cv.DNN_LAYOUT_NCDHW	5DデータのためのOpenCVデータレイアウト。
DNN_LAYOUT_NHWC  Python: cv.DNN_LAYOUT_NHWC	4DデータのためのTensorflow風データレイアウト。
DNN_LAYOUT_NDHWC  Python: cv.DNN_LAYOUT_NDHWC	5DデータのためのTensorflow風データレイアウト。
DNN_LAYOUT_PLANAR  Python: cv.DNN_LAYOUT_PLANAR	Tensorflow風データレイアウト。tfまたはtfliteモデルの解析時にのみ使用すべきである。
DNN_LAYOUT_BLOCK  Python: cv.DNN_LAYOUT_BLOCK	ブロックレイアウト（'NC1HWC0' とも呼ばれる）。一部のアクセラレータで必要とされ、CPU上でもより高い性能が得られる場合がある。

Param

enum struct cv::Param

strong

#include <opencv2/core.hpp>

列挙値
INT
BOOLEAN
REAL
STRING
MAT
MAT_VECTOR
ALGORITHM
FLOAT
UNSIGNED_INT
UINT64
UCHAR
SCALAR

UMatUsageFlags

enum cv::UMatUsageFlags

#include <opencv2/core/mat.hpp>

アロケータのための使用法フラグ。

警告

USAGE_DEFAULT を除くすべてのフラグは実験的である。

OpenCLアロケータでは、USAGE_ALLOCATE_SHARED_MEMORY はOpenCVのオプションかつ実験的なOpenCL SVMとの統合に依存する。この統合を有効にするには、CMakeオプション WITH_OPENCL_SVM=ON を指定してOpenCVをビルドし、実行時に cv::ocl::Context::getDefault().setUseSVM(true); またはこれに類するコードを呼び出す。SVMはOpenCL 1.x とは互換性がないことに注意する。

列挙値
USAGE_DEFAULT  Python: cv.USAGE_DEFAULT
USAGE_ALLOCATE_HOST_MEMORY  Python: cv.USAGE_ALLOCATE_HOST_MEMORY
USAGE_ALLOCATE_DEVICE_MEMORY  Python: cv.USAGE_ALLOCATE_DEVICE_MEMORY
USAGE_ALLOCATE_SHARED_MEMORY  Python: cv.USAGE_ALLOCATE_SHARED_MEMORY
__UMAT_USAGE_FLAGS_32BIT  Python: cv.__UMAT_USAGE_FLAGS_32BIT

関数詳解

determinant()

template<typename _Tp , int m>

static double cv::determinant ( const Matx< _Tp, m, m > & a )

inlinestatic

Python:
	cv.determinant(	mtx	) ->	retval

#include <opencv2/core/matx.hpp>

layoutToString()

std::string cv::layoutToString

(

DataLayout

layout

)

#include <opencv2/core/mat.hpp>

makePtr()

template<typename _Tp , typename ... A1>

static Ptr< _Tp > cv::makePtr ( const A1 &... a1 )

inlinestatic

#include <opencv2/core/cvstd_wrapper.hpp>

noArray()

InputOutputArray cv::noArray

(

)

#include <opencv2/core/mat.hpp>

空の InputArray または OutputArray を返す。

この関数は、特定の関数が省略可能な入力配列または出力配列を受け取るが、それらを指定したくない場合に、「空」または「null」の配列を提供するために使われる。

OpenCVの多くの関数は、省略可能な引数を cv::InputArray または cv::OutputArray として受け取る。これらの省略可能な引数にデータを渡したくない場合は、cv::noArray() を使って、それらを省略していることを示せる。

戻り値

プレースホルダとして使える、空の cv::InputArray または cv::OutputArray。

覚え書き

これは、関数が省略可能な配列を持ち、特定の入力配列または出力配列を提供したくない場合によく使われる。

参照

cv::InputArray, cv::OutputArray

norm() [1/2]

template<typename _Tp , int m, int n>

static double cv::norm ( const Matx< _Tp, m, n > & M )

inlinestatic

Python:
	cv.norm(	src1[, normType[, mask]]	) ->	retval
	cv.norm(	src1, src2[, normType[, mask]]	) ->	retval

#include <opencv2/core/matx.hpp>

norm() [2/2]

template<typename _Tp , int m, int n>

static double cv::norm ( const Matx< _Tp, m, n > & M, int normType )

inlinestatic

Python:
	cv.norm(	src1[, normType[, mask]]	) ->	retval
	cv.norm(	src1, src2[, normType[, mask]]	) ->	retval

#include <opencv2/core/matx.hpp>

normalize()

template<typename _Tp , int cn>

Vec< _Tp, cn > cv::normalize ( const Vec< _Tp, cn > & v )

inline

Python:
	cv.normalize(	src, dst[, alpha[, beta[, norm_type[, dtype[, mask]]]]]	) ->	dst

#include <opencv2/core/matx.hpp>

operator!=() [1/2]

bool cv::operator!=	(	const MatShape &	shape1,
		const MatShape &	shape2 )

#include <opencv2/core/mat.hpp>

operator!=() [2/2]

template<typename _Tp , int m, int n>

static bool cv::operator!= ( const Matx< _Tp, m, n > & a, const Matx< _Tp, m, n > & b )

inlinestatic

#include <opencv2/core/matx.hpp>

operator*() [1/15]

template<typename _Tp , int m, int n, int l>

static Matx< _Tp, m, n > cv::operator* ( const Matx< _Tp, m, l > & a, const Matx< _Tp, l, n > & b )

inlinestatic

#include <opencv2/core/matx.hpp>

operator*() [2/15]

template<typename _Tp , int m, int n>

static Vec< _Tp, m > cv::operator* ( const Matx< _Tp, m, n > & a, const Vec< _Tp, n > & b )

inlinestatic

#include <opencv2/core/matx.hpp>

operator*() [3/15]

template<typename _Tp , int m, int n>

static Matx< _Tp, m, n > cv::operator* ( const Matx< _Tp, m, n > & a, double alpha )

inlinestatic

#include <opencv2/core/matx.hpp>

operator*() [4/15]

template<typename _Tp , int m, int n>

static Matx< _Tp, m, n > cv::operator* ( const Matx< _Tp, m, n > & a, float alpha )

inlinestatic

#include <opencv2/core/matx.hpp>

operator*() [5/15]

template<typename _Tp , int m, int n>

static Matx< _Tp, m, n > cv::operator* ( const Matx< _Tp, m, n > & a, int alpha )

inlinestatic

#include <opencv2/core/matx.hpp>

operator*() [6/15]

template<typename _Tp >

Vec< _Tp, 4 > cv::operator* ( const Vec< _Tp, 4 > & v1, const Vec< _Tp, 4 > & v2 )

inline

#include <opencv2/core/matx.hpp>

operator*() [7/15]

template<typename _Tp , int cn>

static Vec< _Tp, cn > cv::operator* ( const Vec< _Tp, cn > & a, double alpha )

inlinestatic

#include <opencv2/core/matx.hpp>

operator*() [8/15]

template<typename _Tp , int cn>

static Vec< _Tp, cn > cv::operator* ( const Vec< _Tp, cn > & a, float alpha )

inlinestatic

#include <opencv2/core/matx.hpp>

operator*() [9/15]

template<typename _Tp , int cn>

static Vec< _Tp, cn > cv::operator* ( const Vec< _Tp, cn > & a, int alpha )

inlinestatic

#include <opencv2/core/matx.hpp>

operator*() [10/15]

template<typename _Tp , int m, int n>

static Matx< _Tp, m, n > cv::operator* ( double alpha, const Matx< _Tp, m, n > & a )

inlinestatic

#include <opencv2/core/matx.hpp>

operator*() [11/15]

template<typename _Tp , int cn>

static Vec< _Tp, cn > cv::operator* ( double alpha, const Vec< _Tp, cn > & a )

inlinestatic

#include <opencv2/core/matx.hpp>

operator*() [12/15]

template<typename _Tp , int m, int n>

static Matx< _Tp, m, n > cv::operator* ( float alpha, const Matx< _Tp, m, n > & a )

inlinestatic

#include <opencv2/core/matx.hpp>

operator*() [13/15]

template<typename _Tp , int cn>

static Vec< _Tp, cn > cv::operator* ( float alpha, const Vec< _Tp, cn > & a )

inlinestatic

#include <opencv2/core/matx.hpp>

operator*() [14/15]

template<typename _Tp , int m, int n>

static Matx< _Tp, m, n > cv::operator* ( int alpha, const Matx< _Tp, m, n > & a )

inlinestatic

#include <opencv2/core/matx.hpp>

operator*() [15/15]

template<typename _Tp , int cn>

static Vec< _Tp, cn > cv::operator* ( int alpha, const Vec< _Tp, cn > & a )

inlinestatic

#include <opencv2/core/matx.hpp>

operator*=() [1/7]

template<typename _Tp , int m, int n>

static Matx< _Tp, m, n > & cv::operator*= ( Matx< _Tp, m, n > & a, double alpha )

inlinestatic

#include <opencv2/core/matx.hpp>

operator*=() [2/7]

template<typename _Tp , int m, int n>

static Matx< _Tp, m, n > & cv::operator*= ( Matx< _Tp, m, n > & a, float alpha )

inlinestatic

#include <opencv2/core/matx.hpp>

operator*=() [3/7]

template<typename _Tp , int m, int n>

static Matx< _Tp, m, n > & cv::operator*= ( Matx< _Tp, m, n > & a, int alpha )

inlinestatic

#include <opencv2/core/matx.hpp>

operator*=() [4/7]

template<typename _Tp >

Vec< _Tp, 4 > & cv::operator*= ( Vec< _Tp, 4 > & v1, const Vec< _Tp, 4 > & v2 )

inline

#include <opencv2/core/matx.hpp>

operator*=() [5/7]

template<typename _Tp , int cn>

static Vec< _Tp, cn > & cv::operator*= ( Vec< _Tp, cn > & a, double alpha )

inlinestatic

#include <opencv2/core/matx.hpp>

operator*=() [6/7]

template<typename _Tp , int cn>

static Vec< _Tp, cn > & cv::operator*= ( Vec< _Tp, cn > & a, float alpha )

inlinestatic

#include <opencv2/core/matx.hpp>

operator*=() [7/7]

template<typename _Tp , int cn>

static Vec< _Tp, cn > & cv::operator*= ( Vec< _Tp, cn > & a, int alpha )

inlinestatic

#include <opencv2/core/matx.hpp>

operator+() [1/2]

template<typename _Tp , int m, int n>

static Matx< _Tp, m, n > cv::operator+ ( const Matx< _Tp, m, n > & a, const Matx< _Tp, m, n > & b )

inlinestatic

#include <opencv2/core/matx.hpp>

operator+() [2/2]

template<typename _Tp , int cn>

static Vec< _Tp, cn > cv::operator+ ( const Vec< _Tp, cn > & a, const Vec< _Tp, cn > & b )

inlinestatic

#include <opencv2/core/matx.hpp>

operator+=() [1/2]

template<typename _Tp1 , typename _Tp2 , int m, int n>

static Matx< _Tp1, m, n > & cv::operator+= ( Matx< _Tp1, m, n > & a, const Matx< _Tp2, m, n > & b )

inlinestatic

#include <opencv2/core/matx.hpp>

operator+=() [2/2]

template<typename _Tp1 , typename _Tp2 , int cn>

static Vec< _Tp1, cn > & cv::operator+= ( Vec< _Tp1, cn > & a, const Vec< _Tp2, cn > & b )

inlinestatic

#include <opencv2/core/matx.hpp>

operator-() [1/4]

template<typename _Tp , int m, int n>

static Matx< _Tp, m, n > cv::operator- ( const Matx< _Tp, m, n > & a )

inlinestatic

#include <opencv2/core/matx.hpp>

operator-() [2/4]

template<typename _Tp , int m, int n>

static Matx< _Tp, m, n > cv::operator- ( const Matx< _Tp, m, n > & a, const Matx< _Tp, m, n > & b )

inlinestatic

#include <opencv2/core/matx.hpp>

operator-() [3/4]

template<typename _Tp , int cn>

static Vec< _Tp, cn > cv::operator- ( const Vec< _Tp, cn > & a )

inlinestatic

#include <opencv2/core/matx.hpp>

operator-() [4/4]

template<typename _Tp , int cn>

static Vec< _Tp, cn > cv::operator- ( const Vec< _Tp, cn > & a, const Vec< _Tp, cn > & b )

inlinestatic

#include <opencv2/core/matx.hpp>

operator-=() [1/2]

template<typename _Tp1 , typename _Tp2 , int m, int n>

static Matx< _Tp1, m, n > & cv::operator-= ( Matx< _Tp1, m, n > & a, const Matx< _Tp2, m, n > & b )

inlinestatic

#include <opencv2/core/matx.hpp>

operator-=() [2/2]

template<typename _Tp1 , typename _Tp2 , int cn>

static Vec< _Tp1, cn > & cv::operator-= ( Vec< _Tp1, cn > & a, const Vec< _Tp2, cn > & b )

inlinestatic

#include <opencv2/core/matx.hpp>

operator/() [1/5]

template<typename _Tp , int m, int n>

static Matx< _Tp, m, n > cv::operator/ ( const Matx< _Tp, m, n > & a, double alpha )

inlinestatic

#include <opencv2/core/matx.hpp>

operator/() [2/5]

template<typename _Tp , int m, int n>

static Matx< _Tp, m, n > cv::operator/ ( const Matx< _Tp, m, n > & a, float alpha )

inlinestatic

#include <opencv2/core/matx.hpp>

operator/() [3/5]

template<typename _Tp , int cn>

static Vec< _Tp, cn > cv::operator/ ( const Vec< _Tp, cn > & a, double alpha )

inlinestatic

#include <opencv2/core/matx.hpp>

operator/() [4/5]

template<typename _Tp , int cn>

static Vec< _Tp, cn > cv::operator/ ( const Vec< _Tp, cn > & a, float alpha )

inlinestatic

#include <opencv2/core/matx.hpp>

operator/() [5/5]

template<typename _Tp , int cn>

static Vec< _Tp, cn > cv::operator/ ( const Vec< _Tp, cn > & a, int alpha )

inlinestatic

#include <opencv2/core/matx.hpp>

operator/=() [1/5]

template<typename _Tp , int m, int n>

static Matx< _Tp, m, n > & cv::operator/= ( Matx< _Tp, m, n > & a, double alpha )

inlinestatic

#include <opencv2/core/matx.hpp>

operator/=() [2/5]

template<typename _Tp , int m, int n>

static Matx< _Tp, m, n > & cv::operator/= ( Matx< _Tp, m, n > & a, float alpha )

inlinestatic

#include <opencv2/core/matx.hpp>

operator/=() [3/5]

template<typename _Tp , int cn>

static Vec< _Tp, cn > & cv::operator/= ( Vec< _Tp, cn > & a, double alpha )

inlinestatic

#include <opencv2/core/matx.hpp>

operator/=() [4/5]

template<typename _Tp , int cn>

static Vec< _Tp, cn > & cv::operator/= ( Vec< _Tp, cn > & a, float alpha )

inlinestatic

#include <opencv2/core/matx.hpp>

operator/=() [5/5]

template<typename _Tp , int cn>

static Vec< _Tp, cn > & cv::operator/= ( Vec< _Tp, cn > & a, int alpha )

inlinestatic

#include <opencv2/core/matx.hpp>

operator<<() [1/2]

static String & cv::operator<< ( String & out, const Mat & mtx )

inlinestatic

#include <opencv2/core.hpp>

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

operator<<() [2/2]

static String & cv::operator<< ( String & out, Ptr< Formatted > fmtd )

inlinestatic

#include <opencv2/core.hpp>

operator==() [1/2]

bool cv::operator==	(	const MatShape &	shape1,
		const MatShape &	shape2 )

#include <opencv2/core/mat.hpp>

operator==() [2/2]

template<typename _Tp , int m, int n>

static bool cv::operator== ( const Matx< _Tp, m, n > & a, const Matx< _Tp, m, n > & b )

inlinestatic

#include <opencv2/core/matx.hpp>

rawIn()

template<typename _Tp >

static _InputArray cv::rawIn ( _Tp & v )

inlinestatic

#include <opencv2/core/mat.hpp>

カスタム型をラップするためのヘルパー。

参照

InputArray

rawInOut()

template<typename _Tp >

static _InputOutputArray cv::rawInOut ( _Tp & v )

inlinestatic

#include <opencv2/core/mat.hpp>

カスタム型をラップするためのヘルパー。

参照

InputArray

rawOut()

template<typename _Tp >

static _OutputArray cv::rawOut ( _Tp & v )

inlinestatic

#include <opencv2/core/mat.hpp>

カスタム型をラップするためのヘルパー。

参照

InputArray

toLowerCase()

static std::string cv::toLowerCase ( const std::string & str )

inlinestatic

#include <opencv2/core/cvstd.hpp>

toUpperCase()

static std::string cv::toUpperCase ( const std::string & str )

inlinestatic

#include <opencv2/core/cvstd.hpp>

trace()

template<typename _Tp , int m, int n>

static double cv::trace ( const Matx< _Tp, m, n > & a )

inlinestatic

Python:
	cv.trace(	mtx	) ->	retval

#include <opencv2/core/matx.hpp>