OpenCV  4.1.0
Open Source Computer Vision
Modules | Classes | Macros | Typedefs | Functions | Variables
Universal intrinsics

Modules

 Private implementation helpers
 

Classes

struct  cv::v_reg< _Tp, n >
 

Macros

#define OPENCV_HAL_IMPL_ROTATE_SHIFT_OP(suffix, opA, opB)
 Element shift left among vector.
 

Typedefs

typedef v_reg< float, 4 > cv::v_float32x4
 Four 32-bit floating point values (single precision)
 
typedef v_reg< double, 2 > cv::v_float64x2
 Two 64-bit floating point values (double precision)
 
typedef v_reg< short, 8 > cv::v_int16x8
 Eight 16-bit signed integer values.
 
typedef v_reg< int, 4 > cv::v_int32x4
 Four 32-bit signed integer values.
 
typedef v_reg< int64, 2 > cv::v_int64x2
 Two 64-bit signed integer values.
 
typedef v_reg< schar, 16 > cv::v_int8x16
 Sixteen 8-bit signed integer values.
 
typedef v_reg< ushort, 8 > cv::v_uint16x8
 Eight 16-bit unsigned integer values.
 
typedef v_reg< unsigned, 4 > cv::v_uint32x4
 Four 32-bit unsigned integer values.
 
typedef v_reg< uint64, 2 > cv::v_uint64x2
 Two 64-bit unsigned integer values.
 
typedef v_reg< uchar, 16 > cv::v_uint8x16
 Sixteen 8-bit unsigned integer values.
 

Functions

template<typename _Tp , int n>
v_reg< _Tp, n > cv::operator!= (const v_reg< _Tp, n > &a, const v_reg< _Tp, n > &b)
 Not equal comparison.
 
template<typename _Tp , int n>
v_reg< _Tp, n > cv::operator& (const v_reg< _Tp, n > &a, const v_reg< _Tp, n > &b)
 Bitwise AND.
 
template<typename _Tp , int n>
v_reg< _Tp, n > & cv::operator&= (v_reg< _Tp, n > &a, const v_reg< _Tp, n > &b)
 
template<typename _Tp , int n>
v_reg< _Tp, n > cv::operator* (const v_reg< _Tp, n > &a, const v_reg< _Tp, n > &b)
 Multiply values.
 
template<typename _Tp , int n>
v_reg< _Tp, n > & cv::operator*= (v_reg< _Tp, n > &a, const v_reg< _Tp, n > &b)
 
template<typename _Tp , int n>
v_reg< _Tp, n > cv::operator+ (const v_reg< _Tp, n > &a, const v_reg< _Tp, n > &b)
 Add values.
 
template<typename _Tp , int n>
v_reg< _Tp, n > & cv::operator+= (v_reg< _Tp, n > &a, const v_reg< _Tp, n > &b)
 
template<typename _Tp , int n>
v_reg< _Tp, n > cv::operator- (const v_reg< _Tp, n > &a, const v_reg< _Tp, n > &b)
 Subtract values.
 
template<typename _Tp , int n>
v_reg< _Tp, n > & cv::operator-= (v_reg< _Tp, n > &a, const v_reg< _Tp, n > &b)
 
template<typename _Tp , int n>
v_reg< _Tp, n > cv::operator/ (const v_reg< _Tp, n > &a, const v_reg< _Tp, n > &b)
 Divide values.
 
template<typename _Tp , int n>
v_reg< _Tp, n > & cv::operator/= (v_reg< _Tp, n > &a, const v_reg< _Tp, n > &b)
 
template<typename _Tp , int n>
v_reg< _Tp, n > cv::operator< (const v_reg< _Tp, n > &a, const v_reg< _Tp, n > &b)
 Less-than comparison.
 
template<typename _Tp , int n>
v_reg< _Tp, n > cv::operator<< (const v_reg< _Tp, n > &a, int imm)
 Bitwise shift left.
 
template<typename _Tp , int n>
v_reg< _Tp, n > cv::operator<= (const v_reg< _Tp, n > &a, const v_reg< _Tp, n > &b)
 Less-than or equal comparison.
 
template<typename _Tp , int n>
v_reg< _Tp, n > cv::operator== (const v_reg< _Tp, n > &a, const v_reg< _Tp, n > &b)
 Equal comparison.
 
template<typename _Tp , int n>
v_reg< _Tp, n > cv::operator> (const v_reg< _Tp, n > &a, const v_reg< _Tp, n > &b)
 Greater-than comparison.
 
template<typename _Tp , int n>
v_reg< _Tp, n > cv::operator>= (const v_reg< _Tp, n > &a, const v_reg< _Tp, n > &b)
 Greater-than or equal comparison.
 
template<typename _Tp , int n>
v_reg< _Tp, n > cv::operator>> (const v_reg< _Tp, n > &a, int imm)
 Bitwise shift right.
 
template<typename _Tp , int n>
v_reg< _Tp, n > cv::operator^ (const v_reg< _Tp, n > &a, const v_reg< _Tp, n > &b)
 Bitwise XOR.
 
template<typename _Tp , int n>
v_reg< _Tp, n > & cv::operator^= (v_reg< _Tp, n > &a, const v_reg< _Tp, n > &b)
 
template<typename _Tp , int n>
v_reg< _Tp, n > cv::operator| (const v_reg< _Tp, n > &a, const v_reg< _Tp, n > &b)
 Bitwise OR.
 
template<typename _Tp , int n>
v_reg< _Tp, n > & cv::operator|= (v_reg< _Tp, n > &a, const v_reg< _Tp, n > &b)
 
template<typename _Tp , int n>
v_reg< _Tp, n > cv::operator~ (const v_reg< _Tp, n > &a)
 Bitwise NOT.
 
template<typename _Tp , int n>
v_reg< typename V_TypeTraits
< _Tp >::abs_type, n > 
cv::v_abs (const v_reg< _Tp, n > &a)
 Absolute value of elements.
 
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)
 Absolute difference.
 
v_float32x4 cv::v_absdiff (const v_float32x4 &a, const v_float32x4 &b)
 
v_float64x2 cv::v_absdiff (const v_float64x2 &a, const v_float64x2 &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)
 Saturating absolute difference.
 
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)
 Add values without saturation.
 
template<typename _Tp , int n>
v_reg< int, n > cv::v_ceil (const v_reg< _Tp, n > &a)
 Ceil elements.
 
template<int n>
v_reg< int, n > cv::v_ceil (const v_reg< float, n > &a)
 Ceil.
 
template<int n>
v_reg< int, n *2 > cv::v_ceil (const v_reg< double, n > &a)
 
template<typename _Tp , int n>
bool cv::v_check_all (const v_reg< _Tp, n > &a)
 Check if all packed values are less than zero.
 
template<typename _Tp , int n>
bool cv::v_check_any (const v_reg< _Tp, n > &a)
 Check if any of packed values is less than zero.
 
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)
 Combine vector from last elements of two vectors.
 
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)
 Combine vector from first elements of two vectors.
 
template<int n>
v_reg< float, n > cv::v_cvt_f32 (const v_reg< int, n > &a)
 Convert to float.
 
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< double, n > cv::v_cvt_f64 (const v_reg< int, n *2 > &a)
 Convert to double.
 
template<int n>
v_reg< double, n > cv::v_cvt_f64 (const v_reg< float, n *2 > &a)
 Convert to double.
 
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)
 Dot product of elements.
 
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)
 Dot product of elements.
 
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)
 Expand values to the wider pack type.
 
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)
 Expand higher values to the wider pack type.
 
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)
 Expand lower values to the wider pack type.
 
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)
 Vector extract.
 
template<typename _Tp , int n>
v_reg< int, n > cv::v_floor (const v_reg< _Tp, n > &a)
 Floor elements.
 
template<int n>
v_reg< int, n > cv::v_floor (const v_reg< float, n > &a)
 Floor.
 
template<int n>
v_reg< int, n *2 > cv::v_floor (const v_reg< double, 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)
 Multiply and add.
 
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)
 Inversed square root.
 
template<typename _Tp >
v_reg< _Tp, V_TypeTraits< _Tp >
::nlanes128 > 
cv::v_load (const _Tp *ptr)
 Load register contents from memory.
 
template<typename _Tp >
v_reg< _Tp, V_TypeTraits< _Tp >
::nlanes128 > 
cv::v_load_aligned (const _Tp *ptr)
 Load register contents from memory (aligned)
 
template<typename _Tp , int n>
void cv::v_load_deinterleave (const _Tp *ptr, v_reg< _Tp, n > &a, v_reg< _Tp, n > &b)
 Load and deinterleave (2 channels)
 
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)
 Load and deinterleave (3 channels)
 
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)
 Load and deinterleave (4 channels)
 
template<typename _Tp >
v_reg< typename V_TypeTraits
< _Tp >::w_type, V_TypeTraits
< _Tp >::nlanes128/2 > 
cv::v_load_expand (const _Tp *ptr)
 Load register contents from memory with double expand.
 
v_reg< float, V_TypeTraits
< float >::nlanes128 > 
cv::v_load_expand (const float16_t *ptr)
 
template<typename _Tp >
v_reg< typename V_TypeTraits
< _Tp >::q_type, V_TypeTraits
< _Tp >::nlanes128/4 > 
cv::v_load_expand_q (const _Tp *ptr)
 Load register contents from memory with quad expand.
 
template<typename _Tp >
v_reg< _Tp, V_TypeTraits< _Tp >
::nlanes128 > 
cv::v_load_halves (const _Tp *loptr, const _Tp *hiptr)
 Load register contents from two memory blocks.
 
template<typename _Tp >
v_reg< _Tp, V_TypeTraits< _Tp >
::nlanes128 > 
cv::v_load_low (const _Tp *ptr)
 Load 64-bits of data to lower part (high part is undefined).
 
template<typename _Tp >
v_reg< _Tp, V_TypeTraits< _Tp >
::nlanes128 > 
cv::v_lut (const _Tp *tab, const int *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>
v_reg< float, n > cv::v_lut (const float *tab, const v_reg< int, n > &idx)
 
template<int n>
v_reg< double, n > cv::v_lut (const double *tab, const v_reg< int, n *2 > &idx)
 
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<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<typename _Tp >
v_reg< _Tp, V_TypeTraits< _Tp >
::nlanes128 > 
cv::v_lut_pairs (const _Tp *tab, const int *idx)
 
template<typename _Tp >
v_reg< _Tp, V_TypeTraits< _Tp >
::nlanes128 > 
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)
 Magnitude.
 
v_float32x4 cv::v_matmul (const v_float32x4 &v, const v_float32x4 &m0, const v_float32x4 &m1, const v_float32x4 &m2, const v_float32x4 &m3)
 Matrix multiplication.
 
v_float32x4 cv::v_matmuladd (const v_float32x4 &v, const v_float32x4 &m0, const v_float32x4 &m1, const v_float32x4 &m2, const v_float32x4 &m3)
 Matrix multiplication and add.
 
template<typename _Tp , int n>
v_reg< _Tp, n > cv::v_max (const v_reg< _Tp, n > &a, const v_reg< _Tp, n > &b)
 Choose max values for each pair.
 
template<typename _Tp , int n>
v_reg< _Tp, n > cv::v_min (const v_reg< _Tp, n > &a, const v_reg< _Tp, n > &b)
 Choose min values for each pair.
 
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)
 Multiply and expand.
 
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)
 Multiply and extract high part.
 
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)
 Multiply values without saturation.
 
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)
 A synonym for v_fma.
 
template<int n>
v_reg< float, n > cv::v_not_nan (const v_reg< float, n > &a)
 
template<int n>
v_reg< double, n > cv::v_not_nan (const v_reg< double, n > &a)
 
void cv::v_pack_store (float16_t *ptr, v_reg< float, V_TypeTraits< float >::nlanes128 > &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_uint32x4 cv::v_popcount (const v_reg< _Tp, n > &a)
 Count the 1 bits in the vector and return 4 values.
 
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)
 Combine two vectors from lower and higher parts of two other vectors.
 
template<typename _Tp , int n>
_Tp cv::v_reduce_max (const v_reg< _Tp, n > &a)
 Find one max value.
 
template<typename _Tp , int n>
_Tp cv::v_reduce_min (const v_reg< _Tp, n > &a)
 Find one min value.
 
template<typename _Tp , int n>
V_TypeTraits< typename
V_TypeTraits< _Tp >::abs_type >
::sum_type 
cv::v_reduce_sad (const v_reg< _Tp, n > &a, const v_reg< _Tp, n > &b)
 Sum absolute differences of values.
 
template<typename _Tp , int n>
V_TypeTraits< _Tp >::sum_type cv::v_reduce_sum (const v_reg< _Tp, n > &a)
 Sum packed values.
 
v_float32x4 cv::v_reduce_sum4 (const v_float32x4 &a, const v_float32x4 &b, const v_float32x4 &c, const v_float32x4 &d)
 Sums all elements of each input vector, returns the vector of sums.
 
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<typename _Tp , int n>
v_reg< int, n > cv::v_round (const v_reg< _Tp, n > &a)
 Round elements.
 
template<int n>
v_reg< int, n > cv::v_round (const v_reg< float, n > &a)
 Round.
 
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 *2 > cv::v_round (const v_reg< double, 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)
 Per-element select (blend operation)
 
template<typename _Tp , int n>
int cv::v_signmask (const v_reg< _Tp, n > &a)
 Get negative values mask.
 
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)
 Square of the magnitude.
 
template<typename _Tp , int n>
v_reg< _Tp, n > cv::v_sqrt (const v_reg< _Tp, n > &a)
 Square root of elements.
 
template<typename _Tp , int n>
void cv::v_store (_Tp *ptr, const v_reg< _Tp, n > &a)
 Store data to memory.
 
template<typename _Tp , int n>
void cv::v_store_aligned (_Tp *ptr, const v_reg< _Tp, n > &a)
 Store data to memory (aligned)
 
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)
 Store data to memory (higher half)
 
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)
 Interleave and store (2 channels)
 
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)
 Interleave and store (3 channels)
 
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)
 Interleave and store (4 channels)
 
template<typename _Tp , int n>
void cv::v_store_low (_Tp *ptr, const v_reg< _Tp, n > &a)
 Store data to memory (lower half)
 
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)
 Subtract values without saturation.
 
template<typename _Tp >
void cv::v_transpose4x4 (v_reg< _Tp, 4 > &a0, const v_reg< _Tp, 4 > &a1, const v_reg< _Tp, 4 > &a2, const v_reg< _Tp, 4 > &a3, v_reg< _Tp, 4 > &b0, v_reg< _Tp, 4 > &b1, v_reg< _Tp, 4 > &b2, v_reg< _Tp, 4 > &b3)
 Transpose 4x4 matrix.
 
template<typename _Tp , int n>
v_reg< int, n > cv::v_trunc (const v_reg< _Tp, n > &a)
 Truncate elements.
 
template<int n>
v_reg< int, n > cv::v_trunc (const v_reg< float, n > &a)
 Trunc.
 
template<int n>
v_reg< int, n *2 > cv::v_trunc (const v_reg< double, n > &a)
 
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)
 Interleave two vectors.
 

Variables

static const unsigned char cv::popCountTable []
 

Init with zero

Create new vector with zero elements

v_uint8x16 cv::v_setzero_u8 ()
 
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 ()
 

Init with value

Create new vector with elements set to a specific value

v_uint8x16 cv::v_setall_u8 (uchar val)
 
v_int8x16 cv::v_setall_s8 (schar val)
 
v_uint16x8 cv::v_setall_u16 (ushort val)
 
v_int16x8 cv::v_setall_s16 (short val)
 
v_uint32x4 cv::v_setall_u32 (unsigned val)
 
v_int32x4 cv::v_setall_s32 (int val)
 
v_float32x4 cv::v_setall_f32 (float val)
 
v_float64x2 cv::v_setall_f64 (double val)
 
v_uint64x2 cv::v_setall_u64 (uint64 val)
 
v_int64x2 cv::v_setall_s64 (int64 val)
 

Reinterpret

Convert vector to different type without modifying underlying data.

template<typename _Tp0 , int n0>
v_uint8x16 cv::v_reinterpret_as_u8 (const v_reg< _Tp0, n0 > &a)
 
template<typename _Tp0 , int n0>
v_int8x16 cv::v_reinterpret_as_s8 (const v_reg< _Tp0, n0 > &a)
 
template<typename _Tp0 , int n0>
v_uint16x8 cv::v_reinterpret_as_u16 (const v_reg< _Tp0, n0 > &a)
 
template<typename _Tp0 , int n0>
v_int16x8 cv::v_reinterpret_as_s16 (const v_reg< _Tp0, n0 > &a)
 
template<typename _Tp0 , int n0>
v_uint32x4 cv::v_reinterpret_as_u32 (const v_reg< _Tp0, n0 > &a)
 
template<typename _Tp0 , int n0>
v_int32x4 cv::v_reinterpret_as_s32 (const v_reg< _Tp0, n0 > &a)
 
template<typename _Tp0 , int n0>
v_float32x4 cv::v_reinterpret_as_f32 (const v_reg< _Tp0, n0 > &a)
 
template<typename _Tp0 , int n0>
v_float64x2 cv::v_reinterpret_as_f64 (const v_reg< _Tp0, n0 > &a)
 
template<typename _Tp0 , int n0>
v_uint64x2 cv::v_reinterpret_as_u64 (const v_reg< _Tp0, n0 > &a)
 
template<typename _Tp0 , int n0>
v_int64x2 cv::v_reinterpret_as_s64 (const v_reg< _Tp0, n0 > &a)
 

Left shift

Shift left

template<int n>
v_uint16x8 cv::v_shl (const v_uint16x8 &a)
 
template<int n>
v_int16x8 cv::v_shl (const v_int16x8 &a)
 
template<int n>
v_uint32x4 cv::v_shl (const v_uint32x4 &a)
 
template<int n>
v_int32x4 cv::v_shl (const v_int32x4 &a)
 
template<int n>
v_uint64x2 cv::v_shl (const v_uint64x2 &a)
 
template<int n>
v_int64x2 cv::v_shl (const v_int64x2 &a)
 

Right shift

Shift right

template<int n>
v_uint16x8 cv::v_shr (const v_uint16x8 &a)
 
template<int n>
v_int16x8 cv::v_shr (const v_int16x8 &a)
 
template<int n>
v_uint32x4 cv::v_shr (const v_uint32x4 &a)
 
template<int n>
v_int32x4 cv::v_shr (const v_int32x4 &a)
 
template<int n>
v_uint64x2 cv::v_shr (const v_uint64x2 &a)
 
template<int n>
v_int64x2 cv::v_shr (const v_int64x2 &a)
 

Rounding shift

Rounding shift right

template<int n>
v_uint16x8 cv::v_rshr (const v_uint16x8 &a)
 
template<int n>
v_int16x8 cv::v_rshr (const v_int16x8 &a)
 
template<int n>
v_uint32x4 cv::v_rshr (const v_uint32x4 &a)
 
template<int n>
v_int32x4 cv::v_rshr (const v_int32x4 &a)
 
template<int n>
v_uint64x2 cv::v_rshr (const v_uint64x2 &a)
 
template<int n>
v_int64x2 cv::v_rshr (const v_int64x2 &a)
 

Pack

Pack values from two vectors to one

Return vector type have twice more elements than input vector types. Variant with u suffix also converts to corresponding unsigned type.

  • pack: for 16-, 32- and 64-bit integer input types
  • pack_u: for 16- and 32-bit signed integer input types
Note
All variants except 64-bit use saturation.
v_uint8x16 cv::v_pack (const v_uint16x8 &a, const v_uint16x8 &b)
 
v_int8x16 cv::v_pack (const v_int16x8 &a, const v_int16x8 &b)
 
v_uint16x8 cv::v_pack (const v_uint32x4 &a, const v_uint32x4 &b)
 
v_int16x8 cv::v_pack (const v_int32x4 &a, const v_int32x4 &b)
 
v_uint32x4 cv::v_pack (const v_uint64x2 &a, const v_uint64x2 &b)
 
v_int32x4 cv::v_pack (const v_int64x2 &a, const v_int64x2 &b)
 
v_uint8x16 cv::v_pack_u (const v_int16x8 &a, const v_int16x8 &b)
 
v_uint16x8 cv::v_pack_u (const v_int32x4 &a, const v_int32x4 &b)
 

Pack with rounding shift

Pack values from two vectors to one with rounding shift

Values from the input vectors will be shifted right by n bits with rounding, converted to narrower type and returned in the result vector. Variant with u suffix converts to unsigned type.

  • pack: for 16-, 32- and 64-bit integer input types
  • pack_u: for 16- and 32-bit signed integer input types
Note
All variants except 64-bit use saturation.
template<int n>
v_uint8x16 cv::v_rshr_pack (const v_uint16x8 &a, const v_uint16x8 &b)
 
template<int n>
v_int8x16 cv::v_rshr_pack (const v_int16x8 &a, const v_int16x8 &b)
 
template<int n>
v_uint16x8 cv::v_rshr_pack (const v_uint32x4 &a, const v_uint32x4 &b)
 
template<int n>
v_int16x8 cv::v_rshr_pack (const v_int32x4 &a, const v_int32x4 &b)
 
template<int n>
v_uint32x4 cv::v_rshr_pack (const v_uint64x2 &a, const v_uint64x2 &b)
 
template<int n>
v_int32x4 cv::v_rshr_pack (const v_int64x2 &a, const v_int64x2 &b)
 
template<int n>
v_uint8x16 cv::v_rshr_pack_u (const v_int16x8 &a, const v_int16x8 &b)
 
template<int n>
v_uint16x8 cv::v_rshr_pack_u (const v_int32x4 &a, const v_int32x4 &b)
 

Pack and store

Store values from the input vector into memory with pack

Values will be stored into memory with conversion to narrower type. Variant with u suffix converts to corresponding unsigned type.

  • pack: for 16-, 32- and 64-bit integer input types
  • pack_u: for 16- and 32-bit signed integer input types
Note
All variants except 64-bit use saturation.
void cv::v_pack_store (uchar *ptr, const v_uint16x8 &a)
 
void cv::v_pack_store (schar *ptr, const v_int16x8 &a)
 
void cv::v_pack_store (ushort *ptr, const v_uint32x4 &a)
 
void cv::v_pack_store (short *ptr, const v_int32x4 &a)
 
void cv::v_pack_store (unsigned *ptr, const v_uint64x2 &a)
 
void cv::v_pack_store (int *ptr, const v_int64x2 &a)
 
void cv::v_pack_u_store (uchar *ptr, const v_int16x8 &a)
 
void cv::v_pack_u_store (ushort *ptr, const v_int32x4 &a)
 

Pack and store with rounding shift

Store values from the input vector into memory with pack

Values will be shifted n bits right with rounding, converted to narrower type and stored into memory. Variant with u suffix converts to unsigned type.

  • pack: for 16-, 32- and 64-bit integer input types
  • pack_u: for 16- and 32-bit signed integer input types
Note
All variants except 64-bit use saturation.
template<int n>
void cv::v_rshr_pack_store (uchar *ptr, const v_uint16x8 &a)
 
template<int n>
void cv::v_rshr_pack_store (schar *ptr, const v_int16x8 &a)
 
template<int n>
void cv::v_rshr_pack_store (ushort *ptr, const v_uint32x4 &a)
 
template<int n>
void cv::v_rshr_pack_store (short *ptr, const v_int32x4 &a)
 
template<int n>
void cv::v_rshr_pack_store (unsigned *ptr, const v_uint64x2 &a)
 
template<int n>
void cv::v_rshr_pack_store (int *ptr, const v_int64x2 &a)
 
template<int n>
void cv::v_rshr_pack_u_store (uchar *ptr, const v_int16x8 &a)
 
template<int n>
void cv::v_rshr_pack_u_store (ushort *ptr, const v_int32x4 &a)
 

Pack boolean values

Pack boolean values from multiple vectors to one unsigned 8-bit integer vector

Note
Must provide valid boolean values to guarantee same result for all architectures.
v_uint8x16 cv::v_pack_b (const v_uint16x8 &a, const v_uint16x8 &b)
 ! For 16-bit boolean values
 
v_uint8x16 cv::v_pack_b (const v_uint32x4 &a, const v_uint32x4 &b, const v_uint32x4 &c, const v_uint32x4 &d)
 
v_uint8x16 cv::v_pack_b (const v_uint64x2 &a, const v_uint64x2 &b, const v_uint64x2 &c, const v_uint64x2 &d, const v_uint64x2 &e, const v_uint64x2 &f, const v_uint64x2 &g, const v_uint64x2 &h)
 

Detailed Description

"Universal intrinsics" is a types and functions set intended to simplify vectorization of code on different platforms. Currently there are two supported SIMD extensions: SSE/SSE2 on x86 architectures and NEON on ARM architectures, both allow working with 128 bit registers containing packed values of different types. In case when there is no SIMD extension available during compilation, fallback C++ implementation of intrinsics will be chosen and code will work as expected although it could be slower.

Types

There are several types representing 128-bit register as a vector of packed values, each type is implemented as a structure based on a one SIMD register.

Note
cv::v_float64x2 is not implemented in NEON variant, if you want to use this type, don't forget to check the CV_SIMD128_64F preprocessor definition:
#if CV_SIMD128_64F
//...
#endif

Load and store operations

These operations allow to set contents of the register explicitly or by loading it from some memory block and to save contents of the register to memory block.

Value reordering

These operations allow to reorder or recombine elements in one or multiple vectors.

Arithmetic, bitwise and comparison operations

Element-wise binary and unary operations.

Reduce and mask

Most of these operations return only one value.

Other math

Conversions

Different type conversions and casts:

Matrix operations

In these operations vectors represent matrix rows/columns: v_dotprod, v_matmul, v_transpose4x4

Usability

Most operations are implemented only for some subset of the available types, following matrices shows the applicability of different operations to the types.

Regular integers:

Operations\Types uint 8x16 int 8x16 uint 16x8 int 16x8 uint 32x4 int 32x4
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
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
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

Big integers:

Operations\Types uint 64x2 int 64x2
load, store x x
add, sub x x
shift x x
logical x x
extract x x
rotate (lanes) x x

Floating point:

Operations\Types float 32x4 float 64x2
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

Macro Definition Documentation

#define OPENCV_HAL_IMPL_ROTATE_SHIFT_OP (   suffix,
  opA,
  opB 
)

Element shift left among vector.

For all type

Typedef Documentation

typedef v_reg<float, 4> cv::v_float32x4

Four 32-bit floating point values (single precision)

typedef v_reg<double, 2> cv::v_float64x2

Two 64-bit floating point values (double precision)

typedef v_reg<short, 8> cv::v_int16x8

Eight 16-bit signed integer values.

typedef v_reg<int, 4> cv::v_int32x4

Four 32-bit signed integer values.

typedef v_reg<int64, 2> cv::v_int64x2

Two 64-bit signed integer values.

typedef v_reg<schar, 16> cv::v_int8x16

Sixteen 8-bit signed integer values.

typedef v_reg<ushort, 8> cv::v_uint16x8

Eight 16-bit unsigned integer values.

typedef v_reg<unsigned, 4> cv::v_uint32x4

Four 32-bit unsigned integer values.

typedef v_reg<uint64, 2> cv::v_uint64x2

Two 64-bit unsigned integer values.

typedef v_reg<uchar, 16> cv::v_uint8x16

Sixteen 8-bit unsigned integer values.

Function Documentation

template<typename _Tp , int n>
v_reg<_Tp, n> cv::operator!= ( const v_reg< _Tp, n > &  a,
const v_reg< _Tp, n > &  b 
)
inline

Not equal comparison.

For all types except 64-bit integer values.

template<typename _Tp , int n>
v_reg<_Tp, n> cv::operator& ( const v_reg< _Tp, n > &  a,
const v_reg< _Tp, n > &  b 
)
inline

Bitwise AND.

Only for integer types.

template<typename _Tp , int n>
v_reg<_Tp, n>& cv::operator&= ( v_reg< _Tp, n > &  a,
const v_reg< _Tp, n > &  b 
)
inline
template<typename _Tp , int n>
v_reg<_Tp, n> cv::operator* ( const v_reg< _Tp, n > &  a,
const v_reg< _Tp, n > &  b 
)
inline

Multiply values.

For 16- and 32-bit integer types and floating types.

template<typename _Tp , int n>
v_reg<_Tp, n>& cv::operator*= ( v_reg< _Tp, n > &  a,
const v_reg< _Tp, n > &  b 
)
inline
template<typename _Tp , int n>
v_reg<_Tp, n> cv::operator+ ( const v_reg< _Tp, n > &  a,
const v_reg< _Tp, n > &  b 
)
inline

Add values.

For all types.

template<typename _Tp , int n>
v_reg<_Tp, n>& cv::operator+= ( v_reg< _Tp, n > &  a,
const v_reg< _Tp, n > &  b 
)
inline
template<typename _Tp , int n>
v_reg<_Tp, n> cv::operator- ( const v_reg< _Tp, n > &  a,
const v_reg< _Tp, n > &  b 
)
inline

Subtract values.

For all types.

template<typename _Tp , int n>
v_reg<_Tp, n>& cv::operator-= ( v_reg< _Tp, n > &  a,
const v_reg< _Tp, n > &  b 
)
inline
template<typename _Tp , int n>
v_reg<_Tp, n> cv::operator/ ( const v_reg< _Tp, n > &  a,
const v_reg< _Tp, n > &  b 
)
inline

Divide values.

For floating types only.

template<typename _Tp , int n>
v_reg<_Tp, n>& cv::operator/= ( v_reg< _Tp, n > &  a,
const v_reg< _Tp, n > &  b 
)
inline
template<typename _Tp , int n>
v_reg<_Tp, n> cv::operator< ( const v_reg< _Tp, n > &  a,
const v_reg< _Tp, n > &  b 
)
inline

Less-than comparison.

For all types except 64-bit integer values.

template<typename _Tp , int n>
v_reg<_Tp, n> cv::operator<< ( const v_reg< _Tp, n > &  a,
int  imm 
)
inline

Bitwise shift left.

For 16-, 32- and 64-bit integer values.

Examples:
samples/cpp/filestorage.cpp.
template<typename _Tp , int n>
v_reg<_Tp, n> cv::operator<= ( const v_reg< _Tp, n > &  a,
const v_reg< _Tp, n > &  b 
)
inline

Less-than or equal comparison.

For all types except 64-bit integer values.

template<typename _Tp , int n>
v_reg<_Tp, n> cv::operator== ( const v_reg< _Tp, n > &  a,
const v_reg< _Tp, n > &  b 
)
inline

Equal comparison.

For all types except 64-bit integer values.

template<typename _Tp , int n>
v_reg<_Tp, n> cv::operator> ( const v_reg< _Tp, n > &  a,
const v_reg< _Tp, n > &  b 
)
inline

Greater-than comparison.

For all types except 64-bit integer values.

template<typename _Tp , int n>
v_reg<_Tp, n> cv::operator>= ( const v_reg< _Tp, n > &  a,
const v_reg< _Tp, n > &  b 
)
inline

Greater-than or equal comparison.

For all types except 64-bit integer values.

template<typename _Tp , int n>
v_reg<_Tp, n> cv::operator>> ( const v_reg< _Tp, n > &  a,
int  imm 
)
inline

Bitwise shift right.

For 16-, 32- and 64-bit integer values.

template<typename _Tp , int n>
v_reg<_Tp, n> cv::operator^ ( const v_reg< _Tp, n > &  a,
const v_reg< _Tp, n > &  b 
)
inline

Bitwise XOR.

Only for integer types.

template<typename _Tp , int n>
v_reg<_Tp, n>& cv::operator^= ( v_reg< _Tp, n > &  a,
const v_reg< _Tp, n > &  b 
)
inline
template<typename _Tp , int n>
v_reg<_Tp, n> cv::operator| ( const v_reg< _Tp, n > &  a,
const v_reg< _Tp, n > &  b 
)
inline

Bitwise OR.

Only for integer types.

template<typename _Tp , int n>
v_reg<_Tp, n>& cv::operator|= ( v_reg< _Tp, n > &  a,
const v_reg< _Tp, n > &  b 
)
inline
template<typename _Tp , int n>
v_reg<_Tp, n> cv::operator~ ( const v_reg< _Tp, n > &  a)
inline

Bitwise NOT.

Only for integer types.

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

Absolute value of elements.

Only for floating point types.

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

Absolute difference.

Returns \( |a - b| \) converted to corresponding unsigned type. Example:

v_int32x4 a, b; // {1, 2, 3, 4} and {4, 3, 2, 1}
v_uint32x4 c = v_absdiff(a, b); // result is {3, 1, 1, 3}

For 8-, 16-, 32-bit integer source types.

v_float32x4 cv::v_absdiff ( const v_float32x4 &  a,
const v_float32x4 &  b 
)
inline

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. For 32-bit floating point values

v_float64x2 cv::v_absdiff ( const v_float64x2 &  a,
const v_float64x2 &  b 
)
inline

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. For 64-bit floating point values

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

Saturating absolute difference.

Returns \( saturate(|a - b|) \) . For 8-, 16-bit signed integer source types.

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

Add values without saturation.

For 8- and 16-bit integer values.

template<typename _Tp , int n>
v_reg< int , n> cv::v_ceil ( const v_reg< _Tp, n > &  a)
inline

Ceil elements.

Only for floating point types.

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

Ceil.

Ceil each value. Input type is float vector ==> output type is int vector.

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

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

template<typename _Tp , int n>
bool cv::v_check_all ( const v_reg< _Tp, n > &  a)
inline

Check if all packed values are less than zero.

Unsigned values will be casted to signed: uchar 254 => char -2. For all types except 64-bit.

template<typename _Tp , int n>
bool cv::v_check_any ( const v_reg< _Tp, n > &  a)
inline

Check if any of packed values is less than zero.

Unsigned values will be casted to signed: uchar 254 => char -2. For all types except 64-bit.

void cv::v_cleanup ( )
inline
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

Combine vector from last elements of two vectors.

Scheme:

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

For all types except 64-bit.

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

Combine vector from first elements of two vectors.

Scheme:

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

For all types except 64-bit.

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

Convert to float.

Supported input type is cv::v_int32x4.

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
template<int n>
v_reg<double, n> cv::v_cvt_f64 ( const v_reg< int, n *2 > &  a)
inline

Convert to double.

Supported input type is cv::v_int32x4.

template<int n>
v_reg<double, n> cv::v_cvt_f64 ( const v_reg< float, n *2 > &  a)
inline

Convert to double.

Supported input type is cv::v_float32x4.

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

Dot product of elements.

Multiply values in two registers and sum adjacent result pairs. Scheme:

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

Implemented only for 16-bit signed source type (v_int16x8).

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

Dot product of elements.

Same as cv::v_dotprod, but add a third element to the sum of adjacent pairs. Scheme:

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

Implemented only for 16-bit signed source type (v_int16x8).

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

Expand values to the wider pack type.

Copy contents of register to two registers with 2x wider pack type. Scheme:

int32x4 int64x2 int64x2
{A B C D} ==> {A B} , {C D}
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

Expand higher values to the wider pack type.

Same as cv::v_expand_low, but expand higher half of the vector instead.

Scheme:

int32x4 int64x2
{A B C D} ==> {C D}
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

Expand lower values to the wider pack type.

Same as cv::v_expand, but return lower half of the vector.

Scheme:

int32x4 int64x2
{A B C D} ==> {A B}
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

Vector extract.

Scheme:

{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}

Restriction: 0 <= shift < nlanes

Usage:

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

For all types.

template<typename _Tp , int n>
v_reg< int , n> cv::v_floor ( const v_reg< _Tp, n > &  a)
inline

Floor elements.

Only for floating point types.

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

Floor.

Floor each value. Input type is float vector ==> output type is int vector.

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

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

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

Multiply and add.

Returns \( a*b + c \) For floating point types and signed 32bit int only.

template<typename _Tp , int n>
v_reg<_Tp, n> cv::v_interleave_pairs ( const v_reg< _Tp, n > &  vec)
inline
template<typename _Tp , int n>
v_reg<_Tp, n> cv::v_interleave_quads ( const v_reg< _Tp, n > &  vec)
inline
template<typename _Tp , int n>
v_reg<_Tp, n> cv::v_invsqrt ( const v_reg< _Tp, n > &  a)
inline

Inversed square root.

Returns \( 1/sqrt(a) \) For floating point types only.

template<typename _Tp >
v_reg<_Tp, V_TypeTraits<_Tp>::nlanes128> cv::v_load ( const _Tp *  ptr)
inline

Load register contents from memory.

Parameters
ptrpointer to memory block with data
Returns
register object
Note
Returned type will be detected from passed pointer type, for example uchar ==> cv::v_uint8x16, int ==> cv::v_int32x4, etc.
template<typename _Tp >
v_reg<_Tp, V_TypeTraits<_Tp>::nlanes128> cv::v_load_aligned ( const _Tp *  ptr)
inline

Load register contents from memory (aligned)

similar to cv::v_load, but source memory block should be aligned (to 16-byte boundary)

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

Load and deinterleave (2 channels)

Load data from memory deinterleave and store to 2 registers. Scheme:

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

For all types except 64-bit.

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

Load and deinterleave (3 channels)

Load data from memory deinterleave and store to 3 registers. Scheme:

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

For all types except 64-bit.

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

Load and deinterleave (4 channels)

Load data from memory deinterleave and store to 4 registers. Scheme:

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

For all types except 64-bit.

template<typename _Tp >
v_reg<typename V_TypeTraits<_Tp>::w_type, V_TypeTraits<_Tp>::nlanes128 / 2> cv::v_load_expand ( const _Tp *  ptr)
inline

Load register contents from memory with double expand.

Same as cv::v_load, but result pack type will be 2x wider than memory type.

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

For 8-, 16-, 32-bit integer source types.

v_reg<float, V_TypeTraits<float>::nlanes128> cv::v_load_expand ( const float16_t *  ptr)
inline
template<typename _Tp >
v_reg<typename V_TypeTraits<_Tp>::q_type, V_TypeTraits<_Tp>::nlanes128 / 4> cv::v_load_expand_q ( const _Tp *  ptr)
inline

Load register contents from memory with quad expand.

Same as cv::v_load_expand, but result type is 4 times wider than source.

char buf[4] = {1, 2, 3, 4}; // type is int8
v_int32x4 r = v_load_q(buf); // r = {1, 2, 3, 4} - type is int32

For 8-bit integer source types.

template<typename _Tp >
v_reg<_Tp, V_TypeTraits<_Tp>::nlanes128> cv::v_load_halves ( const _Tp *  loptr,
const _Tp *  hiptr 
)
inline

Load register contents from two memory blocks.

Parameters
loptrmemory block containing data for first half (0..n/2)
hiptrmemory block containing data for second half (n/2..n)
int lo[2] = { 1, 2 }, hi[2] = { 3, 4 };
template<typename _Tp >
v_reg<_Tp, V_TypeTraits<_Tp>::nlanes128> cv::v_load_low ( const _Tp *  ptr)
inline

Load 64-bits of data to lower part (high part is undefined).

Parameters
ptrmemory block containing data for first half (0..n/2)
int lo[2] = { 1, 2 };
template<typename _Tp >
v_reg<_Tp, V_TypeTraits<_Tp>::nlanes128> cv::v_lut ( const _Tp *  tab,
const int *  idx 
)
inline
template<int n>
v_reg<int, n> cv::v_lut ( const int *  tab,
const v_reg< int, n > &  idx 
)
inline
template<int n>
v_reg<unsigned, n> cv::v_lut ( const unsigned *  tab,
const v_reg< int, n > &  idx 
)
inline
template<int n>
v_reg<float, n> cv::v_lut ( const float *  tab,
const v_reg< int, n > &  idx 
)
inline
template<int n>
v_reg<double, n> cv::v_lut ( const double *  tab,
const v_reg< int, n *2 > &  idx 
)
inline
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
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
template<typename _Tp >
v_reg<_Tp, V_TypeTraits<_Tp>::nlanes128> cv::v_lut_pairs ( const _Tp *  tab,
const int *  idx 
)
inline
template<typename _Tp >
v_reg<_Tp, V_TypeTraits<_Tp>::nlanes128> cv::v_lut_quads ( const _Tp *  tab,
const int *  idx 
)
inline
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

Magnitude.

Returns \( sqrt(a^2 + b^2) \) For floating point types only.

v_float32x4 cv::v_matmul ( const v_float32x4 &  v,
const v_float32x4 &  m0,
const v_float32x4 &  m1,
const v_float32x4 &  m2,
const v_float32x4 &  m3 
)
inline

Matrix multiplication.

Scheme:

{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 + A1V1 + A2V2 + A3V3,
R1 = B0V0 + B1V1 + B2V2 + B3V3
...
v_float32x4 cv::v_matmuladd ( const v_float32x4 &  v,
const v_float32x4 &  m0,
const v_float32x4 &  m1,
const v_float32x4 &  m2,
const v_float32x4 &  m3 
)
inline

Matrix multiplication and add.

Scheme:

{A0 A1 A2 } |V0| |D0|
{B0 B1 B2 } |V1| |D1|
{C0 C1 C2 } x |V2| + |D2|
====================
{R0 R1 R2 R3}, where:
R0 = A0V0 + A1V1 + A2V2 + D0,
R1 = B0V0 + B1V1 + B2V2 + D1
...
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

Choose max values for each pair.

Scheme:

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

For all types except 64-bit integer.

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

Choose min values for each pair.

Scheme:

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

For all types except 64-bit integer.

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

Multiply and expand.

Multiply values two registers and store results in two registers with wider pack type. Scheme:

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

Example:

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

Implemented only for 16- and unsigned 32-bit source types (v_int16x8, v_uint16x8, v_uint32x4).

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

Multiply and extract high part.

Multiply values two registers and store high part of the results. Implemented only for 16-bit source types (v_int16x8, v_uint16x8). Returns \( a*b >> 16 \)

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

Multiply values without saturation.

For 8- and 16-bit integer values.

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

A synonym for v_fma.

template<int n>
v_reg<float, n> cv::v_not_nan ( const v_reg< float, n > &  a)
inline
template<int n>
v_reg<double, n> cv::v_not_nan ( const v_reg< double, n > &  a)
inline
v_uint8x16 cv::v_pack ( const v_uint16x8 &  a,
const v_uint16x8 &  b 
)
inline
v_int8x16 cv::v_pack ( const v_int16x8 &  a,
const v_int16x8 &  b 
)
inline
v_uint16x8 cv::v_pack ( const v_uint32x4 &  a,
const v_uint32x4 &  b 
)
inline
v_int16x8 cv::v_pack ( const v_int32x4 &  a,
const v_int32x4 &  b 
)
inline
v_uint32x4 cv::v_pack ( const v_uint64x2 &  a,
const v_uint64x2 &  b 
)
inline
v_int32x4 cv::v_pack ( const v_int64x2 &  a,
const v_int64x2 &  b 
)
inline
v_uint8x16 cv::v_pack_b ( const v_uint16x8 &  a,
const v_uint16x8 &  b 
)
inline

! For 16-bit boolean values

Scheme:

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_uint8x16 cv::v_pack_b ( const v_uint32x4 &  a,
const v_uint32x4 &  b,
const v_uint32x4 &  c,
const v_uint32x4 &  d 
)
inline

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.For 32-bit boolean values

Scheme:

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_uint8x16 cv::v_pack_b ( const v_uint64x2 &  a,
const v_uint64x2 &  b,
const v_uint64x2 &  c,
const v_uint64x2 &  d,
const v_uint64x2 &  e,
const v_uint64x2 &  f,
const v_uint64x2 &  g,
const v_uint64x2 &  h 
)
inline

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.For 64-bit boolean values

Scheme:

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
}
void cv::v_pack_store ( uchar ptr,
const v_uint16x8 &  a 
)
inline
void cv::v_pack_store ( schar ptr,
const v_int16x8 &  a 
)
inline
void cv::v_pack_store ( ushort ptr,
const v_uint32x4 &  a 
)
inline
void cv::v_pack_store ( short *  ptr,
const v_int32x4 &  a 
)
inline
void cv::v_pack_store ( unsigned *  ptr,
const v_uint64x2 &  a 
)
inline
void cv::v_pack_store ( int *  ptr,
const v_int64x2 &  a 
)
inline
void cv::v_pack_store ( float16_t *  ptr,
v_reg< float, V_TypeTraits< float >::nlanes128 > &  v 
)
inline
template<typename _Tp , int n>
v_reg<_Tp, n> cv::v_pack_triplets ( const v_reg< _Tp, n > &  vec)
inline
v_uint8x16 cv::v_pack_u ( const v_int16x8 &  a,
const v_int16x8 &  b 
)
inline
v_uint16x8 cv::v_pack_u ( const v_int32x4 &  a,
const v_int32x4 &  b 
)
inline
void cv::v_pack_u_store ( uchar ptr,
const v_int16x8 &  a 
)
inline
void cv::v_pack_u_store ( ushort ptr,
const v_int32x4 &  a 
)
inline
template<typename _Tp , int n>
v_uint32x4 cv::v_popcount ( const v_reg< _Tp, n > &  a)
inline

Count the 1 bits in the vector and return 4 values.

Scheme:

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

Any types but result will be in v_uint32x4

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

Combine two vectors from lower and higher parts of two other vectors.

low = cv::v_combine_low(a, b);
high = cv::v_combine_high(a, b);
template<typename _Tp , int n>
_Tp cv::v_reduce_max ( const v_reg< _Tp, n > &  a)
inline

Find one max value.

Scheme:

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

For 32-bit integer and 32-bit floating point types.

template<typename _Tp , int n>
_Tp cv::v_reduce_min ( const v_reg< _Tp, n > &  a)
inline

Find one min value.

Scheme:

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

For 32-bit integer and 32-bit floating point types.

template<typename _Tp , int n>
V_TypeTraits< typename V_TypeTraits<_Tp>::abs_type >::sum_type cv::v_reduce_sad ( const v_reg< _Tp, n > &  a,
const v_reg< _Tp, n > &  b 
)
inline

Sum absolute differences of values.

Scheme:

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

For all types except 64-bit types.

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

Sum packed values.

Scheme:

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

For 32-bit integer and 32-bit floating point types.

v_float32x4 cv::v_reduce_sum4 ( const v_float32x4 &  a,
const v_float32x4 &  b,
const v_float32x4 &  c,
const v_float32x4 &  d 
)
inline

Sums all elements of each input vector, returns the vector of sums.

Scheme:

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]
template<typename _Tp0 , int n0>
v_float32x4 cv::v_reinterpret_as_f32 ( const v_reg< _Tp0, n0 > &  a)
inline
template<typename _Tp0 , int n0>
v_float64x2 cv::v_reinterpret_as_f64 ( const v_reg< _Tp0, n0 > &  a)
inline
template<typename _Tp0 , int n0>
v_int16x8 cv::v_reinterpret_as_s16 ( const v_reg< _Tp0, n0 > &  a)
inline
template<typename _Tp0 , int n0>
v_int32x4 cv::v_reinterpret_as_s32 ( const v_reg< _Tp0, n0 > &  a)
inline
template<typename _Tp0 , int n0>
v_int64x2 cv::v_reinterpret_as_s64 ( const v_reg< _Tp0, n0 > &  a)
inline
template<typename _Tp0 , int n0>
v_int8x16 cv::v_reinterpret_as_s8 ( const v_reg< _Tp0, n0 > &  a)
inline
template<typename _Tp0 , int n0>
v_uint16x8 cv::v_reinterpret_as_u16 ( const v_reg< _Tp0, n0 > &  a)
inline
template<typename _Tp0 , int n0>
v_uint32x4 cv::v_reinterpret_as_u32 ( const v_reg< _Tp0, n0 > &  a)
inline
template<typename _Tp0 , int n0>
v_uint64x2 cv::v_reinterpret_as_u64 ( const v_reg< _Tp0, n0 > &  a)
inline
template<typename _Tp0 , int n0>
v_uint8x16 cv::v_reinterpret_as_u8 ( const v_reg< _Tp0, n0 > &  a)
inline
template<int imm, typename _Tp , int n>
v_reg<_Tp, n> cv::v_rotate_left ( const v_reg< _Tp, n > &  a)
inline
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
template<int imm, typename _Tp , int n>
v_reg<_Tp, n> cv::v_rotate_right ( const v_reg< _Tp, n > &  a)
inline
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
template<typename _Tp , int n>
v_reg< int , n> cv::v_round ( const v_reg< _Tp, n > &  a)
inline

Round elements.

Only for floating point types.

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

Round.

Rounds each value. Input type is float vector ==> output type is int vector.

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

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

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

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

template<int n>
v_uint16x8 cv::v_rshr ( const v_uint16x8 &  a)
inline
template<int n>
v_int16x8 cv::v_rshr ( const v_int16x8 &  a)
inline
template<int n>
v_uint32x4 cv::v_rshr ( const v_uint32x4 &  a)
inline
template<int n>
v_int32x4 cv::v_rshr ( const v_int32x4 &  a)
inline
template<int n>
v_uint64x2 cv::v_rshr ( const v_uint64x2 &  a)
inline
template<int n>
v_int64x2 cv::v_rshr ( const v_int64x2 &  a)
inline
template<int n>
v_uint8x16 cv::v_rshr_pack ( const v_uint16x8 &  a,
const v_uint16x8 &  b 
)
inline
template<int n>
v_int8x16 cv::v_rshr_pack ( const v_int16x8 &  a,
const v_int16x8 &  b 
)
inline
template<int n>
v_uint16x8 cv::v_rshr_pack ( const v_uint32x4 &  a,
const v_uint32x4 &  b 
)
inline
template<int n>
v_int16x8 cv::v_rshr_pack ( const v_int32x4 &  a,
const v_int32x4 &  b 
)
inline
template<int n>
v_uint32x4 cv::v_rshr_pack ( const v_uint64x2 &  a,
const v_uint64x2 &  b 
)
inline
template<int n>
v_int32x4 cv::v_rshr_pack ( const v_int64x2 &  a,
const v_int64x2 &  b 
)
inline
template<int n>
void cv::v_rshr_pack_store ( uchar ptr,
const v_uint16x8 &  a 
)
inline
template<int n>
void cv::v_rshr_pack_store ( schar ptr,
const v_int16x8 &  a 
)
inline
template<int n>
void cv::v_rshr_pack_store ( ushort ptr,
const v_uint32x4 &  a 
)
inline
template<int n>
void cv::v_rshr_pack_store ( short *  ptr,
const v_int32x4 &  a 
)
inline
template<int n>
void cv::v_rshr_pack_store ( unsigned *  ptr,
const v_uint64x2 &  a 
)
inline
template<int n>
void cv::v_rshr_pack_store ( int *  ptr,
const v_int64x2 &  a 
)
inline
template<int n>
v_uint8x16 cv::v_rshr_pack_u ( const v_int16x8 &  a,
const v_int16x8 &  b 
)
inline
template<int n>
v_uint16x8 cv::v_rshr_pack_u ( const v_int32x4 &  a,
const v_int32x4 &  b 
)
inline
template<int n>
void cv::v_rshr_pack_u_store ( uchar ptr,
const v_int16x8 &  a 
)
inline
template<int n>
void cv::v_rshr_pack_u_store ( ushort ptr,
const v_int32x4 &  a 
)
inline
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

Per-element select (blend operation)

Return value will be built by combining values a and b using the following scheme: result[i] = mask[i] ? a[i] : b[i];

Note
: mask element values are restricted to these values:
  • 0: select element from b
  • 0xff/0xffff/etc: select element from a (fully compatible with bitwise-based operator)
v_float32x4 cv::v_setall_f32 ( float  val)
inline
v_float64x2 cv::v_setall_f64 ( double  val)
inline
v_int16x8 cv::v_setall_s16 ( short  val)
inline
v_int32x4 cv::v_setall_s32 ( int  val)
inline
v_int64x2 cv::v_setall_s64 ( int64  val)
inline
v_int8x16 cv::v_setall_s8 ( schar  val)
inline
v_uint16x8 cv::v_setall_u16 ( ushort  val)
inline
v_uint32x4 cv::v_setall_u32 ( unsigned  val)
inline
v_uint64x2 cv::v_setall_u64 ( uint64  val)
inline
v_uint8x16 cv::v_setall_u8 ( uchar  val)
inline
v_float32x4 cv::v_setzero_f32 ( )
inline
v_float64x2 cv::v_setzero_f64 ( )
inline
v_int16x8 cv::v_setzero_s16 ( )
inline
v_int32x4 cv::v_setzero_s32 ( )
inline
v_int64x2 cv::v_setzero_s64 ( )
inline
v_int8x16 cv::v_setzero_s8 ( )
inline
v_uint16x8 cv::v_setzero_u16 ( )
inline
v_uint32x4 cv::v_setzero_u32 ( )
inline
v_uint64x2 cv::v_setzero_u64 ( )
inline
v_uint8x16 cv::v_setzero_u8 ( )
inline
template<int n>
v_uint16x8 cv::v_shl ( const v_uint16x8 &  a)
inline
template<int n>
v_int16x8 cv::v_shl ( const v_int16x8 &  a)
inline
template<int n>
v_uint32x4 cv::v_shl ( const v_uint32x4 &  a)
inline
template<int n>
v_int32x4 cv::v_shl ( const v_int32x4 &  a)
inline
template<int n>
v_uint64x2 cv::v_shl ( const v_uint64x2 &  a)
inline
template<int n>
v_int64x2 cv::v_shl ( const v_int64x2 &  a)
inline
template<int n>
v_uint16x8 cv::v_shr ( const v_uint16x8 &  a)
inline
template<int n>
v_int16x8 cv::v_shr ( const v_int16x8 &  a)
inline
template<int n>
v_uint32x4 cv::v_shr ( const v_uint32x4 &  a)
inline
template<int n>
v_int32x4 cv::v_shr ( const v_int32x4 &  a)
inline
template<int n>
v_uint64x2 cv::v_shr ( const v_uint64x2 &  a)
inline
template<int n>
v_int64x2 cv::v_shr ( const v_int64x2 &  a)
inline
template<typename _Tp , int n>
int cv::v_signmask ( const v_reg< _Tp, n > &  a)
inline

Get negative values mask.

Returned value is a bit mask with bits set to 1 on places corresponding to negative packed values indexes. Example:

v_int32x4 r; // set to {-1, -1, 1, 1}
int mask = v_signmask(r); // mask = 3 <== 00000000 00000000 00000000 00000011

For all types except 64-bit.

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

Square of the magnitude.

Returns \( a^2 + b^2 \) For floating point types only.

template<typename _Tp , int n>
v_reg< _Tp , n> cv::v_sqrt ( const v_reg< _Tp, n > &  a)
inline

Square root of elements.

Only for floating point types.

template<typename _Tp , int n>
void cv::v_store ( _Tp *  ptr,
const v_reg< _Tp, n > &  a 
)
inline

Store data to memory.

Store register contents to memory. Scheme:

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

Pointer can be unaligned.

template<typename _Tp , int n>
void cv::v_store_aligned ( _Tp *  ptr,
const v_reg< _Tp, n > &  a 
)
inline

Store data to memory (aligned)

Store register contents to memory. Scheme:

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

Pointer should be aligned by 16-byte boundary.

template<typename _Tp , int n>
void cv::v_store_aligned ( _Tp *  ptr,
const v_reg< _Tp, n > &  a,
hal::StoreMode   
)
inline
template<typename _Tp , int n>
void cv::v_store_aligned_nocache ( _Tp *  ptr,
const v_reg< _Tp, n > &  a 
)
inline
template<typename _Tp , int n>
void cv::v_store_high ( _Tp *  ptr,
const v_reg< _Tp, n > &  a 
)
inline

Store data to memory (higher half)

Store higher half of register contents to memory. Scheme:

REG {A B C D} ==> MEM {C D}
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 
)
inline

Interleave and store (2 channels)

Interleave and store data from 2 registers to memory. Scheme:

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

For all types except 64-bit.

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 
)
inline

Interleave and store (3 channels)

Interleave and store data from 3 registers to memory. Scheme:

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

For all types except 64-bit.

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 
)
inline

Interleave and store (4 channels)

Interleave and store data from 4 registers to memory. Scheme:

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

For all types except 64-bit.

template<typename _Tp , int n>
void cv::v_store_low ( _Tp *  ptr,
const v_reg< _Tp, n > &  a 
)
inline

Store data to memory (lower half)

Store lower half of register contents to memory. Scheme:

REG {A B C D} ==> MEM {A 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 
)
inline

Subtract values without saturation.

For 8- and 16-bit integer values.

template<typename _Tp >
void cv::v_transpose4x4 ( v_reg< _Tp, 4 > &  a0,
const v_reg< _Tp, 4 > &  a1,
const v_reg< _Tp, 4 > &  a2,
const v_reg< _Tp, 4 > &  a3,
v_reg< _Tp, 4 > &  b0,
v_reg< _Tp, 4 > &  b1,
v_reg< _Tp, 4 > &  b2,
v_reg< _Tp, 4 > &  b3 
)
inline

Transpose 4x4 matrix.

Scheme:

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}
template<typename _Tp , int n>
v_reg< int , n> cv::v_trunc ( const v_reg< _Tp, n > &  a)
inline

Truncate elements.

Only for floating point types.

template<int n>
v_reg<int, n> cv::v_trunc ( const v_reg< float, n > &  a)
inline

Trunc.

Truncate each value. Input type is float vector ==> output type is int vector.

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

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

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 
)
inline

Interleave two vectors.

Scheme:

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

For all types except 64-bit.

Variable Documentation

const unsigned char cv::popCountTable[]
static
Initial value:
=
{
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,
}