通用内联函数

主题
	私有实现助手

详细描述

"通用内联函数" 是一组类型和函数，旨在简化不同平台上代码的向量化。目前支持不同架构上的多种SIMD扩展。针对包括x86 (SSE/SSE2/SSE4.2)、ARM (NEON)、PowerPC (VSX)、MIPS (MSA) 在内的多种架构，实现了对128位各种类型寄存器的支持。x86架构支持256位长寄存器 (AVX2)，x86架构还支持512位长寄存器 (AVX512)。如果在编译时没有可用的SIMD扩展，将选择内联函数的C++回退实现，代码仍将按预期工作，尽管速度可能会较慢。

类型

有几种类型表示打包值的向量寄存器，每种类型都作为基于一个SIMD寄存器的结构体实现。

• cv::v_uint8 和 cv::v_int8: 8位整数值（无符号/有符号）- char
• cv::v_uint16 和 cv::v_int16: 16位整数值（无符号/有符号）- short
• cv::v_uint32 和 cv::v_int32: 32位整数值（无符号/有符号）- int
• cv::v_uint64 和 cv::v_int64: 64位整数值（无符号/有符号）- int64
• cv::v_float32: 32位浮点值（有符号）- float
• cv::v_float64: 64位浮点值（有符号）- double

所列类型的确切位长度（和值数量）是在编译时推导的，取决于在库编译期间选择的架构SIMD能力。所有类型都包含 nlanes 枚举，用于检查该类型的确切值数量。

如果类型的确切位长度很重要，则可以使用特定的固定长度寄存器类型。

有几种类型表示128位寄存器。

• cv::v_uint8x16 和 cv::v_int8x16: 十六个8位整数值（无符号/有符号）- char
• cv::v_uint16x8 和 cv::v_int16x8: 八个16位整数值（无符号/有符号）- short
• cv::v_uint32x4 和 cv::v_int32x4: 四个32位整数值（无符号/有符号）- int
• cv::v_uint64x2 和 cv::v_int64x2: 两个64位整数值（无符号/有符号）- int64
• cv::v_float32x4: 四个32位浮点值（有符号）- float
• cv::v_float64x2: 两个64位浮点值（有符号）- double

有几种类型表示256位寄存器。

• cv::v_uint8x32 和 cv::v_int8x32: 三十二个8位整数值（无符号/有符号）- char
• cv::v_uint16x16 和 cv::v_int16x16: 十六个16位整数值（无符号/有符号）- short
• cv::v_uint32x8 和 cv::v_int32x8: 八个32位整数值（无符号/有符号）- int
• cv::v_uint64x4 和 cv::v_int64x4: 四个64位整数值（无符号/有符号）- int64
• cv::v_float32x8: 八个32位浮点值（有符号）- float
• cv::v_float64x4: 四个64位浮点值（有符号）- double

注意

目前256位寄存器仅为AVX2 SIMD扩展实现，如果想直接使用此类型，请不要忘记检查CV_SIMD256预处理器定义

#if CV_SIMD256
//...
#endif

有几种类型表示512位寄存器。

• cv::v_uint8x64 和 cv::v_int8x64: 六十四个8位整数值（无符号/有符号）- char
• cv::v_uint16x32 和 cv::v_int16x32: 三十二个16位整数值（无符号/有符号）- short
• cv::v_uint32x16 和 cv::v_int32x16: 十六个32位整数值（无符号/有符号）- int
• cv::v_uint64x8 和 cv::v_int64x8: 八个64位整数值（无符号/有符号）- int64
• cv::v_float32x16: 十六个32位浮点值（有符号）- float
• cv::v_float64x8: 八个64位浮点值（有符号）- double

  注意

  目前512位寄存器仅为AVX512 SIMD扩展实现，如果想直接使用此类型，请不要忘记检查CV_SIMD512预处理器定义。

  cv::v_float64x2 在NEON变体中未实现，如果想使用此类型，请不要忘记检查CV_SIMD128_64F预处理器定义。

加载和存储操作

这些操作允许显式设置寄存器内容，或从某个内存块加载，以及将寄存器内容保存到内存块。

有可变大小的寄存器加载操作，它们根据所选平台功能提供最大可用大小的结果。

• 构造函数：从内存加载，
• 其他创建方法：vx_setall_s8, vx_setall_u8, ..., vx_setzero_u8, vx_setzero_s8, ...
• 内存加载操作：vx_load, vx_load_aligned, vx_load_low, vx_load_halves,
• 具有值扩展的内存操作：vx_load_expand, vx_load_expand_q

此外，还有固定大小的寄存器加载/存储操作。

对于128位寄存器

• 构造函数：从内存加载，从两个值加载，...
• 其他创建方法：v_setall_s8, v_setall_u8, ..., v_setzero_u8, v_setzero_s8, ...
• 内存加载操作：v_load, v_load_aligned, v_load_low, v_load_halves,
• 具有值扩展的内存操作：v_load_expand, v_load_expand_q

对于256位寄存器（请检查CV_SIMD256预处理器定义）

• 构造函数：从内存加载，从四个值加载，...
• 其他创建方法：v256_setall_s8, v256_setall_u8, ..., v256_setzero_u8, v256_setzero_s8, ...
• 内存加载操作：v256_load, v256_load_aligned, v256_load_low, v256_load_halves,
• 具有值扩展的内存操作：v256_load_expand, v256_load_expand_q

对于512位寄存器（请检查CV_SIMD512预处理器定义）

• 构造函数：从内存加载，从八个值加载，...
• 其他创建方法：v512_setall_s8, v512_setall_u8, ..., v512_setzero_u8, v512_setzero_s8, ...
• 内存加载操作：v512_load, v512_load_aligned, v512_load_low, v512_load_halves,
• 具有值扩展的内存操作：v512_load_expand, v512_load_expand_q

存储到内存的操作在不同的平台功能上是相似的：v_store, v_store_aligned, v_store_high, v_store_low

值重排序

这些操作允许重排序或重组一个或多个向量中的元素。

• 交错、去交错（2、3和4通道）：v_load_deinterleave, v_store_interleave
• 扩展：v_expand, v_expand_low, v_expand_high
• 打包：v_pack, v_pack_u, v_pack_b, v_rshr_pack, v_rshr_pack_u, v_pack_store, v_pack_u_store, v_rshr_pack_store, v_rshr_pack_u_store
• 重组：v_zip, v_recombine, v_combine_low, v_combine_high
• 反转：v_reverse
• 提取：v_extract

算术、位运算和比较操作

元素级二元和一元操作。

• 算术：v_add, v_sub, v_mul, v_div, v_mul_expand
• 非饱和算术：v_add_wrap, v_sub_wrap
• 位移：v_shl, v_shr
• 位逻辑：v_and, v_or, v_xor, v_not
• 比较：v_gt, v_ge, v_lt, v_le, v_eq, v_ne
• 最小/最大值：v_min, v_max

归约和掩码

这些操作大多数只返回一个值。

• 归约：v_reduce_min, v_reduce_max, v_reduce_sum, v_popcount
• 掩码：v_signmask, v_check_all, v_check_any, v_select

其他数学函数

• 常用操作：v_sqrt, v_invsqrt, v_magnitude, v_sqr_magnitude, v_exp, v_log, v_erf, v_sin, v_cos
• 绝对值：v_abs, v_absdiff, v_absdiffs

转换

不同的类型转换和类型转换

• 四舍五入：v_round, v_floor, v_ceil, v_trunc,
• 转换为浮点型：v_cvt_f32, v_cvt_f64
• 重新解释：v_reinterpret_as_u8, v_reinterpret_as_s8, ...

矩阵操作

在这些操作中，向量代表矩阵的行/列：v_dotprod, v_dotprod_fast, v_dotprod_expand, v_dotprod_expand_fast, v_matmul, v_transpose4x4

可用性

大多数操作仅针对可用类型的子集实现，下表显示了不同操作对这些类型的适用性。

常规整数

操作\类型	uint 8	int 8	uint 16	int 16	uint 32	int 32
load, store	x	x	x	x	x	x
interleave	x	x	x	x	x	x
expand	x	x	x	x	x	x
expand_low	x	x	x	x	x	x
expand_high	x	x	x	x	x	x
expand_q	x	x
add, sub	x	x	x	x	x	x
add_wrap, sub_wrap	x	x	x	x
mul_wrap	x	x	x	x
mul	x	x	x	x	x	x
mul_expand	x	x	x	x	x
compare	x	x	x	x	x	x
移位 (shift)			x	x	x	x
dotprod				x		x
dotprod_fast				x		x
dotprod_expand	x	x	x	x		x
dotprod_expand_fast	x	x	x	x		x
logical	x	x	x	x	x	x
min, max	x	x	x	x	x	x
absdiff	x	x	x	x	x	x
absdiffs		x		x
reduce	x	x	x	x	x	x
mask	x	x	x	x	x	x
pack	x	x	x	x	x	x
pack_u	x		x
pack_b	x
unpack	x	x	x	x	x	x
extract	x	x	x	x	x	x
rotate (lanes)	x	x	x	x	x	x
cvt_flt32						x
cvt_flt64						x
transpose4x4					x	x
reverse（反向）	x	x	x	x	x	x
extract_n	x	x	x	x	x	x
broadcast_element					x	x

大整数

操作\类型	uint 64	int 64
load, store	x	x
add, sub	x	x
移位 (shift)	x	x
logical	x	x
reverse（反向）	x	x
extract	x	x
rotate (lanes)	x	x
cvt_flt64		x
extract_n	x	x

浮点数

操作\类型	float 32	float 64
load, store	x	x
interleave	x
add, sub	x	x
mul	x	x
div	x	x
compare	x	x
min, max	x	x
absdiff	x	x
reduce	x
mask	x	x
unpack	x	x
cvt_flt32		x
cvt_flt64	x
sqrt, abs	x	x
float math	x	x
transpose4x4	x
extract	x	x
rotate (lanes)	x	x
reverse（反向）	x	x
extract_n	x	x
broadcast_element	x
exp	x	x
log	x	x
sin, cos	x	x

类
结构体	cv::v_reg< _Tp, n >

宏
#define	OPENCV_HAL_MATH_HAVE_EXP   1

类型定义
typedef v_float32x16	simd512::v_float32
	最大可用向量寄存器容量 32位浮点值（单精度）
typedef v_reg< float, 16 >	cv::v_float32x16
	十六个32位浮点值（单精度）
typedef v_reg< float, 4 >	cv::v_float32x4
	四个32位浮点值（单精度）
typedef v_reg< float, 8 >	cv::v_float32x8
	八个32位浮点值（单精度）
typedef v_float64x8	simd512::v_float64
	最大可用向量寄存器容量 64位浮点值（双精度）
typedef v_reg< double, 2 >	cv::v_float64x2
	两个64位浮点值（双精度）
typedef v_reg< double, 4 >	cv::v_float64x4
	四个64位浮点值（双精度）
typedef v_reg< double, 8 >	cv::v_float64x8
	八个64位浮点值（双精度）
typedef v_int16x32	simd512::v_int16
	最大可用向量寄存器容量 16位有符号整数值。
typedef v_reg< short, 16 >	cv::v_int16x16
	十六个16位有符号整数值。
typedef v_reg< short, 32 >	cv::v_int16x32
	三十二个16位有符号整数值。
typedef v_reg< short, 8 >	cv::v_int16x8
	八个16位有符号整数值。
typedef v_int32x16	simd512::v_int32
	最大可用向量寄存器容量 32位有符号整数值。
typedef v_reg< int, 16 >	cv::v_int32x16
	十六个32位有符号整数值。
typedef v_reg< int, 4 >	cv::v_int32x4
	四个32位有符号整数值。
typedef v_reg< int, 8 >	cv::v_int32x8
	八个32位有符号整数值。
typedef v_int64x8	simd512::v_int64
	最大可用向量寄存器容量 64位有符号整数值。
typedef v_reg< int64, 2 >	cv::v_int64x2
	两个64位有符号整数值。
typedef v_reg< int64, 4 >	cv::v_int64x4
	四个64位有符号整数值。
typedef v_reg< int64, 8 >	cv::v_int64x8
	八个64位有符号整数值。
typedef v_int8x64	simd512::v_int8
	最大可用向量寄存器容量 8位有符号整数值。
typedef v_reg< schar, 16 >	cv::v_int8x16
	十六个8位有符号整数值。
typedef v_reg< schar, 32 >	cv::v_int8x32
	三十二个8位有符号整数值。
typedef v_reg< schar, 64 >	cv::v_int8x64
	六十四个8位有符号整数值。
typedef v_uint16x32	simd512::v_uint16
	最大可用向量寄存器容量 16位无符号整数值。
typedef v_reg< ushort, 16 >	cv::v_uint16x16
	十六个16位无符号整数值。
typedef v_reg< ushort, 32 >	cv::v_uint16x32
	三十二个16位无符号整数值。
typedef v_reg< ushort, 8 >	cv::v_uint16x8
	八个16位无符号整数值。
typedef v_uint32x16	simd512::v_uint32
	最大可用向量寄存器容量 32位无符号整数值。
typedef v_reg< unsigned, 16 >	cv::v_uint32x16
	十六个32位无符号整数值。
typedef v_reg< unsigned, 4 >	cv::v_uint32x4
	四个32位无符号整数值。
typedef v_reg< unsigned, 8 >	cv::v_uint32x8
	八个32位无符号整数值。
typedef v_uint64x8	simd512::v_uint64
	最大可用向量寄存器容量 64位无符号整数值。
typedef v_reg< uint64, 2 >	cv::v_uint64x2
	两个64位无符号整数值。
typedef v_reg< uint64, 4 >	cv::v_uint64x4
	四个64位无符号整数值。
typedef v_reg< uint64, 8 >	cv::v_uint64x8
	八个64位无符号整数值。
typedef v_uint8x64	simd512::v_uint8
	最大可用向量寄存器容量 8位无符号整数值。
typedef v_reg< uchar, 16 >	cv::v_uint8x16
	十六个8位无符号整数值。
typedef v_reg< uchar, 32 >	cv::v_uint8x32
	三十二个8位无符号整数值。
typedef v_reg< uchar, 64 >	cv::v_uint8x64
	六十四个8位无符号整数值。

枚举
枚举	{   cv::simd128_width = 16 ,   cv::simd256_width = 32 ,   cv::simd512_width = 64 ,   cv::simdmax_width = simd512_width }

函数
void	cv::v256_cleanup ()
template<typename _Tp >
v_reg< _Tp, simd256_width/sizeof(_Tp)>	cv::v256_load (const _Tp *ptr)
	从内存加载256位长度寄存器内容。
template<typename _Tp >
v_reg< _Tp, simd256_width/sizeof(_Tp)>	cv::v256_load_aligned (const _Tp *ptr)
	从内存加载寄存器内容（对齐）
template<typename _Tp >
v_reg< typename V_TypeTraits< _Tp >::w_type, simd256_width/sizeof(typename V_TypeTraits< _Tp >::w_type)>	cv::v256_load_expand (const _Tp *ptr)
	从内存加载寄存器内容并双重扩展。
v_reg< float, simd256_width/sizeof(float)>	cv::v256_load_expand (const hfloat *ptr)
template<typename _Tp >
v_reg< typename V_TypeTraits< _Tp >::q_type, simd256_width/sizeof(typename V_TypeTraits< _Tp >::q_type)>	cv::v256_load_expand_q (const _Tp *ptr)
	从内存加载寄存器内容并四重扩展。
template<typename _Tp >
v_reg< _Tp, simd256_width/sizeof(_Tp)>	cv::v256_load_halves (const _Tp *loptr, const _Tp *hiptr)
	从两个内存块加载寄存器内容。
template<typename _Tp >
v_reg< _Tp, simd256_width/sizeof(_Tp)>	cv::v256_load_low (const _Tp *ptr)
	加载128位数据到低位部分（高位部分未定义）。
void	cv::v512_cleanup ()
template<typename _Tp >
v_reg< _Tp, simd512_width/sizeof(_Tp)>	cv::v512_load (const _Tp *ptr)
	从内存加载512位长度寄存器内容。
template<typename _Tp >
v_reg< _Tp, simd512_width/sizeof(_Tp)>	cv::v512_load_aligned (const _Tp *ptr)
	从内存加载寄存器内容（对齐）
template<typename _Tp >
v_reg< typename V_TypeTraits< _Tp >::w_type, simd512_width/sizeof(typename V_TypeTraits< _Tp >::w_type)>	cv::v512_load_expand (const _Tp *ptr)
	从内存加载寄存器内容并双重扩展。
v_reg< float, simd512_width/sizeof(float)>	cv::v512_load_expand (const hfloat *ptr)
template<typename _Tp >
v_reg< typename V_TypeTraits< _Tp >::q_type, simd512_width/sizeof(typename V_TypeTraits< _Tp >::q_type)>	cv::v512_load_expand_q (const _Tp *ptr)
	从内存加载寄存器内容并四重扩展。
template<typename _Tp >
v_reg< _Tp, simd512_width/sizeof(_Tp)>	cv::v512_load_halves (const _Tp *loptr, const _Tp *hiptr)
	从两个内存块加载寄存器内容。
template<typename _Tp >
v_reg< _Tp, simd512_width/sizeof(_Tp)>	cv::v512_load_low (const _Tp *ptr)
	加载256位数据到低位部分（高位部分未定义）。
template<typename _Tp , int n>
v_reg< typename V_TypeTraits< _Tp >::abs_type, n >	cv::v_abs (const v_reg< _Tp, n > &a)
	元素的绝对值。
template<typename _Tp , int n>
v_reg< typename V_TypeTraits< _Tp >::abs_type, n >	cv::v_absdiff (const v_reg< _Tp, n > &a, const v_reg< _Tp, n > &b)
	绝对差。
template<int n>
v_reg< double, n >	cv::v_absdiff (const v_reg< double, n > &a, const v_reg< double, n > &b)
template<int n>
v_reg< float, n >	cv::v_absdiff (const v_reg< float, n > &a, const v_reg< float, n > &b)
template<typename _Tp , int n>
v_reg< _Tp, n >	cv::v_absdiffs (const v_reg< _Tp, n > &a, const v_reg< _Tp, n > &b)
	饱和绝对差。
template<typename _Tp , int n>
v_reg< _Tp, n >	cv::v_add (const v_reg< _Tp, n > &a, const v_reg< _Tp, n > &b)
	添加值。
template<typename _Tp , int n>
v_reg< _Tp, n >	cv::v_add_wrap (const v_reg< _Tp, n > &a, const v_reg< _Tp, n > &b)
	无饱和添加值。
template<typename _Tp , int n>
v_reg< _Tp, n >	cv::v_and (const v_reg< _Tp, n > &a, const v_reg< _Tp, n > &b)
	按位与。
template<int i, typename _Tp , int n>
v_reg< _Tp, n >	cv::v_broadcast_element (const v_reg< _Tp, n > &a)
	广播向量的第i个元素。
template<int n>
v_reg< int, n *2 >	cv::v_ceil (const v_reg< double, n > &a)
template<int n>
v_reg< int, n >	cv::v_ceil (const v_reg< float, n > &a)
	向上取整元素。
template<typename _Tp , int n>
bool	cv::v_check_all (const v_reg< _Tp, n > &a)
	检查所有打包值是否都小于零。
template<typename _Tp , int n>
bool	cv::v_check_any (const v_reg< _Tp, n > &a)
	检查是否有任何打包值小于零。
void	cv::v_cleanup ()
template<typename _Tp , int n>
v_reg< _Tp, n >	cv::v_combine_high (const v_reg< _Tp, n > &a, const v_reg< _Tp, n > &b)
	从两个向量的最后元素组合向量。
template<typename _Tp , int n>
v_reg< _Tp, n >	cv::v_combine_low (const v_reg< _Tp, n > &a, const v_reg< _Tp, n > &b)
	从两个向量的第一个元素组合向量。
template<typename _Tp , int n>
v_reg< _Tp, n >	cv::v_cos (const v_reg< _Tp, n > &a)
	元素的余弦 \( cos(x) \)。
template<int n>
v_reg< float, n *2 >	cv::v_cvt_f32 (const v_reg< double, n > &a)
	将下半部分转换为浮点数。
template<int n>
v_reg< float, n *2 >	cv::v_cvt_f32 (const v_reg< double, n > &a, const v_reg< double, n > &b)
	转换为浮点数。
template<int n>
v_reg< float, n >	cv::v_cvt_f32 (const v_reg< int, n > &a)
	转换为浮点数。
template<int n>
v_reg< double,(n/2)>	cv::v_cvt_f64 (const v_reg< float, n > &a)
	将下半部分转换为双精度浮点数。
template<int n>
v_reg< double, n/2 >	cv::v_cvt_f64 (const v_reg< int, n > &a)
	将下半部分转换为双精度浮点数。
template<int n>
v_reg< double, n >	cv::v_cvt_f64 (const v_reg< int64, n > &a)
	转换为双精度浮点数。
template<int n>
v_reg< double,(n/2)>	cv::v_cvt_f64_high (const v_reg< float, n > &a)
	将向量高位部分转换为双精度浮点数。
template<int n>
v_reg< double,(n/2)>	cv::v_cvt_f64_high (const v_reg< int, n > &a)
	将向量高位部分转换为双精度浮点数。
template<typename _Tp , int n>
v_reg< _Tp, n >	cv::v_div (const v_reg< _Tp, n > &a, const v_reg< _Tp, n > &b)
	除法。
template<typename _Tp , int n>
v_reg< typename V_TypeTraits< _Tp >::w_type, n/2 >	cv::v_dotprod (const v_reg< _Tp, n > &a, const v_reg< _Tp, n > &b)
	元素的点积。
template<typename _Tp , int n>
v_reg< typename V_TypeTraits< _Tp >::w_type, n/2 >	cv::v_dotprod (const v_reg< _Tp, n > &a, const v_reg< _Tp, n > &b, const v_reg< typename V_TypeTraits< _Tp >::w_type, n/2 > &c)
	元素的点积。
template<typename _Tp , int n>
v_reg< typename V_TypeTraits< _Tp >::q_type, n/4 >	cv::v_dotprod_expand (const v_reg< _Tp, n > &a, const v_reg< _Tp, n > &b)
	元素的点积并扩展。
template<typename _Tp , int n>
v_reg< typename V_TypeTraits< _Tp >::q_type, n/4 >	cv::v_dotprod_expand (const v_reg< _Tp, n > &a, const v_reg< _Tp, n > &b, const v_reg< typename V_TypeTraits< _Tp >::q_type, n/4 > &c)
	元素的点积。
template<int n>
v_reg< double, n/2 >	cv::v_dotprod_expand (const v_reg< int, n > &a, const v_reg< int, n > &b)
template<int n>
v_reg< double, n/2 >	cv::v_dotprod_expand (const v_reg< int, n > &a, const v_reg< int, n > &b, const v_reg< double, n/2 > &c)
template<typename _Tp , int n>
v_reg< typename V_TypeTraits< _Tp >::q_type, n/4 >	cv::v_dotprod_expand_fast (const v_reg< _Tp, n > &a, const v_reg< _Tp, n > &b)
	快速元素的点积并扩展。
template<typename _Tp , int n>
v_reg< typename V_TypeTraits< _Tp >::q_type, n/4 >	cv::v_dotprod_expand_fast (const v_reg< _Tp, n > &a, const v_reg< _Tp, n > &b, const v_reg< typename V_TypeTraits< _Tp >::q_type, n/4 > &c)
	快速元素的点积。
template<int n>
v_reg< double, n/2 >	cv::v_dotprod_expand_fast (const v_reg< int, n > &a, const v_reg< int, n > &b)
template<int n>
v_reg< double, n/2 >	cv::v_dotprod_expand_fast (const v_reg< int, n > &a, const v_reg< int, n > &b, const v_reg< double, n/2 > &c)
template<typename _Tp , int n>
v_reg< typename V_TypeTraits< _Tp >::w_type, n/2 >	cv::v_dotprod_fast (const v_reg< _Tp, n > &a, const v_reg< _Tp, n > &b)
	快速元素的点积。
template<typename _Tp , int n>
v_reg< typename V_TypeTraits< _Tp >::w_type, n/2 >	cv::v_dotprod_fast (const v_reg< _Tp, n > &a, const v_reg< _Tp, n > &b, const v_reg< typename V_TypeTraits< _Tp >::w_type, n/2 > &c)
	快速元素的点积。
template<typename _Tp , int n>
v_reg< _Tp, n >	cv::v_eq (const v_reg< _Tp, n > &a, const v_reg< _Tp, n > &b)
	相等比较。
template<typename _Tp , int n>
v_reg< _Tp, n >	cv::v_erf (const v_reg< _Tp, n > &a)
	误差函数。
template<typename _Tp , int n>
v_reg< _Tp, n >	cv::v_exp (const v_reg< _Tp, n > &a)
	元素的指数 \( e^x \)。
template<typename _Tp , int n>
void	cv::v_expand (const v_reg< _Tp, n > &a, v_reg< typename V_TypeTraits< _Tp >::w_type, n/2 > &b0, v_reg< typename V_TypeTraits< _Tp >::w_type, n/2 > &b1)
	将值扩展到更宽的打包类型。
template<typename _Tp , int n>
v_reg< typename V_TypeTraits< _Tp >::w_type, n/2 >	cv::v_expand_high (const v_reg< _Tp, n > &a)
	将更高值扩展到更宽的打包类型。
template<typename _Tp , int n>
v_reg< typename V_TypeTraits< _Tp >::w_type, n/2 >	cv::v_expand_low (const v_reg< _Tp, n > &a)
	将更低值扩展到更宽的打包类型。
template<int s, typename _Tp , int n>
v_reg< _Tp, n >	cv::v_extract (const v_reg< _Tp, n > &a, const v_reg< _Tp, n > &b)
	向量提取。
template<int s, typename _Tp , int n>
_Tp	cv::v_extract_n (const v_reg< _Tp, n > &v)
	向量提取。
template<int n>
v_reg< int, n *2 >	cv::v_floor (const v_reg< double, n > &a)
template<int n>
v_reg< int, n >	cv::v_floor (const v_reg< float, n > &a)
	向下取整元素。
template<typename _Tp , int n>
v_reg< _Tp, n >	cv::v_fma (const v_reg< _Tp, n > &a, const v_reg< _Tp, n > &b, const v_reg< _Tp, n > &c)
	乘加运算。
template<typename _Tp , int n>
v_reg< _Tp, n >	cv::v_ge (const v_reg< _Tp, n > &a, const v_reg< _Tp, n > &b)
	大于或等于比较。
template<typename _Tp , int n>
v_reg< _Tp, n >	cv::v_gt (const v_reg< _Tp, n > &a, const v_reg< _Tp, n > &b)
	大于比较。
template<typename _Tp , int n>
v_reg< _Tp, n >	cv::v_interleave_pairs (const v_reg< _Tp, n > &vec)
template<typename _Tp , int n>
v_reg< _Tp, n >	cv::v_interleave_quads (const v_reg< _Tp, n > &vec)
template<typename _Tp , int n>
v_reg< _Tp, n >	cv::v_invsqrt (const v_reg< _Tp, n > &a)
	平方根倒数。
template<typename _Tp , int n>
v_reg< _Tp, n >	cv::v_le (const v_reg< _Tp, n > &a, const v_reg< _Tp, n > &b)
	小于或等于比较。
template<typename _Tp >
v_reg< _Tp, simd128_width/sizeof(_Tp)>	cv::v_load (const _Tp *ptr)
	从内存加载寄存器内容。
template<typename _Tp >
v_reg< _Tp, simd128_width/sizeof(_Tp)>	cv::v_load_aligned (const _Tp *ptr)
	从内存加载寄存器内容（对齐）
template<typename _Tp , int n>
void	cv::v_load_deinterleave (const _Tp *ptr, v_reg< _Tp, n > &a, v_reg< _Tp, n > &b)
	加载和解交错（2通道）
template<typename _Tp , int n>
void	cv::v_load_deinterleave (const _Tp *ptr, v_reg< _Tp, n > &a, v_reg< _Tp, n > &b, v_reg< _Tp, n > &c)
	加载和解交错（3通道）
template<typename _Tp , int n>
void	cv::v_load_deinterleave (const _Tp *ptr, v_reg< _Tp, n > &a, v_reg< _Tp, n > &b, v_reg< _Tp, n > &c, v_reg< _Tp, n > &d)
	加载和解交错（4通道）
template<typename _Tp >
v_reg< typename V_TypeTraits< _Tp >::w_type, simd128_width/sizeof(typename V_TypeTraits< _Tp >::w_type)>	cv::v_load_expand (const _Tp *ptr)
	从内存加载寄存器内容并双重扩展。
v_reg< float, simd128_width/sizeof(float)>	cv::v_load_expand (const hfloat *ptr)
template<typename _Tp >
v_reg< typename V_TypeTraits< _Tp >::q_type, simd128_width/sizeof(typename V_TypeTraits< _Tp >::q_type)>	cv::v_load_expand_q (const _Tp *ptr)
	从内存加载寄存器内容并四重扩展。
template<typename _Tp >
v_reg< _Tp, simd128_width/sizeof(_Tp)>	cv::v_load_halves (const _Tp *loptr, const _Tp *hiptr)
	从两个内存块加载寄存器内容。
template<typename _Tp >
v_reg< _Tp, simd128_width/sizeof(_Tp)>	cv::v_load_low (const _Tp *ptr)
	加载64位数据到低位部分（高位部分未定义）。
template<typename _Tp , int n>
v_reg< _Tp, n >	cv::v_log (const v_reg< _Tp, n > &a)
	元素的自然对数 \( \log(x) \)。
template<typename _Tp , int n>
v_reg< _Tp, n >	cv::v_lt (const v_reg< _Tp, n > &a, const v_reg< _Tp, n > &b)
	小于比较。
template<typename _Tp >
v_reg< _Tp, simd128_width/sizeof(_Tp)>	cv::v_lut (const _Tp *tab, const int *idx)
template<int n>
v_reg< double, n/2 >	cv::v_lut (const double *tab, const v_reg< int, n > &idx)
template<int n>
v_reg< float, n >	cv::v_lut (const float *tab, const v_reg< int, n > &idx)
template<int n>
v_reg< int, n >	cv::v_lut (const int *tab, const v_reg< int, n > &idx)
template<int n>
v_reg< unsigned, n >	cv::v_lut (const unsigned *tab, const v_reg< int, n > &idx)
template<int n>
void	cv::v_lut_deinterleave (const double *tab, const v_reg< int, n *2 > &idx, v_reg< double, n > &x, v_reg< double, n > &y)
template<int n>
void	cv::v_lut_deinterleave (const float *tab, const v_reg< int, n > &idx, v_reg< float, n > &x, v_reg< float, n > &y)
template<typename _Tp >
v_reg< _Tp, simd128_width/sizeof(_Tp)>	cv::v_lut_pairs (const _Tp *tab, const int *idx)
template<typename _Tp >
v_reg< _Tp, simd128_width/sizeof(_Tp)>	cv::v_lut_quads (const _Tp *tab, const int *idx)
template<typename _Tp , int n>
v_reg< _Tp, n >	cv::v_magnitude (const v_reg< _Tp, n > &a, const v_reg< _Tp, n > &b)
	幅值。
template<int n>
v_reg< float, n >	cv::v_matmul (const v_reg< float, n > &v, const v_reg< float, n > &a, const v_reg< float, n > &b, const v_reg< float, n > &c, const v_reg< float, n > &d)
	矩阵乘法。
template<int n>
v_reg< float, n >	cv::v_matmuladd (const v_reg< float, n > &v, const v_reg< float, n > &a, const v_reg< float, n > &b, const v_reg< float, n > &c, const v_reg< float, n > &d)
	矩阵乘加。
template<typename _Tp , int n>
v_reg< _Tp, n >	cv::v_max (const v_reg< _Tp, n > &a, const v_reg< _Tp, n > &b)
	为每对选择最大值。
template<typename _Tp , int n>
v_reg< _Tp, n >	cv::v_min (const v_reg< _Tp, n > &a, const v_reg< _Tp, n > &b)
	为每对选择最小值。
template<typename _Tp , int n>
v_reg< _Tp, n >	cv::v_mul (const v_reg< _Tp, n > &a, const v_reg< _Tp, n > &b)
	乘法。
template<typename _Tp , int n>
void	cv::v_mul_expand (const v_reg< _Tp, n > &a, const v_reg< _Tp, n > &b, v_reg< typename V_TypeTraits< _Tp >::w_type, n/2 > &c, v_reg< typename V_TypeTraits< _Tp >::w_type, n/2 > &d)
	乘法并扩展。
template<typename _Tp , int n>
v_reg< _Tp, n >	cv::v_mul_hi (const v_reg< _Tp, n > &a, const v_reg< _Tp, n > &b)
	乘法并提取高位部分。
template<typename _Tp , int n>
v_reg< _Tp, n >	cv::v_mul_wrap (const v_reg< _Tp, n > &a, const v_reg< _Tp, n > &b)
	无饱和乘法。
template<typename _Tp , int n>
v_reg< _Tp, n >	cv::v_muladd (const v_reg< _Tp, n > &a, const v_reg< _Tp, n > &b, const v_reg< _Tp, n > &c)
	v_fma 的同义词。
template<typename _Tp , int n>
v_reg< _Tp, n >	cv::v_ne (const v_reg< _Tp, n > &a, const v_reg< _Tp, n > &b)
	不相等比较。
template<typename _Tp , int n>
v_reg< _Tp, n >	cv::v_not (const v_reg< _Tp, n > &a)
	按位非。
template<int n>
v_reg< double, n >	cv::v_not_nan (const v_reg< double, n > &a)
template<int n>
v_reg< float, n >	cv::v_not_nan (const v_reg< float, n > &a)
template<typename _Tp , int n>
v_reg< _Tp, n >	cv::v_or (const v_reg< _Tp, n > &a, const v_reg< _Tp, n > &b)
	按位或。
template<int n>
void	cv::v_pack_store (hfloat *ptr, const v_reg< float, n > &v)
template<typename _Tp , int n>
v_reg< _Tp, n >	cv::v_pack_triplets (const v_reg< _Tp, n > &vec)
template<typename _Tp , int n>
v_reg< typename V_TypeTraits< _Tp >::abs_type, n >	cv::v_popcount (const v_reg< _Tp, n > &a)
	计算向量通道中的1位数量，并以相应的无符号类型返回结果。
template<typename _Tp , int n>
void	cv::v_recombine (const v_reg< _Tp, n > &a, const v_reg< _Tp, n > &b, v_reg< _Tp, n > &low, v_reg< _Tp, n > &high)
	将两个向量从另外两个向量的低部和高部组合起来。
template<typename _Tp , int n>
_Tp	cv::v_reduce_max (const v_reg< _Tp, n > &a)
	查找一个最大值。
template<typename _Tp , int n>
_Tp	cv::v_reduce_min (const v_reg< _Tp, n > &a)
	查找一个最小值。
template<typename _Tp , int n>
V_TypeTraits< typenameV_TypeTraits< _Tp >::abs_type >::sum_type	cv::v_reduce_sad (const v_reg< _Tp, n > &a, const v_reg< _Tp, n > &b)
	值的绝对差之和。
template<typename _Tp , int n>
V_TypeTraits< _Tp >::sum_type	cv::v_reduce_sum (const v_reg< _Tp, n > &a)
	对打包值求和。
template<int n>
v_reg< float, n >	cv::v_reduce_sum4 (const v_reg< float, n > &a, const v_reg< float, n > &b, const v_reg< float, n > &c, const v_reg< float, n > &d)
	求和每个输入向量的所有元素，返回和的向量。
template<typename _Tp , int n>
v_reg< _Tp, n >	cv::v_reverse (const v_reg< _Tp, n > &a)
	向量反序。
template<int imm, typename _Tp , int n>
v_reg< _Tp, n >	cv::v_rotate_left (const v_reg< _Tp, n > &a)
	向量内元素左移。
template<int imm, typename _Tp , int n>
v_reg< _Tp, n >	cv::v_rotate_left (const v_reg< _Tp, n > &a, const v_reg< _Tp, n > &b)
template<int imm, typename _Tp , int n>
v_reg< _Tp, n >	cv::v_rotate_right (const v_reg< _Tp, n > &a)
	向量内元素右移。
template<int imm, typename _Tp , int n>
v_reg< _Tp, n >	cv::v_rotate_right (const v_reg< _Tp, n > &a, const v_reg< _Tp, n > &b)
template<int n>
v_reg< int, n *2 >	cv::v_round (const v_reg< double, n > &a)
template<int n>
v_reg< int, n *2 >	cv::v_round (const v_reg< double, n > &a, const v_reg< double, n > &b)
template<int n>
v_reg< int, n >	cv::v_round (const v_reg< float, n > &a)
	四舍五入元素。
template<typename _Tp , int n>
int	cv::v_scan_forward (const v_reg< _Tp, n > &a)
	获取第一个负通道索引。
template<typename _Tp , int n>
v_reg< _Tp, n >	cv::v_select (const v_reg< _Tp, n > &mask, const v_reg< _Tp, n > &a, const v_reg< _Tp, n > &b)
	逐元素选择（混合操作）
template<typename _Tp , int n>
v_reg< _Tp, n >	cv::v_shl (const v_reg< _Tp, n > &a, int imm)
	按位左移。
template<typename _Tp , int n>
v_reg< _Tp, n >	cv::v_shr (const v_reg< _Tp, n > &a, int imm)
	按位右移。
template<typename _Tp , int n>
int	cv::v_signmask (const v_reg< _Tp, n > &a)
	获取负值掩码。
template<typename _Tp , int n>
v_reg< _Tp, n >	cv::v_sin (const v_reg< _Tp, n > &a)
	元素的正弦 \( sin(x) \)。
template<typename _Tp , int n>
void	cv::v_sincos (const v_reg< _Tp, n > &x, v_reg< _Tp, n > &s, v_reg< _Tp, n > &c)
	同时计算元素的正弦 \( sin(x) \) 和余弦 \( cos(x) \) 。
template<typename _Tp , int n>
v_reg< _Tp, n >	cv::v_sqr_magnitude (const v_reg< _Tp, n > &a, const v_reg< _Tp, n > &b)
	幅值的平方。
template<typename _Tp , int n>
v_reg< _Tp, n >	cv::v_sqrt (const v_reg< _Tp, n > &a)
	元素的平方根。
template<typename _Tp , int n>
void	cv::v_store (_Tp *ptr, const v_reg< _Tp, n > &a)
	将数据存储到内存。
template<typename _Tp , int n>
void	cv::v_store (_Tp *ptr, const v_reg< _Tp, n > &a, hal::StoreMode)
template<typename _Tp , int n>
void	cv::v_store_aligned (_Tp *ptr, const v_reg< _Tp, n > &a)
	将数据存储到内存（对齐）
template<typename _Tp , int n>
void	cv::v_store_aligned (_Tp *ptr, const v_reg< _Tp, n > &a, hal::StoreMode)
template<typename _Tp , int n>
void	cv::v_store_aligned_nocache (_Tp *ptr, const v_reg< _Tp, n > &a)
template<typename _Tp , int n>
void	cv::v_store_high (_Tp *ptr, const v_reg< _Tp, n > &a)
	将数据存储到内存（高位半部）
template<typename _Tp , int n>
void	cv::v_store_interleave (_Tp *ptr, const v_reg< _Tp, n > &a, const v_reg< _Tp, n > &b, const v_reg< _Tp, n > &c, const v_reg< _Tp, n > &d, hal::StoreMode=hal::STORE_UNALIGNED)
	交错并存储（4通道）
template<typename _Tp , int n>
void	cv::v_store_interleave (_Tp *ptr, const v_reg< _Tp, n > &a, const v_reg< _Tp, n > &b, const v_reg< _Tp, n > &c, hal::StoreMode=hal::STORE_UNALIGNED)
	交错并存储（3通道）
template<typename _Tp , int n>
void	cv::v_store_interleave (_Tp *ptr, const v_reg< _Tp, n > &a, const v_reg< _Tp, n > &b, hal::StoreMode=hal::STORE_UNALIGNED)
	交错并存储（2通道）
template<typename _Tp , int n>
void	cv::v_store_low (_Tp *ptr, const v_reg< _Tp, n > &a)
	将数据存储到内存（低位半部）
template<typename _Tp , int n>
v_reg< _Tp, n >	cv::v_sub (const v_reg< _Tp, n > &a, const v_reg< _Tp, n > &b)
	减法。
template<typename _Tp , int n>
v_reg< _Tp, n >	cv::v_sub_wrap (const v_reg< _Tp, n > &a, const v_reg< _Tp, n > &b)
	无饱和减法。
template<typename _Tp , int n>
void	cv::v_transpose4x4 (v_reg< _Tp, n > &a0, const v_reg< _Tp, n > &a1, const v_reg< _Tp, n > &a2, const v_reg< _Tp, n > &a3, v_reg< _Tp, n > &b0, v_reg< _Tp, n > &b1, v_reg< _Tp, n > &b2, v_reg< _Tp, n > &b3)
	转置4x4矩阵。
template<int n>
v_reg< int, n *2 >	cv::v_trunc (const v_reg< double, n > &a)
template<int n>
v_reg< int, n >	cv::v_trunc (const v_reg< float, n > &a)
	截断元素。
template<typename _Tp , int n>
v_reg< _Tp, n >	cv::v_xor (const v_reg< _Tp, n > &a, const v_reg< _Tp, n > &b)
	按位异或。
template<typename _Tp , int n>
void	cv::v_zip (const v_reg< _Tp, n > &a0, const v_reg< _Tp, n > &a1, v_reg< _Tp, n > &b0, v_reg< _Tp, n > &b1)
	交错两个向量。

变量
static const unsigned char	cv::popCountTable []

初始化为零
创建具有零元素的新向量
v_uint8x16	cv::v_setzero_u8 ()
template<>
v_uint8x16	cv::v_setzero_ ()
v_int8x16	cv::v_setzero_s8 ()
v_uint16x8	cv::v_setzero_u16 ()
v_int16x8	cv::v_setzero_s16 ()
v_uint32x4	cv::v_setzero_u32 ()
v_int32x4	cv::v_setzero_s32 ()
v_float32x4	cv::v_setzero_f32 ()
v_float64x2	cv::v_setzero_f64 ()
v_uint64x2	cv::v_setzero_u64 ()
v_int64x2	cv::v_setzero_s64 ()
v_uint8x32	cv::v256_setzero_u8 ()
v_int8x32	cv::v256_setzero_s8 ()
v_uint16x16	cv::v256_setzero_u16 ()
v_int16x16	cv::v256_setzero_s16 ()
v_uint32x8	cv::v256_setzero_u32 ()
v_int32x8	cv::v256_setzero_s32 ()
v_float32x8	cv::v256_setzero_f32 ()
v_float64x4	cv::v256_setzero_f64 ()
v_uint64x4	cv::v256_setzero_u64 ()
v_int64x4	cv::v256_setzero_s64 ()
v_uint8x64	cv::v512_setzero_u8 ()
v_int8x64	cv::v512_setzero_s8 ()
v_uint16x32	cv::v512_setzero_u16 ()
v_int16x32	cv::v512_setzero_s16 ()
v_uint32x16	cv::v512_setzero_u32 ()
v_int32x16	cv::v512_setzero_s32 ()
v_float32x16	cv::v512_setzero_f32 ()
v_float64x8	cv::v512_setzero_f64 ()
v_uint64x8	cv::v512_setzero_u64 ()
v_int64x8	cv::v512_setzero_s64 ()

初始化为指定值
创建元素设置为特定值的新向量
v_uint8x16	cv::v_setall_u8 (uchar val)
template<>
v_uint8x16	cv::v_setall_ (uchar val)
v_int8x16	cv::v_setall_s8 (schar val)
template<>
v_int8x16	cv::v_setall_ (schar val)
v_uint16x8	cv::v_setall_u16 (ushort val)
template<>
v_uint16x8	cv::v_setall_ (ushort val)
v_int16x8	cv::v_setall_s16 (short val)
template<>
v_int16x8	cv::v_setall_ (short val)
v_uint32x4	cv::v_setall_u32 (unsigned val)
template<>
v_uint32x4	cv::v_setall_ (unsigned val)
v_int32x4	cv::v_setall_s32 (int val)
template<>
v_int32x4	cv::v_setall_ (int val)
v_float32x4	cv::v_setall_f32 (float val)
template<>
v_float32x4	cv::v_setall_ (float val)
v_float64x2	cv::v_setall_f64 (double val)
template<>
v_float64x2	cv::v_setall_ (double val)
v_uint64x2	cv::v_setall_u64 (uint64 val)
template<>
v_uint64x2	cv::v_setall_ (uint64 val)
v_int64x2	cv::v_setall_s64 (int64 val)
template<>
v_int64x2	cv::v_setall_ (int64 val)
v_uint8x32	cv::v256_setall_u8 (uchar val)
v_int8x32	cv::v256_setall_s8 (schar val)
v_uint16x16	cv::v256_setall_u16 (ushort val)
v_int16x16	cv::v256_setall_s16 (short val)
v_uint32x8	cv::v256_setall_u32 (unsigned val)
v_int32x8	cv::v256_setall_s32 (int val)
v_float32x8	cv::v256_setall_f32 (float val)
v_float64x4	cv::v256_setall_f64 (double val)
v_uint64x4	cv::v256_setall_u64 (uint64 val)
v_int64x4	cv::v256_setall_s64 (int64 val)
v_uint8x64	cv::v512_setall_u8 (uchar val)
v_int8x64	cv::v512_setall_s8 (schar val)
v_uint16x32	cv::v512_setall_u16 (ushort val)
v_int16x32	cv::v512_setall_s16 (short val)
v_uint32x16	cv::v512_setall_u32 (unsigned val)
v_int32x16	cv::v512_setall_s32 (int val)
v_float32x16	cv::v512_setall_f32 (float val)
v_float64x8	cv::v512_setall_f64 (double val)
v_uint64x8	cv::v512_setall_u64 (uint64 val)
v_int64x8	cv::v512_setall_s64 (int64 val)

重新解释
将向量转换为不同类型而不修改底层数据。
template<typename _Tp0 , int n0>
v_reg< uchar, n0 *sizeof(_Tp0)/sizeof(uchar)>	cv::v_reinterpret_as_u8 (const v_reg< _Tp0, n0 > &a)
template<typename _Tp0 , int n0>
v_reg< schar, n0 *sizeof(_Tp0)/sizeof(schar)>	cv::v_reinterpret_as_s8 (const v_reg< _Tp0, n0 > &a)
template<typename _Tp0 , int n0>
v_reg< ushort, n0 *sizeof(_Tp0)/sizeof(ushort)>	cv::v_reinterpret_as_u16 (const v_reg< _Tp0, n0 > &a)
template<typename _Tp0 , int n0>
v_reg< short, n0 *sizeof(_Tp0)/sizeof(short)>	cv::v_reinterpret_as_s16 (const v_reg< _Tp0, n0 > &a)
template<typename _Tp0 , int n0>
v_reg< unsigned, n0 *sizeof(_Tp0)/sizeof(unsigned)>	cv::v_reinterpret_as_u32 (const v_reg< _Tp0, n0 > &a)
template<typename _Tp0 , int n0>
v_reg< int, n0 *sizeof(_Tp0)/sizeof(int)>	cv::v_reinterpret_as_s32 (const v_reg< _Tp0, n0 > &a)
template<typename _Tp0 , int n0>
v_reg< float, n0 *sizeof(_Tp0)/sizeof(float)>	cv::v_reinterpret_as_f32 (const v_reg< _Tp0, n0 > &a)
template<typename _Tp0 , int n0>
v_reg< double, n0 *sizeof(_Tp0)/sizeof(double)>	cv::v_reinterpret_as_f64 (const v_reg< _Tp0, n0 > &a)
template<typename _Tp0 , int n0>
v_reg< uint64, n0 *sizeof(_Tp0)/sizeof(uint64)>	cv::v_reinterpret_as_u64 (const v_reg< _Tp0, n0 > &a)
template<typename _Tp0 , int n0>
v_reg< int64, n0 *sizeof(_Tp0)/sizeof(int64)>	cv::v_reinterpret_as_s64 (const v_reg< _Tp0, n0 > &a)

左移
左移
template<int shift, int n>
v_reg< ushort, n >	cv::v_shl (const v_reg< ushort, n > &a)
template<int shift, int n>
v_reg< short, n >	cv::v_shl (const v_reg< short, n > &a)
template<int shift, int n>
v_reg< unsigned, n >	cv::v_shl (const v_reg< unsigned, n > &a)
template<int shift, int n>
v_reg< int, n >	cv::v_shl (const v_reg< int, n > &a)
template<int shift, int n>
v_reg< uint64, n >	cv::v_shl (const v_reg< uint64, n > &a)
template<int shift, int n>
v_reg< int64, n >	cv::v_shl (const v_reg< int64, n > &a)

右移
右移
template<int shift, int n>
v_reg< ushort, n >	cv::v_shr (const v_reg< ushort, n > &a)
template<int shift, int n>
v_reg< short, n >	cv::v_shr (const v_reg< short, n > &a)
template<int shift, int n>
v_reg< unsigned, n >	cv::v_shr (const v_reg< unsigned, n > &a)
template<int shift, int n>
v_reg< int, n >	cv::v_shr (const v_reg< int, n > &a)
template<int shift, int n>
v_reg< uint64, n >	cv::v_shr (const v_reg< uint64, n > &a)
template<int shift, int n>
v_reg< int64, n >	cv::v_shr (const v_reg< int64, n > &a)

舍入移位
舍入右移
template<int shift, int n>
v_reg< ushort, n >	cv::v_rshr (const v_reg< ushort, n > &a)
template<int shift, int n>
v_reg< short, n >	cv::v_rshr (const v_reg< short, n > &a)
template<int shift, int n>
v_reg< unsigned, n >	cv::v_rshr (const v_reg< unsigned, n > &a)
template<int shift, int n>
v_reg< int, n >	cv::v_rshr (const v_reg< int, n > &a)
template<int shift, int n>
v_reg< uint64, n >	cv::v_rshr (const v_reg< uint64, n > &a)
template<int shift, int n>
v_reg< int64, n >	cv::v_rshr (const v_reg< int64, n > &a)

打包
将两个向量的值打包成一个 返回的向量类型具有两倍于输入向量元素的数量。带有 *u* 后缀的变体也会转换为相应的无符号类型。 pack：适用于 16 位、32 位和 64 位整数输入类型 pack_u：适用于 16 位和 32 位有符号整数输入类型 注意 除 64 位外的所有变体均使用饱和。
template<int n>
v_reg< uchar, 2 *n >	cv::v_pack (const v_reg< ushort, n > &a, const v_reg< ushort, n > &b)
template<int n>
v_reg< schar, 2 *n >	cv::v_pack (const v_reg< short, n > &a, const v_reg< short, n > &b)
template<int n>
v_reg< ushort, 2 *n >	cv::v_pack (const v_reg< unsigned, n > &a, const v_reg< unsigned, n > &b)
template<int n>
v_reg< short, 2 *n >	cv::v_pack (const v_reg< int, n > &a, const v_reg< int, n > &b)
template<int n>
v_reg< unsigned, 2 *n >	cv::v_pack (const v_reg< uint64, n > &a, const v_reg< uint64, n > &b)
template<int n>
v_reg< int, 2 *n >	cv::v_pack (const v_reg< int64, n > &a, const v_reg< int64, n > &b)
template<int n>
v_reg< uchar, 2 *n >	cv::v_pack_u (const v_reg< short, n > &a, const v_reg< short, n > &b)
template<int n>
v_reg< ushort, 2 *n >	cv::v_pack_u (const v_reg< int, n > &a, const v_reg< int, n > &b)

带舍入移位的打包
将两个向量的值打包成一个，并带舍入移位 输入向量中的值将右移 *n* 位并进行舍入，然后转换为较窄类型并在结果向量中返回。带有 *u* 后缀的变体转换为无符号类型。 pack：适用于 16 位、32 位和 64 位整数输入类型 pack_u：适用于 16 位和 32 位有符号整数输入类型 注意 除 64 位外的所有变体均使用饱和。
template<int shift, int n>
v_reg< uchar, 2 *n >	cv::v_rshr_pack (const v_reg< ushort, n > &a, const v_reg< ushort, n > &b)
template<int shift, int n>
v_reg< schar, 2 *n >	cv::v_rshr_pack (const v_reg< short, n > &a, const v_reg< short, n > &b)
template<int shift, int n>
v_reg< ushort, 2 *n >	cv::v_rshr_pack (const v_reg< unsigned, n > &a, const v_reg< unsigned, n > &b)
template<int shift, int n>
v_reg< short, 2 *n >	cv::v_rshr_pack (const v_reg< int, n > &a, const v_reg< int, n > &b)
template<int shift, int n>
v_reg< unsigned, 2 *n >	cv::v_rshr_pack (const v_reg< uint64, n > &a, const v_reg< uint64, n > &b)
template<int shift, int n>
v_reg< int, 2 *n >	cv::v_rshr_pack (const v_reg< int64, n > &a, const v_reg< int64, n > &b)
template<int shift, int n>
v_reg< uchar, 2 *n >	cv::v_rshr_pack_u (const v_reg< short, n > &a, const v_reg< short, n > &b)
template<int shift, int n>
v_reg< ushort, 2 *n >	cv::v_rshr_pack_u (const v_reg< int, n > &a, const v_reg< int, n > &b)

打包并存储
将输入向量的值打包并存储到内存中 值将被存储到内存中，并转换为较窄类型。带有 *u* 后缀的变体转换为相应的无符号类型。 pack：适用于 16 位、32 位和 64 位整数输入类型 pack_u：适用于 16 位和 32 位有符号整数输入类型 注意 除 64 位外的所有变体均使用饱和。
template<int n>
void	cv::v_pack_store (uchar *ptr, const v_reg< ushort, n > &a)
template<int n>
void	cv::v_pack_store (schar *ptr, const v_reg< short, n > &a)
template<int n>
void	cv::v_pack_store (ushort *ptr, const v_reg< unsigned, n > &a)
template<int n>
void	cv::v_pack_store (short *ptr, const v_reg< int, n > &a)
template<int n>
void	cv::v_pack_store (unsigned *ptr, const v_reg< uint64, n > &a)
template<int n>
void	cv::v_pack_store (int *ptr, const v_reg< int64, n > &a)
template<int n>
void	cv::v_pack_u_store (uchar *ptr, const v_reg< short, n > &a)
template<int n>
void	cv::v_pack_u_store (ushort *ptr, const v_reg< int, n > &a)

带舍入移位的打包和存储
将输入向量的值打包并存储到内存中 值将右移 *n* 位并进行舍入，然后转换为较窄类型并存储到内存中。带有 *u* 后缀的变体转换为无符号类型。 pack：适用于 16 位、32 位和 64 位整数输入类型 pack_u：适用于 16 位和 32 位有符号整数输入类型 注意 除 64 位外的所有变体均使用饱和。
template<int shift, int n>
void	cv::v_rshr_pack_store (uchar *ptr, const v_reg< ushort, n > &a)
template<int shift, int n>
void	cv::v_rshr_pack_store (schar *ptr, const v_reg< short, n > &a)
template<int shift, int n>
void	cv::v_rshr_pack_store (ushort *ptr, const v_reg< unsigned, n > &a)
template<int shift, int n>
void	cv::v_rshr_pack_store (short *ptr, const v_reg< int, n > &a)
template<int shift, int n>
void	cv::v_rshr_pack_store (unsigned *ptr, const v_reg< uint64, n > &a)
template<int shift, int n>
void	cv::v_rshr_pack_store (int *ptr, const v_reg< int64, n > &a)
template<int shift, int n>
void	cv::v_rshr_pack_u_store (uchar *ptr, const v_reg< short, n > &a)
template<int shift, int n>
void	cv::v_rshr_pack_u_store (ushort *ptr, const v_reg< int, n > &a)

打包布尔值
将来自多个向量的布尔值打包到一个无符号8位整数向量中 注意 必须提供有效的布尔值以保证所有架构的结果一致。
template<int n>
v_reg< uchar, 2 *n >	cv::v_pack_b (const v_reg< ushort, n > &a, const v_reg< ushort, n > &b)
	！适用于 16 位布尔值
template<int n>
v_reg< uchar, 4 *n >	cv::v_pack_b (const v_reg< unsigned, n > &a, const v_reg< unsigned, n > &b, const v_reg< unsigned, n > &c, const v_reg< unsigned, n > &d)
template<int n>
v_reg< uchar, 8 *n >	cv::v_pack_b (const v_reg< uint64, n > &a, const v_reg< uint64, n > &b, const v_reg< uint64, n > &c, const v_reg< uint64, n > &d, const v_reg< uint64, n > &e, const v_reg< uint64, n > &f, const v_reg< uint64, n > &g, const v_reg< uint64, n > &h)

宏定义文档

OPENCV_HAL_MATH_HAVE_EXP

#define OPENCV_HAL_MATH_HAVE_EXP   1

#include <opencv2/core/hal/intrin_cpp.hpp>

类型定义文档

v_float32

typedef v_float32x16 simd512::v_float32

#include <opencv2/core/hal/intrin.hpp>

最大可用向量寄存器容量 32位浮点值（单精度）

v_float32x16

typedef v_reg<float, 16> cv::v_float32x16

#include <opencv2/core/hal/intrin_cpp.hpp>

十六个32位浮点值（单精度）

v_float32x4

typedef v_reg<float, 4> cv::v_float32x4

#include <opencv2/core/hal/intrin_cpp.hpp>

四个32位浮点值（单精度）

v_float32x8

typedef v_reg<float, 8> cv::v_float32x8

#include <opencv2/core/hal/intrin_cpp.hpp>

八个32位浮点值（单精度）

v_float64

typedef v_float64x8 simd512::v_float64

#include <opencv2/core/hal/intrin.hpp>

最大可用向量寄存器容量 64位浮点值（双精度）

v_float64x2

typedef v_reg<double, 2> cv::v_float64x2

#include <opencv2/core/hal/intrin_cpp.hpp>

两个64位浮点值（双精度）

v_float64x4

typedef v_reg<double, 4> cv::v_float64x4

#include <opencv2/core/hal/intrin_cpp.hpp>

四个64位浮点值（双精度）

v_float64x8

typedef v_reg<double, 8> cv::v_float64x8

#include <opencv2/core/hal/intrin_cpp.hpp>

八个64位浮点值（双精度）

v_int16

typedef v_int16x32 simd512::v_int16

#include <opencv2/core/hal/intrin.hpp>

最大可用向量寄存器容量 16位有符号整数值。

v_int16x16

typedef v_reg<short, 16> cv::v_int16x16

#include <opencv2/core/hal/intrin_cpp.hpp>

十六个16位有符号整数值。

v_int16x32

typedef v_reg<short, 32> cv::v_int16x32

#include <opencv2/core/hal/intrin_cpp.hpp>

三十二个16位有符号整数值。

v_int16x8

typedef v_reg<short, 8> cv::v_int16x8

#include <opencv2/core/hal/intrin_cpp.hpp>

八个16位有符号整数值。

v_int32

typedef v_int32x16 simd512::v_int32

#include <opencv2/core/hal/intrin.hpp>

最大可用向量寄存器容量 32位有符号整数值。

v_int32x16

typedef v_reg<int, 16> cv::v_int32x16

#include <opencv2/core/hal/intrin_cpp.hpp>

十六个32位有符号整数值。

v_int32x4

typedef v_reg<int, 4> cv::v_int32x4

#include <opencv2/core/hal/intrin_cpp.hpp>

四个32位有符号整数值。

v_int32x8

typedef v_reg<int, 8> cv::v_int32x8

#include <opencv2/core/hal/intrin_cpp.hpp>

八个32位有符号整数值。

v_int64

typedef v_int64x8 simd512::v_int64

#include <opencv2/core/hal/intrin.hpp>

最大可用向量寄存器容量 64位有符号整数值。

v_int64x2

typedef v_reg<int64, 2> cv::v_int64x2

#include <opencv2/core/hal/intrin_cpp.hpp>

两个64位有符号整数值。

v_int64x4

typedef v_reg<int64, 4> cv::v_int64x4

#include <opencv2/core/hal/intrin_cpp.hpp>

四个64位有符号整数值。

v_int64x8

typedef v_reg<int64, 8> cv::v_int64x8

#include <opencv2/core/hal/intrin_cpp.hpp>

八个64位有符号整数值。

v_int8

typedef v_int8x64 simd512::v_int8

#include <opencv2/core/hal/intrin.hpp>

最大可用向量寄存器容量 8位有符号整数值。

v_int8x16

typedef v_reg<schar, 16> cv::v_int8x16

#include <opencv2/core/hal/intrin_cpp.hpp>

十六个8位有符号整数值。

v_int8x32

typedef v_reg<schar, 32> cv::v_int8x32

#include <opencv2/core/hal/intrin_cpp.hpp>

三十二个8位有符号整数值。

v_int8x64

typedef v_reg<schar, 64> cv::v_int8x64

#include <opencv2/core/hal/intrin_cpp.hpp>

六十四个8位有符号整数值。

v_uint16

typedef v_uint16x32 simd512::v_uint16

#include <opencv2/core/hal/intrin.hpp>

最大可用向量寄存器容量 16位无符号整数值。

v_uint16x16

typedef v_reg<ushort, 16> cv::v_uint16x16

#include <opencv2/core/hal/intrin_cpp.hpp>

十六个16位无符号整数值。

v_uint16x32

typedef v_reg<ushort, 32> cv::v_uint16x32

#include <opencv2/core/hal/intrin_cpp.hpp>

三十二个16位无符号整数值。

v_uint16x8

typedef v_reg<ushort, 8> cv::v_uint16x8

#include <opencv2/core/hal/intrin_cpp.hpp>

八个16位无符号整数值。

v_uint32

typedef v_uint32x16 simd512::v_uint32

#include <opencv2/core/hal/intrin.hpp>

最大可用向量寄存器容量 32位无符号整数值。

v_uint32x16

typedef v_reg<unsigned, 16> cv::v_uint32x16

#include <opencv2/core/hal/intrin_cpp.hpp>

十六个32位无符号整数值。

v_uint32x4

typedef v_reg<unsigned, 4> cv::v_uint32x4

#include <opencv2/core/hal/intrin_cpp.hpp>

四个32位无符号整数值。

v_uint32x8

typedef v_reg<unsigned, 8> cv::v_uint32x8

#include <opencv2/core/hal/intrin_cpp.hpp>

八个32位无符号整数值。

v_uint64

typedef v_uint64x8 simd512::v_uint64

#include <opencv2/core/hal/intrin.hpp>

最大可用向量寄存器容量 64位无符号整数值。

v_uint64x2

typedef v_reg<uint64, 2> cv::v_uint64x2

#include <opencv2/core/hal/intrin_cpp.hpp>

两个64位无符号整数值。

v_uint64x4

typedef v_reg<uint64, 4> cv::v_uint64x4

#include <opencv2/core/hal/intrin_cpp.hpp>

四个64位无符号整数值。

v_uint64x8

typedef v_reg<uint64, 8> cv::v_uint64x8

#include <opencv2/core/hal/intrin_cpp.hpp>

八个64位无符号整数值。

v_uint8

typedef v_uint8x64 simd512::v_uint8

#include <opencv2/core/hal/intrin.hpp>

最大可用向量寄存器容量 8位无符号整数值。

v_uint8x16

typedef v_reg<uchar, 16> cv::v_uint8x16

#include <opencv2/core/hal/intrin_cpp.hpp>

十六个8位无符号整数值。

v_uint8x32

typedef v_reg<uchar, 32> cv::v_uint8x32

#include <opencv2/core/hal/intrin_cpp.hpp>

三十二个8位无符号整数值。

v_uint8x64

typedef v_reg<uchar, 64> cv::v_uint8x64

#include <opencv2/core/hal/intrin_cpp.hpp>

六十四个8位无符号整数值。

枚举类型文档

匿名枚举

匿名枚举

#include <opencv2/core/hal/intrin_cpp.hpp>

枚举器
simd128_width
simd256_width
simd512_width
simdmax_width

函数文档

v256_cleanup()

void cv::v256_cleanup ( )

inline

#include <opencv2/core/hal/intrin_cpp.hpp>

v256_load()

template<typename _Tp >

v_reg< _Tp, simd256_width/sizeof(_Tp)> cv::v256_load ( const _Tp * ptr )

inline

#include <opencv2/core/hal/intrin_cpp.hpp>

从内存加载256位长度寄存器内容。

参数

ptr

指向内存块的指针

返回

寄存器对象

注意

返回类型将根据传入的指针类型进行检测，例如 uchar ==> cv::v_uint8x32, int ==> cv::v_int32x8, 等。

在使用前检查 CV_SIMD256 预处理器定义。使用 vx_load 版本可获得最大可用寄存器长度结果

对齐要求：如果 CV_STRONG_ALIGNMENT=1，则传入的指针必须对齐（`sizeof(lane type)` 应该足够）。不要在没有运行时检查指针对齐（例如 `uchar*` => `int*`）的情况下进行指针类型转换。

此函数的调用图如下

v256_load_aligned()

template<typename _Tp >

v_reg< _Tp, simd256_width/sizeof(_Tp)> cv::v256_load_aligned ( const _Tp * ptr )

inline

#include <opencv2/core/hal/intrin_cpp.hpp>

从内存加载寄存器内容（对齐）

类似于 cv::v256_load，但源内存块应进行对齐（SIMD256 情况下为 32 字节对齐，SIMD512 情况下为 64 字节对齐，依此类推）

注意

在使用前检查 CV_SIMD256 预处理器定义。使用 vx_load_aligned 版本可获得最大可用寄存器长度结果

此函数的调用图如下

v256_load_expand() [1/2]

template<typename _Tp >

v_reg< typename V_TypeTraits< _Tp >::w_type, simd256_width/sizeof(typename V_TypeTraits< _Tp >::w_type)> cv::v256_load_expand ( const _Tp * ptr )

inline

#include <opencv2/core/hal/intrin_cpp.hpp>

从内存加载寄存器内容并双重扩展。

与 cv::v256_load 相同，但结果包类型将比内存类型宽 2 倍。

short buf[8] = {1, 2, 3, 4, 5, 6, 7, 8}; // 类型为 int16
v_int32x8 r = v256_load_expand(buf); // r = {1, 2, 3, 4, 5, 6, 7, 8} - 类型为 int32

适用于 8 位、16 位、32 位整数源类型。

注意

在使用前检查 CV_SIMD256 预处理器定义。使用 vx_load_expand 版本可获得最大可用寄存器长度结果

此函数的调用图如下

v256_load_expand() [2/2]

v_reg< float, simd256_width/sizeof(float)> cv::v256_load_expand ( const hfloat * ptr )

inline

#include <opencv2/core/hal/intrin_cpp.hpp>

v256_load_expand_q()

template<typename _Tp >

v_reg< typename V_TypeTraits< _Tp >::q_type, simd256_width/sizeof(typename V_TypeTraits< _Tp >::q_type)> cv::v256_load_expand_q ( const _Tp * ptr )

inline

#include <opencv2/core/hal/intrin_cpp.hpp>

从内存加载寄存器内容并四重扩展。

与 cv::v256_load_expand 相同，但结果类型是源类型的 4 倍宽。

char buf[8] = {1, 2, 3, 4, 5, 6, 7, 8}; // 类型为 int8
v_int32x8 r = v256_load_expand_q(buf); // r = {1, 2, 3, 4, 5, 6, 7, 8} - 类型为 int32

适用于 8 位整数源类型。

注意

在使用前检查 CV_SIMD256 预处理器定义。使用 vx_load_expand_q 版本可获得最大可用寄存器长度结果

此函数的调用图如下

v256_load_halves()

template<typename _Tp >

v_reg< _Tp, simd256_width/sizeof(_Tp)> cv::v256_load_halves ( const _Tp * loptr, const _Tp * hiptr )

inline

#include <opencv2/core/hal/intrin_cpp.hpp>

从两个内存块加载寄存器内容。

参数

loptr	包含前半部分数据 (0..n/2) 的内存块
hiptr	包含后半部分数据 (n/2..n) 的内存块

int lo[4] = { 1, 2, 3, 4 }, hi[4] = { 5, 6, 7, 8 };
v_int32x8 r = v256_load_halves(lo, hi);

注意

在使用前检查 CV_SIMD256 预处理器定义。使用 vx_load_halves 版本可获得最大可用寄存器长度结果

此函数的调用图如下

v256_load_low()

template<typename _Tp >

v_reg< _Tp, simd256_width/sizeof(_Tp)> cv::v256_load_low ( const _Tp * ptr )

inline

#include <opencv2/core/hal/intrin_cpp.hpp>

加载128位数据到低位部分（高位部分未定义）。

参数

ptr	包含前半部分数据 (0..n/2) 的内存块

int lo[4] = { 1, 2, 3, 4 };
v_int32x8 r = v256_load_low(lo);

注意

在使用前检查 CV_SIMD256 预处理器定义。使用 vx_load_low 版本可获得最大可用寄存器长度结果

此函数的调用图如下

v256_setall_f32()

v_float32x8 cv::v256_setall_f32 ( float val )

inline

#include <opencv2/core/hal/intrin_cpp.hpp>

v256_setall_f64()

v_float64x4 cv::v256_setall_f64 ( double val )

inline

#include <opencv2/core/hal/intrin_cpp.hpp>

v256_setall_s16()

v_int16x16 cv::v256_setall_s16 ( short val )

inline

#include <opencv2/core/hal/intrin_cpp.hpp>

v256_setall_s32()

v_int32x8 cv::v256_setall_s32 ( int val )

inline

#include <opencv2/core/hal/intrin_cpp.hpp>

v256_setall_s64()

v_int64x4 cv::v256_setall_s64 ( int64 val )

inline

#include <opencv2/core/hal/intrin_cpp.hpp>

v256_setall_s8()

v_int8x32 cv::v256_setall_s8 ( schar val )

inline

#include <opencv2/core/hal/intrin_cpp.hpp>

v256_setall_u16()

v_uint16x16 cv::v256_setall_u16 ( ushort val )

inline

#include <opencv2/core/hal/intrin_cpp.hpp>

v256_setall_u32()

v_uint32x8 cv::v256_setall_u32 ( unsigned val )

inline

#include <opencv2/core/hal/intrin_cpp.hpp>

v256_setall_u64()

v_uint64x4 cv::v256_setall_u64 ( uint64 val )

inline

#include <opencv2/core/hal/intrin_cpp.hpp>

v256_setall_u8()

v_uint8x32 cv::v256_setall_u8 ( I.at<uchar>(y, x) = saturate_cast<uchar>(r); val )

inline

#include <opencv2/core/hal/intrin_cpp.hpp>

v256_setzero_f32()

v_float32x8 cv::v256_setzero_f32 ( )

inline

#include <opencv2/core/hal/intrin_cpp.hpp>

v256_setzero_f64()

v_float64x4 cv::v256_setzero_f64 ( )

inline

#include <opencv2/core/hal/intrin_cpp.hpp>

v256_setzero_s16()

v_int16x16 cv::v256_setzero_s16 ( )

inline

#include <opencv2/core/hal/intrin_cpp.hpp>

v256_setzero_s32()

v_int32x8 cv::v256_setzero_s32 ( )

inline

#include <opencv2/core/hal/intrin_cpp.hpp>

v256_setzero_s64()

v_int64x4 cv::v256_setzero_s64 ( )

inline

#include <opencv2/core/hal/intrin_cpp.hpp>

v256_setzero_s8()

v_int8x32 cv::v256_setzero_s8 ( )

inline

#include <opencv2/core/hal/intrin_cpp.hpp>

v256_setzero_u16()

v_uint16x16 cv::v256_setzero_u16 ( )

inline

#include <opencv2/core/hal/intrin_cpp.hpp>

v256_setzero_u32()

v_uint32x8 cv::v256_setzero_u32 ( )

inline

#include <opencv2/core/hal/intrin_cpp.hpp>

v256_setzero_u64()

v_uint64x4 cv::v256_setzero_u64 ( )

inline

#include <opencv2/core/hal/intrin_cpp.hpp>

v256_setzero_u8()

v_uint8x32 cv::v256_setzero_u8 ( )

inline

#include <opencv2/core/hal/intrin_cpp.hpp>

v512_cleanup()

void cv::v512_cleanup ( )

inline

#include <opencv2/core/hal/intrin_cpp.hpp>

v512_load()

template<typename _Tp >

v_reg< _Tp, simd512_width/sizeof(_Tp)> cv::v512_load ( const _Tp * ptr )

inline

#include <opencv2/core/hal/intrin_cpp.hpp>

从内存加载512位长度寄存器内容。

参数

ptr

指向内存块的指针

返回

寄存器对象

注意

返回类型将根据传入的指针类型进行检测，例如 uchar ==> cv::v_uint8x64, int ==> cv::v_int32x16, 等。

在使用前检查 CV_SIMD512 预处理器定义。使用 vx_load 版本可获得最大可用寄存器长度结果

对齐要求：如果 CV_STRONG_ALIGNMENT=1，则传入的指针必须对齐（`sizeof(lane type)` 应该足够）。不要在没有运行时检查指针对齐（例如 `uchar*` => `int*`）的情况下进行指针类型转换。

此函数的调用图如下

v512_load_aligned()

template<typename _Tp >

v_reg< _Tp, simd512_width/sizeof(_Tp)> cv::v512_load_aligned ( const _Tp * ptr )

inline

#include <opencv2/core/hal/intrin_cpp.hpp>

从内存加载寄存器内容（对齐）

类似于 cv::v512_load，但源内存块应进行对齐（SIMD512 情况下为 64 字节对齐，依此类推）

注意

在使用前检查 CV_SIMD512 预处理器定义。使用 vx_load_aligned 版本可获得最大可用寄存器长度结果

此函数的调用图如下

v512_load_expand() [1/2]

template<typename _Tp >

v_reg< typename V_TypeTraits< _Tp >::w_type, simd512_width/sizeof(typename V_TypeTraits< _Tp >::w_type)> cv::v512_load_expand ( const _Tp * ptr )

inline

#include <opencv2/core/hal/intrin_cpp.hpp>

从内存加载寄存器内容并双重扩展。

与 cv::v512_load 相同，但结果包类型将比内存类型宽 2 倍。

short buf[8] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16}; // 类型为 int16
v_int32x16 r = v512_load_expand(buf); // r = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16} - 类型为 int32

适用于 8 位、16 位、32 位整数源类型。

注意

在使用前检查 CV_SIMD512 预处理器定义。使用 vx_load_expand 版本可获得最大可用寄存器长度结果

此函数的调用图如下

v512_load_expand() [2/2]

v_reg< float, simd512_width/sizeof(float)> cv::v512_load_expand ( const hfloat * ptr )

inline

#include <opencv2/core/hal/intrin_cpp.hpp>

v512_load_expand_q()

template<typename _Tp >

v_reg< typename V_TypeTraits< _Tp >::q_type, simd512_width/sizeof(typename V_TypeTraits< _Tp >::q_type)> cv::v512_load_expand_q ( const _Tp * ptr )

inline

#include <opencv2/core/hal/intrin_cpp.hpp>

从内存加载寄存器内容并四重扩展。

与 cv::v512_load_expand 相同，但结果类型是源类型的 4 倍宽。

char buf[16] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16}; // 类型为 int8
v_int32x16 r = v512_load_expand_q(buf); // r = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16} - 类型为 int32

适用于 8 位整数源类型。

注意

在使用前检查 CV_SIMD512 预处理器定义。使用 vx_load_expand_q 版本可获得最大可用寄存器长度结果

此函数的调用图如下

v512_load_halves()

template<typename _Tp >

v_reg< _Tp, simd512_width/sizeof(_Tp)> cv::v512_load_halves ( const _Tp * loptr, const _Tp * hiptr )

inline

#include <opencv2/core/hal/intrin_cpp.hpp>

从两个内存块加载寄存器内容。

参数

loptr	包含前半部分数据 (0..n/2) 的内存块
hiptr	包含后半部分数据 (n/2..n) 的内存块

int lo[4] = { 1, 2, 3, 4, 5, 6, 7, 8 }, hi[4] = { 9, 10, 11, 12, 13, 14, 15, 16 };
v_int32x16 r = v512_load_halves(lo, hi);

注意

在使用前检查 CV_SIMD512 预处理器定义。使用 vx_load_halves 版本可获得最大可用寄存器长度结果

此函数的调用图如下

v512_load_low()

template<typename _Tp >

v_reg< _Tp, simd512_width/sizeof(_Tp)> cv::v512_load_low ( const _Tp * ptr )

inline

#include <opencv2/core/hal/intrin_cpp.hpp>

加载256位数据到低位部分（高位部分未定义）。

参数

ptr	包含前半部分数据 (0..n/2) 的内存块

int lo[8] = { 1, 2, 3, 4, 5, 6, 7, 8 };
v_int32x16 r = v512_load_low(lo);

注意

在使用前检查 CV_SIMD512 预处理器定义。使用 vx_load_low 版本可获得最大可用寄存器长度结果

此函数的调用图如下

v512_setall_f32()

v_float32x16 cv::v512_setall_f32 ( float val )

inline

#include <opencv2/core/hal/intrin_cpp.hpp>

v512_setall_f64()

v_float64x8 cv::v512_setall_f64 ( double val )

inline

#include <opencv2/core/hal/intrin_cpp.hpp>

v512_setall_s16()

v_int16x32 cv::v512_setall_s16 ( short val )

inline

#include <opencv2/core/hal/intrin_cpp.hpp>

v512_setall_s32()

v_int32x16 cv::v512_setall_s32 ( int val )

inline

#include <opencv2/core/hal/intrin_cpp.hpp>

v512_setall_s64()

v_int64x8 cv::v512_setall_s64 ( int64 val )

inline

#include <opencv2/core/hal/intrin_cpp.hpp>

v512_setall_s8()

v_int8x64 cv::v512_setall_s8 ( schar val )

inline

#include <opencv2/core/hal/intrin_cpp.hpp>

v512_setall_u16()

v_uint16x32 cv::v512_setall_u16 ( ushort val )

inline

#include <opencv2/core/hal/intrin_cpp.hpp>

v512_setall_u32()

v_uint32x16 cv::v512_setall_u32 ( unsigned val )

inline

#include <opencv2/core/hal/intrin_cpp.hpp>

v512_setall_u64()

v_uint64x8 cv::v512_setall_u64 ( uint64 val )

inline

#include <opencv2/core/hal/intrin_cpp.hpp>

v512_setall_u8()

v_uint8x64 cv::v512_setall_u8 ( I.at<uchar>(y, x) = saturate_cast<uchar>(r); val )

inline

#include <opencv2/core/hal/intrin_cpp.hpp>

v512_setzero_f32()

v_float32x16 cv::v512_setzero_f32 ( )

inline

#include <opencv2/core/hal/intrin_cpp.hpp>

v512_setzero_f64()

v_float64x8 cv::v512_setzero_f64 ( )

inline

#include <opencv2/core/hal/intrin_cpp.hpp>

v512_setzero_s16()

v_int16x32 cv::v512_setzero_s16 ( )

inline

#include <opencv2/core/hal/intrin_cpp.hpp>

v512_setzero_s32()

v_int32x16 cv::v512_setzero_s32 ( )

inline

#include <opencv2/core/hal/intrin_cpp.hpp>

v512_setzero_s64()

v_int64x8 cv::v512_setzero_s64 ( )

inline

#include <opencv2/core/hal/intrin_cpp.hpp>

v512_setzero_s8()

v_int8x64 cv::v512_setzero_s8 ( )

inline

#include <opencv2/core/hal/intrin_cpp.hpp>

v512_setzero_u16()

v_uint16x32 cv::v512_setzero_u16 ( )

inline

#include <opencv2/core/hal/intrin_cpp.hpp>

v512_setzero_u32()

v_uint32x16 cv::v512_setzero_u32 ( )

inline

#include <opencv2/core/hal/intrin_cpp.hpp>

v512_setzero_u64()

v_uint64x8 cv::v512_setzero_u64 ( )

inline

#include <opencv2/core/hal/intrin_cpp.hpp>

v512_setzero_u8()

v_uint8x64 cv::v512_setzero_u8 ( )

inline

#include <opencv2/core/hal/intrin_cpp.hpp>

v_abs()

template<typename _Tp , int n>

v_reg< typename V_TypeTraits< _Tp >::abs_type, n > cv::v_abs ( const v_reg< _Tp, n > & a )

inline

#include <opencv2/core/hal/intrin_cpp.hpp>

元素的绝对值。

仅适用于浮点类型。

v_absdiff() [1/3]

template<typename _Tp , int n>

v_reg< typename V_TypeTraits< _Tp >::abs_type, n > cv::v_absdiff ( const v_reg< _Tp, n > & a, const v_reg< _Tp, n > & b )

inline

#include <opencv2/core/hal/intrin_cpp.hpp>

绝对差。

返回 \( |a - b| \) 并转换为相应的无符号类型。示例：

v_int32x4 a, b; // {1, 2, 3, 4} 和 {4, 3, 2, 1}
v_uint32x4 c = v_absdiff(a, b); // 结果为 {3, 1, 1, 3}

适用于 8 位、16 位、32 位整数源类型。

v_absdiff() [2/3]

template<int n>

v_reg< double, n > cv::v_absdiff ( const v_reg< double, n > & a, const v_reg< double, n > & b )

inline

#include <opencv2/core/hal/intrin_cpp.hpp>

这是为方便而提供的重载成员函数。它与上述函数的唯一区别在于其接受的参数。

适用于64位浮点值

v_absdiff() [3/3]

template<int n>

v_reg< float, n > cv::v_absdiff ( const v_reg< float, n > & a, const v_reg< float, n > & b )

inline

#include <opencv2/core/hal/intrin_cpp.hpp>

这是为方便而提供的重载成员函数。它与上述函数的唯一区别在于其接受的参数。

适用于32位浮点值

v_absdiffs()

template<typename _Tp , int n>

v_reg< _Tp, n > cv::v_absdiffs ( const v_reg< _Tp, n > & a, const v_reg< _Tp, n > & b )

inline

#include <opencv2/core/hal/intrin_cpp.hpp>

饱和绝对差。

返回 \( saturate(|a - b|) \) 。适用于8位、16位有符号整数源类型。

此函数的调用图如下

v_add()

template<typename _Tp , int n>

v_reg< _Tp, n > cv::v_add	(	const v_reg< _Tp, n > &	a,
		const v_reg< _Tp, n > &	b )

#include <opencv2/core/hal/intrin_cpp.hpp>

添加值。

适用于所有类型。

v_add_wrap()

template<typename _Tp , int n>

v_reg< _Tp, n > cv::v_add_wrap ( const v_reg< _Tp, n > & a, const v_reg< _Tp, n > & b )

inline

#include <opencv2/core/hal/intrin_cpp.hpp>

无饱和添加值。

适用于8位和16位整数值。

v_and()

template<typename _Tp , int n>

v_reg< _Tp, n > cv::v_and	(	const v_reg< _Tp, n > &	a,
		const v_reg< _Tp, n > &	b )

#include <opencv2/core/hal/intrin_cpp.hpp>

按位与。

仅适用于整数类型。

v_broadcast_element()

template<int i, typename _Tp , int n>

v_reg< _Tp, n > cv::v_broadcast_element ( const v_reg< _Tp, n > & a )

inline

#include <opencv2/core/hal/intrin_cpp.hpp>

广播向量的第i个元素。

方案

{ v[0] v[1] v[2] ... v[SZ] } => { v[i], v[i], v[i] ... v[i] }

限制：0 <= i < nlanes 支持的类型：32 位整数和浮点数 (s32/u32/f32)

v_ceil() [1/2]

template<int n>

v_reg< int, n *2 > cv::v_ceil ( const v_reg< double, n > & a )

inline

#include <opencv2/core/hal/intrin_cpp.hpp>

这是为方便而提供的重载成员函数。它与上述函数的唯一区别在于其接受的参数。

此函数的调用图如下

v_ceil() [2/2]

template<int n>

v_reg< int, n > cv::v_ceil ( const v_reg< float, n > & a )

inline

#include <opencv2/core/hal/intrin_cpp.hpp>

向上取整元素。

对每个值进行向上取整。输入类型为浮点向量 ==> 输出类型为整数向量。

注意

仅适用于浮点类型。

此函数的调用图如下

v_check_all()

template<typename _Tp , int n>

bool cv::v_check_all ( const v_reg< _Tp, n > & a )

inline

#include <opencv2/core/hal/intrin_cpp.hpp>

检查所有打包值是否都小于零。

无符号值将被转换为有符号值：`uchar 254 => char -2`。

v_check_any()

template<typename _Tp , int n>

bool cv::v_check_any ( const v_reg< _Tp, n > & a )

inline

#include <opencv2/core/hal/intrin_cpp.hpp>

检查是否有任何打包值小于零。

无符号值将被转换为有符号值：`uchar 254 => char -2`。

v_cleanup()

void cv::v_cleanup ( )

inline

#include <opencv2/core/hal/intrin_cpp.hpp>

v_combine_high()

template<typename _Tp , int n>

v_reg< _Tp, n > cv::v_combine_high ( const v_reg< _Tp, n > & a, const v_reg< _Tp, n > & b )

inline

#include <opencv2/core/hal/intrin_cpp.hpp>

从两个向量的最后元素组合向量。

方案

{A1 A2 A3 A4}
{B1 B2 B3 B4}
---------------
{A3 A4 B3 B4}

适用于除64位以外的所有类型。

v_combine_low()

template<typename _Tp , int n>

v_reg< _Tp, n > cv::v_combine_low ( const v_reg< _Tp, n > & a, const v_reg< _Tp, n > & b )

inline

#include <opencv2/core/hal/intrin_cpp.hpp>

从两个向量的第一个元素组合向量。

方案

{A1 A2 A3 A4}
{B1 B2 B3 B4}
---------------
{A1 A2 B1 B2}

适用于除64位以外的所有类型。

v_cos()

template<typename _Tp , int n>

v_reg< _Tp, n > cv::v_cos ( const v_reg< _Tp, n > & a )

inline

#include <opencv2/core/hal/intrin_cpp.hpp>

元素的余弦 \( cos(x) \)。

仅适用于浮点类型。核心实现与 v_sincos 相同。

v_cvt_f32() [1/3]

template<int n>

v_reg< float, n *2 > cv::v_cvt_f32 ( const v_reg< double, n > & a )

inline

#include <opencv2/core/hal/intrin_cpp.hpp>

将下半部分转换为浮点数。

支持的输入类型为 cv::v_float64。

v_cvt_f32() [2/3]

template<int n>

v_reg< float, n *2 > cv::v_cvt_f32 ( const v_reg< double, n > & a, const v_reg< double, n > & b )

inline

#include <opencv2/core/hal/intrin_cpp.hpp>

转换为浮点数。

支持的输入类型为 cv::v_float64。

v_cvt_f32() [3/3]

template<int n>

v_reg< float, n > cv::v_cvt_f32 ( const v_reg< int, n > & a )

inline

#include <opencv2/core/hal/intrin_cpp.hpp>

转换为浮点数。

支持的输入类型为 cv::v_int32。

v_cvt_f64() [1/3]

template<int n>

v_reg< double,(n/2)> cv::v_cvt_f64

(

const v_reg< float, n > &

a

)

#include <opencv2/core/hal/intrin_cpp.hpp>

将下半部分转换为双精度浮点数。

支持的输入类型为 cv::v_float32。

v_cvt_f64() [2/3]

template<int n>

v_reg< double, n/2 > cv::v_cvt_f64

(

const v_reg< int, n > &

a

)

#include <opencv2/core/hal/intrin_cpp.hpp>

将下半部分转换为双精度浮点数。

支持的输入类型为 cv::v_int32。

v_cvt_f64() [3/3]

template<int n>

v_reg< double, n > cv::v_cvt_f64

(

const int64, n > &

a

)

#include <opencv2/core/hal/intrin_cpp.hpp>

转换为双精度浮点数。

支持的输入类型为 cv::v_int64。

v_cvt_f64_high() [1/2]

template<int n>

v_reg< double,(n/2)> cv::v_cvt_f64_high

(

const v_reg< float, n > &

a

)

#include <opencv2/core/hal/intrin_cpp.hpp>

将向量高位部分转换为双精度浮点数。

支持的输入类型为 cv::v_float32。

v_cvt_f64_high() [2/2]

template<int n>

v_reg< double,(n/2)> cv::v_cvt_f64_high

(

const v_reg< int, n > &

a

)

#include <opencv2/core/hal/intrin_cpp.hpp>

将向量高位部分转换为双精度浮点数。

支持的输入类型为 cv::v_int32。

v_div()

template<typename _Tp , int n>

v_reg< _Tp, n > cv::v_div	(	const v_reg< _Tp, n > &	a,
		const v_reg< _Tp, n > &	b )

#include <opencv2/core/hal/intrin_cpp.hpp>

除法。

仅适用于浮点类型。

v_dotprod() [1/2]

template<typename _Tp , int n>

v_reg< typename V_TypeTraits< _Tp >::w_type, n/2 > cv::v_dotprod ( const v_reg< _Tp, n > & a, const v_reg< _Tp, n > & b )

inline

#include <opencv2/core/hal/intrin_cpp.hpp>

元素的点积。

将两个寄存器中的值相乘并对相邻结果对求和。

方案

{A1 A2 ...} // 16位
x {B1 B2 ...} // 16位
-------------
{A1B1+A2B2 ...} // 32位

v_dotprod() [2/2]

template<typename _Tp , int n>

v_reg< typename V_TypeTraits< _Tp >::w_type, n/2 > cv::v_dotprod ( const v_reg< _Tp, n > & a, const v_reg< _Tp, n > & b, const v_reg< typename V_TypeTraits< _Tp >::w_type, n/2 > & c )

inline

#include <opencv2/core/hal/intrin_cpp.hpp>

元素的点积。

与 cv::v_dotprod 相同，但将第三个元素添加到相邻对的和中。方案：

{A1 A2 ...} // 16位
x {B1 B2 ...} // 16位
-------------
{A1B1+A2B2+C1 ...} // 32位

v_dotprod_expand() [1/4]

template<typename _Tp , int n>

v_reg< typename V_TypeTraits< _Tp >::q_type, n/4 > cv::v_dotprod_expand ( const v_reg< _Tp, n > & a, const v_reg< _Tp, n > & b )

inline

#include <opencv2/core/hal/intrin_cpp.hpp>

元素的点积并扩展。

将两个寄存器中的值相乘并展开相邻结果对的和。

方案

{A1 A2 A3 A4 ...} // 8位
x {B1 B2 B3 B4 ...} // 8位
-------------
{A1B1+A2B2+A3B3+A4B4 ...} // 32位

v_dotprod_expand() [2/4]

template<typename _Tp , int n>

v_reg< typename V_TypeTraits< _Tp >::q_type, n/4 > cv::v_dotprod_expand ( const v_reg< _Tp, n > & a, const v_reg< _Tp, n > & b, const v_reg< typename V_TypeTraits< _Tp >::q_type, n/4 > & c )

inline

#include <opencv2/core/hal/intrin_cpp.hpp>

元素的点积。

与 cv::v_dotprod_expand 相同，但将第三个元素添加到相邻对的和中。方案：

{A1 A2 A3 A4 ...} // 8位
x {B1 B2 B3 B4 ...} // 8位
-------------
{A1B1+A2B2+A3B3+A4B4+C1 ...} // 32位

v_dotprod_expand() [3/4]

template<int n>

v_reg< double, n/2 > cv::v_dotprod_expand ( const v_reg< int, n > & a, const v_reg< int, n > & b )

inline

#include <opencv2/core/hal/intrin_cpp.hpp>

此函数的调用图如下

v_dotprod_expand() [4/4]

template<int n>

v_reg< double, n/2 > cv::v_dotprod_expand ( const v_reg< int, n > & a, const v_reg< int, n > & b, const v_reg< double, n/2 > & c )

inline

#include <opencv2/core/hal/intrin_cpp.hpp>

此函数的调用图如下

v_dotprod_expand_fast() [1/4]

template<typename _Tp , int n>

v_reg< typename V_TypeTraits< _Tp >::q_type, n/4 > cv::v_dotprod_expand_fast ( const v_reg< _Tp, n > & a, const v_reg< _Tp, n > & b )

inline

#include <opencv2/core/hal/intrin_cpp.hpp>

快速元素的点积并扩展。

将两个寄存器中的值相乘并展开相邻结果对的和。

与 cv::v_dotprod_expand 相同，但在某些平台上它可能会在结果对之间执行无序求和，如果只关心所有通道的总和，并且它在受影响的平台上能提供更好的性能，则可以使用此内在函数。

此函数的调用图如下

v_dotprod_expand_fast() [2/4]

template<typename _Tp , int n>

v_reg< typename V_TypeTraits< _Tp >::q_type, n/4 > cv::v_dotprod_expand_fast ( const v_reg< _Tp, n > & a, const v_reg< _Tp, n > & b, const v_reg< typename V_TypeTraits< _Tp >::q_type, n/4 > & c )

inline

#include <opencv2/core/hal/intrin_cpp.hpp>

快速元素的点积。

与 cv::v_dotprod_expand_fast 相同，但会在相邻对的和中添加第三个元素。

此函数的调用图如下

v_dotprod_expand_fast() [3/4]

template<int n>

v_reg< double, n/2 > cv::v_dotprod_expand_fast ( const v_reg< int, n > & a, const v_reg< int, n > & b )

inline

#include <opencv2/core/hal/intrin_cpp.hpp>

此函数的调用图如下

v_dotprod_expand_fast() [4/4]

template<int n>

v_reg< double, n/2 > cv::v_dotprod_expand_fast ( const v_reg< int, n > & a, const v_reg< int, n > & b, const v_reg< double, n/2 > & c )

inline

#include <opencv2/core/hal/intrin_cpp.hpp>

此函数的调用图如下

v_dotprod_fast() [1/2]

template<typename _Tp , int n>

v_reg< typename V_TypeTraits< _Tp >::w_type, n/2 > cv::v_dotprod_fast ( const v_reg< _Tp, n > & a, const v_reg< _Tp, n > & b )

inline

#include <opencv2/core/hal/intrin_cpp.hpp>

快速元素的点积。

与 cv::v_dotprod 相同，但在某些平台上它可能会在结果对之间执行无序求和，如果只关心所有通道的总和，并且它在受影响的平台上能提供更好的性能，则可以使用此内在函数。

此函数的调用图如下

v_dotprod_fast() [2/2]

template<typename _Tp , int n>

v_reg< typename V_TypeTraits< _Tp >::w_type, n/2 > cv::v_dotprod_fast ( const v_reg< _Tp, n > & a, const v_reg< _Tp, n > & b, const v_reg< typename V_TypeTraits< _Tp >::w_type, n/2 > & c )

inline

#include <opencv2/core/hal/intrin_cpp.hpp>

快速元素的点积。

与 cv::v_dotprod_fast 相同，但会在相邻对的和中添加第三个元素。

此函数的调用图如下

v_eq()

template<typename _Tp , int n>

v_reg< _Tp, n > cv::v_eq ( const v_reg< _Tp, n > & a, const v_reg< _Tp, n > & b )

inline

#include <opencv2/core/hal/intrin_cpp.hpp>

相等比较。

v_erf()

template<typename _Tp , int n>

v_reg< _Tp, n > cv::v_erf ( const v_reg< _Tp, n > & a )

inline

#include <opencv2/core/hal/intrin_cpp.hpp>

误差函数。

注意

目前支持 FP32 精度。

v_exp()

template<typename _Tp , int n>

v_reg< _Tp, n > cv::v_exp ( const v_reg< _Tp, n > & a )

inline

#include <opencv2/core/hal/intrin_cpp.hpp>

元素的指数 \( e^x \)。

仅适用于浮点类型。核心实现步骤

1. 分解输入：将输入转换为 \( 2^{x \cdot \log_2e} \)，并将其指数部分拆分为整数部分和分数部分：\( x \cdot \log_2e = n + f \)，其中 \( n \) 是整数部分，\( f \) 是分数部分。
2. 计算 \( 2^n \)：通过位移计算得出。
3. 调整小数部分：计算 \( f \cdot \ln2 \) 将小数部分转换为以 \( e \) 为底。\( C1 \) 和 \( C2 \) 用于调整小数部分。
4. \( e^{f \cdot \ln2} \) 的多项式近似：小数部分越接近 0，结果越精确。
   • 对于 float16 和 float32，使用 6 项泰勒级数。
   • 对于 float64，使用 4 项 Padé 多项式近似。
5. 合并结果：将两部分相乘得到最终结果：\( e^x = 2^n \cdot e^{f \cdot \ln2} \)。

注意

计算精度取决于实现和输入向量的数据类型。

v_expand()

template<typename _Tp , int n>

void cv::v_expand ( const v_reg< _Tp, n > & a, v_reg< typename V_TypeTraits< _Tp >::w_type, n/2 > & b0, v_reg< typename V_TypeTraits< _Tp >::w_type, n/2 > & b1 )

inline

#include <opencv2/core/hal/intrin_cpp.hpp>

将值扩展到更宽的打包类型。

将寄存器内容复制到两个具有 2 倍宽封装类型的寄存器。方案

int32x4 int64x2 int64x2
{A B C D} ==> {A B} , {C D}

v_expand_high()

template<typename _Tp , int n>

v_reg< typename V_TypeTraits< _Tp >::w_type, n/2 > cv::v_expand_high ( const v_reg< _Tp, n > & a )

inline

#include <opencv2/core/hal/intrin_cpp.hpp>

将更高值扩展到更宽的打包类型。

与 cv::v_expand_low 相同，但扩展向量的更高一半。

方案

int32x4 int64x2
{A B C D} ==> {C D}

v_expand_low()

template<typename _Tp , int n>

v_reg< typename V_TypeTraits< _Tp >::w_type, n/2 > cv::v_expand_low ( const v_reg< _Tp, n > & a )

inline

#include <opencv2/core/hal/intrin_cpp.hpp>

将更低值扩展到更宽的打包类型。

与 cv::v_expand 相同，但返回向量的较低一半。

方案

int32x4 int64x2
{A B C D} ==> {A B}

v_extract()

template<int s, typename _Tp , int n>

v_reg< _Tp, n > cv::v_extract ( const v_reg< _Tp, n > & a, const v_reg< _Tp, n > & b )

inline

#include <opencv2/core/hal/intrin_cpp.hpp>

向量提取。

方案

{A1 A2 A3 A4}
{B1 B2 B3 B4}
========================
shift = 1 {A2 A3 A4 B1}
shift = 2 {A3 A4 B1 B2}
shift = 3 {A4 B1 B2 B3}

限制：0 <= shift < nlanes

用法

v_int32x4 a, b, c;
c = v_extract<2>(a, b);

适用于所有类型。

v_extract_n()

template<int s, typename _Tp , int n>

_Tp cv::v_extract_n ( const v_reg< _Tp, n > & v )

inline

#include <opencv2/core/hal/intrin_cpp.hpp>

向量提取。

方案：返回 v 的第 s 个元素。限制：0 <= s < nlanes

用法

v_int32x4 a;
int r;
r = v_extract_n<2>(a);

适用于所有类型。

v_floor() [1/2]

template<int n>

v_reg< int, n *2 > cv::v_floor ( const v_reg< double, n > & a )

inline

#include <opencv2/core/hal/intrin_cpp.hpp>

这是为方便而提供的重载成员函数。它与上述函数的唯一区别在于其接受的参数。

此函数的调用图如下

v_floor() [2/2]

template<int n>

v_reg< int, n > cv::v_floor ( const v_reg< float, n > & a )

inline

#include <opencv2/core/hal/intrin_cpp.hpp>

向下取整元素。

对每个值进行向下取整。输入类型为浮点向量 ==> 输出类型为整数向量。

注意

仅适用于浮点类型。

此函数的调用图如下

v_fma()

template<typename _Tp , int n>

v_reg< _Tp, n > cv::v_fma ( const v_reg< _Tp, n > & a, const v_reg< _Tp, n > & b, const v_reg< _Tp, n > & c )

inline

#include <opencv2/core/hal/intrin_cpp.hpp>

乘加运算。

返回 \( a*b + c \)。仅适用于浮点类型和有符号 32 位整数。

v_ge()

template<typename _Tp , int n>

v_reg< _Tp, n > cv::v_ge ( const v_reg< _Tp, n > & a, const v_reg< _Tp, n > & b )

inline

#include <opencv2/core/hal/intrin_cpp.hpp>

大于或等于比较。

适用于除 64 位整数值之外的所有类型。

v_gt()

template<typename _Tp , int n>

v_reg< _Tp, n > cv::v_gt ( const v_reg< _Tp, n > & a, const v_reg< _Tp, n > & b )

inline

#include <opencv2/core/hal/intrin_cpp.hpp>

大于比较。

适用于除 64 位整数值之外的所有类型。

v_interleave_pairs()

template<typename _Tp , int n>

v_reg< _Tp, n > cv::v_interleave_pairs ( const v_reg< _Tp, n > & vec )

inline

#include <opencv2/core/hal/intrin_cpp.hpp>

v_interleave_quads()

template<typename _Tp , int n>

v_reg< _Tp, n > cv::v_interleave_quads ( const v_reg< _Tp, n > & vec )

inline

#include <opencv2/core/hal/intrin_cpp.hpp>

v_invsqrt()

template<typename _Tp , int n>

v_reg< _Tp, n > cv::v_invsqrt ( const v_reg< _Tp, n > & a )

inline

#include <opencv2/core/hal/intrin_cpp.hpp>

平方根倒数。

返回 \( 1/sqrt(a) \)。仅适用于浮点类型。

v_le()

template<typename _Tp , int n>

v_reg< _Tp, n > cv::v_le ( const v_reg< _Tp, n > & a, const v_reg< _Tp, n > & b )

inline

#include <opencv2/core/hal/intrin_cpp.hpp>

小于或等于比较。

适用于除 64 位整数值之外的所有类型。

v_load()

template<typename _Tp >

v_reg< _Tp, simd128_width/sizeof(_Tp)> cv::v_load ( const _Tp * ptr )

inline

#include <opencv2/core/hal/intrin_cpp.hpp>

从内存加载寄存器内容。

参数

ptr

指向内存块的指针

返回

寄存器对象

注意

返回类型将根据传入的指针类型检测，例如 uchar ==> cv::v_uint8x16，int ==> cv::v_int32x4 等。

使用 vx_load 版本以获得最大可用寄存器长度结果

对齐要求：如果 CV_STRONG_ALIGNMENT=1，则传入的指针必须对齐（`sizeof(lane type)` 应该足够）。不要在没有运行时检查指针对齐（例如 `uchar*` => `int*`）的情况下进行指针类型转换。

此函数的调用图如下

v_load_aligned()

template<typename _Tp >

v_reg< _Tp, simd128_width/sizeof(_Tp)> cv::v_load_aligned ( const _Tp * ptr )

inline

#include <opencv2/core/hal/intrin_cpp.hpp>

从内存加载寄存器内容（对齐）

类似于 cv::v_load，但源内存块应进行对齐（SIMD128 的情况为 16 字节对齐，SIMD256 为 32 字节对齐等）

注意

使用 vx_load_aligned 版本以获得最大可用寄存器长度结果

此函数的调用图如下

v_load_deinterleave() [1/3]

template<typename _Tp , int n>

void cv::v_load_deinterleave ( const _Tp * ptr, v_reg< _Tp, n > & a, v_reg< _Tp, n > & b )

inline

#include <opencv2/core/hal/intrin_cpp.hpp>

加载和解交错（2通道）

从内存中加载数据并解交错存储到 2 个寄存器。方案

{A1 B1 A2 B2 ...} ==> {A1 A2 ...}, {B1 B2 ...}

适用于除64位以外的所有类型。

此函数的调用图如下

v_load_deinterleave() [2/3]

template<typename _Tp , int n>

void cv::v_load_deinterleave ( const _Tp * ptr, v_reg< _Tp, n > & a, v_reg< _Tp, n > & b, v_reg< _Tp, n > & c )

inline

#include <opencv2/core/hal/intrin_cpp.hpp>

加载和解交错（3通道）

从内存中加载数据并解交错存储到 3 个寄存器。方案

{A1 B1 C1 A2 B2 C2 ...} ==> {A1 A2 ...}, {B1 B2 ...}, {C1 C2 ...}

适用于除64位以外的所有类型。

此函数的调用图如下

v_load_deinterleave() [3/3]

template<typename _Tp , int n>

void cv::v_load_deinterleave ( const _Tp * ptr, v_reg< _Tp, n > & a, v_reg< _Tp, n > & b, v_reg< _Tp, n > & c, v_reg< _Tp, n > & d )

inline

#include <opencv2/core/hal/intrin_cpp.hpp>

加载和解交错（4通道）

从内存中加载数据并解交错存储到 4 个寄存器。方案

{A1 B1 C1 D1 A2 B2 C2 D2 ...} ==> {A1 A2 ...}, {B1 B2 ...}, {C1 C2 ...}, {D1 D2 ...}

适用于除64位以外的所有类型。

此函数的调用图如下

v_load_expand() [1/2]

template<typename _Tp >

v_reg< typename V_TypeTraits< _Tp >::w_type, simd128_width/sizeof(typename V_TypeTraits< _Tp >::w_type)> cv::v_load_expand ( const _Tp * ptr )

inline

#include <opencv2/core/hal/intrin_cpp.hpp>

从内存加载寄存器内容并双重扩展。

与 cv::v_load 相同，但结果封装类型将是内存类型的 2 倍宽。

short buf[4] = {1, 2, 3, 4}; // 类型为 int16
v_int32x4 r = v_load_expand(buf); // r = {1, 2, 3, 4} - 类型为 int32

适用于 8 位、16 位、32 位整数源类型。

注意

使用 vx_load_expand 版本以获得最大可用寄存器长度结果

此函数的调用图如下

v_load_expand() [2/2]

v_reg< float, simd128_width/sizeof(float)> cv::v_load_expand ( const hfloat * ptr )

inline

#include <opencv2/core/hal/intrin_cpp.hpp>

v_load_expand_q()

template<typename _Tp >

v_reg< typename V_TypeTraits< _Tp >::q_type, simd128_width/sizeof(typename V_TypeTraits< _Tp >::q_type)> cv::v_load_expand_q ( const _Tp * ptr )

inline

#include <opencv2/core/hal/intrin_cpp.hpp>

从内存加载寄存器内容并四重扩展。

与 cv::v_load_expand 相同，但结果类型是源类型的 4 倍宽。

char buf[4] = {1, 2, 3, 4}; // 类型为 int8
v_int32x4 r = v_load_expand_q(buf); // r = {1, 2, 3, 4} - 类型为 int32

适用于 8 位整数源类型。

注意

使用 vx_load_expand_q 版本以获得最大可用寄存器长度结果

此函数的调用图如下

v_load_halves()

template<typename _Tp >

v_reg< _Tp, simd128_width/sizeof(_Tp)> cv::v_load_halves ( const _Tp * loptr, const _Tp * hiptr )

inline

#include <opencv2/core/hal/intrin_cpp.hpp>

从两个内存块加载寄存器内容。

参数

loptr	包含前半部分数据 (0..n/2) 的内存块
hiptr	包含后半部分数据 (n/2..n) 的内存块

int lo[2] = { 1, 2 }, hi[2] = { 3, 4 };
v_int32x4 r = v_load_halves(lo, hi);

注意

使用 vx_load_halves 版本以获得最大可用寄存器长度结果

此函数的调用图如下

v_load_low()

template<typename _Tp >

v_reg< _Tp, simd128_width/sizeof(_Tp)> cv::v_load_low ( const _Tp * ptr )

inline

#include <opencv2/core/hal/intrin_cpp.hpp>

加载64位数据到低位部分（高位部分未定义）。

参数

ptr	包含前半部分数据 (0..n/2) 的内存块

int lo[2] = { 1, 2 };
v_int32x4 r = v_load_low(lo);

注意

使用 vx_load_low 版本以获得最大可用寄存器长度结果

此函数的调用图如下

v_log()

template<typename _Tp , int n>

v_reg< _Tp, n > cv::v_log ( const v_reg< _Tp, n > & a )

inline

#include <opencv2/core/hal/intrin_cpp.hpp>

元素的自然对数 \( \log(x) \)。

仅适用于浮点类型。核心实现步骤

1. 分解输入：使用二进制表示将输入分解为尾数部分 \( m \) 和指数部分 \( e \)。使得 \( \log(x) = \log(m \cdot 2^e) = \log(m) + e \cdot \ln(2) \)。
2. 调整尾数和指数部分：如果尾数小于 \( \sqrt{0.5} \)，则调整指数和尾数以确保尾数在 \( (\sqrt{0.5}, \sqrt{2}) \) 范围内，以获得更好的近似。
3. \( \log(m) \) 的多项式近似：\( m \) 越接近 1，结果越精确。
   • 对于 float16 和 float32，使用 9 项泰勒级数。
   • 对于 float64，使用 6 项 Padé 多项式近似。
4. 合并结果：将两部分相加得到最终结果。

注意

计算精度取决于实现和输入数据类型。

类似于 std::log() 的行为，\( \ln(0) = -\infty \)。

v_lt()

template<typename _Tp , int n>

v_reg< _Tp, n > cv::v_lt ( const v_reg< _Tp, n > & a, const v_reg< _Tp, n > & b )

inline

#include <opencv2/core/hal/intrin_cpp.hpp>

小于比较。

适用于除 64 位整数值之外的所有类型。

v_lut() [1/5]

template<typename _Tp >

v_reg< _Tp, simd128_width/sizeof(_Tp)> cv::v_lut ( const _Tp * tab, const int * idx )

inline

#include <opencv2/core/hal/intrin_cpp.hpp>

v_lut() [2/5]

template<int n>

v_reg< double, n/2 > cv::v_lut ( const double * tab, const v_reg< int, n > & idx )

inline

#include <opencv2/core/hal/intrin_cpp.hpp>

v_lut() [3/5]

template<int n>

v_reg< float, n > cv::v_lut ( const float * tab, const v_reg< int, n > & idx )

inline

#include <opencv2/core/hal/intrin_cpp.hpp>

v_lut() [4/5]

template<int n>

v_reg< int, n > cv::v_lut ( const int * tab, const v_reg< int, n > & idx )

inline

#include <opencv2/core/hal/intrin_cpp.hpp>

v_lut() [5/5]

template<int n>

v_reg< unsigned, n > cv::v_lut ( const unsigned * tab, const v_reg< int, n > & idx )

inline

#include <opencv2/core/hal/intrin_cpp.hpp>

v_lut_deinterleave() [1/2]

template<int n>

void cv::v_lut_deinterleave ( const double * tab, const v_reg< int, n *2 > & idx, v_reg< double, n > & x, v_reg< double, n > & y )

inline

#include <opencv2/core/hal/intrin_cpp.hpp>

v_lut_deinterleave() [2/2]

template<int n>

void cv::v_lut_deinterleave ( const float * tab, const v_reg< int, n > & idx, v_reg< float, n > & x, v_reg< float, n > & y )

inline

#include <opencv2/core/hal/intrin_cpp.hpp>

v_lut_pairs()

template<typename _Tp >

v_reg< _Tp, simd128_width/sizeof(_Tp)> cv::v_lut_pairs ( const _Tp * tab, const int * idx )

inline

#include <opencv2/core/hal/intrin_cpp.hpp>

v_lut_quads()

template<typename _Tp >

v_reg< _Tp, simd128_width/sizeof(_Tp)> cv::v_lut_quads ( const _Tp * tab, const int * idx )

inline

#include <opencv2/core/hal/intrin_cpp.hpp>

v_magnitude()

template<typename _Tp , int n>

v_reg< _Tp, n > cv::v_magnitude ( const v_reg< _Tp, n > & a, const v_reg< _Tp, n > & b )

inline

#include <opencv2/core/hal/intrin_cpp.hpp>

幅值。

返回 \( sqrt(a^2 + b^2) \)。仅适用于浮点类型。

v_matmul()

template<int n>

v_reg< float, n > cv::v_matmul ( const v_reg< float, n > & v, const v_reg< float, n > & a, const v_reg< float, n > & b, const v_reg< float, n > & c, const v_reg< float, n > & d )

inline

#include <opencv2/core/hal/intrin_cpp.hpp>

矩阵乘法。

方案

{A0 A1 A2 A3} |V0|
{B0 B1 B2 B3} |V1|
{C0 C1 C2 C3} |V2|
{D0 D1 D2 D3} x |V3|
====================
{R0 R1 R2 R3}, where
R0 = A0V0 + B0V1 + C0V2 + D0V3,
R1 = A1V0 + B1V1 + C1V2 + D1V3
...

v_matmuladd()

template<int n>

v_reg< float, n > cv::v_matmuladd ( const v_reg< float, n > & v, const v_reg< float, n > & a, const v_reg< float, n > & b, const v_reg< float, n > & c, const v_reg< float, n > & d )

inline

#include <opencv2/core/hal/intrin_cpp.hpp>

矩阵乘加。

方案

{A0 A1 A2 A3} |V0| |D0|
{B0 B1 B2 B3} |V1| |D1|
{C0 C1 C2 C3} x |V2| + |D2|
==================== |D3|
{R0 R1 R2 R3}, where
R0 = A0V0 + B0V1 + C0V2 + D0,
R1 = A1V0 + B1V1 + C1V2 + D1
...

v_max()

template<typename _Tp , int n>

v_reg< _Tp, n > cv::v_max ( const v_reg< _Tp, n > & a, const v_reg< _Tp, n > & b )

inline

#include <opencv2/core/hal/intrin_cpp.hpp>

为每对选择最大值。

方案

{A1 A2 ...}
{B1 B2 ...}
--------------
{max(A1,B1) max(A2,B2) ...}

适用于除 64 位整数之外的所有类型。

v_min()

template<typename _Tp , int n>

v_reg< _Tp, n > cv::v_min ( const v_reg< _Tp, n > & a, const v_reg< _Tp, n > & b )

inline

#include <opencv2/core/hal/intrin_cpp.hpp>

为每对选择最小值。

方案

{A1 A2 ...}
{B1 B2 ...}
--------------
{min(A1,B1) min(A2,B2) ...}

适用于除 64 位整数之外的所有类型。

v_mul()

template<typename _Tp , int n>

v_reg< _Tp, n > cv::v_mul	(	const v_reg< _Tp, n > &	a,
		const v_reg< _Tp, n > &	b )

#include <opencv2/core/hal/intrin_cpp.hpp>

乘法。

适用于 16 位和 32 位整数类型以及浮点类型。

v_mul_expand()

template<typename _Tp , int n>

void cv::v_mul_expand ( const v_reg< _Tp, n > & a, const v_reg< _Tp, n > & b, v_reg< typename V_TypeTraits< _Tp >::w_type, n/2 > & c, v_reg< typename V_TypeTraits< _Tp >::w_type, n/2 > & d )

inline

#include <opencv2/core/hal/intrin_cpp.hpp>

乘法并扩展。

将两个寄存器中的值相乘，并将结果存储到两个具有更宽封装类型的寄存器中。方案

{A B C D} // 32-bit
x {E F G H} // 32-bit
---------------
{AE BF} // 64-bit
{CG DH} // 64-bit

示例

v_uint32x4 a, b; // {1,2,3,4} 和 {2,2,2,2}
v_uint64x2 c, d; // 结果
v_mul_expand(a, b, c, d); // c, d = {2,4}, {6, 8}

仅适用于 16 位和无符号 32 位源类型 (v_int16x8, v_uint16x8, v_uint32x4)。

v_mul_hi()

template<typename _Tp , int n>

v_reg< _Tp, n > cv::v_mul_hi ( const v_reg< _Tp, n > & a, const v_reg< _Tp, n > & b )

inline

#include <opencv2/core/hal/intrin_cpp.hpp>

乘法并提取高位部分。

将两个寄存器中的值相乘并存储结果的高位部分。仅适用于 16 位源类型 (v_int16x8, v_uint16x8)。返回 \( a*b >> 16 \)

v_mul_wrap()

template<typename _Tp , int n>

v_reg< _Tp, n > cv::v_mul_wrap ( const v_reg< _Tp, n > & a, const v_reg< _Tp, n > & b )

inline

#include <opencv2/core/hal/intrin_cpp.hpp>

无饱和乘法。

适用于8位和16位整数值。

v_muladd()

template<typename _Tp , int n>

v_reg< _Tp, n > cv::v_muladd ( const v_reg< _Tp, n > & a, const v_reg< _Tp, n > & b, const v_reg< _Tp, n > & c )

inline

#include <opencv2/core/hal/intrin_cpp.hpp>

v_fma 的同义词。

此函数的调用图如下

v_ne()

template<typename _Tp , int n>

v_reg< _Tp, n > cv::v_ne ( const v_reg< _Tp, n > & a, const v_reg< _Tp, n > & b )

inline

#include <opencv2/core/hal/intrin_cpp.hpp>

不相等比较。

v_not()

template<typename _Tp , int n>

v_reg< _Tp, n > cv::v_not

(

const v_reg< _Tp, n > &

a

)

#include <opencv2/core/hal/intrin_cpp.hpp>

按位非。

仅适用于整数类型。

v_not_nan() [1/2]

template<int n>

v_reg< double, n > cv::v_not_nan ( const v_reg< double, n > & a )

inline

#include <opencv2/core/hal/intrin_cpp.hpp>

v_not_nan() [2/2]

template<int n>

v_reg< float, n > cv::v_not_nan ( const v_reg< float, n > & a )

inline

#include <opencv2/core/hal/intrin_cpp.hpp>

v_or()

template<typename _Tp , int n>

v_reg< _Tp, n > cv::v_or	(	const v_reg< _Tp, n > &	a,
		const v_reg< _Tp, n > &	b )

#include <opencv2/core/hal/intrin_cpp.hpp>

按位或。

仅适用于整数类型。

v_pack() [1/6]

template<int n>

v_reg< short, 2 *n > cv::v_pack ( const v_reg< int, n > & a, const v_reg< int, n > & b )

inline

#include <opencv2/core/hal/intrin_cpp.hpp>

v_pack() [2/6]

template<int n>

v_reg< int, 2 *n > cv::v_pack ( const int64, n > & a, const int64, n > & b )

inline

#include <opencv2/core/hal/intrin_cpp.hpp>

v_pack() [3/6]

template<int n>

v_reg< schar, 2 *n > cv::v_pack ( const v_reg< short, n > & a, const v_reg< short, n > & b )

inline

#include <opencv2/core/hal/intrin_cpp.hpp>

v_pack() [4/6]

template<int n>

v_reg< unsigned, 2 *n > cv::v_pack ( const v_reg< uint64, n > & a, const v_reg< uint64, n > & b )

inline

#include <opencv2/core/hal/intrin_cpp.hpp>

v_pack() [5/6]

template<int n>

v_reg< ushort, 2 *n > cv::v_pack ( const v_reg< unsigned, n > & a, const v_reg< unsigned, n > & b )

inline

#include <opencv2/core/hal/intrin_cpp.hpp>

v_pack() [6/6]

template<int n>

v_reg< uchar, 2 *n > cv::v_pack ( const v_reg< ushort, n > & a, const v_reg< ushort, n > & b )

inline

#include <opencv2/core/hal/intrin_cpp.hpp>

v_pack_b() [1/3]

template<int n>

v_reg< uchar, 8 *n > cv::v_pack_b ( const v_reg< uint64, n > & a, const v_reg< uint64, n > & b, const v_reg< uint64, n > & c, const v_reg< uint64, n > & d, const v_reg< uint64, n > & e, const v_reg< uint64, n > & hashtableResize(), const v_reg< uint64, n > & g, const v_reg< uint64, n > & h )

inline

#include <opencv2/core/hal/intrin_cpp.hpp>

这是一个重载的成员函数，为方便起见而提供。它与上述函数的区别仅在于其接受的参数。对于 64 位布尔值

方案

a {0xFFFF.. 0}
b {0 0xFFFF..}
c {0xFFFF.. 0}
d {0 0xFFFF..}
 
e {0xFFFF.. 0}
f {0xFFFF.. 0}
g {0 0xFFFF..}
h {0 0xFFFF..}
===============
{
0xFF 0 0 0xFF 0xFF 0 0 0xFF
0xFF 0 0xFF 0 0 0xFF 0 0xFF
}

v_pack_b() [2/3]

template<int n>

v_reg< uchar, 4 *n > cv::v_pack_b ( const v_reg< unsigned, n > & a, const v_reg< unsigned, n > & b, const v_reg< unsigned, n > & c, const v_reg< unsigned, n > & d )

inline

#include <opencv2/core/hal/intrin_cpp.hpp>

这是一个重载的成员函数，为方便起见而提供。它与上述函数的区别仅在于其接受的参数。对于 32 位布尔值

方案

a {0xFFFF.. 0 0 0xFFFF..}
b {0 0xFFFF.. 0xFFFF.. 0}
c {0xFFFF.. 0 0xFFFF.. 0}
d {0 0xFFFF.. 0 0xFFFF..}
===============
{
0xFF 0 0 0xFF 0 0xFF 0xFF 0
0xFF 0 0xFF 0 0 0xFF 0 0xFF
}

v_pack_b() [3/3]

template<int n>

v_reg< uchar, 2 *n > cv::v_pack_b ( const v_reg< ushort, n > & a, const v_reg< ushort, n > & b )

inline

#include <opencv2/core/hal/intrin_cpp.hpp>

！适用于 16 位布尔值

方案

a {0xFFFF 0 0 0xFFFF 0 0xFFFF 0xFFFF 0}
b {0xFFFF 0 0xFFFF 0 0 0xFFFF 0 0xFFFF}
===============
{
0xFF 0 0 0xFF 0 0xFF 0xFF 0
0xFF 0 0xFF 0 0 0xFF 0 0xFF
}

v_pack_store() [1/7]

template<int n>

void cv::v_pack_store ( hfloat * ptr, const v_reg< float, n > & v )

inline

#include <opencv2/core/hal/intrin_cpp.hpp>

v_pack_store() [2/7]

template<int n>

void cv::v_pack_store ( int * ptr, const int64, n > & a )

inline

#include <opencv2/core/hal/intrin_cpp.hpp>

v_pack_store() [3/7]

template<int n>

void cv::v_pack_store ( schar * ptr, const v_reg< short, n > & a )

inline

#include <opencv2/core/hal/intrin_cpp.hpp>

v_pack_store() [4/7]

template<int n>

void cv::v_pack_store ( short * ptr, const v_reg< int, n > & a )

inline

#include <opencv2/core/hal/intrin_cpp.hpp>

v_pack_store() [5/7]

template<int n>

void cv::v_pack_store ( I.at<uchar>(y, x) = saturate_cast<uchar>(r); * ptr, const v_reg< ushort, n > & a )

inline

#include <opencv2/core/hal/intrin_cpp.hpp>

v_pack_store() [6/7]

template<int n>

void cv::v_pack_store ( unsigned * ptr, const v_reg< uint64, n > & a )

inline

#include <opencv2/core/hal/intrin_cpp.hpp>

v_pack_store() [7/7]

template<int n>

void cv::v_pack_store ( ushort * ptr, const v_reg< unsigned, n > & a )

inline

#include <opencv2/core/hal/intrin_cpp.hpp>

v_pack_triplets()

template<typename _Tp , int n>

v_reg< _Tp, n > cv::v_pack_triplets ( const v_reg< _Tp, n > & vec )

inline

#include <opencv2/core/hal/intrin_cpp.hpp>

v_pack_u() [1/2]

template<int n>

v_reg< ushort, 2 *n > cv::v_pack_u ( const v_reg< int, n > & a, const v_reg< int, n > & b )

inline

#include <opencv2/core/hal/intrin_cpp.hpp>

v_pack_u() [2/2]

template<int n>

v_reg< uchar, 2 *n > cv::v_pack_u ( const v_reg< short, n > & a, const v_reg< short, n > & b )

inline

#include <opencv2/core/hal/intrin_cpp.hpp>

v_pack_u_store() [1/2]

template<int n>

void cv::v_pack_u_store ( I.at<uchar>(y, x) = saturate_cast<uchar>(r); * ptr, const v_reg< short, n > & a )

inline

#include <opencv2/core/hal/intrin_cpp.hpp>

v_pack_u_store() [2/2]

template<int n>

void cv::v_pack_u_store ( ushort * ptr, const v_reg< int, n > & a )

inline

#include <opencv2/core/hal/intrin_cpp.hpp>

v_popcount()

template<typename _Tp , int n>

v_reg< typename V_TypeTraits< _Tp >::abs_type, n > cv::v_popcount ( const v_reg< _Tp, n > & a )

inline

#include <opencv2/core/hal/intrin_cpp.hpp>

计算向量通道中的1位数量，并以相应的无符号类型返回结果。

方案

{A1 A2 A3 ...} => {popcount(A1), popcount(A2), popcount(A3), ...}

适用于所有整数类型。

此函数的调用图如下

v_recombine()

template<typename _Tp , int n>

void cv::v_recombine ( const v_reg< _Tp, n > & a, const v_reg< _Tp, n > & b, v_reg< _Tp, n > & low, v_reg< _Tp, n > & high )

inline

#include <opencv2/core/hal/intrin_cpp.hpp>

将两个向量从另外两个向量的低部和高部组合起来。

low = cv::v_combine_low(a, b);
high = cv::v_combine_high(a, b);

v_reduce_max()

template<typename _Tp , int n>

_Tp cv::v_reduce_max ( const v_reg< _Tp, n > & a )

inline

#include <opencv2/core/hal/intrin_cpp.hpp>

查找一个最大值。

方案

{A1 A2 A3 ...} => max(A1,A2,A3,...)

适用于除 64 位整数和 64 位浮点类型之外的所有类型。

v_reduce_min()

template<typename _Tp , int n>

_Tp cv::v_reduce_min ( const v_reg< _Tp, n > & a )

inline

#include <opencv2/core/hal/intrin_cpp.hpp>

查找一个最小值。

方案

{A1 A2 A3 ...} => min(A1,A2,A3,...)

适用于除 64 位整数和 64 位浮点类型之外的所有类型。

v_reduce_sad()

template<typename _Tp , int n>

V_TypeTraits< typenameV_TypeTraits< _Tp >::abs_type >::sum_type cv::v_reduce_sad ( const v_reg< _Tp, n > & a, const v_reg< _Tp, n > & b )

inline

#include <opencv2/core/hal/intrin_cpp.hpp>

值的绝对差之和。

方案

{A1 A2 A3 ...} {B1 B2 B3 ...} => sum{ABS(A1-B1),abs(A2-B2),abs(A3-B3),...}

适用于除 64 位类型之外的所有类型。

v_reduce_sum()

template<typename _Tp , int n>

V_TypeTraits< _Tp >::sum_type cv::v_reduce_sum ( const v_reg< _Tp, n > & a )

inline

#include <opencv2/core/hal/intrin_cpp.hpp>

对打包值求和。

方案

{A1 A2 A3 ...} => sum{A1,A2,A3,...}

v_reduce_sum4()

template<int n>

v_reg< float, n > cv::v_reduce_sum4 ( const v_reg< float, n > & a, const v_reg< float, n > & b, const v_reg< float, n > & c, const v_reg< float, n > & d )

inline

#include <opencv2/core/hal/intrin_cpp.hpp>

求和每个输入向量的所有元素，返回和的向量。

方案

result[0] = a[0] + a[1] + a[2] + a[3]
result[1] = b[0] + b[1] + b[2] + b[3]
result[2] = c[0] + c[1] + c[2] + c[3]
result[3] = d[0] + d[1] + d[2] + d[3]

v_reinterpret_as_f32()

template<typename _Tp0 , int n0>

v_reg< float, n0 *sizeof(_Tp0)/sizeof(float)> cv::v_reinterpret_as_f32 ( const v_reg< _Tp0, n0 > & a )

inline

#include <opencv2/core/hal/intrin_cpp.hpp>

v_reinterpret_as_f64()

template<typename _Tp0 , int n0>

v_reg< double, n0 *sizeof(_Tp0)/sizeof(double)> cv::v_reinterpret_as_f64 ( const v_reg< _Tp0, n0 > & a )

inline

#include <opencv2/core/hal/intrin_cpp.hpp>

v_reinterpret_as_s16()

template<typename _Tp0 , int n0>

v_reg< short, n0 *sizeof(_Tp0)/sizeof(short)> cv::v_reinterpret_as_s16 ( const v_reg< _Tp0, n0 > & a )

inline

#include <opencv2/core/hal/intrin_cpp.hpp>

v_reinterpret_as_s32()

template<typename _Tp0 , int n0>

v_reg< int, n0 *sizeof(_Tp0)/sizeof(int)> cv::v_reinterpret_as_s32 ( const v_reg< _Tp0, n0 > & a )

inline

#include <opencv2/core/hal/intrin_cpp.hpp>

v_reinterpret_as_s64()

template<typename _Tp0 , int n0>

v_reg< int64, n0 *sizeof(_Tp0)/sizeof(int64)> cv::v_reinterpret_as_s64 ( const v_reg< _Tp0, n0 > & a )

inline

#include <opencv2/core/hal/intrin_cpp.hpp>

v_reinterpret_as_s8()

template<typename _Tp0 , int n0>

v_reg< schar, n0 *sizeof(_Tp0)/sizeof(schar)> cv::v_reinterpret_as_s8 ( const v_reg< _Tp0, n0 > & a )

inline

#include <opencv2/core/hal/intrin_cpp.hpp>

v_reinterpret_as_u16()

template<typename _Tp0 , int n0>

v_reg< ushort, n0 *sizeof(_Tp0)/sizeof(ushort)> cv::v_reinterpret_as_u16 ( const v_reg< _Tp0, n0 > & a )

inline

#include <opencv2/core/hal/intrin_cpp.hpp>

v_reinterpret_as_u32()

template<typename _Tp0 , int n0>

v_reg< unsigned, n0 *sizeof(_Tp0)/sizeof(unsigned)> cv::v_reinterpret_as_u32 ( const v_reg< _Tp0, n0 > & a )

inline

#include <opencv2/core/hal/intrin_cpp.hpp>

v_reinterpret_as_u64()

template<typename _Tp0 , int n0>

v_reg< uint64, n0 *sizeof(_Tp0)/sizeof(uint64)> cv::v_reinterpret_as_u64 ( const v_reg< _Tp0, n0 > & a )

inline

#include <opencv2/core/hal/intrin_cpp.hpp>

v_reinterpret_as_u8()

template<typename _Tp0 , int n0>

v_reg< uchar, n0 *sizeof(_Tp0)/sizeof(uchar)> cv::v_reinterpret_as_u8 ( const v_reg< _Tp0, n0 > & a )

inline

#include <opencv2/core/hal/intrin_cpp.hpp>

v_reverse()

template<typename _Tp , int n>

v_reg< _Tp, n > cv::v_reverse ( const v_reg< _Tp, n > & a )

inline

#include <opencv2/core/hal/intrin_cpp.hpp>

向量反序。

反转向量的顺序。方案

REG {A1 ... An} ==> REG {An ... A1}

适用于所有类型。

v_rotate_left() [1/2]

template<int imm, typename _Tp , int n>

v_reg< _Tp, n > cv::v_rotate_left ( const v_reg< _Tp, n > & a )

inline

#include <opencv2/core/hal/intrin_cpp.hpp>

向量内元素左移。

适用于所有类型

v_rotate_left() [2/2]

template<int imm, typename _Tp , int n>

v_reg< _Tp, n > cv::v_rotate_left ( const v_reg< _Tp, n > & a, const v_reg< _Tp, n > & b )

inline

#include <opencv2/core/hal/intrin_cpp.hpp>

v_rotate_right() [1/2]

template<int imm, typename _Tp , int n>

v_reg< _Tp, n > cv::v_rotate_right ( const v_reg< _Tp, n > & a )

inline

#include <opencv2/core/hal/intrin_cpp.hpp>

向量内元素右移。

适用于所有类型

v_rotate_right() [2/2]

template<int imm, typename _Tp , int n>

v_reg< _Tp, n > cv::v_rotate_right ( const v_reg< _Tp, n > & a, const v_reg< _Tp, n > & b )

inline

#include <opencv2/core/hal/intrin_cpp.hpp>

v_round() [1/3]

template<int n>

v_reg< int, n *2 > cv::v_round ( const v_reg< double, n > & a )

inline

#include <opencv2/core/hal/intrin_cpp.hpp>

这是为方便而提供的重载成员函数。它与上述函数的唯一区别在于其接受的参数。

此函数的调用图如下

v_round() [2/3]

template<int n>

v_reg< int, n *2 > cv::v_round ( const v_reg< double, n > & a, const v_reg< double, n > & b )

inline

#include <opencv2/core/hal/intrin_cpp.hpp>

这是为方便而提供的重载成员函数。它与上述函数的唯一区别在于其接受的参数。

此函数的调用图如下

v_round() [3/3]

template<int n>

v_reg< int, n > cv::v_round ( const v_reg< float, n > & a )

inline

#include <opencv2/core/hal/intrin_cpp.hpp>

四舍五入元素。

对每个值进行四舍五入。输入类型为浮点向量 ==> 输出类型为整数向量。

注意

仅适用于浮点类型。

此函数的调用图如下

v_rshr() [1/6]

template<int shift, int n>

v_reg< int, n > cv::v_rshr ( const v_reg< int, n > & a )

inline

#include <opencv2/core/hal/intrin_cpp.hpp>

v_rshr() [2/6]

template<int shift, int n>

v_reg< int64, n > cv::v_rshr ( const int64, n > & a )

inline

#include <opencv2/core/hal/intrin_cpp.hpp>

v_rshr() [3/6]

template<int shift, int n>

v_reg< short, n > cv::v_rshr ( const v_reg< short, n > & a )

inline

#include <opencv2/core/hal/intrin_cpp.hpp>

v_rshr() [4/6]

template<int shift, int n>

v_reg< uint64, n > cv::v_rshr ( const v_reg< uint64, n > & a )

inline

#include <opencv2/core/hal/intrin_cpp.hpp>

v_rshr() [5/6]

template<int shift, int n>

v_reg< unsigned, n > cv::v_rshr ( const v_reg< unsigned, n > & a )

inline

#include <opencv2/core/hal/intrin_cpp.hpp>

v_rshr() [6/6]

template<int shift, int n>

v_reg< ushort, n > cv::v_rshr ( const v_reg< ushort, n > & a )

inline

#include <opencv2/core/hal/intrin_cpp.hpp>

v_rshr_pack() [1/6]

template<int shift, int n>

v_reg< short, 2 *n > cv::v_rshr_pack ( const v_reg< int, n > & a, const v_reg< int, n > & b )

inline

#include <opencv2/core/hal/intrin_cpp.hpp>

v_rshr_pack() [2/6]

template<int shift, int n>

v_reg< int, 2 *n > cv::v_rshr_pack ( const int64, n > & a, const int64, n > & b )

inline

#include <opencv2/core/hal/intrin_cpp.hpp>

v_rshr_pack() [3/6]

template<int shift, int n>

v_reg< schar, 2 *n > cv::v_rshr_pack ( const v_reg< short, n > & a, const v_reg< short, n > & b )

inline

#include <opencv2/core/hal/intrin_cpp.hpp>

v_rshr_pack() [4/6]

template<int shift, int n>

v_reg< unsigned, 2 *n > cv::v_rshr_pack ( const v_reg< uint64, n > & a, const v_reg< uint64, n > & b )

inline

#include <opencv2/core/hal/intrin_cpp.hpp>

v_rshr_pack() [5/6]

template<int shift, int n>

v_reg< ushort, 2 *n > cv::v_rshr_pack ( const v_reg< unsigned, n > & a, const v_reg< unsigned, n > & b )

inline

#include <opencv2/core/hal/intrin_cpp.hpp>

v_rshr_pack() [6/6]

template<int shift, int n>

v_reg< uchar, 2 *n > cv::v_rshr_pack ( const v_reg< ushort, n > & a, const v_reg< ushort, n > & b )

inline

#include <opencv2/core/hal/intrin_cpp.hpp>

v_rshr_pack_store() [1/6]

template<int shift, int n>

void cv::v_rshr_pack_store ( int * ptr, const int64, n > & a )

inline

#include <opencv2/core/hal/intrin_cpp.hpp>

v_rshr_pack_store() [2/6]

template<int shift, int n>

void cv::v_rshr_pack_store ( schar * ptr, const v_reg< short, n > & a )

inline

#include <opencv2/core/hal/intrin_cpp.hpp>

v_rshr_pack_store() [3/6]

template<int shift, int n>

void cv::v_rshr_pack_store ( short * ptr, const v_reg< int, n > & a )

inline

#include <opencv2/core/hal/intrin_cpp.hpp>

v_rshr_pack_store() [4/6]

template<int shift, int n>

void cv::v_rshr_pack_store ( I.at<uchar>(y, x) = saturate_cast<uchar>(r); * ptr, const v_reg< ushort, n > & a )

inline

#include <opencv2/core/hal/intrin_cpp.hpp>

v_rshr_pack_store() [5/6]

template<int shift, int n>

void cv::v_rshr_pack_store ( unsigned * ptr, const v_reg< uint64, n > & a )

inline

#include <opencv2/core/hal/intrin_cpp.hpp>

v_rshr_pack_store() [6/6]

template<int shift, int n>

void cv::v_rshr_pack_store ( ushort * ptr, const v_reg< unsigned, n > & a )

inline

#include <opencv2/core/hal/intrin_cpp.hpp>

v_rshr_pack_u() [1/2]

template<int shift, int n>

v_reg< ushort, 2 *n > cv::v_rshr_pack_u ( const v_reg< int, n > & a, const v_reg< int, n > & b )

inline

#include <opencv2/core/hal/intrin_cpp.hpp>

v_rshr_pack_u() [2/2]

template<int shift, int n>

v_reg< uchar, 2 *n > cv::v_rshr_pack_u ( const v_reg< short, n > & a, const v_reg< short, n > & b )

inline

#include <opencv2/core/hal/intrin_cpp.hpp>

v_rshr_pack_u_store() [1/2]

template<int shift, int n>

void cv::v_rshr_pack_u_store ( I.at<uchar>(y, x) = saturate_cast<uchar>(r); * ptr, const v_reg< short, n > & a )

inline

#include <opencv2/core/hal/intrin_cpp.hpp>

v_rshr_pack_u_store() [2/2]

template<int shift, int n>

void cv::v_rshr_pack_u_store ( ushort * ptr, const v_reg< int, n > & a )

inline

#include <opencv2/core/hal/intrin_cpp.hpp>

v_scan_forward()

template<typename _Tp , int n>

int cv::v_scan_forward ( const v_reg< _Tp, n > & a )

inline

#include <opencv2/core/hal/intrin_cpp.hpp>

获取第一个负通道索引。

返回值为第一个负通道的索引（对于所有正数值的输入则未定义）。示例

v_int32x4 r; // 设置为 {0, 0, -1, -1}
int idx = v_heading_zeros(r); // idx = 2

v_select()

template<typename _Tp , int n>

v_reg< _Tp, n > cv::v_select ( const v_reg< _Tp, n > & mask, const v_reg< _Tp, n > & a, const v_reg< _Tp, n > & b )

inline

#include <opencv2/core/hal/intrin_cpp.hpp>

逐元素选择（混合操作）

返回值将通过以下方案组合值 a 和 b 构建：result[i] = mask[i] ? a[i] : b[i];

注意

: mask 元素值仅限于这些值

• 0：从 b 中选择元素
• 0xff/0xffff/etc：从 a 中选择元素（与基于位运算的运算符完全兼容）

v_setall_() [1/10]

template<>

v_float64x2 cv::v_setall_ ( double val )

inline

#include <opencv2/core/hal/intrin_cpp.hpp>

v_setall_() [2/10]

template<>

v_float32x4 cv::v_setall_ ( float val )

inline

#include <opencv2/core/hal/intrin_cpp.hpp>

v_setall_() [3/10]

template<>

v_int32x4 cv::v_setall_ ( int val )

inline

#include <opencv2/core/hal/intrin_cpp.hpp>

v_setall_() [4/10]

template<>

v_int64x2 cv::v_setall_ ( int64 val )

inline

#include <opencv2/core/hal/intrin_cpp.hpp>

v_setall_() [5/10]

template<>

v_int8x16 cv::v_setall_ ( schar val )

inline

#include <opencv2/core/hal/intrin_cpp.hpp>

v_setall_() [6/10]

template<>

v_int16x8 cv::v_setall_ ( short val )

inline

#include <opencv2/core/hal/intrin_cpp.hpp>

v_setall_() [7/10]

template<>

v_uint8x16 cv::v_setall_ ( I.at<uchar>(y, x) = saturate_cast<uchar>(r); val )

inline

#include <opencv2/core/hal/intrin_cpp.hpp>

v_setall_() [8/10]

template<>

v_uint64x2 cv::v_setall_ ( uint64 val )

inline

#include <opencv2/core/hal/intrin_cpp.hpp>

v_setall_() [9/10]

template<>

v_uint32x4 cv::v_setall_ ( unsigned val )

inline

#include <opencv2/core/hal/intrin_cpp.hpp>

v_setall_() [10/10]

template<>

v_uint16x8 cv::v_setall_ ( ushort val )

inline

#include <opencv2/core/hal/intrin_cpp.hpp>

v_setall_f32()

v_float32x4 cv::v_setall_f32 ( float val )

inline

#include <opencv2/core/hal/intrin_cpp.hpp>

v_setall_f64()

v_float64x2 cv::v_setall_f64 ( double val )

inline

#include <opencv2/core/hal/intrin_cpp.hpp>

v_setall_s16()

v_int16x8 cv::v_setall_s16 ( short val )

inline

#include <opencv2/core/hal/intrin_cpp.hpp>

v_setall_s32()

v_int32x4 cv::v_setall_s32 ( int val )

inline

#include <opencv2/core/hal/intrin_cpp.hpp>

v_setall_s64()

v_int64x2 cv::v_setall_s64 ( int64 val )

inline

#include <opencv2/core/hal/intrin_cpp.hpp>

v_setall_s8()

v_int8x16 cv::v_setall_s8 ( schar val )

inline

#include <opencv2/core/hal/intrin_cpp.hpp>

v_setall_u16()

v_uint16x8 cv::v_setall_u16 ( ushort val )

inline

#include <opencv2/core/hal/intrin_cpp.hpp>

v_setall_u32()

v_uint32x4 cv::v_setall_u32 ( unsigned val )

inline

#include <opencv2/core/hal/intrin_cpp.hpp>

v_setall_u64()

v_uint64x2 cv::v_setall_u64 ( uint64 val )

inline

#include <opencv2/core/hal/intrin_cpp.hpp>

v_setall_u8()

v_uint8x16 cv::v_setall_u8 ( I.at<uchar>(y, x) = saturate_cast<uchar>(r); val )

inline

#include <opencv2/core/hal/intrin_cpp.hpp>

v_setzero_()

template<>

v_uint8x16 cv::v_setzero_ ( )

inline

#include <opencv2/core/hal/intrin_cpp.hpp>

v_setzero_f32()

v_float32x4 cv::v_setzero_f32 ( )

inline

#include <opencv2/core/hal/intrin_cpp.hpp>

v_setzero_f64()

v_float64x2 cv::v_setzero_f64 ( )

inline

#include <opencv2/core/hal/intrin_cpp.hpp>

v_setzero_s16()

v_int16x8 cv::v_setzero_s16 ( )

inline

#include <opencv2/core/hal/intrin_cpp.hpp>

v_setzero_s32()

v_int32x4 cv::v_setzero_s32 ( )

inline

#include <opencv2/core/hal/intrin_cpp.hpp>

v_setzero_s64()

v_int64x2 cv::v_setzero_s64 ( )

inline

#include <opencv2/core/hal/intrin_cpp.hpp>

v_setzero_s8()

v_int8x16 cv::v_setzero_s8 ( )

inline

#include <opencv2/core/hal/intrin_cpp.hpp>

v_setzero_u16()

v_uint16x8 cv::v_setzero_u16 ( )

inline

#include <opencv2/core/hal/intrin_cpp.hpp>

v_setzero_u32()

v_uint32x4 cv::v_setzero_u32 ( )

inline

#include <opencv2/core/hal/intrin_cpp.hpp>

v_setzero_u64()

v_uint64x2 cv::v_setzero_u64 ( )

inline

#include <opencv2/core/hal/intrin_cpp.hpp>

v_setzero_u8()

v_uint8x16 cv::v_setzero_u8 ( )

inline

#include <opencv2/core/hal/intrin_cpp.hpp>

v_shl() [1/7]

template<typename _Tp , int n>

v_reg< _Tp, n > cv::v_shl ( const v_reg< _Tp, n > & a, int imm )

inline

#include <opencv2/core/hal/intrin_cpp.hpp>

按位左移。

适用于 16 位、32 位和 64 位整数值。

v_shl() [2/7]

template<int shift, int n>

v_reg< int, n > cv::v_shl ( const v_reg< int, n > & a )

inline

#include <opencv2/core/hal/intrin_cpp.hpp>

v_shl() [3/7]

template<int shift, int n>

v_reg< int64, n > cv::v_shl ( const int64, n > & a )

inline

#include <opencv2/core/hal/intrin_cpp.hpp>

v_shl() [4/7]

template<int shift, int n>

v_reg< short, n > cv::v_shl ( const v_reg< short, n > & a )

inline

#include <opencv2/core/hal/intrin_cpp.hpp>

v_shl() [5/7]

template<int shift, int n>

v_reg< uint64, n > cv::v_shl ( const v_reg< uint64, n > & a )

inline

#include <opencv2/core/hal/intrin_cpp.hpp>

v_shl() [6/7]

template<int shift, int n>

v_reg< unsigned, n > cv::v_shl ( const v_reg< unsigned, n > & a )

inline

#include <opencv2/core/hal/intrin_cpp.hpp>

v_shl() [7/7]

template<int shift, int n>

v_reg< ushort, n > cv::v_shl ( const v_reg< ushort, n > & a )

inline

#include <opencv2/core/hal/intrin_cpp.hpp>

v_shr() [1/7]

template<typename _Tp , int n>

v_reg< _Tp, n > cv::v_shr ( const v_reg< _Tp, n > & a, int imm )

inline

#include <opencv2/core/hal/intrin_cpp.hpp>

按位右移。

适用于 16 位、32 位和 64 位整数值。

v_shr() [2/7]

template<int shift, int n>

v_reg< int, n > cv::v_shr ( const v_reg< int, n > & a )

inline

#include <opencv2/core/hal/intrin_cpp.hpp>

v_shr() [3/7]

template<int shift, int n>

v_reg< int64, n > cv::v_shr ( const int64, n > & a )

inline

#include <opencv2/core/hal/intrin_cpp.hpp>

v_shr() [4/7]

template<int shift, int n>

v_reg< short, n > cv::v_shr ( const v_reg< short, n > & a )

inline

#include <opencv2/core/hal/intrin_cpp.hpp>

v_shr() [5/7]

template<int shift, int n>

v_reg< uint64, n > cv::v_shr ( const v_reg< uint64, n > & a )

inline

#include <opencv2/core/hal/intrin_cpp.hpp>

v_shr() [6/7]

template<int shift, int n>

v_reg< unsigned, n > cv::v_shr ( const v_reg< unsigned, n > & a )

inline

#include <opencv2/core/hal/intrin_cpp.hpp>

v_shr() [7/7]

template<int shift, int n>

v_reg< ushort, n > cv::v_shr ( const v_reg< ushort, n > & a )

inline

#include <opencv2/core/hal/intrin_cpp.hpp>

v_signmask()

template<typename _Tp , int n>

int cv::v_signmask ( const v_reg< _Tp, n > & a )

inline

#include <opencv2/core/hal/intrin_cpp.hpp>

获取负值掩码。

已弃用

v_signmask 严重依赖于通道计数，因此不够通用

返回值为一个位掩码，其位在对应负打包值索引的位置设置为 1。示例

v_int32x4 r; // 设置为 {-1, -1, 1, 1}
int mask = v_signmask(r); // mask = 3 <== 00000000 00000000 00000000 00000011

v_sin()

template<typename _Tp , int n>

v_reg< _Tp, n > cv::v_sin ( const v_reg< _Tp, n > & a )

inline

#include <opencv2/core/hal/intrin_cpp.hpp>

元素的正弦 \( sin(x) \)。

仅适用于浮点类型。核心实现与 v_sincos 相同。

v_sincos()

template<typename _Tp , int n>

void cv::v_sincos ( const v_reg< _Tp, n > & x, v_reg< _Tp, n > & s, v_reg< _Tp, n > & c )

inline

#include <opencv2/core/hal/intrin_cpp.hpp>

同时计算元素的正弦 \( sin(x) \) 和余弦 \( cos(x) \) 。

仅适用于浮点类型。核心实现步骤

1. 输入归一化：将周期性从 2π 缩放到 4，并利用周期性和三角恒等式将角度减小到 \( [0, \frac{\pi}{4}] \) 范围。
2. \( sin(x) \) 和 \( cos(x) \) 的多项式近似
   • 对于 float16 和 float32，正弦使用 4 项泰勒级数，余弦使用 5 项泰勒级数。
   • 对于 float64，正弦使用 7 项泰勒级数，余弦使用 8 项泰勒级数。
3. 选择结果：选择并转换原始输入角度的最终正弦和余弦值。

注意

计算精度取决于实现和输入向量的数据类型。

v_sqr_magnitude()

template<typename _Tp , int n>

v_reg< _Tp, n > cv::v_sqr_magnitude ( const v_reg< _Tp, n > & a, const v_reg< _Tp, n > & b )

inline

#include <opencv2/core/hal/intrin_cpp.hpp>

幅值的平方。

返回 \( a^2 + b^2 \)。仅适用于浮点类型。

v_sqrt()

template<typename _Tp , int n>

v_reg< _Tp, n > cv::v_sqrt ( const v_reg< _Tp, n > & a )

inline

#include <opencv2/core/hal/intrin_cpp.hpp>

元素的平方根。

仅适用于浮点类型。

v_store() [1/2]

template<typename _Tp , int n>

void cv::v_store ( 包装自定义类型的辅助函数。 * ptr, const v_reg< _Tp, n > & a )

inline

#include <opencv2/core/hal/intrin_cpp.hpp>

将数据存储到内存。

将寄存器内容存储到内存。方案

REG {A B C D} ==> MEM {A B C D}

指针可以不对齐。

此函数的调用图如下

v_store() [2/2]

template<typename _Tp , int n>

void cv::v_store ( 包装自定义类型的辅助函数。 * ptr, const v_reg< _Tp, n > & a, hal::StoreMode  )

inline

#include <opencv2/core/hal/intrin_cpp.hpp>

此函数的调用图如下

v_store_aligned() [1/2]

template<typename _Tp , int n>

void cv::v_store_aligned ( 包装自定义类型的辅助函数。 * ptr, const v_reg< _Tp, n > & a )

inline

#include <opencv2/core/hal/intrin_cpp.hpp>

将数据存储到内存（对齐）

将寄存器内容存储到内存。方案

REG {A B C D} ==> MEM {A B C D}

指针应按 16 字节边界对齐。

此函数的调用图如下

v_store_aligned() [2/2]

template<typename _Tp , int n>

void cv::v_store_aligned ( 包装自定义类型的辅助函数。 * ptr, const v_reg< _Tp, n > & a, hal::StoreMode  )

inline

#include <opencv2/core/hal/intrin_cpp.hpp>

此函数的调用图如下

v_store_aligned_nocache()

template<typename _Tp , int n>

void cv::v_store_aligned_nocache ( 包装自定义类型的辅助函数。 * ptr, const v_reg< _Tp, n > & a )

inline

#include <opencv2/core/hal/intrin_cpp.hpp>

此函数的调用图如下

v_store_high()

template<typename _Tp , int n>

void cv::v_store_high ( 包装自定义类型的辅助函数。 * ptr, const v_reg< _Tp, n > & a )

inline

#include <opencv2/core/hal/intrin_cpp.hpp>

将数据存储到内存（高位半部）

将寄存器内容的高半部分存储到内存。方案

REG {A B C D} ==> MEM {C D}

此函数的调用图如下

v_store_interleave() [1/3]

template<typename _Tp , int n>

void cv::v_store_interleave ( 包装自定义类型的辅助函数。 * ptr, const v_reg< _Tp, n > & a, const v_reg< _Tp, n > & b, const v_reg< _Tp, n > & c, const v_reg< _Tp, n > & d, hal::StoreMode = hal::STORE_UNALIGNED )

inline

#include <opencv2/core/hal/intrin_cpp.hpp>

交错并存储（4通道）

交错并存储来自 4 个寄存器的数据到内存。方案

{A1 A2 ...}, {B1 B2 ...}, {C1 C2 ...}, {D1 D2 ...} ==> {A1 B1 C1 D1 A2 B2 C2 D2 ...}

适用于除64位以外的所有类型。

此函数的调用图如下

v_store_interleave() [2/3]

template<typename _Tp , int n>

void cv::v_store_interleave ( 包装自定义类型的辅助函数。 * ptr, const v_reg< _Tp, n > & a, const v_reg< _Tp, n > & b, const v_reg< _Tp, n > & c, hal::StoreMode = hal::STORE_UNALIGNED )

inline

#include <opencv2/core/hal/intrin_cpp.hpp>

交错并存储（3通道）

交错并存储来自 3 个寄存器的数据到内存。方案

{A1 A2 ...}, {B1 B2 ...}, {C1 C2 ...} ==> {A1 B1 C1 A2 B2 C2 ...}

适用于除64位以外的所有类型。

此函数的调用图如下

v_store_interleave() [3/3]

template<typename _Tp , int n>

void cv::v_store_interleave ( 包装自定义类型的辅助函数。 * ptr, const v_reg< _Tp, n > & a, const v_reg< _Tp, n > & b, hal::StoreMode = hal::STORE_UNALIGNED )

inline

#include <opencv2/core/hal/intrin_cpp.hpp>

交错并存储（2通道）

交错并存储来自 2 个寄存器的数据到内存。方案

{A1 A2 ...}, {B1 B2 ...} ==> {A1 B1 A2 B2 ...}

适用于除64位以外的所有类型。

此函数的调用图如下

v_store_low()

template<typename _Tp , int n>

void cv::v_store_low ( 包装自定义类型的辅助函数。 * ptr, const v_reg< _Tp, n > & a )

inline

#include <opencv2/core/hal/intrin_cpp.hpp>

将数据存储到内存（低位半部）

将寄存器内容的低半部分存储到内存。方案

REG {A B C D} ==> MEM {A B}

此函数的调用图如下

v_sub()

template<typename _Tp , int n>

v_reg< _Tp, n > cv::v_sub	(	const v_reg< _Tp, n > &	a,
		const v_reg< _Tp, n > &	b )

#include <opencv2/core/hal/intrin_cpp.hpp>

减法。

适用于所有类型。

v_sub_wrap()

template<typename _Tp , int n>

v_reg< _Tp, n > cv::v_sub_wrap ( const v_reg< _Tp, n > & a, const v_reg< _Tp, n > & b )

inline

#include <opencv2/core/hal/intrin_cpp.hpp>

无饱和减法。

适用于8位和16位整数值。

v_transpose4x4()

template<typename _Tp , int n>

void cv::v_transpose4x4 ( v_reg< _Tp, n > & a0, const v_reg< _Tp, n > & noArray(), const v_reg< _Tp, n > & a2, const v_reg< _Tp, n > & a3, v_reg< _Tp, n > & b0, v_reg< _Tp, n > & b1, v_reg< _Tp, n > & b2, v_reg< _Tp, n > & b3 )

inline

#include <opencv2/core/hal/intrin_cpp.hpp>

转置4x4矩阵。

方案

a0 {A1 A2 A3 A4}
a1 {B1 B2 B3 B4}
a2 {C1 C2 C3 C4}
a3 {D1 D2 D3 D4}
===============
b0 {A1 B1 C1 D1}
b1 {A2 B2 C2 D2}
b2 {A3 B3 C3 D3}
b3 {A4 B4 C4 D4}

v_trunc() [1/2]

template<int n>

v_reg< int, n *2 > cv::v_trunc ( const v_reg< double, n > & a )

inline

#include <opencv2/core/hal/intrin_cpp.hpp>

这是为方便而提供的重载成员函数。它与上述函数的唯一区别在于其接受的参数。

v_trunc() [2/2]

template<int n>

v_reg< int, n > cv::v_trunc ( const v_reg< float, n > & a )

inline

#include <opencv2/core/hal/intrin_cpp.hpp>

截断元素。

截断每个值。输入类型为浮点向量 ==> 输出类型为整数向量。

注意

仅适用于浮点类型。

v_xor()

template<typename _Tp , int n>

v_reg< _Tp, n > cv::v_xor	(	const v_reg< _Tp, n > &	a,
		const v_reg< _Tp, n > &	b )

#include <opencv2/core/hal/intrin_cpp.hpp>

按位异或。

仅适用于整数类型。

v_zip()

template<typename _Tp , int n>

void cv::v_zip ( const v_reg< _Tp, n > & a0, const v_reg< _Tp, n > & noArray(), v_reg< _Tp, n > & b0, v_reg< _Tp, n > & b1 )

inline

#include <opencv2/core/hal/intrin_cpp.hpp>

交错两个向量。

方案

{A1 A2 A3 A4}
{B1 B2 B3 B4}
---------------
{A1 B1 A2 B2} and {A3 B3 A4 B4}

适用于除64位以外的所有类型。

变量文档

popCountTable

const unsigned char cv::popCountTable[]

static

#include <opencv2/core/hal/intrin_cpp.hpp>

初始值

=
{
    0, 1, 1, 2, 1, 2, 2, 3, 1, 2, 2, 3, 2, 3, 3, 4,
    1, 2, 2, 3, 2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5,
    1, 2, 2, 3, 2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5,
    2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6,
    1, 2, 2, 3, 2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5,
    2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6,
    2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6,
    3, 4, 4, 5, 4, 5, 5, 6, 4, 5, 5, 6, 5, 6, 6, 7,
    1, 2, 2, 3, 2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5,
    2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6,
    2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6,
    3, 4, 4, 5, 4, 5, 5, 6, 4, 5, 5, 6, 5, 6, 6, 7,
    2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6,
    3, 4, 4, 5, 4, 5, 5, 6, 4, 5, 5, 6, 5, 6, 6, 7,
    3, 4, 4, 5, 4, 5, 5, 6, 4, 5, 5, 6, 5, 6, 6, 7,
    4, 5, 5, 6, 5, 6, 6, 7, 5, 6, 6, 7, 6, 7, 7, 8,
}