Loading...
Searching...
No Matches

"black box" representation of the file storage associated with a file on disk. More...

Namespaces

namespace  alphamat
 
namespace  aruco
 
namespace  barcode
 
namespace  bgsegm
 
namespace  bioinspired
 
namespace  ccalib
 
namespace  ccm
 
namespace  colored_kinfu
 
namespace  cuda
 
namespace  cudacodec
 
namespace  cudev
 
namespace  datasets
 
namespace  detail
 
namespace  details
 
namespace  directx
 
namespace  dnn
 
namespace  dnn_objdetect
 
namespace  dnn_superres
 
namespace  dpm
 
namespace  dynafu
 
namespace  Error
 
namespace  face
 
namespace  fisheye
 The methods in this namespace use a so-called fisheye camera model.
 
namespace  flann
 
namespace  freetype
 
namespace  ft
 
namespace  gapi
 
namespace  gimpl
 
namespace  hal
 
namespace  hdf
 
namespace  hfs
 
namespace  img_hash
 
namespace  instr
 
namespace  intensity_transform
 
namespace  internal
 
namespace  julia
 
namespace  kinfu
 
namespace  large_kinfu
 
namespace  legacy
 
namespace  line_descriptor
 
namespace  linemod
 
namespace  mcc
 
namespace  ml
 
namespace  motempl
 
namespace  multicalib
 
namespace  ocl
 
namespace  ogl
 
namespace  omnidir
 
namespace  optflow
 
namespace  ovis
 
namespace  parallel
 
namespace  phase_unwrapping
 
namespace  plot
 
namespace  ppf_match_3d
 
namespace  quality
 
namespace  randpattern
 
namespace  rapid
 
namespace  reg
 
namespace  rgbd
 
namespace  saliency
 
namespace  samples
 
namespace  segmentation
 
namespace  sfm
 
namespace  stereo
 
namespace  structured_light
 
namespace  superres
 
namespace  text
 
namespace  traits
 
namespace  util
 
namespace  utils
 
namespace  v4d
 
namespace  va_intel
 
namespace  videoio_registry
 
namespace  videostab
 
namespace  viz
 
namespace  wechat_qrcode
 
namespace  xfeatures2d
 
namespace  ximgproc
 
namespace  xobjdetect
 
namespace  xphoto
 

Classes

class  _InputArray
 This is the proxy class for passing read-only input arrays into OpenCV functions. More...
 
class  _InputOutputArray
 
class  _OutputArray
 This type is very similar to InputArray except that it is used for input/output and output function parameters. More...
 
struct  Accumulator
 
struct  Accumulator< char >
 
struct  Accumulator< short >
 
struct  Accumulator< unsigned char >
 
struct  Accumulator< unsigned short >
 
class  Affine3
 Affine transform. More...
 
class  AffineFeature
 Class for implementing the wrapper which makes detectors and extractors to be affine invariant, described as ASIFT in [YM11] . More...
 
class  AffineTransformer
 Wrapper class for the OpenCV Affine Transformation algorithm. : More...
 
class  AffineWarper
 Affine warper factory class. More...
 
class  AgastFeatureDetector
 Wrapping class for feature detection using the AGAST method. : More...
 
class  AKAZE
 Class implementing the AKAZE keypoint detector and descriptor extractor, described in [ANB13]. More...
 
class  Algorithm
 This is a base class for all more or less complex algorithms in OpenCV. More...
 
class  AlignExposures
 The base class for algorithms that align images of the same scene with different exposures. More...
 
class  AlignMTB
 This algorithm converts images to median threshold bitmaps (1 for pixels brighter than median luminance and 0 otherwise) and than aligns the resulting bitmaps using bit operations. More...
 
class  Allocator
 
class  AsyncArray
 Returns result of asynchronous operations. More...
 
class  AsyncPromise
 Provides result of asynchronous operations. More...
 
class  AutoBuffer
 Automatically Allocated Buffer Class. More...
 
class  AVIReadContainer
 
class  AVIWriteContainer
 
class  BackgroundSubtractor
 Base class for background/foreground segmentation. : More...
 
class  BackgroundSubtractorKNN
 K-nearest neighbours - based Background/Foreground Segmentation Algorithm. More...
 
class  BackgroundSubtractorMOG2
 Gaussian Mixture-based Background/Foreground Segmentation Algorithm. More...
 
class  BaseCascadeClassifier
 
class  BFMatcher
 Brute-force descriptor matcher. More...
 
class  BOWImgDescriptorExtractor
 Class to compute an image descriptor using the bag of visual words. More...
 
class  BOWKMeansTrainer
 kmeans -based class to train visual vocabulary using the bag of visual words approach. : More...
 
class  BOWTrainer
 Abstract base class for training the bag of visual words vocabulary from a set of descriptors. More...
 
class  BRISK
 Class implementing the BRISK keypoint detector and descriptor extractor, described in [LCS11] . More...
 
class  BufferPoolController
 
class  CalibrateCRF
 The base class for camera response calibration algorithms. More...
 
class  CalibrateDebevec
 Inverse camera response function is extracted for each brightness value by minimizing an objective function as linear system. Objective function is constructed using pixel values on the same position in all images, extra term is added to make the result smoother. More...
 
class  CalibrateRobertson
 Inverse camera response function is extracted for each brightness value by minimizing an objective function as linear system. This algorithm uses all image pixels. More...
 
class  CascadeClassifier
 Cascade classifier class for object detection. More...
 
class  ChiHistogramCostExtractor
 An Chi based cost extraction. : More...
 
struct  CirclesGridFinderParameters
 
class  CLAHE
 Base class for Contrast Limited Adaptive Histogram Equalization. More...
 
class  CommandLineParser
 Designed for command line parsing. More...
 
class  Complex
 A complex number class. More...
 
class  CompressedRectilinearPortraitWarper
 
class  CompressedRectilinearWarper
 
class  ConjGradSolver
 This class is used to perform the non-linear non-constrained minimization of a function with known gradient,. More...
 
class  CylindricalWarper
 Cylindrical warper factory class. More...
 
class  DataDepth
 A helper class for cv::DataType. More...
 
class  DataType
 Template "trait" class for OpenCV primitive data types. More...
 
class  DataType< Affine3< _Tp > >
 
class  DataType< bool >
 
class  DataType< char >
 
class  DataType< char1 >
 
class  DataType< char2 >
 
class  DataType< char3 >
 
class  DataType< char4 >
 
class  DataType< Complex< _Tp > >
 
class  DataType< double >
 
class  DataType< double1 >
 
class  DataType< double2 >
 
class  DataType< double3 >
 
class  DataType< double4 >
 
class  DataType< float >
 
class  DataType< float1 >
 
class  DataType< float16_t >
 
class  DataType< float2 >
 
class  DataType< float3 >
 
class  DataType< float4 >
 
class  DataType< int >
 
class  DataType< int1 >
 
class  DataType< int2 >
 
class  DataType< int3 >
 
class  DataType< int4 >
 
class  DataType< Matx< _Tp, m, n > >
 
class  DataType< Moments >
 
class  DataType< Point3_< _Tp > >
 
class  DataType< Point_< _Tp > >
 
class  DataType< Range >
 
class  DataType< Rect_< _Tp > >
 
class  DataType< RotatedRect >
 
class  DataType< Scalar_< _Tp > >
 
class  DataType< schar >
 
class  DataType< short >
 
class  DataType< short1 >
 
class  DataType< short2 >
 
class  DataType< short3 >
 
class  DataType< short4 >
 
class  DataType< Size_< _Tp > >
 
class  DataType< uchar >
 
class  DataType< uchar1 >
 
class  DataType< uchar2 >
 
class  DataType< uchar3 >
 
class  DataType< uchar4 >
 
class  DataType< uint >
 
class  DataType< uint1 >
 
class  DataType< uint2 >
 
class  DataType< uint3 >
 
class  DataType< uint4 >
 
class  DataType< ushort >
 
class  DataType< ushort1 >
 
class  DataType< ushort2 >
 
class  DataType< ushort3 >
 
class  DataType< ushort4 >
 
class  DataType< Vec< _Tp, cn > >
 
struct  DefaultDeleter< CvHaarClassifierCascade >
 
class  DenseOpticalFlow
 
class  DescriptorMatcher
 Abstract base class for matching keypoint descriptors. More...
 
class  DetectionBasedTracker
 
struct  DetectionROI
 struct for detection region of interest (ROI) More...
 
class  DISOpticalFlow
 DIS optical flow algorithm. More...
 
class  DMatch
 Class for matching keypoint descriptors. More...
 
class  DownhillSolver
 This class is used to perform the non-linear non-constrained minimization of a function,. More...
 
class  DualQuat
 
class  EMDHistogramCostExtractor
 An EMD based cost extraction. : More...
 
class  EMDL1HistogramCostExtractor
 An EMD-L1 based cost extraction. : More...
 
class  Exception
 Class passed to an error. More...
 
class  FaceDetectorYN
 DNN-based face detector. More...
 
class  FaceRecognizerSF
 DNN-based face recognizer. More...
 
class  FarnebackOpticalFlow
 Class computing a dense optical flow using the Gunnar Farneback's algorithm. More...
 
class  FastFeatureDetector
 Wrapping class for feature detection using the FAST method. : More...
 
class  Feature2D
 Abstract base class for 2D image feature detectors and descriptor extractors. More...
 
class  FileNode
 File Storage Node class. More...
 
class  FileNodeIterator
 used to iterate through sequences and mappings. More...
 
class  FileStorage
 XML/YAML/JSON file storage class that encapsulates all the information necessary for writing or reading data to/from a file. More...
 
class  FisheyeWarper
 
class  FlannBasedMatcher
 Flann-based descriptor matcher. More...
 
class  float16_t
 
class  Formatted
 
class  Formatter
 
class  GArg
 
class  GArray
 cv::GArray<T> template class represents a list of objects of class T in the graph. More...
 
struct  GArrayDesc
 
class  GCall
 
struct  GCompileArg
 Represents an arbitrary compilation argument. More...
 
class  GCompiled
 Represents a compiled computation (graph). Can only be used with image / data formats & resolutions it was compiled for, with some exceptions. More...
 
class  GComputation
 GComputation class represents a captured computation graph. GComputation objects form boundaries for expression code user writes with G-API, allowing to compile and execute it. More...
 
class  GComputationT
 This class is a typed wrapper over a regular GComputation. More...
 
class  GComputationT< R(Args...)>
 
class  GComputationT< std::tuple< R... >(Args...)>
 
class  GCPUContext
 
class  GCPUKernel
 
class  GCPUKernelImpl
 
class  GCPUStKernelImpl
 
class  GeneralizedHough
 finds arbitrary template in the grayscale image using Generalized Hough Transform More...
 
class  GeneralizedHoughBallard
 finds arbitrary template in the grayscale image using Generalized Hough Transform More...
 
class  GeneralizedHoughGuil
 finds arbitrary template in the grayscale image using Generalized Hough Transform More...
 
class  GFluidKernel
 
class  GFluidKernelImpl
 
struct  GFluidOutputRois
 This structure allows to control the output image region which Fluid backend will produce in the graph. More...
 
struct  GFluidParallelFor
 This structure allows to customize the way how Fluid executes parallel regions. More...
 
struct  GFluidParallelOutputRois
 This structure forces Fluid backend to generate multiple parallel output regions in the graph. These regions execute in parallel. More...
 
class  GFrame
 GFrame class represents an image or media frame in the graph. More...
 
struct  GFrameDesc
 
class  GFTTDetector
 Wrapping class for feature detection using the goodFeaturesToTrack function. : More...
 
struct  GInfer
 
struct  GInferBase
 
struct  GInferList
 
struct  GInferList2
 
struct  GInferList2Base
 
struct  GInferListBase
 
struct  GInferROI
 
struct  GInferROIBase
 
struct  GIOProtoArgs
 
struct  GKernel
 
struct  GKernelImpl
 
class  GKernelPackage
 A container class for heterogeneous kernel implementation collections and graph transformations. More...
 
class  GKernelType
 
class  GKernelType< K, std::function< R(Args...)> >
 
class  GKernelTypeM
 
class  GKernelTypeM< K, std::function< std::tuple< R... >(Args...)> >
 
class  GMat
 GMat class represents image or tensor data in the graph. More...
 
struct  GMatDesc
 
class  GMatP
 
class  GNetworkType
 
class  GNetworkType< K, std::function< R(Args...)> >
 
class  GNetworkType< K, std::function< std::tuple< R... >(Args...)> >
 
class  GOCLContext
 
class  GOCLKernel
 
class  GOCLKernelImpl
 
class  GOpaque
 cv::GOpaque<T> template class represents an object of class T in the graph. More...
 
struct  GOpaqueDesc
 
struct  GPlaidMLContext
 
class  GPlaidMLKernel
 
class  GPlaidMLKernelImpl
 
struct  graph_dump_path
 Ask G-API to dump compiled graph in Graphviz format under the given file name. More...
 
class  GraphicalCodeDetector
 
struct  GRunArg
 
class  GScalar
 GScalar class represents cv::Scalar data in the graph. More...
 
struct  GScalarDesc
 
class  GStreamingCompiled
 Represents a computation (graph) compiled for streaming. More...
 
struct  GTransform
 
class  GTransformImpl
 
class  GTransformImpl< K, std::function< R(Args...)> >
 
struct  GTypeInfo
 
struct  Hamming
 
class  HausdorffDistanceExtractor
 A simple Hausdorff distance measure between shapes defined by contours. More...
 
class  HistogramCostExtractor
 Abstract base class for histogram cost algorithms. More...
 
struct  HOGDescriptor
 Implementation of HOG (Histogram of Oriented Gradients) descriptor and object detector. More...
 
class  ImageCollection
 To read Multi Page images on demand. More...
 
struct  In_Tag
 
struct  InferAPI
 
struct  InferAPIList
 
struct  InferAPIList2
 
struct  InferAPIRoi
 
class  KalmanFilter
 Kalman filter class. More...
 
class  KAZE
 Class implementing the KAZE keypoint detector and descriptor extractor, described in [ABD12] . More...
 
class  KeyPoint
 Data structure for salient point detectors. More...
 
class  KeyPointsFilter
 A class filters a vector of keypoints. More...
 
struct  L1
 
struct  L2
 
class  LDA
 Linear Discriminant Analysis. More...
 
class  LineIterator
 Class for iterating over all pixels on a raster line segment. More...
 
class  LineSegmentDetector
 Line segment detector class. More...
 
class  LMSolver
 
class  Mat
 n-dimensional dense array class More...
 
class  Mat_
 Template matrix class derived from Mat. More...
 
class  MatAllocator
 Custom array allocator. More...
 
class  MatCommaInitializer_
 Comma-separated Matrix Initializer. More...
 
class  MatConstIterator
 
class  MatConstIterator_
 Matrix read-only iterator. More...
 
class  MatExpr
 Matrix expression representation This is a list of implemented matrix operations that can be combined in arbitrary complex expressions (here A, B stand for matrices ( Mat ), s for a scalar ( Scalar ), alpha for a real-valued scalar ( double )): More...
 
class  MatIterator_
 Matrix read-write iterator. More...
 
class  MatOp
 
struct  MatSize
 
struct  MatStep
 
class  Matx
 Template class for small matrices whose type and size are known at compilation time. More...
 
class  MatxCommaInitializer
 Comma-separated Matrix Initializer. More...
 
class  MediaFrame
 cv::MediaFrame class represents an image/media frame obtained from an external source. More...
 
class  MercatorWarper
 
class  MergeDebevec
 The resulting HDR image is calculated as weighted average of the exposures considering exposure values and camera response. More...
 
class  MergeExposures
 The base class algorithms that can merge exposure sequence to a single image. More...
 
class  MergeMertens
 Pixels are weighted using contrast, saturation and well-exposedness measures, than images are combined using laplacian pyramids. More...
 
class  MergeRobertson
 The resulting HDR image is calculated as weighted average of the exposures considering exposure values and camera response. More...
 
class  MinProblemSolver
 Basic interface for all solvers. More...
 
class  Moments
 struct returned by cv::moments More...
 
class  MSER
 Maximally stable extremal region extractor. More...
 
class  NAryMatIterator
 n-ary multi-dimensional array iterator. More...
 
class  Node
 
class  NormHistogramCostExtractor
 A norm based cost extraction. : More...
 
class  ORB
 Class implementing the ORB (oriented BRIEF) keypoint detector and descriptor extractor. More...
 
struct  Out_Tag
 
class  PaniniPortraitWarper
 
class  PaniniWarper
 
class  ParallelLoopBody
 Base class for parallel data processors. More...
 
class  ParallelLoopBodyLambdaWrapper
 
struct  ParamType
 
struct  ParamType< _Tp, typename std::enable_if< std::is_enum< _Tp >::value >::type >
 
struct  ParamType< Algorithm >
 
struct  ParamType< bool >
 
struct  ParamType< double >
 
struct  ParamType< float >
 
struct  ParamType< int >
 
struct  ParamType< Mat >
 
struct  ParamType< Scalar >
 
struct  ParamType< std::vector< Mat > >
 
struct  ParamType< String >
 
struct  ParamType< uchar >
 
struct  ParamType< uint64 >
 
struct  ParamType< unsigned >
 
class  PCA
 Principal Component Analysis. More...
 
class  PlaneWarper
 Plane warper factory class. More...
 
class  Point3_
 Template class for 3D points specified by its coordinates x, y and z. More...
 
class  Point_
 Template class for 2D points specified by its coordinates x and y. More...
 
class  PyRotationWarper
 
class  QRCodeDetector
 
class  QRCodeDetectorAruco
 
class  QRCodeEncoder
 
struct  QtFont
 QtFont available only for Qt. See cv::fontQt. More...
 
class  Quat
 
class  QuatEnum
 
class  Range
 Template class specifying a continuous subsequence (slice) of a sequence. More...
 
class  Rect_
 Template class for 2D rectangles. More...
 
class  RMat
 
class  RNG
 Random Number Generator. More...
 
class  RNG_MT19937
 Mersenne Twister random number generator. More...
 
class  RotatedRect
 The class represents rotated (i.e. not up-right) rectangles on a plane. More...
 
class  Scalar_
 Template class for a 4-element vector derived from Vec. More...
 
class  ShapeContextDistanceExtractor
 Implementation of the Shape Context descriptor and matching algorithm. More...
 
class  ShapeDistanceExtractor
 Abstract base class for shape distance algorithms. More...
 
class  ShapeTransformer
 Abstract base class for shape transformation algorithms. More...
 
class  SIFT
 Class for extracting keypoints and computing descriptors using the Scale Invariant Feature Transform (SIFT) algorithm by D. Lowe [Lowe04] . More...
 
class  SimilarRects
 This class is used for grouping object candidates detected by Cascade Classifier, HOG etc. More...
 
class  SimpleBlobDetector
 Class for extracting blobs from an image. : More...
 
class  Size_
 Template class for specifying the size of an image or rectangle. More...
 
struct  SL2
 
struct  softdouble
 
struct  softfloat
 
class  SparseMat
 The class SparseMat represents multi-dimensional sparse numerical arrays. More...
 
class  SparseMat_
 Template sparse n-dimensional array class derived from SparseMat. More...
 
class  SparseMatConstIterator
 Read-Only Sparse Matrix Iterator. More...
 
class  SparseMatConstIterator_
 Template Read-Only Sparse Matrix Iterator Class. More...
 
class  SparseMatIterator
 Read-write Sparse Matrix Iterator. More...
 
class  SparseMatIterator_
 Template Read-Write Sparse Matrix Iterator Class. More...
 
class  SparseOpticalFlow
 Base interface for sparse optical flow algorithms. More...
 
class  SparsePyrLKOpticalFlow
 Class used for calculating a sparse optical flow. More...
 
class  SphericalWarper
 Spherical warper factory class. More...
 
class  StereoBM
 Class for computing stereo correspondence using the block matching algorithm, introduced and contributed to OpenCV by K. Konolige. More...
 
class  StereographicWarper
 
class  StereoMatcher
 The base class for stereo correspondence algorithms. More...
 
class  StereoSGBM
 The class implements the modified H. Hirschmuller algorithm [HH08] that differs from the original one as follows: More...
 
class  Stitcher
 High level image stitcher. More...
 
class  Subdiv2D
 
class  SVD
 Singular Value Decomposition. More...
 
class  TermCriteria
 The class defining termination criteria for iterative algorithms. More...
 
class  ThinPlateSplineShapeTransformer
 Definition of the transformation. More...
 
class  TickMeter
 a Class to measure passing time. More...
 
class  TLSData
 Simple TLS data class. More...
 
class  TLSDataAccumulator
 TLS data accumulator with gathering methods. More...
 
class  TLSDataContainer
 
class  Tonemap
 Base class for tonemapping algorithms - tools that are used to map HDR image to 8-bit range. More...
 
class  TonemapDrago
 Adaptive logarithmic mapping is a fast global tonemapping algorithm that scales the image in logarithmic domain. More...
 
class  TonemapMantiuk
 This algorithm transforms image to contrast using gradients on all levels of gaussian pyramid, transforms contrast values to HVS response and scales the response. After this the image is reconstructed from new contrast values. More...
 
class  TonemapReinhard
 This is a global tonemapping operator that models human visual system. More...
 
class  Tracker
 Base abstract class for the long-term tracker. More...
 
class  TrackerCSRT
 the CSRT tracker More...
 
class  TrackerDaSiamRPN
 
class  TrackerGOTURN
 the GOTURN (Generic Object Tracking Using Regression Networks) tracker More...
 
class  TrackerKCF
 the KCF (Kernelized Correlation Filter) tracker More...
 
class  TrackerMIL
 The MIL algorithm trains a classifier in an online manner to separate the object from the background. More...
 
class  TrackerNano
 the Nano tracker is a super lightweight dnn-based general object tracking. More...
 
class  TrackerVit
 the VIT tracker is a super lightweight dnn-based general object tracking. More...
 
class  TransverseMercatorWarper
 
class  UMat
 
struct  UMatData
 
struct  UsacParams
 
struct  v_float32x4
 
struct  v_float64x2
 
struct  v_int16x8
 
struct  v_int32x4
 
struct  v_int64x2
 
struct  v_int8x16
 
struct  v_reg
 
struct  V_TypeTraits
 
struct  V_TypeTraits< double >
 
struct  V_TypeTraits< float >
 
struct  V_TypeTraits< int >
 
struct  V_TypeTraits< int64 >
 
struct  V_TypeTraits< schar >
 
struct  V_TypeTraits< short >
 
struct  V_TypeTraits< uchar >
 
struct  V_TypeTraits< uint64 >
 
struct  V_TypeTraits< unsigned >
 
struct  V_TypeTraits< ushort >
 
struct  v_uint16x8
 
struct  v_uint32x4
 
struct  v_uint64x2
 
struct  v_uint8x16
 
class  VariationalRefinement
 Variational optical flow refinement. More...
 
class  Vec
 Template class for short numerical vectors, a partial case of Matx. More...
 
class  VecCommaInitializer
 Comma-separated Vec Initializer. More...
 
struct  vfloat32mf2_t
 
struct  vfloat64mf2_t
 
class  VideoCapture
 Class for video capturing from video files, image sequences or cameras. More...
 
class  VideoWriter
 Video writer class. More...
 
struct  vint16mf2_t
 
struct  vint32mf2_t
 
struct  vint64mf2_t
 
struct  vint8mf2_t
 
struct  vint8mf4_t
 
struct  VTraits
 
struct  VTraits< vfloat32m1_t >
 
struct  VTraits< vfloat32m2_t >
 
struct  VTraits< vfloat32m4_t >
 
struct  VTraits< vfloat32m8_t >
 
struct  VTraits< vfloat64m1_t >
 
struct  VTraits< vfloat64m2_t >
 
struct  VTraits< vfloat64m4_t >
 
struct  VTraits< vfloat64m8_t >
 
struct  VTraits< vint16m1_t >
 
struct  VTraits< vint16m2_t >
 
struct  VTraits< vint16m4_t >
 
struct  VTraits< vint16m8_t >
 
struct  VTraits< vint32m1_t >
 
struct  VTraits< vint32m2_t >
 
struct  VTraits< vint32m4_t >
 
struct  VTraits< vint32m8_t >
 
struct  VTraits< vint64m1_t >
 
struct  VTraits< vint64m2_t >
 
struct  VTraits< vint64m4_t >
 
struct  VTraits< vint64m8_t >
 
struct  VTraits< vint8m1_t >
 
struct  VTraits< vint8m2_t >
 
struct  VTraits< vint8m4_t >
 
struct  VTraits< vint8m8_t >
 
struct  VTraits< vuint16m1_t >
 
struct  VTraits< vuint16m2_t >
 
struct  VTraits< vuint16m4_t >
 
struct  VTraits< vuint16m8_t >
 
struct  VTraits< vuint32m1_t >
 
struct  VTraits< vuint32m2_t >
 
struct  VTraits< vuint32m4_t >
 
struct  VTraits< vuint32m8_t >
 
struct  VTraits< vuint64m1_t >
 
struct  VTraits< vuint64m2_t >
 
struct  VTraits< vuint64m4_t >
 
struct  VTraits< vuint64m8_t >
 
struct  VTraits< vuint8m1_t >
 
struct  VTraits< vuint8m2_t >
 
struct  VTraits< vuint8m4_t >
 
struct  VTraits< vuint8m8_t >
 
struct  vuint16mf2_t
 
struct  vuint32mf2_t
 
struct  vuint64mf2_t
 
struct  vuint8mf2_t
 
struct  vuint8mf4_t
 
class  WarperCreator
 Image warper factories base class. More...
 

Typedefs

typedef Affine3< double > Affine3d
 
typedef Affine3< float > Affine3f
 
typedef AffineFeature AffineDescriptorExtractor
 
typedef AffineFeature AffineFeatureDetector
 
typedef std::lock_guard< cv::MutexAutoLock
 
typedef void(* ButtonCallback) (int state, void *userdata)
 Callback function for a button created by cv::createButton.
 
typedef CirclesGridFinderParameters CirclesGridFinderParameters2
 
typedef Complex< double > Complexd
 
typedef Complex< float > Complexf
 
typedef Feature2D DescriptorExtractor
 
using DualQuatd = DualQuat< double >
 
using DualQuatf = DualQuat< float >
 
typedef int(* ErrorCallback) (int status, const char *func_name, const char *err_msg, const char *file_name, int line, void *userdata)
 
typedef Feature2D FeatureDetector
 
typedef details::FPDenormalsIgnoreHintScopeNOOP FPDenormalsIgnoreHintScope
 
typedef frame_list::iterator frame_iterator
 
typedef std::deque< std::pair< uint64_t, uint32_t > > frame_list
 
using GArgs = std::vector< GArg >
 
using GCompileArgs = std::vector< GCompileArg >
 
using GCtors = std::vector< detail::HostCtor >
 
using GInferInputs = cv::detail::GInferInputsTyped< cv::GMat, cv::GFrame >
 G-API object used to collect network inputs.
 
using GInferListInputs = cv::detail::GInferInputsTyped< cv::GArray< cv::GMat >, cv::GArray< cv::Rect > >
 G-API object used to collect the list of network inputs.
 
using GInferListOutputs = cv::detail::GInferOutputsTyped< cv::GArray< cv::GMat > >
 G-API object used to collect the list of network outputs.
 
using GInferOutputs = cv::detail::GInferOutputsTyped< cv::GMat >
 G-API object used to collect network outputs.
 
using GKinds = std::vector< cv::detail::OpaqueKind >
 
using GMetaArg = util::variant< util::monostate, GMatDesc, GScalarDesc, GArrayDesc, GOpaqueDesc, GFrameDesc >
 
using GMetaArgs = std::vector< GMetaArg >
 
using GOptRunArg = util::variant< optional< cv::Mat >, optional< cv::RMat >, optional< cv::MediaFrame >, optional< cv::Scalar >, optional< cv::detail::VectorRef >, optional< cv::detail::OpaqueRef > >
 
using GOptRunArgP = util::variant< optional< cv::Mat > *, optional< cv::RMat > *, optional< cv::MediaFrame > *, optional< cv::Scalar > *, cv::detail::OptionalVectorRef, cv::detail::OptionalOpaqueRef >
 
using GOptRunArgs = std::vector< GOptRunArg >
 
using GOptRunArgsP = std::vector< GOptRunArgP >
 
using GProtoArg = util::variant< GMat, GMatP, GFrame, GScalar, detail::GArrayU, detail::GOpaqueU >
 
using GProtoArgs = std::vector< GProtoArg >
 
using GProtoInputArgs = GIOProtoArgs< In_Tag >
 
using GProtoOutputArgs = GIOProtoArgs< Out_Tag >
 
using GRunArgBase = util::variant< cv::UMat, cv::RMat, cv::gapi::wip::IStreamSource::Ptr, cv::Mat, cv::Scalar, cv::detail::VectorRef, cv::detail::OpaqueRef, cv::MediaFrame >
 
using GRunArgP = util::variant< cv::UMat *, cv::Mat *, cv::RMat *, cv::Scalar *, cv::MediaFrame *, cv::detail::VectorRef, cv::detail::OpaqueRef >
 
using GRunArgs = std::vector< GRunArg >
 
using GRunArgsP = std::vector< GRunArgP >
 
using GShapes = std::vector< GShape >
 
using GTypesInfo = std::vector< GTypeInfo >
 
typedef Hamming HammingLUT
 
typedef const _InputArrayInputArray
 
typedef InputArray InputArrayOfArrays
 
typedef const _InputOutputArrayInputOutputArray
 
typedef InputOutputArray InputOutputArrayOfArrays
 
typedef ::int16_t int16_t
 
typedef ::int32_t int32_t
 
using int64 = long int
 
typedef ::int64_t int64_t
 
typedef ::int8_t int8_t
 
typedef Mat_< ucharMat1b
 
typedef Mat_< double > Mat1d
 
typedef Mat_< float > Mat1f
 
typedef Mat_< int > Mat1i
 
typedef Mat_< short > Mat1s
 
typedef Mat_< ushortMat1w
 
typedef Mat_< Vec2bMat2b
 
typedef Mat_< Vec2dMat2d
 
typedef Mat_< Vec2fMat2f
 
typedef Mat_< Vec2iMat2i
 
typedef Mat_< Vec2sMat2s
 
typedef Mat_< Vec2wMat2w
 
typedef Mat_< Vec3bMat3b
 
typedef Mat_< Vec3dMat3d
 
typedef Mat_< Vec3fMat3f
 
typedef Mat_< Vec3iMat3i
 
typedef Mat_< Vec3sMat3s
 
typedef Mat_< Vec3wMat3w
 
typedef Mat_< Vec4bMat4b
 
typedef Mat_< Vec4dMat4d
 
typedef Mat_< Vec4fMat4f
 
typedef Mat_< Vec4iMat4i
 
typedef Mat_< Vec4sMat4s
 
typedef Mat_< Vec4wMat4w
 
typedef Matx< double, 1, 2 > Matx12d
 
typedef Matx< float, 1, 2 > Matx12f
 
typedef Matx< double, 1, 3 > Matx13d
 
typedef Matx< float, 1, 3 > Matx13f
 
typedef Matx< double, 1, 4 > Matx14d
 
typedef Matx< float, 1, 4 > Matx14f
 
typedef Matx< double, 1, 6 > Matx16d
 
typedef Matx< float, 1, 6 > Matx16f
 
typedef Matx< double, 2, 1 > Matx21d
 
typedef Matx< float, 2, 1 > Matx21f
 
typedef Matx< double, 2, 2 > Matx22d
 
typedef Matx< float, 2, 2 > Matx22f
 
typedef Matx< double, 2, 3 > Matx23d
 
typedef Matx< float, 2, 3 > Matx23f
 
typedef Matx< double, 3, 1 > Matx31d
 
typedef Matx< float, 3, 1 > Matx31f
 
typedef Matx< double, 3, 2 > Matx32d
 
typedef Matx< float, 3, 2 > Matx32f
 
typedef Matx< double, 3, 3 > Matx33d
 
typedef Matx< float, 3, 3 > Matx33f
 
typedef Matx< double, 3, 4 > Matx34d
 
typedef Matx< float, 3, 4 > Matx34f
 
typedef Matx< double, 4, 1 > Matx41d
 
typedef Matx< float, 4, 1 > Matx41f
 
typedef Matx< double, 4, 3 > Matx43d
 
typedef Matx< float, 4, 3 > Matx43f
 
typedef Matx< double, 4, 4 > Matx44d
 
typedef Matx< float, 4, 4 > Matx44f
 
typedef Matx< double, 6, 1 > Matx61d
 
typedef Matx< float, 6, 1 > Matx61f
 
typedef Matx< double, 6, 6 > Matx66d
 
typedef Matx< float, 6, 6 > Matx66f
 
typedef void(* MouseCallback) (int event, int x, int y, int flags, void *userdata)
 Callback function for mouse events. see cv::setMouseCallback.
 
typedef std::recursive_mutex Mutex
 
typedef void(* OpenGlDrawCallback) (void *userdata)
 Callback function defined to be called every frame. See cv::setOpenGlDrawCallback.
 
template<class T >
using optional = cv::util::optional< T >
 
typedef const _OutputArrayOutputArray
 
typedef OutputArray OutputArrayOfArrays
 
typedef Point2i Point
 
typedef Point_< double > Point2d
 
typedef Point_< float > Point2f
 
typedef Point_< int > Point2i
 
typedef Point_< int64Point2l
 
typedef Point3_< double > Point3d
 
typedef Point3_< float > Point3f
 
typedef Point3_< int > Point3i
 
template<typename _Tp >
using Ptr = std::shared_ptr< _Tp >
 
using Quatd = Quat< double >
 
using Quatf = Quat< float >
 
typedef Rect2i Rect
 
typedef Rect_< double > Rect2d
 
typedef Rect_< float > Rect2f
 
typedef Rect_< int > Rect2i
 
typedef Scalar_< double > Scalar
 
using schar = signed char
 
typedef SIFT SiftDescriptorExtractor
 
typedef SIFT SiftFeatureDetector
 
typedef Size2i Size
 
typedef Size_< double > Size2d
 
typedef Size_< float > Size2f
 
typedef Size_< int > Size2i
 
typedef Size_< int64Size2l
 
typedef std::string String
 
typedef void(* TrackbarCallback) (int pos, void *userdata)
 Callback function for Trackbar see cv::createTrackbar.
 
using uchar = unsigned char
 
using uint = unsigned int
 
typedef ::uint16_t uint16_t
 
typedef ::uint32_t uint32_t
 
using uint64 = unsigned long int
 
typedef ::uint64_t uint64_t
 
typedef ::uint8_t uint8_t
 
using ushort = unsigned short
 
using v_float32 = vfloat32m1_t
 
typedef v_reg< float, 16 > v_float32x16
 Sixteen 32-bit floating point values (single precision)
 
typedef v_reg< float, 4 > v_float32x4
 Four 32-bit floating point values (single precision)
 
typedef v_reg< float, 8 > v_float32x8
 Eight 32-bit floating point values (single precision)
 
using v_float64 = vfloat64m1_t
 
typedef v_reg< double, 2 > v_float64x2
 Two 64-bit floating point values (double precision)
 
typedef v_reg< double, 4 > v_float64x4
 Four 64-bit floating point values (double precision)
 
typedef v_reg< double, 8 > v_float64x8
 Eight 64-bit floating point values (double precision)
 
using v_int16 = vint16m1_t
 
typedef v_reg< short, 16 > v_int16x16
 Sixteen 16-bit signed integer values.
 
typedef v_reg< short, 32 > v_int16x32
 Thirty two 16-bit signed integer values.
 
typedef v_reg< short, 8 > v_int16x8
 Eight 16-bit signed integer values.
 
using v_int32 = vint32m1_t
 
typedef v_reg< int, 16 > v_int32x16
 Sixteen 32-bit signed integer values.
 
typedef v_reg< int, 4 > v_int32x4
 Four 32-bit signed integer values.
 
typedef v_reg< int, 8 > v_int32x8
 Eight 32-bit signed integer values.
 
using v_int64 = vint64m1_t
 
typedef v_reg< int64, 2 > v_int64x2
 Two 64-bit signed integer values.
 
typedef v_reg< int64, 4 > v_int64x4
 Four 64-bit signed integer values.
 
typedef v_reg< int64, 8 > v_int64x8
 Eight 64-bit signed integer values.
 
using v_int8 = vint8m1_t
 
typedef v_reg< schar, 16 > v_int8x16
 Sixteen 8-bit signed integer values.
 
typedef v_reg< schar, 32 > v_int8x32
 Thirty two 8-bit signed integer values.
 
typedef v_reg< schar, 64 > v_int8x64
 Sixty four 8-bit signed integer values.
 
using v_uint16 = vuint16m1_t
 
typedef v_reg< ushort, 16 > v_uint16x16
 Sixteen 16-bit unsigned integer values.
 
typedef v_reg< ushort, 32 > v_uint16x32
 Thirty two 16-bit unsigned integer values.
 
typedef v_reg< ushort, 8 > v_uint16x8
 Eight 16-bit unsigned integer values.
 
using v_uint32 = vuint32m1_t
 
typedef v_reg< unsigned, 16 > v_uint32x16
 Sixteen 32-bit unsigned integer values.
 
typedef v_reg< unsigned, 4 > v_uint32x4
 Four 32-bit unsigned integer values.
 
typedef v_reg< unsigned, 8 > v_uint32x8
 Eight 32-bit unsigned integer values.
 
using v_uint64 = vuint64m1_t
 
typedef v_reg< uint64, 2 > v_uint64x2
 Two 64-bit unsigned integer values.
 
typedef v_reg< uint64, 4 > v_uint64x4
 Four 64-bit unsigned integer values.
 
typedef v_reg< uint64, 8 > v_uint64x8
 Eight 64-bit unsigned integer values.
 
using v_uint8 = vuint8m1_t
 
typedef v_reg< uchar, 16 > v_uint8x16
 Sixteen 8-bit unsigned integer values.
 
typedef v_reg< uchar, 32 > v_uint8x32
 Thirty two 8-bit unsigned integer values.
 
typedef v_reg< uchar, 64 > v_uint8x64
 Sixty four 8-bit unsigned integer values.
 
Shorter aliases for the most popular specializations of Vec<T,n>
typedef Vec< uchar, 2 > Vec2b
 
typedef Vec< uchar, 3 > Vec3b
 
typedef Vec< uchar, 4 > Vec4b
 
typedef Vec< short, 2 > Vec2s
 
typedef Vec< short, 3 > Vec3s
 
typedef Vec< short, 4 > Vec4s
 
typedef Vec< ushort, 2 > Vec2w
 
typedef Vec< ushort, 3 > Vec3w
 
typedef Vec< ushort, 4 > Vec4w
 
typedef Vec< int, 2 > Vec2i
 
typedef Vec< int, 3 > Vec3i
 
typedef Vec< int, 4 > Vec4i
 
typedef Vec< int, 6 > Vec6i
 
typedef Vec< int, 8 > Vec8i
 
typedef Vec< float, 2 > Vec2f
 
typedef Vec< float, 3 > Vec3f
 
typedef Vec< float, 4 > Vec4f
 
typedef Vec< float, 6 > Vec6f
 
typedef Vec< double, 2 > Vec2d
 
typedef Vec< double, 3 > Vec3d
 
typedef Vec< double, 4 > Vec4d
 
typedef Vec< double, 6 > Vec6d
 

Enumerations

enum  {
  OPEN_CAMERA = 300 ,
  CLOSE_CAMERA ,
  UPDATE_IMAGE_ELEMENT ,
  SHOW_TRACKBAR
}
 
enum  {
  COLORSPACE_GRAY =0 ,
  COLORSPACE_RGBA =1 ,
  COLORSPACE_BGR =2 ,
  COLORSPACE_YUV444P =3
}
 
enum  {
  OPTFLOW_USE_INITIAL_FLOW = 4 ,
  OPTFLOW_LK_GET_MIN_EIGENVALS = 8 ,
  OPTFLOW_FARNEBACK_GAUSSIAN = 256
}
 
enum  {
  MOTION_TRANSLATION = 0 ,
  MOTION_EUCLIDEAN = 1 ,
  MOTION_AFFINE = 2 ,
  MOTION_HOMOGRAPHY = 3
}
 
enum  {
  LMEDS = 4 ,
  RANSAC = 8 ,
  RHO = 16 ,
  USAC_DEFAULT = 32 ,
  USAC_PARALLEL = 33 ,
  USAC_FM_8PTS = 34 ,
  USAC_FAST = 35 ,
  USAC_ACCURATE = 36 ,
  USAC_PROSAC = 37 ,
  USAC_MAGSAC = 38
}
 type of the robust estimation algorithm More...
 
enum  {
  CALIB_CB_ADAPTIVE_THRESH = 1 ,
  CALIB_CB_NORMALIZE_IMAGE = 2 ,
  CALIB_CB_FILTER_QUADS = 4 ,
  CALIB_CB_FAST_CHECK = 8 ,
  CALIB_CB_EXHAUSTIVE = 16 ,
  CALIB_CB_ACCURACY = 32 ,
  CALIB_CB_LARGER = 64 ,
  CALIB_CB_MARKER = 128
}
 
enum  {
  CALIB_CB_SYMMETRIC_GRID = 1 ,
  CALIB_CB_ASYMMETRIC_GRID = 2 ,
  CALIB_CB_CLUSTERING = 4
}
 
enum  {
  CALIB_NINTRINSIC = 18 ,
  CALIB_USE_INTRINSIC_GUESS = 0x00001 ,
  CALIB_FIX_ASPECT_RATIO = 0x00002 ,
  CALIB_FIX_PRINCIPAL_POINT = 0x00004 ,
  CALIB_ZERO_TANGENT_DIST = 0x00008 ,
  CALIB_FIX_FOCAL_LENGTH = 0x00010 ,
  CALIB_FIX_K1 = 0x00020 ,
  CALIB_FIX_K2 = 0x00040 ,
  CALIB_FIX_K3 = 0x00080 ,
  CALIB_FIX_K4 = 0x00800 ,
  CALIB_FIX_K5 = 0x01000 ,
  CALIB_FIX_K6 = 0x02000 ,
  CALIB_RATIONAL_MODEL = 0x04000 ,
  CALIB_THIN_PRISM_MODEL = 0x08000 ,
  CALIB_FIX_S1_S2_S3_S4 = 0x10000 ,
  CALIB_TILTED_MODEL = 0x40000 ,
  CALIB_FIX_TAUX_TAUY = 0x80000 ,
  CALIB_USE_QR = 0x100000 ,
  CALIB_FIX_TANGENT_DIST = 0x200000 ,
  CALIB_FIX_INTRINSIC = 0x00100 ,
  CALIB_SAME_FOCAL_LENGTH = 0x00200 ,
  CALIB_ZERO_DISPARITY = 0x00400 ,
  CALIB_USE_LU = (1 << 17) ,
  CALIB_USE_EXTRINSIC_GUESS = (1 << 22)
}
 
enum  {
  FM_7POINT = 1 ,
  FM_8POINT = 2 ,
  FM_LMEDS = 4 ,
  FM_RANSAC = 8
}
 the algorithm for finding fundamental matrix More...
 
enum  {
  CASCADE_DO_CANNY_PRUNING = 1 ,
  CASCADE_SCALE_IMAGE = 2 ,
  CASCADE_FIND_BIGGEST_OBJECT = 4 ,
  CASCADE_DO_ROUGH_SEARCH = 8
}
 
enum  {
  INPAINT_NS = 0 ,
  INPAINT_TELEA = 1
}
 
enum  { LDR_SIZE = 256 }
 
enum  {
  NORMAL_CLONE = 1 ,
  MIXED_CLONE = 2 ,
  MONOCHROME_TRANSFER = 3
}
 seamlessClone algorithm flags More...
 
enum  {
  RECURS_FILTER = 1 ,
  NORMCONV_FILTER = 2
}
 Edge preserving filters. More...
 
enum  {
  simd128_width = 16 ,
  simd256_width = 32 ,
  simd512_width = 64 ,
  simdmax_width = simd512_width
}
 
enum  AccessFlag {
  ACCESS_READ =1<<24 ,
  ACCESS_WRITE =1<<25 ,
  ACCESS_RW =3<<24 ,
  ACCESS_MASK =ACCESS_RW ,
  ACCESS_FAST =1<<26
}
 
enum  AdaptiveThresholdTypes {
  ADAPTIVE_THRESH_MEAN_C = 0 ,
  ADAPTIVE_THRESH_GAUSSIAN_C = 1
}
 
enum  BorderTypes {
  BORDER_CONSTANT = 0 ,
  BORDER_REPLICATE = 1 ,
  BORDER_REFLECT = 2 ,
  BORDER_WRAP = 3 ,
  BORDER_REFLECT_101 = 4 ,
  BORDER_TRANSPARENT = 5 ,
  BORDER_REFLECT101 = BORDER_REFLECT_101 ,
  BORDER_DEFAULT = BORDER_REFLECT_101 ,
  BORDER_ISOLATED = 16
}
 
enum  CmpTypes {
  CMP_EQ = 0 ,
  CMP_GT = 1 ,
  CMP_GE = 2 ,
  CMP_LT = 3 ,
  CMP_LE = 4 ,
  CMP_NE = 5
}
 comparison types More...
 
enum  Codecs { MJPEG }
 
enum  ColorConversionCodes {
  COLOR_BGR2BGRA = 0 ,
  COLOR_RGB2RGBA = COLOR_BGR2BGRA ,
  COLOR_BGRA2BGR = 1 ,
  COLOR_RGBA2RGB = COLOR_BGRA2BGR ,
  COLOR_BGR2RGBA = 2 ,
  COLOR_RGB2BGRA = COLOR_BGR2RGBA ,
  COLOR_RGBA2BGR = 3 ,
  COLOR_BGRA2RGB = COLOR_RGBA2BGR ,
  COLOR_BGR2RGB = 4 ,
  COLOR_RGB2BGR = COLOR_BGR2RGB ,
  COLOR_BGRA2RGBA = 5 ,
  COLOR_RGBA2BGRA = COLOR_BGRA2RGBA ,
  COLOR_BGR2GRAY = 6 ,
  COLOR_RGB2GRAY = 7 ,
  COLOR_GRAY2BGR = 8 ,
  COLOR_GRAY2RGB = COLOR_GRAY2BGR ,
  COLOR_GRAY2BGRA = 9 ,
  COLOR_GRAY2RGBA = COLOR_GRAY2BGRA ,
  COLOR_BGRA2GRAY = 10 ,
  COLOR_RGBA2GRAY = 11 ,
  COLOR_BGR2BGR565 = 12 ,
  COLOR_RGB2BGR565 = 13 ,
  COLOR_BGR5652BGR = 14 ,
  COLOR_BGR5652RGB = 15 ,
  COLOR_BGRA2BGR565 = 16 ,
  COLOR_RGBA2BGR565 = 17 ,
  COLOR_BGR5652BGRA = 18 ,
  COLOR_BGR5652RGBA = 19 ,
  COLOR_GRAY2BGR565 = 20 ,
  COLOR_BGR5652GRAY = 21 ,
  COLOR_BGR2BGR555 = 22 ,
  COLOR_RGB2BGR555 = 23 ,
  COLOR_BGR5552BGR = 24 ,
  COLOR_BGR5552RGB = 25 ,
  COLOR_BGRA2BGR555 = 26 ,
  COLOR_RGBA2BGR555 = 27 ,
  COLOR_BGR5552BGRA = 28 ,
  COLOR_BGR5552RGBA = 29 ,
  COLOR_GRAY2BGR555 = 30 ,
  COLOR_BGR5552GRAY = 31 ,
  COLOR_BGR2XYZ = 32 ,
  COLOR_RGB2XYZ = 33 ,
  COLOR_XYZ2BGR = 34 ,
  COLOR_XYZ2RGB = 35 ,
  COLOR_BGR2YCrCb = 36 ,
  COLOR_RGB2YCrCb = 37 ,
  COLOR_YCrCb2BGR = 38 ,
  COLOR_YCrCb2RGB = 39 ,
  COLOR_BGR2HSV = 40 ,
  COLOR_RGB2HSV = 41 ,
  COLOR_BGR2Lab = 44 ,
  COLOR_RGB2Lab = 45 ,
  COLOR_BGR2Luv = 50 ,
  COLOR_RGB2Luv = 51 ,
  COLOR_BGR2HLS = 52 ,
  COLOR_RGB2HLS = 53 ,
  COLOR_HSV2BGR = 54 ,
  COLOR_HSV2RGB = 55 ,
  COLOR_Lab2BGR = 56 ,
  COLOR_Lab2RGB = 57 ,
  COLOR_Luv2BGR = 58 ,
  COLOR_Luv2RGB = 59 ,
  COLOR_HLS2BGR = 60 ,
  COLOR_HLS2RGB = 61 ,
  COLOR_BGR2HSV_FULL = 66 ,
  COLOR_RGB2HSV_FULL = 67 ,
  COLOR_BGR2HLS_FULL = 68 ,
  COLOR_RGB2HLS_FULL = 69 ,
  COLOR_HSV2BGR_FULL = 70 ,
  COLOR_HSV2RGB_FULL = 71 ,
  COLOR_HLS2BGR_FULL = 72 ,
  COLOR_HLS2RGB_FULL = 73 ,
  COLOR_LBGR2Lab = 74 ,
  COLOR_LRGB2Lab = 75 ,
  COLOR_LBGR2Luv = 76 ,
  COLOR_LRGB2Luv = 77 ,
  COLOR_Lab2LBGR = 78 ,
  COLOR_Lab2LRGB = 79 ,
  COLOR_Luv2LBGR = 80 ,
  COLOR_Luv2LRGB = 81 ,
  COLOR_BGR2YUV = 82 ,
  COLOR_RGB2YUV = 83 ,
  COLOR_YUV2BGR = 84 ,
  COLOR_YUV2RGB = 85 ,
  COLOR_YUV2RGB_NV12 = 90 ,
  COLOR_YUV2BGR_NV12 = 91 ,
  COLOR_YUV2RGB_NV21 = 92 ,
  COLOR_YUV2BGR_NV21 = 93 ,
  COLOR_YUV420sp2RGB = COLOR_YUV2RGB_NV21 ,
  COLOR_YUV420sp2BGR = COLOR_YUV2BGR_NV21 ,
  COLOR_YUV2RGBA_NV12 = 94 ,
  COLOR_YUV2BGRA_NV12 = 95 ,
  COLOR_YUV2RGBA_NV21 = 96 ,
  COLOR_YUV2BGRA_NV21 = 97 ,
  COLOR_YUV420sp2RGBA = COLOR_YUV2RGBA_NV21 ,
  COLOR_YUV420sp2BGRA = COLOR_YUV2BGRA_NV21 ,
  COLOR_YUV2RGB_YV12 = 98 ,
  COLOR_YUV2BGR_YV12 = 99 ,
  COLOR_YUV2RGB_IYUV = 100 ,
  COLOR_YUV2BGR_IYUV = 101 ,
  COLOR_YUV2RGB_I420 = COLOR_YUV2RGB_IYUV ,
  COLOR_YUV2BGR_I420 = COLOR_YUV2BGR_IYUV ,
  COLOR_YUV420p2RGB = COLOR_YUV2RGB_YV12 ,
  COLOR_YUV420p2BGR = COLOR_YUV2BGR_YV12 ,
  COLOR_YUV2RGBA_YV12 = 102 ,
  COLOR_YUV2BGRA_YV12 = 103 ,
  COLOR_YUV2RGBA_IYUV = 104 ,
  COLOR_YUV2BGRA_IYUV = 105 ,
  COLOR_YUV2RGBA_I420 = COLOR_YUV2RGBA_IYUV ,
  COLOR_YUV2BGRA_I420 = COLOR_YUV2BGRA_IYUV ,
  COLOR_YUV420p2RGBA = COLOR_YUV2RGBA_YV12 ,
  COLOR_YUV420p2BGRA = COLOR_YUV2BGRA_YV12 ,
  COLOR_YUV2GRAY_420 = 106 ,
  COLOR_YUV2GRAY_NV21 = COLOR_YUV2GRAY_420 ,
  COLOR_YUV2GRAY_NV12 = COLOR_YUV2GRAY_420 ,
  COLOR_YUV2GRAY_YV12 = COLOR_YUV2GRAY_420 ,
  COLOR_YUV2GRAY_IYUV = COLOR_YUV2GRAY_420 ,
  COLOR_YUV2GRAY_I420 = COLOR_YUV2GRAY_420 ,
  COLOR_YUV420sp2GRAY = COLOR_YUV2GRAY_420 ,
  COLOR_YUV420p2GRAY = COLOR_YUV2GRAY_420 ,
  COLOR_YUV2RGB_UYVY = 107 ,
  COLOR_YUV2BGR_UYVY = 108 ,
  COLOR_YUV2RGB_Y422 = COLOR_YUV2RGB_UYVY ,
  COLOR_YUV2BGR_Y422 = COLOR_YUV2BGR_UYVY ,
  COLOR_YUV2RGB_UYNV = COLOR_YUV2RGB_UYVY ,
  COLOR_YUV2BGR_UYNV = COLOR_YUV2BGR_UYVY ,
  COLOR_YUV2RGBA_UYVY = 111 ,
  COLOR_YUV2BGRA_UYVY = 112 ,
  COLOR_YUV2RGBA_Y422 = COLOR_YUV2RGBA_UYVY ,
  COLOR_YUV2BGRA_Y422 = COLOR_YUV2BGRA_UYVY ,
  COLOR_YUV2RGBA_UYNV = COLOR_YUV2RGBA_UYVY ,
  COLOR_YUV2BGRA_UYNV = COLOR_YUV2BGRA_UYVY ,
  COLOR_YUV2RGB_YUY2 = 115 ,
  COLOR_YUV2BGR_YUY2 = 116 ,
  COLOR_YUV2RGB_YVYU = 117 ,
  COLOR_YUV2BGR_YVYU = 118 ,
  COLOR_YUV2RGB_YUYV = COLOR_YUV2RGB_YUY2 ,
  COLOR_YUV2BGR_YUYV = COLOR_YUV2BGR_YUY2 ,
  COLOR_YUV2RGB_YUNV = COLOR_YUV2RGB_YUY2 ,
  COLOR_YUV2BGR_YUNV = COLOR_YUV2BGR_YUY2 ,
  COLOR_YUV2RGBA_YUY2 = 119 ,
  COLOR_YUV2BGRA_YUY2 = 120 ,
  COLOR_YUV2RGBA_YVYU = 121 ,
  COLOR_YUV2BGRA_YVYU = 122 ,
  COLOR_YUV2RGBA_YUYV = COLOR_YUV2RGBA_YUY2 ,
  COLOR_YUV2BGRA_YUYV = COLOR_YUV2BGRA_YUY2 ,
  COLOR_YUV2RGBA_YUNV = COLOR_YUV2RGBA_YUY2 ,
  COLOR_YUV2BGRA_YUNV = COLOR_YUV2BGRA_YUY2 ,
  COLOR_YUV2GRAY_UYVY = 123 ,
  COLOR_YUV2GRAY_YUY2 = 124 ,
  COLOR_YUV2GRAY_Y422 = COLOR_YUV2GRAY_UYVY ,
  COLOR_YUV2GRAY_UYNV = COLOR_YUV2GRAY_UYVY ,
  COLOR_YUV2GRAY_YVYU = COLOR_YUV2GRAY_YUY2 ,
  COLOR_YUV2GRAY_YUYV = COLOR_YUV2GRAY_YUY2 ,
  COLOR_YUV2GRAY_YUNV = COLOR_YUV2GRAY_YUY2 ,
  COLOR_RGBA2mRGBA = 125 ,
  COLOR_mRGBA2RGBA = 126 ,
  COLOR_RGB2YUV_I420 = 127 ,
  COLOR_BGR2YUV_I420 = 128 ,
  COLOR_RGB2YUV_IYUV = COLOR_RGB2YUV_I420 ,
  COLOR_BGR2YUV_IYUV = COLOR_BGR2YUV_I420 ,
  COLOR_RGBA2YUV_I420 = 129 ,
  COLOR_BGRA2YUV_I420 = 130 ,
  COLOR_RGBA2YUV_IYUV = COLOR_RGBA2YUV_I420 ,
  COLOR_BGRA2YUV_IYUV = COLOR_BGRA2YUV_I420 ,
  COLOR_RGB2YUV_YV12 = 131 ,
  COLOR_BGR2YUV_YV12 = 132 ,
  COLOR_RGBA2YUV_YV12 = 133 ,
  COLOR_BGRA2YUV_YV12 = 134 ,
  COLOR_BayerBG2BGR = 46 ,
  COLOR_BayerGB2BGR = 47 ,
  COLOR_BayerRG2BGR = 48 ,
  COLOR_BayerGR2BGR = 49 ,
  COLOR_BayerRGGB2BGR = COLOR_BayerBG2BGR ,
  COLOR_BayerGRBG2BGR = COLOR_BayerGB2BGR ,
  COLOR_BayerBGGR2BGR = COLOR_BayerRG2BGR ,
  COLOR_BayerGBRG2BGR = COLOR_BayerGR2BGR ,
  COLOR_BayerRGGB2RGB = COLOR_BayerBGGR2BGR ,
  COLOR_BayerGRBG2RGB = COLOR_BayerGBRG2BGR ,
  COLOR_BayerBGGR2RGB = COLOR_BayerRGGB2BGR ,
  COLOR_BayerGBRG2RGB = COLOR_BayerGRBG2BGR ,
  COLOR_BayerBG2RGB = COLOR_BayerRG2BGR ,
  COLOR_BayerGB2RGB = COLOR_BayerGR2BGR ,
  COLOR_BayerRG2RGB = COLOR_BayerBG2BGR ,
  COLOR_BayerGR2RGB = COLOR_BayerGB2BGR ,
  COLOR_BayerBG2GRAY = 86 ,
  COLOR_BayerGB2GRAY = 87 ,
  COLOR_BayerRG2GRAY = 88 ,
  COLOR_BayerGR2GRAY = 89 ,
  COLOR_BayerRGGB2GRAY = COLOR_BayerBG2GRAY ,
  COLOR_BayerGRBG2GRAY = COLOR_BayerGB2GRAY ,
  COLOR_BayerBGGR2GRAY = COLOR_BayerRG2GRAY ,
  COLOR_BayerGBRG2GRAY = COLOR_BayerGR2GRAY ,
  COLOR_BayerBG2BGR_VNG = 62 ,
  COLOR_BayerGB2BGR_VNG = 63 ,
  COLOR_BayerRG2BGR_VNG = 64 ,
  COLOR_BayerGR2BGR_VNG = 65 ,
  COLOR_BayerRGGB2BGR_VNG = COLOR_BayerBG2BGR_VNG ,
  COLOR_BayerGRBG2BGR_VNG = COLOR_BayerGB2BGR_VNG ,
  COLOR_BayerBGGR2BGR_VNG = COLOR_BayerRG2BGR_VNG ,
  COLOR_BayerGBRG2BGR_VNG = COLOR_BayerGR2BGR_VNG ,
  COLOR_BayerRGGB2RGB_VNG = COLOR_BayerBGGR2BGR_VNG ,
  COLOR_BayerGRBG2RGB_VNG = COLOR_BayerGBRG2BGR_VNG ,
  COLOR_BayerBGGR2RGB_VNG = COLOR_BayerRGGB2BGR_VNG ,
  COLOR_BayerGBRG2RGB_VNG = COLOR_BayerGRBG2BGR_VNG ,
  COLOR_BayerBG2RGB_VNG = COLOR_BayerRG2BGR_VNG ,
  COLOR_BayerGB2RGB_VNG = COLOR_BayerGR2BGR_VNG ,
  COLOR_BayerRG2RGB_VNG = COLOR_BayerBG2BGR_VNG ,
  COLOR_BayerGR2RGB_VNG = COLOR_BayerGB2BGR_VNG ,
  COLOR_BayerBG2BGR_EA = 135 ,
  COLOR_BayerGB2BGR_EA = 136 ,
  COLOR_BayerRG2BGR_EA = 137 ,
  COLOR_BayerGR2BGR_EA = 138 ,
  COLOR_BayerRGGB2BGR_EA = COLOR_BayerBG2BGR_EA ,
  COLOR_BayerGRBG2BGR_EA = COLOR_BayerGB2BGR_EA ,
  COLOR_BayerBGGR2BGR_EA = COLOR_BayerRG2BGR_EA ,
  COLOR_BayerGBRG2BGR_EA = COLOR_BayerGR2BGR_EA ,
  COLOR_BayerRGGB2RGB_EA = COLOR_BayerBGGR2BGR_EA ,
  COLOR_BayerGRBG2RGB_EA = COLOR_BayerGBRG2BGR_EA ,
  COLOR_BayerBGGR2RGB_EA = COLOR_BayerRGGB2BGR_EA ,
  COLOR_BayerGBRG2RGB_EA = COLOR_BayerGRBG2BGR_EA ,
  COLOR_BayerBG2RGB_EA = COLOR_BayerRG2BGR_EA ,
  COLOR_BayerGB2RGB_EA = COLOR_BayerGR2BGR_EA ,
  COLOR_BayerRG2RGB_EA = COLOR_BayerBG2BGR_EA ,
  COLOR_BayerGR2RGB_EA = COLOR_BayerGB2BGR_EA ,
  COLOR_BayerBG2BGRA = 139 ,
  COLOR_BayerGB2BGRA = 140 ,
  COLOR_BayerRG2BGRA = 141 ,
  COLOR_BayerGR2BGRA = 142 ,
  COLOR_BayerRGGB2BGRA = COLOR_BayerBG2BGRA ,
  COLOR_BayerGRBG2BGRA = COLOR_BayerGB2BGRA ,
  COLOR_BayerBGGR2BGRA = COLOR_BayerRG2BGRA ,
  COLOR_BayerGBRG2BGRA = COLOR_BayerGR2BGRA ,
  COLOR_BayerRGGB2RGBA = COLOR_BayerBGGR2BGRA ,
  COLOR_BayerGRBG2RGBA = COLOR_BayerGBRG2BGRA ,
  COLOR_BayerBGGR2RGBA = COLOR_BayerRGGB2BGRA ,
  COLOR_BayerGBRG2RGBA = COLOR_BayerGRBG2BGRA ,
  COLOR_BayerBG2RGBA = COLOR_BayerRG2BGRA ,
  COLOR_BayerGB2RGBA = COLOR_BayerGR2BGRA ,
  COLOR_BayerRG2RGBA = COLOR_BayerBG2BGRA ,
  COLOR_BayerGR2RGBA = COLOR_BayerGB2BGRA ,
  COLOR_COLORCVT_MAX = 143
}
 
enum  ColormapTypes {
  COLORMAP_AUTUMN = 0 ,
  COLORMAP_BONE = 1 ,
  COLORMAP_JET = 2 ,
  COLORMAP_WINTER = 3 ,
  COLORMAP_RAINBOW = 4 ,
  COLORMAP_OCEAN = 5 ,
  COLORMAP_SUMMER = 6 ,
  COLORMAP_SPRING = 7 ,
  COLORMAP_COOL = 8 ,
  COLORMAP_HSV = 9 ,
  COLORMAP_PINK = 10 ,
  COLORMAP_HOT = 11 ,
  COLORMAP_PARULA = 12 ,
  COLORMAP_MAGMA = 13 ,
  COLORMAP_INFERNO = 14 ,
  COLORMAP_PLASMA = 15 ,
  COLORMAP_VIRIDIS = 16 ,
  COLORMAP_CIVIDIS = 17 ,
  COLORMAP_TWILIGHT = 18 ,
  COLORMAP_TWILIGHT_SHIFTED = 19 ,
  COLORMAP_TURBO = 20 ,
  COLORMAP_DEEPGREEN = 21
}
 GNU Octave/MATLAB equivalent colormaps. More...
 
enum  ConnectedComponentsAlgorithmsTypes {
  CCL_DEFAULT = -1 ,
  CCL_WU = 0 ,
  CCL_GRANA = 1 ,
  CCL_BOLELLI = 2 ,
  CCL_SAUF = 3 ,
  CCL_BBDT = 4 ,
  CCL_SPAGHETTI = 5
}
 connected components algorithm More...
 
enum  ConnectedComponentsTypes {
  CC_STAT_LEFT = 0 ,
  CC_STAT_TOP = 1 ,
  CC_STAT_WIDTH = 2 ,
  CC_STAT_HEIGHT = 3 ,
  CC_STAT_AREA = 4
}
 connected components statistics More...
 
enum  ContourApproximationModes {
  CHAIN_APPROX_NONE = 1 ,
  CHAIN_APPROX_SIMPLE = 2 ,
  CHAIN_APPROX_TC89_L1 = 3 ,
  CHAIN_APPROX_TC89_KCOS = 4
}
 the contour approximation algorithm More...
 
enum  CovarFlags {
  COVAR_SCRAMBLED = 0 ,
  COVAR_NORMAL = 1 ,
  COVAR_USE_AVG = 2 ,
  COVAR_SCALE = 4 ,
  COVAR_ROWS = 8 ,
  COVAR_COLS = 16
}
 Covariation flags. More...
 
enum  DecompTypes {
  DECOMP_LU = 0 ,
  DECOMP_SVD = 1 ,
  DECOMP_EIG = 2 ,
  DECOMP_CHOLESKY = 3 ,
  DECOMP_QR = 4 ,
  DECOMP_NORMAL = 16
}
 matrix decomposition types More...
 
enum  DftFlags {
  DFT_INVERSE = 1 ,
  DFT_SCALE = 2 ,
  DFT_ROWS = 4 ,
  DFT_COMPLEX_OUTPUT = 16 ,
  DFT_REAL_OUTPUT = 32 ,
  DFT_COMPLEX_INPUT = 64 ,
  DCT_INVERSE = DFT_INVERSE ,
  DCT_ROWS = DFT_ROWS
}
 
enum  DistanceTransformLabelTypes {
  DIST_LABEL_CCOMP = 0 ,
  DIST_LABEL_PIXEL = 1
}
 distanceTransform algorithm flags More...
 
enum  DistanceTransformMasks {
  DIST_MASK_3 = 3 ,
  DIST_MASK_5 = 5 ,
  DIST_MASK_PRECISE = 0
}
 Mask size for distance transform. More...
 
enum  DistanceTypes {
  DIST_USER = -1 ,
  DIST_L1 = 1 ,
  DIST_L2 = 2 ,
  DIST_C = 3 ,
  DIST_L12 = 4 ,
  DIST_FAIR = 5 ,
  DIST_WELSCH = 6 ,
  DIST_HUBER = 7
}
 
enum struct  DrawMatchesFlags {
  DrawMatchesFlags::DEFAULT = 0 ,
  DrawMatchesFlags::DRAW_OVER_OUTIMG = 1 ,
  DrawMatchesFlags::NOT_DRAW_SINGLE_POINTS = 2 ,
  DrawMatchesFlags::DRAW_RICH_KEYPOINTS = 4
}
 
enum  FloodFillFlags {
  FLOODFILL_FIXED_RANGE = 1 << 16 ,
  FLOODFILL_MASK_ONLY = 1 << 17
}
 floodfill algorithm flags More...
 
enum  GemmFlags {
  GEMM_1_T = 1 ,
  GEMM_2_T = 2 ,
  GEMM_3_T = 4
}
 generalized matrix multiplication flags More...
 
enum  GrabCutClasses {
  GC_BGD = 0 ,
  GC_FGD = 1 ,
  GC_PR_BGD = 2 ,
  GC_PR_FGD = 3
}
 class of the pixel in GrabCut algorithm More...
 
enum  GrabCutModes {
  GC_INIT_WITH_RECT = 0 ,
  GC_INIT_WITH_MASK = 1 ,
  GC_EVAL = 2 ,
  GC_EVAL_FREEZE_MODEL = 3
}
 GrabCut algorithm flags. More...
 
enum class  GShape : int {
  GMAT ,
  GSCALAR ,
  GARRAY ,
  GOPAQUE ,
  GFRAME
}
 
enum  HandEyeCalibrationMethod {
  CALIB_HAND_EYE_TSAI = 0 ,
  CALIB_HAND_EYE_PARK = 1 ,
  CALIB_HAND_EYE_HORAUD = 2 ,
  CALIB_HAND_EYE_ANDREFF = 3 ,
  CALIB_HAND_EYE_DANIILIDIS = 4
}
 
enum  HersheyFonts {
  FONT_HERSHEY_SIMPLEX = 0 ,
  FONT_HERSHEY_PLAIN = 1 ,
  FONT_HERSHEY_DUPLEX = 2 ,
  FONT_HERSHEY_COMPLEX = 3 ,
  FONT_HERSHEY_TRIPLEX = 4 ,
  FONT_HERSHEY_COMPLEX_SMALL = 5 ,
  FONT_HERSHEY_SCRIPT_SIMPLEX = 6 ,
  FONT_HERSHEY_SCRIPT_COMPLEX = 7 ,
  FONT_ITALIC = 16
}
 
enum  HistCompMethods {
  HISTCMP_CORREL = 0 ,
  HISTCMP_CHISQR = 1 ,
  HISTCMP_INTERSECT = 2 ,
  HISTCMP_BHATTACHARYYA = 3 ,
  HISTCMP_HELLINGER = HISTCMP_BHATTACHARYYA ,
  HISTCMP_CHISQR_ALT = 4 ,
  HISTCMP_KL_DIV = 5
}
 
enum  HoughModes {
  HOUGH_STANDARD = 0 ,
  HOUGH_PROBABILISTIC = 1 ,
  HOUGH_MULTI_SCALE = 2 ,
  HOUGH_GRADIENT = 3 ,
  HOUGH_GRADIENT_ALT = 4
}
 Variants of a Hough transform. More...
 
enum  ImreadModes {
  IMREAD_UNCHANGED = -1 ,
  IMREAD_GRAYSCALE = 0 ,
  IMREAD_COLOR = 1 ,
  IMREAD_ANYDEPTH = 2 ,
  IMREAD_ANYCOLOR = 4 ,
  IMREAD_LOAD_GDAL = 8 ,
  IMREAD_REDUCED_GRAYSCALE_2 = 16 ,
  IMREAD_REDUCED_COLOR_2 = 17 ,
  IMREAD_REDUCED_GRAYSCALE_4 = 32 ,
  IMREAD_REDUCED_COLOR_4 = 33 ,
  IMREAD_REDUCED_GRAYSCALE_8 = 64 ,
  IMREAD_REDUCED_COLOR_8 = 65 ,
  IMREAD_IGNORE_ORIENTATION = 128
}
 Imread flags. More...
 
enum  ImwriteEXRCompressionFlags {
  IMWRITE_EXR_COMPRESSION_NO = 0 ,
  IMWRITE_EXR_COMPRESSION_RLE = 1 ,
  IMWRITE_EXR_COMPRESSION_ZIPS = 2 ,
  IMWRITE_EXR_COMPRESSION_ZIP = 3 ,
  IMWRITE_EXR_COMPRESSION_PIZ = 4 ,
  IMWRITE_EXR_COMPRESSION_PXR24 = 5 ,
  IMWRITE_EXR_COMPRESSION_B44 = 6 ,
  IMWRITE_EXR_COMPRESSION_B44A = 7 ,
  IMWRITE_EXR_COMPRESSION_DWAA = 8 ,
  IMWRITE_EXR_COMPRESSION_DWAB = 9
}
 
enum  ImwriteEXRTypeFlags {
  IMWRITE_EXR_TYPE_HALF = 1 ,
  IMWRITE_EXR_TYPE_FLOAT = 2
}
 
enum  ImwriteFlags {
  IMWRITE_JPEG_QUALITY = 1 ,
  IMWRITE_JPEG_PROGRESSIVE = 2 ,
  IMWRITE_JPEG_OPTIMIZE = 3 ,
  IMWRITE_JPEG_RST_INTERVAL = 4 ,
  IMWRITE_JPEG_LUMA_QUALITY = 5 ,
  IMWRITE_JPEG_CHROMA_QUALITY = 6 ,
  IMWRITE_JPEG_SAMPLING_FACTOR = 7 ,
  IMWRITE_PNG_COMPRESSION = 16 ,
  IMWRITE_PNG_STRATEGY = 17 ,
  IMWRITE_PNG_BILEVEL = 18 ,
  IMWRITE_PXM_BINARY = 32 ,
  IMWRITE_EXR_TYPE = (3 << 4) + 0 ,
  IMWRITE_EXR_COMPRESSION = (3 << 4) + 1 ,
  IMWRITE_EXR_DWA_COMPRESSION_LEVEL = (3 << 4) + 2 ,
  IMWRITE_WEBP_QUALITY = 64 ,
  IMWRITE_HDR_COMPRESSION = (5 << 4) + 0 ,
  IMWRITE_PAM_TUPLETYPE = 128 ,
  IMWRITE_TIFF_RESUNIT = 256 ,
  IMWRITE_TIFF_XDPI = 257 ,
  IMWRITE_TIFF_YDPI = 258 ,
  IMWRITE_TIFF_COMPRESSION = 259 ,
  IMWRITE_JPEG2000_COMPRESSION_X1000 = 272 ,
  IMWRITE_AVIF_QUALITY = 512 ,
  IMWRITE_AVIF_DEPTH = 513 ,
  IMWRITE_AVIF_SPEED = 514
}
 Imwrite flags. More...
 
enum  ImwriteHDRCompressionFlags {
  IMWRITE_HDR_COMPRESSION_NONE = 0 ,
  IMWRITE_HDR_COMPRESSION_RLE = 1
}
 Imwrite HDR specific values for IMWRITE_HDR_COMPRESSION parameter key. More...
 
enum  ImwriteJPEGSamplingFactorParams {
  IMWRITE_JPEG_SAMPLING_FACTOR_411 = 0x411111 ,
  IMWRITE_JPEG_SAMPLING_FACTOR_420 = 0x221111 ,
  IMWRITE_JPEG_SAMPLING_FACTOR_422 = 0x211111 ,
  IMWRITE_JPEG_SAMPLING_FACTOR_440 = 0x121111 ,
  IMWRITE_JPEG_SAMPLING_FACTOR_444 = 0x111111
}
 
enum  ImwritePAMFlags {
  IMWRITE_PAM_FORMAT_NULL = 0 ,
  IMWRITE_PAM_FORMAT_BLACKANDWHITE = 1 ,
  IMWRITE_PAM_FORMAT_GRAYSCALE = 2 ,
  IMWRITE_PAM_FORMAT_GRAYSCALE_ALPHA = 3 ,
  IMWRITE_PAM_FORMAT_RGB = 4 ,
  IMWRITE_PAM_FORMAT_RGB_ALPHA = 5
}
 Imwrite PAM specific tupletype flags used to define the 'TUPLETYPE' field of a PAM file. More...
 
enum  ImwritePNGFlags {
  IMWRITE_PNG_STRATEGY_DEFAULT = 0 ,
  IMWRITE_PNG_STRATEGY_FILTERED = 1 ,
  IMWRITE_PNG_STRATEGY_HUFFMAN_ONLY = 2 ,
  IMWRITE_PNG_STRATEGY_RLE = 3 ,
  IMWRITE_PNG_STRATEGY_FIXED = 4
}
 Imwrite PNG specific flags used to tune the compression algorithm. More...
 
enum  InterpolationFlags {
  INTER_NEAREST = 0 ,
  INTER_LINEAR = 1 ,
  INTER_CUBIC = 2 ,
  INTER_AREA = 3 ,
  INTER_LANCZOS4 = 4 ,
  INTER_LINEAR_EXACT = 5 ,
  INTER_NEAREST_EXACT = 6 ,
  INTER_MAX = 7 ,
  WARP_FILL_OUTLIERS = 8 ,
  WARP_INVERSE_MAP = 16
}
 interpolation algorithm More...
 
enum  InterpolationMasks {
  INTER_BITS = 5 ,
  INTER_BITS2 = INTER_BITS * 2 ,
  INTER_TAB_SIZE = 1 << INTER_BITS ,
  INTER_TAB_SIZE2 = INTER_TAB_SIZE * INTER_TAB_SIZE
}
 
enum  KmeansFlags {
  KMEANS_RANDOM_CENTERS = 0 ,
  KMEANS_PP_CENTERS = 2 ,
  KMEANS_USE_INITIAL_LABELS = 1
}
 k-Means flags More...
 
enum  LineSegmentDetectorModes {
  LSD_REFINE_NONE = 0 ,
  LSD_REFINE_STD = 1 ,
  LSD_REFINE_ADV = 2
}
 Variants of Line Segment Detector. More...
 
enum  LineTypes {
  FILLED = -1 ,
  LINE_4 = 4 ,
  LINE_8 = 8 ,
  LINE_AA = 16
}
 
enum  LocalOptimMethod {
  LOCAL_OPTIM_NULL =0 ,
  LOCAL_OPTIM_INNER_LO =1 ,
  LOCAL_OPTIM_INNER_AND_ITER_LO =2 ,
  LOCAL_OPTIM_GC =3 ,
  LOCAL_OPTIM_SIGMA =4
}
 
enum  MarkerTypes {
  MARKER_CROSS = 0 ,
  MARKER_TILTED_CROSS = 1 ,
  MARKER_STAR = 2 ,
  MARKER_DIAMOND = 3 ,
  MARKER_SQUARE = 4 ,
  MARKER_TRIANGLE_UP = 5 ,
  MARKER_TRIANGLE_DOWN = 6
}
 
enum class  MediaFormat : int {
  BGR = 0 ,
  NV12 ,
  GRAY
}
 
enum  MorphShapes {
  MORPH_RECT = 0 ,
  MORPH_CROSS = 1 ,
  MORPH_ELLIPSE = 2
}
 shape of the structuring element More...
 
enum  MorphTypes {
  MORPH_ERODE = 0 ,
  MORPH_DILATE = 1 ,
  MORPH_OPEN = 2 ,
  MORPH_CLOSE = 3 ,
  MORPH_GRADIENT = 4 ,
  MORPH_TOPHAT = 5 ,
  MORPH_BLACKHAT = 6 ,
  MORPH_HITMISS = 7
}
 type of morphological operation More...
 
enum  MouseEventFlags {
  EVENT_FLAG_LBUTTON = 1 ,
  EVENT_FLAG_RBUTTON = 2 ,
  EVENT_FLAG_MBUTTON = 4 ,
  EVENT_FLAG_CTRLKEY = 8 ,
  EVENT_FLAG_SHIFTKEY = 16 ,
  EVENT_FLAG_ALTKEY = 32
}
 Mouse Event Flags see cv::MouseCallback. More...
 
enum  MouseEventTypes {
  EVENT_MOUSEMOVE = 0 ,
  EVENT_LBUTTONDOWN = 1 ,
  EVENT_RBUTTONDOWN = 2 ,
  EVENT_MBUTTONDOWN = 3 ,
  EVENT_LBUTTONUP = 4 ,
  EVENT_RBUTTONUP = 5 ,
  EVENT_MBUTTONUP = 6 ,
  EVENT_LBUTTONDBLCLK = 7 ,
  EVENT_RBUTTONDBLCLK = 8 ,
  EVENT_MBUTTONDBLCLK = 9 ,
  EVENT_MOUSEWHEEL = 10 ,
  EVENT_MOUSEHWHEEL = 11
}
 Mouse Events see cv::MouseCallback. More...
 
enum  NeighborSearchMethod {
  NEIGH_FLANN_KNN =0 ,
  NEIGH_GRID =1 ,
  NEIGH_FLANN_RADIUS =2
}
 
enum  NormTypes {
  NORM_INF = 1 ,
  NORM_L1 = 2 ,
  NORM_L2 = 4 ,
  NORM_L2SQR = 5 ,
  NORM_HAMMING = 6 ,
  NORM_HAMMING2 = 7 ,
  NORM_TYPE_MASK = 7 ,
  NORM_RELATIVE = 8 ,
  NORM_MINMAX = 32
}
 
enum struct  Param {
  Param::INT =0 ,
  Param::BOOLEAN =1 ,
  Param::REAL =2 ,
  Param::STRING =3 ,
  Param::MAT =4 ,
  Param::MAT_VECTOR =5 ,
  Param::ALGORITHM =6 ,
  Param::FLOAT =7 ,
  Param::UNSIGNED_INT =8 ,
  Param::UINT64 =9 ,
  Param::UCHAR =11 ,
  Param::SCALAR =12
}
 
enum  PolishingMethod {
  NONE_POLISHER =0 ,
  LSQ_POLISHER =1 ,
  MAGSAC =2 ,
  COV_POLISHER =3
}
 
enum  QtButtonTypes {
  QT_PUSH_BUTTON = 0 ,
  QT_CHECKBOX = 1 ,
  QT_RADIOBOX = 2 ,
  QT_NEW_BUTTONBAR = 1024
}
 Qt "button" type. More...
 
enum  QtFontStyles {
  QT_STYLE_NORMAL = 0 ,
  QT_STYLE_ITALIC = 1 ,
  QT_STYLE_OBLIQUE = 2
}
 Qt font style. More...
 
enum  QtFontWeights {
  QT_FONT_LIGHT = 25 ,
  QT_FONT_NORMAL = 50 ,
  QT_FONT_DEMIBOLD = 63 ,
  QT_FONT_BOLD = 75 ,
  QT_FONT_BLACK = 87
}
 Qt font weight. More...
 
enum  QuatAssumeType {
  QUAT_ASSUME_NOT_UNIT ,
  QUAT_ASSUME_UNIT
}
 Unit quaternion flag. More...
 
enum  RectanglesIntersectTypes {
  INTERSECT_NONE = 0 ,
  INTERSECT_PARTIAL = 1 ,
  INTERSECT_FULL = 2
}
 types of intersection between rectangles More...
 
enum  ReduceTypes {
  REDUCE_SUM = 0 ,
  REDUCE_AVG = 1 ,
  REDUCE_MAX = 2 ,
  REDUCE_MIN = 3 ,
  REDUCE_SUM2 = 4
}
 
enum  RetrievalModes {
  RETR_EXTERNAL = 0 ,
  RETR_LIST = 1 ,
  RETR_CCOMP = 2 ,
  RETR_TREE = 3 ,
  RETR_FLOODFILL = 4
}
 mode of the contour retrieval algorithm More...
 
enum  RobotWorldHandEyeCalibrationMethod {
  CALIB_ROBOT_WORLD_HAND_EYE_SHAH = 0 ,
  CALIB_ROBOT_WORLD_HAND_EYE_LI = 1
}
 
enum  RotateFlags {
  ROTATE_90_CLOCKWISE = 0 ,
  ROTATE_180 = 1 ,
  ROTATE_90_COUNTERCLOCKWISE = 2
}
 
enum  SamplingMethod {
  SAMPLING_UNIFORM =0 ,
  SAMPLING_PROGRESSIVE_NAPSAC =1 ,
  SAMPLING_NAPSAC =2 ,
  SAMPLING_PROSAC =3
}
 
enum  ScoreMethod {
  SCORE_METHOD_RANSAC =0 ,
  SCORE_METHOD_MSAC =1 ,
  SCORE_METHOD_MAGSAC =2 ,
  SCORE_METHOD_LMEDS =3
}
 
enum  ShapeMatchModes {
  CONTOURS_MATCH_I1 =1 ,
  CONTOURS_MATCH_I2 =2 ,
  CONTOURS_MATCH_I3 =3
}
 Shape matching methods. More...
 
enum  SolveLPResult {
  SOLVELP_LOST = -3 ,
  SOLVELP_UNBOUNDED = -2 ,
  SOLVELP_UNFEASIBLE = -1 ,
  SOLVELP_SINGLE = 0 ,
  SOLVELP_MULTI = 1
}
 return codes for cv::solveLP() function More...
 
enum  SolvePnPMethod {
  SOLVEPNP_ITERATIVE = 0 ,
  SOLVEPNP_EPNP = 1 ,
  SOLVEPNP_P3P = 2 ,
  SOLVEPNP_DLS = 3 ,
  SOLVEPNP_UPNP = 4 ,
  SOLVEPNP_AP3P = 5 ,
  SOLVEPNP_IPPE = 6 ,
  SOLVEPNP_IPPE_SQUARE = 7 ,
  SOLVEPNP_SQPNP = 8
}
 
enum  SortFlags {
  SORT_EVERY_ROW = 0 ,
  SORT_EVERY_COLUMN = 1 ,
  SORT_ASCENDING = 0 ,
  SORT_DESCENDING = 16
}
 
enum  SpecialFilter { FILTER_SCHARR = -1 }
 
enum  StreamType {
  db ,
  dc ,
  pc ,
  wb
}
 
enum  TemplateMatchModes {
  TM_SQDIFF = 0 ,
  TM_SQDIFF_NORMED = 1 ,
  TM_CCORR = 2 ,
  TM_CCORR_NORMED = 3 ,
  TM_CCOEFF = 4 ,
  TM_CCOEFF_NORMED = 5
}
 type of the template matching operation More...
 
enum  ThresholdTypes {
  THRESH_BINARY = 0 ,
  THRESH_BINARY_INV = 1 ,
  THRESH_TRUNC = 2 ,
  THRESH_TOZERO = 3 ,
  THRESH_TOZERO_INV = 4 ,
  THRESH_MASK = 7 ,
  THRESH_OTSU = 8 ,
  THRESH_TRIANGLE = 16
}
 
enum  UMatUsageFlags {
  USAGE_DEFAULT = 0 ,
  USAGE_ALLOCATE_HOST_MEMORY = 1 << 0 ,
  USAGE_ALLOCATE_DEVICE_MEMORY = 1 << 1 ,
  USAGE_ALLOCATE_SHARED_MEMORY = 1 << 2 ,
  __UMAT_USAGE_FLAGS_32BIT = 0x7fffffff
}
 Usage flags for allocator. More...
 
enum  UndistortTypes {
  PROJ_SPHERICAL_ORTHO = 0 ,
  PROJ_SPHERICAL_EQRECT = 1
}
 cv::undistort mode More...
 
enum  VideoCaptureAPIs {
  CAP_ANY = 0 ,
  CAP_VFW = 200 ,
  CAP_V4L = 200 ,
  CAP_V4L2 = CAP_V4L ,
  CAP_FIREWIRE = 300 ,
  CAP_FIREWARE = CAP_FIREWIRE ,
  CAP_IEEE1394 = CAP_FIREWIRE ,
  CAP_DC1394 = CAP_FIREWIRE ,
  CAP_CMU1394 = CAP_FIREWIRE ,
  CAP_QT = 500 ,
  CAP_UNICAP = 600 ,
  CAP_DSHOW = 700 ,
  CAP_PVAPI = 800 ,
  CAP_OPENNI = 900 ,
  CAP_OPENNI_ASUS = 910 ,
  CAP_ANDROID = 1000 ,
  CAP_XIAPI = 1100 ,
  CAP_AVFOUNDATION = 1200 ,
  CAP_GIGANETIX = 1300 ,
  CAP_MSMF = 1400 ,
  CAP_WINRT = 1410 ,
  CAP_INTELPERC = 1500 ,
  CAP_REALSENSE = 1500 ,
  CAP_OPENNI2 = 1600 ,
  CAP_OPENNI2_ASUS = 1610 ,
  CAP_OPENNI2_ASTRA = 1620 ,
  CAP_GPHOTO2 = 1700 ,
  CAP_GSTREAMER = 1800 ,
  CAP_FFMPEG = 1900 ,
  CAP_IMAGES = 2000 ,
  CAP_ARAVIS = 2100 ,
  CAP_OPENCV_MJPEG = 2200 ,
  CAP_INTEL_MFX = 2300 ,
  CAP_XINE = 2400 ,
  CAP_UEYE = 2500 ,
  CAP_OBSENSOR = 2600
}
 cv::VideoCapture API backends identifier. More...
 
enum  VideoCaptureProperties {
  CAP_PROP_POS_MSEC =0 ,
  CAP_PROP_POS_FRAMES =1 ,
  CAP_PROP_POS_AVI_RATIO =2 ,
  CAP_PROP_FRAME_WIDTH =3 ,
  CAP_PROP_FRAME_HEIGHT =4 ,
  CAP_PROP_FPS =5 ,
  CAP_PROP_FOURCC =6 ,
  CAP_PROP_FRAME_COUNT =7 ,
  CAP_PROP_FORMAT =8 ,
  CAP_PROP_MODE =9 ,
  CAP_PROP_BRIGHTNESS =10 ,
  CAP_PROP_CONTRAST =11 ,
  CAP_PROP_SATURATION =12 ,
  CAP_PROP_HUE =13 ,
  CAP_PROP_GAIN =14 ,
  CAP_PROP_EXPOSURE =15 ,
  CAP_PROP_CONVERT_RGB =16 ,
  CAP_PROP_WHITE_BALANCE_BLUE_U =17 ,
  CAP_PROP_RECTIFICATION =18 ,
  CAP_PROP_MONOCHROME =19 ,
  CAP_PROP_SHARPNESS =20 ,
  CAP_PROP_AUTO_EXPOSURE =21 ,
  CAP_PROP_GAMMA =22 ,
  CAP_PROP_TEMPERATURE =23 ,
  CAP_PROP_TRIGGER =24 ,
  CAP_PROP_TRIGGER_DELAY =25 ,
  CAP_PROP_WHITE_BALANCE_RED_V =26 ,
  CAP_PROP_ZOOM =27 ,
  CAP_PROP_FOCUS =28 ,
  CAP_PROP_GUID =29 ,
  CAP_PROP_ISO_SPEED =30 ,
  CAP_PROP_BACKLIGHT =32 ,
  CAP_PROP_PAN =33 ,
  CAP_PROP_TILT =34 ,
  CAP_PROP_ROLL =35 ,
  CAP_PROP_IRIS =36 ,
  CAP_PROP_SETTINGS =37 ,
  CAP_PROP_BUFFERSIZE =38 ,
  CAP_PROP_AUTOFOCUS =39 ,
  CAP_PROP_SAR_NUM =40 ,
  CAP_PROP_SAR_DEN =41 ,
  CAP_PROP_BACKEND =42 ,
  CAP_PROP_CHANNEL =43 ,
  CAP_PROP_AUTO_WB =44 ,
  CAP_PROP_WB_TEMPERATURE =45 ,
  CAP_PROP_CODEC_PIXEL_FORMAT =46 ,
  CAP_PROP_BITRATE =47 ,
  CAP_PROP_ORIENTATION_META =48 ,
  CAP_PROP_ORIENTATION_AUTO =49 ,
  CAP_PROP_HW_ACCELERATION =50 ,
  CAP_PROP_HW_DEVICE =51 ,
  CAP_PROP_HW_ACCELERATION_USE_OPENCL =52 ,
  CAP_PROP_OPEN_TIMEOUT_MSEC =53 ,
  CAP_PROP_READ_TIMEOUT_MSEC =54 ,
  CAP_PROP_STREAM_OPEN_TIME_USEC =55 ,
  CAP_PROP_VIDEO_TOTAL_CHANNELS = 56 ,
  CAP_PROP_VIDEO_STREAM = 57 ,
  CAP_PROP_AUDIO_STREAM = 58 ,
  CAP_PROP_AUDIO_POS = 59 ,
  CAP_PROP_AUDIO_SHIFT_NSEC = 60 ,
  CAP_PROP_AUDIO_DATA_DEPTH = 61 ,
  CAP_PROP_AUDIO_SAMPLES_PER_SECOND = 62 ,
  CAP_PROP_AUDIO_BASE_INDEX = 63 ,
  CAP_PROP_AUDIO_TOTAL_CHANNELS = 64 ,
  CAP_PROP_AUDIO_TOTAL_STREAMS = 65 ,
  CAP_PROP_AUDIO_SYNCHRONIZE = 66 ,
  CAP_PROP_LRF_HAS_KEY_FRAME = 67 ,
  CAP_PROP_CODEC_EXTRADATA_INDEX = 68 ,
  CAP_PROP_FRAME_TYPE = 69 ,
  CAP_PROP_N_THREADS = 70
}
 cv::VideoCapture generic properties identifier. More...
 
enum  VideoWriterProperties {
  VIDEOWRITER_PROP_QUALITY = 1 ,
  VIDEOWRITER_PROP_FRAMEBYTES = 2 ,
  VIDEOWRITER_PROP_NSTRIPES = 3 ,
  VIDEOWRITER_PROP_IS_COLOR = 4 ,
  VIDEOWRITER_PROP_DEPTH = 5 ,
  VIDEOWRITER_PROP_HW_ACCELERATION = 6 ,
  VIDEOWRITER_PROP_HW_DEVICE = 7 ,
  VIDEOWRITER_PROP_HW_ACCELERATION_USE_OPENCL = 8
}
 cv::VideoWriter generic properties identifier. More...
 
enum  WarpPolarMode {
  WARP_POLAR_LINEAR = 0 ,
  WARP_POLAR_LOG = 256
}
 Specify the polar mapping mode. More...
 
enum  WindowFlags {
  WINDOW_NORMAL = 0x00000000 ,
  WINDOW_AUTOSIZE = 0x00000001 ,
  WINDOW_OPENGL = 0x00001000 ,
  WINDOW_FULLSCREEN = 1 ,
  WINDOW_FREERATIO = 0x00000100 ,
  WINDOW_KEEPRATIO = 0x00000000 ,
  WINDOW_GUI_EXPANDED =0x00000000 ,
  WINDOW_GUI_NORMAL = 0x00000010
}
 Flags for cv::namedWindow. More...
 
enum  WindowPropertyFlags {
  WND_PROP_FULLSCREEN = 0 ,
  WND_PROP_AUTOSIZE = 1 ,
  WND_PROP_ASPECT_RATIO = 2 ,
  WND_PROP_OPENGL = 3 ,
  WND_PROP_VISIBLE = 4 ,
  WND_PROP_TOPMOST = 5 ,
  WND_PROP_VSYNC = 6
}
 Flags for cv::setWindowProperty / cv::getWindowProperty. More...
 
Hardware acceleration support
enum  VideoAccelerationType {
  VIDEO_ACCELERATION_NONE = 0 ,
  VIDEO_ACCELERATION_ANY = 1 ,
  VIDEO_ACCELERATION_D3D11 = 2 ,
  VIDEO_ACCELERATION_VAAPI = 3 ,
  VIDEO_ACCELERATION_MFX = 4
}
 Video Acceleration type. More...
 
IEEE 1394 drivers
enum  {
  CAP_PROP_DC1394_OFF = -4 ,
  CAP_PROP_DC1394_MODE_MANUAL = -3 ,
  CAP_PROP_DC1394_MODE_AUTO = -2 ,
  CAP_PROP_DC1394_MODE_ONE_PUSH_AUTO = -1 ,
  CAP_PROP_DC1394_MAX = 31
}
 Modes of the IEEE 1394 controlling registers (can be: auto, manual, auto single push, absolute Latter allowed with any other mode) every feature can have only one mode turned on at a time. More...
 
OpenNI (for Kinect)
enum  {
  CAP_OPENNI_DEPTH_GENERATOR = 1 << 31 ,
  CAP_OPENNI_IMAGE_GENERATOR = 1 << 30 ,
  CAP_OPENNI_IR_GENERATOR = 1 << 29 ,
  CAP_OPENNI_GENERATORS_MASK = CAP_OPENNI_DEPTH_GENERATOR + CAP_OPENNI_IMAGE_GENERATOR + CAP_OPENNI_IR_GENERATOR
}
 OpenNI map generators. More...
 
enum  {
  CAP_PROP_OPENNI_OUTPUT_MODE = 100 ,
  CAP_PROP_OPENNI_FRAME_MAX_DEPTH = 101 ,
  CAP_PROP_OPENNI_BASELINE = 102 ,
  CAP_PROP_OPENNI_FOCAL_LENGTH = 103 ,
  CAP_PROP_OPENNI_REGISTRATION = 104 ,
  CAP_PROP_OPENNI_REGISTRATION_ON = CAP_PROP_OPENNI_REGISTRATION ,
  CAP_PROP_OPENNI_APPROX_FRAME_SYNC = 105 ,
  CAP_PROP_OPENNI_MAX_BUFFER_SIZE = 106 ,
  CAP_PROP_OPENNI_CIRCLE_BUFFER = 107 ,
  CAP_PROP_OPENNI_MAX_TIME_DURATION = 108 ,
  CAP_PROP_OPENNI_GENERATOR_PRESENT = 109 ,
  CAP_PROP_OPENNI2_SYNC = 110 ,
  CAP_PROP_OPENNI2_MIRROR = 111
}
 Properties of cameras available through OpenNI backend. More...
 
enum  {
  CAP_OPENNI_IMAGE_GENERATOR_PRESENT = CAP_OPENNI_IMAGE_GENERATOR + CAP_PROP_OPENNI_GENERATOR_PRESENT ,
  CAP_OPENNI_IMAGE_GENERATOR_OUTPUT_MODE = CAP_OPENNI_IMAGE_GENERATOR + CAP_PROP_OPENNI_OUTPUT_MODE ,
  CAP_OPENNI_DEPTH_GENERATOR_PRESENT = CAP_OPENNI_DEPTH_GENERATOR + CAP_PROP_OPENNI_GENERATOR_PRESENT ,
  CAP_OPENNI_DEPTH_GENERATOR_BASELINE = CAP_OPENNI_DEPTH_GENERATOR + CAP_PROP_OPENNI_BASELINE ,
  CAP_OPENNI_DEPTH_GENERATOR_FOCAL_LENGTH = CAP_OPENNI_DEPTH_GENERATOR + CAP_PROP_OPENNI_FOCAL_LENGTH ,
  CAP_OPENNI_DEPTH_GENERATOR_REGISTRATION = CAP_OPENNI_DEPTH_GENERATOR + CAP_PROP_OPENNI_REGISTRATION ,
  CAP_OPENNI_DEPTH_GENERATOR_REGISTRATION_ON = CAP_OPENNI_DEPTH_GENERATOR_REGISTRATION ,
  CAP_OPENNI_IR_GENERATOR_PRESENT = CAP_OPENNI_IR_GENERATOR + CAP_PROP_OPENNI_GENERATOR_PRESENT
}
 OpenNI shortcuts. More...
 
enum  {
  CAP_OPENNI_DEPTH_MAP = 0 ,
  CAP_OPENNI_POINT_CLOUD_MAP = 1 ,
  CAP_OPENNI_DISPARITY_MAP = 2 ,
  CAP_OPENNI_DISPARITY_MAP_32F = 3 ,
  CAP_OPENNI_VALID_DEPTH_MASK = 4 ,
  CAP_OPENNI_BGR_IMAGE = 5 ,
  CAP_OPENNI_GRAY_IMAGE = 6 ,
  CAP_OPENNI_IR_IMAGE = 7
}
 OpenNI data given from depth generator. More...
 
enum  {
  CAP_OPENNI_VGA_30HZ = 0 ,
  CAP_OPENNI_SXGA_15HZ = 1 ,
  CAP_OPENNI_SXGA_30HZ = 2 ,
  CAP_OPENNI_QVGA_30HZ = 3 ,
  CAP_OPENNI_QVGA_60HZ = 4
}
 Supported output modes of OpenNI image generator. More...
 
GStreamer
enum  { CAP_PROP_GSTREAMER_QUEUE_LENGTH = 200 }
 
PvAPI, Prosilica GigE SDK
enum  {
  CAP_PROP_PVAPI_MULTICASTIP = 300 ,
  CAP_PROP_PVAPI_FRAMESTARTTRIGGERMODE = 301 ,
  CAP_PROP_PVAPI_DECIMATIONHORIZONTAL = 302 ,
  CAP_PROP_PVAPI_DECIMATIONVERTICAL = 303 ,
  CAP_PROP_PVAPI_BINNINGX = 304 ,
  CAP_PROP_PVAPI_BINNINGY = 305 ,
  CAP_PROP_PVAPI_PIXELFORMAT = 306
}
 PVAPI. More...
 
enum  {
  CAP_PVAPI_FSTRIGMODE_FREERUN = 0 ,
  CAP_PVAPI_FSTRIGMODE_SYNCIN1 = 1 ,
  CAP_PVAPI_FSTRIGMODE_SYNCIN2 = 2 ,
  CAP_PVAPI_FSTRIGMODE_FIXEDRATE = 3 ,
  CAP_PVAPI_FSTRIGMODE_SOFTWARE = 4
}
 PVAPI: FrameStartTriggerMode. More...
 
enum  {
  CAP_PVAPI_DECIMATION_OFF = 1 ,
  CAP_PVAPI_DECIMATION_2OUTOF4 = 2 ,
  CAP_PVAPI_DECIMATION_2OUTOF8 = 4 ,
  CAP_PVAPI_DECIMATION_2OUTOF16 = 8
}
 PVAPI: DecimationHorizontal, DecimationVertical. More...
 
enum  {
  CAP_PVAPI_PIXELFORMAT_MONO8 = 1 ,
  CAP_PVAPI_PIXELFORMAT_MONO16 = 2 ,
  CAP_PVAPI_PIXELFORMAT_BAYER8 = 3 ,
  CAP_PVAPI_PIXELFORMAT_BAYER16 = 4 ,
  CAP_PVAPI_PIXELFORMAT_RGB24 = 5 ,
  CAP_PVAPI_PIXELFORMAT_BGR24 = 6 ,
  CAP_PVAPI_PIXELFORMAT_RGBA32 = 7 ,
  CAP_PVAPI_PIXELFORMAT_BGRA32 = 8
}
 PVAPI: PixelFormat. More...
 
XIMEA Camera API
enum  {
  CAP_PROP_XI_DOWNSAMPLING = 400 ,
  CAP_PROP_XI_DATA_FORMAT = 401 ,
  CAP_PROP_XI_OFFSET_X = 402 ,
  CAP_PROP_XI_OFFSET_Y = 403 ,
  CAP_PROP_XI_TRG_SOURCE = 404 ,
  CAP_PROP_XI_TRG_SOFTWARE = 405 ,
  CAP_PROP_XI_GPI_SELECTOR = 406 ,
  CAP_PROP_XI_GPI_MODE = 407 ,
  CAP_PROP_XI_GPI_LEVEL = 408 ,
  CAP_PROP_XI_GPO_SELECTOR = 409 ,
  CAP_PROP_XI_GPO_MODE = 410 ,
  CAP_PROP_XI_LED_SELECTOR = 411 ,
  CAP_PROP_XI_LED_MODE = 412 ,
  CAP_PROP_XI_MANUAL_WB = 413 ,
  CAP_PROP_XI_AUTO_WB = 414 ,
  CAP_PROP_XI_AEAG = 415 ,
  CAP_PROP_XI_EXP_PRIORITY = 416 ,
  CAP_PROP_XI_AE_MAX_LIMIT = 417 ,
  CAP_PROP_XI_AG_MAX_LIMIT = 418 ,
  CAP_PROP_XI_AEAG_LEVEL = 419 ,
  CAP_PROP_XI_TIMEOUT = 420 ,
  CAP_PROP_XI_EXPOSURE = 421 ,
  CAP_PROP_XI_EXPOSURE_BURST_COUNT = 422 ,
  CAP_PROP_XI_GAIN_SELECTOR = 423 ,
  CAP_PROP_XI_GAIN = 424 ,
  CAP_PROP_XI_DOWNSAMPLING_TYPE = 426 ,
  CAP_PROP_XI_BINNING_SELECTOR = 427 ,
  CAP_PROP_XI_BINNING_VERTICAL = 428 ,
  CAP_PROP_XI_BINNING_HORIZONTAL = 429 ,
  CAP_PROP_XI_BINNING_PATTERN = 430 ,
  CAP_PROP_XI_DECIMATION_SELECTOR = 431 ,
  CAP_PROP_XI_DECIMATION_VERTICAL = 432 ,
  CAP_PROP_XI_DECIMATION_HORIZONTAL = 433 ,
  CAP_PROP_XI_DECIMATION_PATTERN = 434 ,
  CAP_PROP_XI_TEST_PATTERN_GENERATOR_SELECTOR = 587 ,
  CAP_PROP_XI_TEST_PATTERN = 588 ,
  CAP_PROP_XI_IMAGE_DATA_FORMAT = 435 ,
  CAP_PROP_XI_SHUTTER_TYPE = 436 ,
  CAP_PROP_XI_SENSOR_TAPS = 437 ,
  CAP_PROP_XI_AEAG_ROI_OFFSET_X = 439 ,
  CAP_PROP_XI_AEAG_ROI_OFFSET_Y = 440 ,
  CAP_PROP_XI_AEAG_ROI_WIDTH = 441 ,
  CAP_PROP_XI_AEAG_ROI_HEIGHT = 442 ,
  CAP_PROP_XI_BPC = 445 ,
  CAP_PROP_XI_WB_KR = 448 ,
  CAP_PROP_XI_WB_KG = 449 ,
  CAP_PROP_XI_WB_KB = 450 ,
  CAP_PROP_XI_WIDTH = 451 ,
  CAP_PROP_XI_HEIGHT = 452 ,
  CAP_PROP_XI_REGION_SELECTOR = 589 ,
  CAP_PROP_XI_REGION_MODE = 595 ,
  CAP_PROP_XI_LIMIT_BANDWIDTH = 459 ,
  CAP_PROP_XI_SENSOR_DATA_BIT_DEPTH = 460 ,
  CAP_PROP_XI_OUTPUT_DATA_BIT_DEPTH = 461 ,
  CAP_PROP_XI_IMAGE_DATA_BIT_DEPTH = 462 ,
  CAP_PROP_XI_OUTPUT_DATA_PACKING = 463 ,
  CAP_PROP_XI_OUTPUT_DATA_PACKING_TYPE = 464 ,
  CAP_PROP_XI_IS_COOLED = 465 ,
  CAP_PROP_XI_COOLING = 466 ,
  CAP_PROP_XI_TARGET_TEMP = 467 ,
  CAP_PROP_XI_CHIP_TEMP = 468 ,
  CAP_PROP_XI_HOUS_TEMP = 469 ,
  CAP_PROP_XI_HOUS_BACK_SIDE_TEMP = 590 ,
  CAP_PROP_XI_SENSOR_BOARD_TEMP = 596 ,
  CAP_PROP_XI_CMS = 470 ,
  CAP_PROP_XI_APPLY_CMS = 471 ,
  CAP_PROP_XI_IMAGE_IS_COLOR = 474 ,
  CAP_PROP_XI_COLOR_FILTER_ARRAY = 475 ,
  CAP_PROP_XI_GAMMAY = 476 ,
  CAP_PROP_XI_GAMMAC = 477 ,
  CAP_PROP_XI_SHARPNESS = 478 ,
  CAP_PROP_XI_CC_MATRIX_00 = 479 ,
  CAP_PROP_XI_CC_MATRIX_01 = 480 ,
  CAP_PROP_XI_CC_MATRIX_02 = 481 ,
  CAP_PROP_XI_CC_MATRIX_03 = 482 ,
  CAP_PROP_XI_CC_MATRIX_10 = 483 ,
  CAP_PROP_XI_CC_MATRIX_11 = 484 ,
  CAP_PROP_XI_CC_MATRIX_12 = 485 ,
  CAP_PROP_XI_CC_MATRIX_13 = 486 ,
  CAP_PROP_XI_CC_MATRIX_20 = 487 ,
  CAP_PROP_XI_CC_MATRIX_21 = 488 ,
  CAP_PROP_XI_CC_MATRIX_22 = 489 ,
  CAP_PROP_XI_CC_MATRIX_23 = 490 ,
  CAP_PROP_XI_CC_MATRIX_30 = 491 ,
  CAP_PROP_XI_CC_MATRIX_31 = 492 ,
  CAP_PROP_XI_CC_MATRIX_32 = 493 ,
  CAP_PROP_XI_CC_MATRIX_33 = 494 ,
  CAP_PROP_XI_DEFAULT_CC_MATRIX = 495 ,
  CAP_PROP_XI_TRG_SELECTOR = 498 ,
  CAP_PROP_XI_ACQ_FRAME_BURST_COUNT = 499 ,
  CAP_PROP_XI_DEBOUNCE_EN = 507 ,
  CAP_PROP_XI_DEBOUNCE_T0 = 508 ,
  CAP_PROP_XI_DEBOUNCE_T1 = 509 ,
  CAP_PROP_XI_DEBOUNCE_POL = 510 ,
  CAP_PROP_XI_LENS_MODE = 511 ,
  CAP_PROP_XI_LENS_APERTURE_VALUE = 512 ,
  CAP_PROP_XI_LENS_FOCUS_MOVEMENT_VALUE = 513 ,
  CAP_PROP_XI_LENS_FOCUS_MOVE = 514 ,
  CAP_PROP_XI_LENS_FOCUS_DISTANCE = 515 ,
  CAP_PROP_XI_LENS_FOCAL_LENGTH = 516 ,
  CAP_PROP_XI_LENS_FEATURE_SELECTOR = 517 ,
  CAP_PROP_XI_LENS_FEATURE = 518 ,
  CAP_PROP_XI_DEVICE_MODEL_ID = 521 ,
  CAP_PROP_XI_DEVICE_SN = 522 ,
  CAP_PROP_XI_IMAGE_DATA_FORMAT_RGB32_ALPHA = 529 ,
  CAP_PROP_XI_IMAGE_PAYLOAD_SIZE = 530 ,
  CAP_PROP_XI_TRANSPORT_PIXEL_FORMAT = 531 ,
  CAP_PROP_XI_SENSOR_CLOCK_FREQ_HZ = 532 ,
  CAP_PROP_XI_SENSOR_CLOCK_FREQ_INDEX = 533 ,
  CAP_PROP_XI_SENSOR_OUTPUT_CHANNEL_COUNT = 534 ,
  CAP_PROP_XI_FRAMERATE = 535 ,
  CAP_PROP_XI_COUNTER_SELECTOR = 536 ,
  CAP_PROP_XI_COUNTER_VALUE = 537 ,
  CAP_PROP_XI_ACQ_TIMING_MODE = 538 ,
  CAP_PROP_XI_AVAILABLE_BANDWIDTH = 539 ,
  CAP_PROP_XI_BUFFER_POLICY = 540 ,
  CAP_PROP_XI_LUT_EN = 541 ,
  CAP_PROP_XI_LUT_INDEX = 542 ,
  CAP_PROP_XI_LUT_VALUE = 543 ,
  CAP_PROP_XI_TRG_DELAY = 544 ,
  CAP_PROP_XI_TS_RST_MODE = 545 ,
  CAP_PROP_XI_TS_RST_SOURCE = 546 ,
  CAP_PROP_XI_IS_DEVICE_EXIST = 547 ,
  CAP_PROP_XI_ACQ_BUFFER_SIZE = 548 ,
  CAP_PROP_XI_ACQ_BUFFER_SIZE_UNIT = 549 ,
  CAP_PROP_XI_ACQ_TRANSPORT_BUFFER_SIZE = 550 ,
  CAP_PROP_XI_BUFFERS_QUEUE_SIZE = 551 ,
  CAP_PROP_XI_ACQ_TRANSPORT_BUFFER_COMMIT = 552 ,
  CAP_PROP_XI_RECENT_FRAME = 553 ,
  CAP_PROP_XI_DEVICE_RESET = 554 ,
  CAP_PROP_XI_COLUMN_FPN_CORRECTION = 555 ,
  CAP_PROP_XI_ROW_FPN_CORRECTION = 591 ,
  CAP_PROP_XI_SENSOR_MODE = 558 ,
  CAP_PROP_XI_HDR = 559 ,
  CAP_PROP_XI_HDR_KNEEPOINT_COUNT = 560 ,
  CAP_PROP_XI_HDR_T1 = 561 ,
  CAP_PROP_XI_HDR_T2 = 562 ,
  CAP_PROP_XI_KNEEPOINT1 = 563 ,
  CAP_PROP_XI_KNEEPOINT2 = 564 ,
  CAP_PROP_XI_IMAGE_BLACK_LEVEL = 565 ,
  CAP_PROP_XI_HW_REVISION = 571 ,
  CAP_PROP_XI_DEBUG_LEVEL = 572 ,
  CAP_PROP_XI_AUTO_BANDWIDTH_CALCULATION = 573 ,
  CAP_PROP_XI_FFS_FILE_ID = 594 ,
  CAP_PROP_XI_FFS_FILE_SIZE = 580 ,
  CAP_PROP_XI_FREE_FFS_SIZE = 581 ,
  CAP_PROP_XI_USED_FFS_SIZE = 582 ,
  CAP_PROP_XI_FFS_ACCESS_KEY = 583 ,
  CAP_PROP_XI_SENSOR_FEATURE_SELECTOR = 585 ,
  CAP_PROP_XI_SENSOR_FEATURE_VALUE = 586
}
 Properties of cameras available through XIMEA SDK backend. More...
 
ARAVIS Camera API
enum  { CAP_PROP_ARAVIS_AUTOTRIGGER = 600 }
 Properties of cameras available through ARAVIS backend. More...
 
AVFoundation framework for iOS
enum  {
  CAP_PROP_IOS_DEVICE_FOCUS = 9001 ,
  CAP_PROP_IOS_DEVICE_EXPOSURE = 9002 ,
  CAP_PROP_IOS_DEVICE_FLASH = 9003 ,
  CAP_PROP_IOS_DEVICE_WHITEBALANCE = 9004 ,
  CAP_PROP_IOS_DEVICE_TORCH = 9005
}
 Properties of cameras available through AVFOUNDATION backend. More...
 
Smartek Giganetix GigEVisionSDK
enum  {
  CAP_PROP_GIGA_FRAME_OFFSET_X = 10001 ,
  CAP_PROP_GIGA_FRAME_OFFSET_Y = 10002 ,
  CAP_PROP_GIGA_FRAME_WIDTH_MAX = 10003 ,
  CAP_PROP_GIGA_FRAME_HEIGH_MAX = 10004 ,
  CAP_PROP_GIGA_FRAME_SENS_WIDTH = 10005 ,
  CAP_PROP_GIGA_FRAME_SENS_HEIGH = 10006
}
 Properties of cameras available through Smartek Giganetix Ethernet Vision backend. More...
 
Intel Perceptual Computing SDK
enum  {
  CAP_PROP_INTELPERC_PROFILE_COUNT = 11001 ,
  CAP_PROP_INTELPERC_PROFILE_IDX = 11002 ,
  CAP_PROP_INTELPERC_DEPTH_LOW_CONFIDENCE_VALUE = 11003 ,
  CAP_PROP_INTELPERC_DEPTH_SATURATION_VALUE = 11004 ,
  CAP_PROP_INTELPERC_DEPTH_CONFIDENCE_THRESHOLD = 11005 ,
  CAP_PROP_INTELPERC_DEPTH_FOCAL_LENGTH_HORZ = 11006 ,
  CAP_PROP_INTELPERC_DEPTH_FOCAL_LENGTH_VERT = 11007
}
 
enum  {
  CAP_INTELPERC_DEPTH_GENERATOR = 1 << 29 ,
  CAP_INTELPERC_IMAGE_GENERATOR = 1 << 28 ,
  CAP_INTELPERC_IR_GENERATOR = 1 << 27 ,
  CAP_INTELPERC_GENERATORS_MASK = CAP_INTELPERC_DEPTH_GENERATOR + CAP_INTELPERC_IMAGE_GENERATOR + CAP_INTELPERC_IR_GENERATOR
}
 Intel Perceptual Streams. More...
 
enum  {
  CAP_INTELPERC_DEPTH_MAP = 0 ,
  CAP_INTELPERC_UVDEPTH_MAP = 1 ,
  CAP_INTELPERC_IR_MAP = 2 ,
  CAP_INTELPERC_IMAGE = 3
}
 
gPhoto2 connection
enum  {
  CAP_PROP_GPHOTO2_PREVIEW = 17001 ,
  CAP_PROP_GPHOTO2_WIDGET_ENUMERATE = 17002 ,
  CAP_PROP_GPHOTO2_RELOAD_CONFIG = 17003 ,
  CAP_PROP_GPHOTO2_RELOAD_ON_CHANGE = 17004 ,
  CAP_PROP_GPHOTO2_COLLECT_MSGS = 17005 ,
  CAP_PROP_GPHOTO2_FLUSH_MSGS = 17006 ,
  CAP_PROP_SPEED = 17007 ,
  CAP_PROP_APERTURE = 17008 ,
  CAP_PROP_EXPOSUREPROGRAM = 17009 ,
  CAP_PROP_VIEWFINDER = 17010
}
 gPhoto2 properties More...
 
Images backend
enum  {
  CAP_PROP_IMAGES_BASE = 18000 ,
  CAP_PROP_IMAGES_LAST = 19000
}
 Images backend properties. More...
 
OBSENSOR (for Orbbec 3D-Sensor device/module )
enum  VideoCaptureOBSensorDataType {
  CAP_OBSENSOR_DEPTH_MAP = 0 ,
  CAP_OBSENSOR_BGR_IMAGE = 1 ,
  CAP_OBSENSOR_IR_IMAGE = 2
}
 OBSENSOR data given from image generator. More...
 
enum  VideoCaptureOBSensorGenerators {
  CAP_OBSENSOR_DEPTH_GENERATOR = 1 << 29 ,
  CAP_OBSENSOR_IMAGE_GENERATOR = 1 << 28 ,
  CAP_OBSENSOR_IR_GENERATOR = 1 << 27 ,
  CAP_OBSENSOR_GENERATORS_MASK = CAP_OBSENSOR_DEPTH_GENERATOR + CAP_OBSENSOR_IMAGE_GENERATOR + CAP_OBSENSOR_IR_GENERATOR
}
 OBSENSOR stream generator. More...
 
enum  VideoCaptureOBSensorProperties {
  CAP_PROP_OBSENSOR_INTRINSIC_FX =26001 ,
  CAP_PROP_OBSENSOR_INTRINSIC_FY =26002 ,
  CAP_PROP_OBSENSOR_INTRINSIC_CX =26003 ,
  CAP_PROP_OBSENSOR_INTRINSIC_CY =26004
}
 OBSENSOR properties. More...
 

Functions

softdouble abs (softdouble a)
 
softfloat abs (softfloat a)
 Absolute value.
 
static uchar abs (uchar a)
 
static uint64 abs (uint64 a)
 
static unsigned abs (unsigned a)
 
static ushort abs (ushort a)
 
void absdiff (InputArray src1, InputArray src2, OutputArray dst)
 Calculates the per-element absolute difference between two arrays or between an array and a scalar.
 
void accumulate (InputArray src, InputOutputArray dst, InputArray mask=noArray())
 Adds an image to the accumulator image.
 
void accumulateProduct (InputArray src1, InputArray src2, InputOutputArray dst, InputArray mask=noArray())
 Adds the per-element product of two input images to the accumulator image.
 
void accumulateSquare (InputArray src, InputOutputArray dst, InputArray mask=noArray())
 Adds the square of a source image to the accumulator image.
 
void accumulateWeighted (InputArray src, InputOutputArray dst, double alpha, InputArray mask=noArray())
 Updates a running average.
 
template<typename T >
Quat< T > acos (const Quat< T > &q)
 
template<typename T >
Quat< T > acosh (const Quat< T > &q)
 
void adaptiveThreshold (InputArray src, OutputArray dst, double maxValue, int adaptiveMethod, int thresholdType, int blockSize, double C)
 Applies an adaptive threshold to an array.
 
void add (InputArray src1, InputArray src2, OutputArray dst, InputArray mask=noArray(), int dtype=-1)
 Calculates the per-element sum of two arrays or an array and a scalar.
 
void addText (const Mat &img, const String &text, Point org, const QtFont &font)
 Draws a text on the image.
 
void addText (const Mat &img, const String &text, Point org, const String &nameFont, int pointSize=-1, Scalar color=Scalar::all(0), int weight=QT_FONT_NORMAL, int style=QT_STYLE_NORMAL, int spacing=0)
 Draws a text on the image.
 
void addWeighted (InputArray src1, double alpha, InputArray src2, double beta, double gamma, OutputArray dst, int dtype=-1)
 Calculates the weighted sum of two arrays.
 
void AGAST (InputArray image, std::vector< KeyPoint > &keypoints, int threshold, bool nonmaxSuppression, AgastFeatureDetector::DetectorType type)
 Detects corners using the AGAST algorithm.
 
void AGAST (InputArray image, std::vector< KeyPoint > &keypoints, int threshold, bool nonmaxSuppression=true)
 
template<typename _Tp >
static _TpalignPtr (_Tp *ptr, int n=(int) sizeof(_Tp))
 Aligns a pointer to the specified number of bytes.
 
static size_t alignSize (size_t sz, int n)
 Aligns a buffer size to the specified number of bytes.
 
void applyColorMap (InputArray src, OutputArray dst, InputArray userColor)
 Applies a user colormap on a given image.
 
void applyColorMap (InputArray src, OutputArray dst, int colormap)
 Applies a GNU Octave/MATLAB equivalent colormap on a given image.
 
void approxPolyDP (InputArray curve, OutputArray approxCurve, double epsilon, bool closed)
 Approximates a polygonal curve(s) with the specified precision.
 
double arcLength (InputArray curve, bool closed)
 Calculates a contour perimeter or a curve length.
 
void arrowedLine (InputOutputArray img, Point pt1, Point pt2, const Scalar &color, int thickness=1, int line_type=8, int shift=0, double tipLength=0.1)
 Draws an arrow segment pointing from the first point to the second one.
 
template<typename T >
Quat< T > asin (const Quat< T > &q)
 
template<typename T >
Quat< T > asinh (const Quat< T > &q)
 
template<typename T >
Quat< T > atan (const Quat< T > &q)
 
template<typename T >
Quat< T > atanh (const Quat< T > &q)
 
void batchDistance (InputArray src1, InputArray src2, OutputArray dist, int dtype, OutputArray nidx, int normType=NORM_L2, int K=0, InputArray mask=noArray(), int update=0, bool crosscheck=false)
 naive nearest neighbor finder
 
void bilateralFilter (InputArray src, OutputArray dst, int d, double sigmaColor, double sigmaSpace, int borderType=BORDER_DEFAULT)
 Applies the bilateral filter to an image.
 
void bitwise_and (InputArray src1, InputArray src2, OutputArray dst, InputArray mask=noArray())
 computes bitwise conjunction of the two arrays (dst = src1 & src2) Calculates the per-element bit-wise conjunction of two arrays or an array and a scalar.
 
void bitwise_not (InputArray src, OutputArray dst, InputArray mask=noArray())
 Inverts every bit of an array.
 
void bitwise_or (InputArray src1, InputArray src2, OutputArray dst, InputArray mask=noArray())
 Calculates the per-element bit-wise disjunction of two arrays or an array and a scalar.
 
void bitwise_xor (InputArray src1, InputArray src2, OutputArray dst, InputArray mask=noArray())
 Calculates the per-element bit-wise "exclusive or" operation on two arrays or an array and a scalar.
 
void blendLinear (InputArray src1, InputArray src2, InputArray weights1, InputArray weights2, OutputArray dst)
 
void blur (InputArray src, OutputArray dst, Size ksize, Point anchor=Point(-1,-1), int borderType=BORDER_DEFAULT)
 Blurs an image using the normalized box filter.
 
int borderInterpolate (int p, int len, int borderType)
 Computes the source location of an extrapolated pixel.
 
Rect boundingRect (InputArray array)
 Calculates the up-right bounding rectangle of a point set or non-zero pixels of gray-scale image.
 
void boxFilter (InputArray src, OutputArray dst, int ddepth, Size ksize, Point anchor=Point(-1,-1), bool normalize=true, int borderType=BORDER_DEFAULT)
 Blurs an image using the box filter.
 
void boxPoints (RotatedRect box, OutputArray points)
 Finds the four vertices of a rotated rect. Useful to draw the rotated rectangle.
 
void broadcast (InputArray src, InputArray shape, OutputArray dst)
 Broadcast the given Mat to the given shape.
 
int buildOpticalFlowPyramid (InputArray img, OutputArrayOfArrays pyramid, Size winSize, int maxLevel, bool withDerivatives=true, int pyrBorder=BORDER_REFLECT_101, int derivBorder=BORDER_CONSTANT, bool tryReuseInputImage=true)
 Constructs the image pyramid which can be passed to calcOpticalFlowPyrLK.
 
void buildPyramid (InputArray src, OutputArrayOfArrays dst, int maxlevel, int borderType=BORDER_DEFAULT)
 Constructs the Gaussian pyramid for an image.
 
void calcBackProject (const Mat *images, int nimages, const int *channels, const SparseMat &hist, OutputArray backProject, const float **ranges, double scale=1, bool uniform=true)
 
void calcBackProject (const Mat *images, int nimages, const int *channels, InputArray hist, OutputArray backProject, const float **ranges, double scale=1, bool uniform=true)
 Calculates the back projection of a histogram.
 
void calcBackProject (InputArrayOfArrays images, const std::vector< int > &channels, InputArray hist, OutputArray dst, const std::vector< float > &ranges, double scale)
 
void calcCovarMatrix (const Mat *samples, int nsamples, Mat &covar, Mat &mean, int flags, int ctype=CV_64F)
 Calculates the covariance matrix of a set of vectors.
 
void calcCovarMatrix (InputArray samples, OutputArray covar, InputOutputArray mean, int flags, int ctype=CV_64F)
 
void calcHist (const Mat *images, int nimages, const int *channels, InputArray mask, OutputArray hist, int dims, const int *histSize, const float **ranges, bool uniform=true, bool accumulate=false)
 Calculates a histogram of a set of arrays.
 
void calcHist (const Mat *images, int nimages, const int *channels, InputArray mask, SparseMat &hist, int dims, const int *histSize, const float **ranges, bool uniform=true, bool accumulate=false)
 
void calcHist (InputArrayOfArrays images, const std::vector< int > &channels, InputArray mask, OutputArray hist, const std::vector< int > &histSize, const std::vector< float > &ranges, bool accumulate=false)
 
void calcOpticalFlowFarneback (InputArray prev, InputArray next, InputOutputArray flow, double pyr_scale, int levels, int winsize, int iterations, int poly_n, double poly_sigma, int flags)
 Computes a dense optical flow using the Gunnar Farneback's algorithm.
 
void calcOpticalFlowPyrLK (InputArray prevImg, InputArray nextImg, InputArray prevPts, InputOutputArray nextPts, OutputArray status, OutputArray err, Size winSize=Size(21, 21), int maxLevel=3, TermCriteria criteria=TermCriteria(TermCriteria::COUNT+TermCriteria::EPS, 30, 0.01), int flags=0, double minEigThreshold=1e-4)
 Calculates an optical flow for a sparse feature set using the iterative Lucas-Kanade method with pyramids.
 
double calibrateCamera (InputArrayOfArrays objectPoints, InputArrayOfArrays imagePoints, Size imageSize, InputOutputArray cameraMatrix, InputOutputArray distCoeffs, OutputArrayOfArrays rvecs, OutputArrayOfArrays tvecs, int flags=0, TermCriteria criteria=TermCriteria(TermCriteria::COUNT+TermCriteria::EPS, 30, DBL_EPSILON))
 
double calibrateCamera (InputArrayOfArrays objectPoints, InputArrayOfArrays imagePoints, Size imageSize, InputOutputArray cameraMatrix, InputOutputArray distCoeffs, OutputArrayOfArrays rvecs, OutputArrayOfArrays tvecs, OutputArray stdDeviationsIntrinsics, OutputArray stdDeviationsExtrinsics, OutputArray perViewErrors, int flags=0, TermCriteria criteria=TermCriteria(TermCriteria::COUNT+TermCriteria::EPS, 30, DBL_EPSILON))
 Finds the camera intrinsic and extrinsic parameters from several views of a calibration pattern.
 
double calibrateCameraRO (InputArrayOfArrays objectPoints, InputArrayOfArrays imagePoints, Size imageSize, int iFixedPoint, InputOutputArray cameraMatrix, InputOutputArray distCoeffs, OutputArrayOfArrays rvecs, OutputArrayOfArrays tvecs, OutputArray newObjPoints, int flags=0, TermCriteria criteria=TermCriteria(TermCriteria::COUNT+TermCriteria::EPS, 30, DBL_EPSILON))
 
double calibrateCameraRO (InputArrayOfArrays objectPoints, InputArrayOfArrays imagePoints, Size imageSize, int iFixedPoint, InputOutputArray cameraMatrix, InputOutputArray distCoeffs, OutputArrayOfArrays rvecs, OutputArrayOfArrays tvecs, OutputArray newObjPoints, OutputArray stdDeviationsIntrinsics, OutputArray stdDeviationsExtrinsics, OutputArray stdDeviationsObjPoints, OutputArray perViewErrors, int flags=0, TermCriteria criteria=TermCriteria(TermCriteria::COUNT+TermCriteria::EPS, 30, DBL_EPSILON))
 Finds the camera intrinsic and extrinsic parameters from several views of a calibration pattern.
 
void calibrateHandEye (InputArrayOfArrays R_gripper2base, InputArrayOfArrays t_gripper2base, InputArrayOfArrays R_target2cam, InputArrayOfArrays t_target2cam, OutputArray R_cam2gripper, OutputArray t_cam2gripper, HandEyeCalibrationMethod method=CALIB_HAND_EYE_TSAI)
 Computes Hand-Eye calibration: \(_{}^{g}\textrm{T}_c\).
 
void calibrateRobotWorldHandEye (InputArrayOfArrays R_world2cam, InputArrayOfArrays t_world2cam, InputArrayOfArrays R_base2gripper, InputArrayOfArrays t_base2gripper, OutputArray R_base2world, OutputArray t_base2world, OutputArray R_gripper2cam, OutputArray t_gripper2cam, RobotWorldHandEyeCalibrationMethod method=CALIB_ROBOT_WORLD_HAND_EYE_SHAH)
 Computes Robot-World/Hand-Eye calibration: \(_{}^{w}\textrm{T}_b\) and \(_{}^{c}\textrm{T}_g\).
 
void calibrationMatrixValues (InputArray cameraMatrix, Size imageSize, double apertureWidth, double apertureHeight, double &fovx, double &fovy, double &focalLength, Point2d &principalPoint, double &aspectRatio)
 Computes useful camera characteristics from the camera intrinsic matrix.
 
RotatedRect CamShift (InputArray probImage, Rect &window, TermCriteria criteria)
 Finds an object center, size, and orientation.
 
bool can_describe (const GMetaArg &meta, const GRunArg &arg)
 
bool can_describe (const GMetaArg &meta, const GRunArgP &argp)
 
bool can_describe (const GMetaArgs &metas, const GRunArgs &args)
 
void Canny (InputArray dx, InputArray dy, OutputArray edges, double threshold1, double threshold2, bool L2gradient=false)
 
void Canny (InputArray image, OutputArray edges, double threshold1, double threshold2, int apertureSize=3, bool L2gradient=false)
 Finds edges in an image using the Canny algorithm [Canny86] .
 
void cartToPolar (InputArray x, InputArray y, OutputArray magnitude, OutputArray angle, bool angleInDegrees=false)
 Calculates the magnitude and angle of 2D vectors.
 
softfloat cbrt (const softfloat &a)
 Cube root.
 
bool checkChessboard (InputArray img, Size size)
 
bool checkHardwareSupport (int feature)
 Returns true if the specified feature is supported by the host hardware.
 
bool checkRange (InputArray a, bool quiet=true, Point *pos=0, double minVal=-DBL_MAX, double maxVal=DBL_MAX)
 Checks every element of an input array for invalid values.
 
bool Cholesky (double *A, size_t astep, int m, double *b, size_t bstep, int n)
 
bool Cholesky (float *A, size_t astep, int m, float *b, size_t bstep, int n)
 
void circle (InputOutputArray img, Point center, int radius, const Scalar &color, int thickness=1, int lineType=LINE_8, int shift=0)
 Draws a circle.
 
bool clipLine (Rect imgRect, Point &pt1, Point &pt2)
 
bool clipLine (Size imgSize, Point &pt1, Point &pt2)
 Clips the line against the image rectangle.
 
bool clipLine (Size2l imgSize, Point2l &pt1, Point2l &pt2)
 
void colorChange (InputArray src, InputArray mask, OutputArray dst, float red_mul=1.0f, float green_mul=1.0f, float blue_mul=1.0f)
 Given an original color image, two differently colored versions of this image can be mixed seamlessly.
 
void compare (InputArray src1, InputArray src2, OutputArray dst, int cmpop)
 Performs the per-element comparison of two arrays or an array and scalar value.
 
double compareHist (const SparseMat &H1, const SparseMat &H2, int method)
 
double compareHist (InputArray H1, InputArray H2, int method)
 Compares two histograms.
 
template<typename... Ts>
GCompileArgs compile_args (Ts &&... args)
 Wraps a list of arguments (a parameter pack) into a vector of compilation arguments (cv::GCompileArg).
 
void completeSymm (InputOutputArray m, bool lowerToUpper=false)
 Copies the lower or the upper half of a square matrix to its another half.
 
void composeRT (InputArray rvec1, InputArray tvec1, InputArray rvec2, InputArray tvec2, OutputArray rvec3, OutputArray tvec3, OutputArray dr3dr1=noArray(), OutputArray dr3dt1=noArray(), OutputArray dr3dr2=noArray(), OutputArray dr3dt2=noArray(), OutputArray dt3dr1=noArray(), OutputArray dt3dt1=noArray(), OutputArray dt3dr2=noArray(), OutputArray dt3dt2=noArray())
 Combines two rotation-and-shift transformations.
 
void computeCorrespondEpilines (InputArray points, int whichImage, InputArray F, OutputArray lines)
 For points in an image of a stereo pair, computes the corresponding epilines in the other image.
 
double computeECC (InputArray templateImage, InputArray inputImage, InputArray inputMask=noArray())
 Computes the Enhanced Correlation Coefficient value between two images [EP08] .
 
void computeRecallPrecisionCurve (const std::vector< std::vector< DMatch > > &matches1to2, const std::vector< std::vector< uchar > > &correctMatches1to2Mask, std::vector< Point2f > &recallPrecisionCurve)
 
int connectedComponents (InputArray image, OutputArray labels, int connectivity, int ltype, int ccltype)
 computes the connected components labeled image of boolean image
 
int connectedComponents (InputArray image, OutputArray labels, int connectivity=8, int ltype=CV_32S)
 
int connectedComponentsWithStats (InputArray image, OutputArray labels, OutputArray stats, OutputArray centroids, int connectivity, int ltype, int ccltype)
 computes the connected components labeled image of boolean image and also produces a statistics output for each label
 
int connectedComponentsWithStats (InputArray image, OutputArray labels, OutputArray stats, OutputArray centroids, int connectivity=8, int ltype=CV_32S)
 
double contourArea (InputArray contour, bool oriented=false)
 Calculates a contour area.
 
void convertFp16 (InputArray src, OutputArray dst)
 Converts an array to half precision floating number.
 
void convertMaps (InputArray map1, InputArray map2, OutputArray dstmap1, OutputArray dstmap2, int dstmap1type, bool nninterpolation=false)
 Converts image transformation maps from one representation to another.
 
void convertPointsFromHomogeneous (InputArray src, OutputArray dst)
 Converts points from homogeneous to Euclidean space.
 
void convertPointsHomogeneous (InputArray src, OutputArray dst)
 Converts points to/from homogeneous coordinates.
 
void convertPointsToHomogeneous (InputArray src, OutputArray dst)
 Converts points from Euclidean to homogeneous space.
 
void convertScaleAbs (InputArray src, OutputArray dst, double alpha=1, double beta=0)
 Scales, calculates absolute values, and converts the result to 8-bit.
 
void convexHull (InputArray points, OutputArray hull, bool clockwise=false, bool returnPoints=true)
 Finds the convex hull of a point set.
 
void convexityDefects (InputArray contour, InputArray convexhull, OutputArray convexityDefects)
 Finds the convexity defects of a contour.
 
void copyMakeBorder (InputArray src, OutputArray dst, int top, int bottom, int left, int right, int borderType, const Scalar &value=Scalar())
 Forms a border around an image.
 
void copyTo (InputArray src, OutputArray dst, InputArray mask)
 This is an overloaded member function, provided for convenience (python) Copies the matrix to another one. When the operation mask is specified, if the Mat::create call shown above reallocates the matrix, the newly allocated matrix is initialized with all zeros before copying the data.
 
void cornerEigenValsAndVecs (InputArray src, OutputArray dst, int blockSize, int ksize, int borderType=BORDER_DEFAULT)
 Calculates eigenvalues and eigenvectors of image blocks for corner detection.
 
void cornerHarris (InputArray src, OutputArray dst, int blockSize, int ksize, double k, int borderType=BORDER_DEFAULT)
 Harris corner detector.
 
void cornerMinEigenVal (InputArray src, OutputArray dst, int blockSize, int ksize=3, int borderType=BORDER_DEFAULT)
 Calculates the minimal eigenvalue of gradient matrices for corner detection.
 
void cornerSubPix (InputArray image, InputOutputArray corners, Size winSize, Size zeroZone, TermCriteria criteria)
 Refines the corner locations.
 
void correctMatches (InputArray F, InputArray points1, InputArray points2, OutputArray newPoints1, OutputArray newPoints2)
 Refines coordinates of corresponding points.
 
template<typename T >
Quat< T > cos (const Quat< T > &q)
 
softdouble cos (const softdouble &a)
 Cosine.
 
template<typename T >
Quat< T > cosh (const Quat< T > &q)
 
int countNonZero (InputArray src)
 Counts non-zero array elements.
 
Ptr< AffineTransformercreateAffineTransformer (bool fullAffine)
 
Ptr< AlignMTBcreateAlignMTB (int max_bits=6, int exclude_range=4, bool cut=true)
 Creates AlignMTB object.
 
Ptr< BackgroundSubtractorKNNcreateBackgroundSubtractorKNN (int history=500, double dist2Threshold=400.0, bool detectShadows=true)
 Creates KNN Background Subtractor.
 
Ptr< BackgroundSubtractorMOG2createBackgroundSubtractorMOG2 (int history=500, double varThreshold=16, bool detectShadows=true)
 Creates MOG2 Background Subtractor.
 
int createButton (const String &bar_name, ButtonCallback on_change, void *userdata=0, int type=QT_PUSH_BUTTON, bool initial_button_state=false)
 Attaches a button to the control panel.
 
Ptr< CalibrateDebeveccreateCalibrateDebevec (int samples=70, float lambda=10.0f, bool random=false)
 Creates CalibrateDebevec object.
 
Ptr< CalibrateRobertsoncreateCalibrateRobertson (int max_iter=30, float threshold=0.01f)
 Creates CalibrateRobertson object.
 
Ptr< HistogramCostExtractorcreateChiHistogramCostExtractor (int nDummies=25, float defaultCost=0.2f)
 
Ptr< CLAHEcreateCLAHE (double clipLimit=40.0, Size tileGridSize=Size(8, 8))
 Creates a smart pointer to a cv::CLAHE class and initializes it.
 
Ptr< HistogramCostExtractorcreateEMDHistogramCostExtractor (int flag=DIST_L2, int nDummies=25, float defaultCost=0.2f)
 
Ptr< HistogramCostExtractorcreateEMDL1HistogramCostExtractor (int nDummies=25, float defaultCost=0.2f)
 
Ptr< BaseCascadeClassifier::MaskGeneratorcreateFaceDetectionMaskGenerator ()
 
Ptr< GeneralizedHoughBallardcreateGeneralizedHoughBallard ()
 Creates a smart pointer to a cv::GeneralizedHoughBallard class and initializes it.
 
Ptr< GeneralizedHoughGuilcreateGeneralizedHoughGuil ()
 Creates a smart pointer to a cv::GeneralizedHoughGuil class and initializes it.
 
void createHanningWindow (OutputArray dst, Size winSize, int type)
 This function computes a Hanning window coefficients in two dimensions.
 
Ptr< HausdorffDistanceExtractorcreateHausdorffDistanceExtractor (int distanceFlag=cv::NORM_L2, float rankProp=0.6f)
 
Ptr< LineSegmentDetectorcreateLineSegmentDetector (int refine=LSD_REFINE_STD, double scale=0.8, double sigma_scale=0.6, double quant=2.0, double ang_th=22.5, double log_eps=0, double density_th=0.7, int n_bins=1024)
 Creates a smart pointer to a LineSegmentDetector object and initializes it.
 
Ptr< MergeDebeveccreateMergeDebevec ()
 Creates MergeDebevec object.
 
Ptr< MergeMertenscreateMergeMertens (float contrast_weight=1.0f, float saturation_weight=1.0f, float exposure_weight=0.0f)
 Creates MergeMertens object.
 
Ptr< MergeRobertsoncreateMergeRobertson ()
 Creates MergeRobertson object.
 
Ptr< HistogramCostExtractorcreateNormHistogramCostExtractor (int flag=DIST_L2, int nDummies=25, float defaultCost=0.2f)
 
Ptr< ShapeContextDistanceExtractorcreateShapeContextDistanceExtractor (int nAngularBins=12, int nRadialBins=4, float innerRadius=0.2f, float outerRadius=2, int iterations=3, const Ptr< HistogramCostExtractor > &comparer=createChiHistogramCostExtractor(), const Ptr< ShapeTransformer > &transformer=createThinPlateSplineShapeTransformer())
 
Ptr< StitchercreateStitcher (bool try_use_gpu=false)
 
Ptr< StitchercreateStitcherScans (bool try_use_gpu=false)
 
Ptr< ThinPlateSplineShapeTransformercreateThinPlateSplineShapeTransformer (double regularizationParameter=0)
 
Ptr< TonemapcreateTonemap (float gamma=1.0f)
 Creates simple linear mapper with gamma correction.
 
Ptr< TonemapDragocreateTonemapDrago (float gamma=1.0f, float saturation=1.0f, float bias=0.85f)
 Creates TonemapDrago object.
 
Ptr< TonemapMantiukcreateTonemapMantiuk (float gamma=1.0f, float scale=0.7f, float saturation=1.0f)
 Creates TonemapMantiuk object.
 
Ptr< TonemapReinhardcreateTonemapReinhard (float gamma=1.0f, float intensity=0.0f, float light_adapt=1.0f, float color_adapt=0.0f)
 Creates TonemapReinhard object.
 
int createTrackbar (const String &trackbarname, const String &winname, int *value, int count, TrackbarCallback onChange=0, void *userdata=0)
 Creates a trackbar and attaches it to the specified window.
 
template<typename T >
Quat< T > crossProduct (const Quat< T > &p, const Quat< T > &q)
 
static double cubeRoot (double val)
 
float cubeRoot (float val)
 Computes the cube root of an argument.
 
template<typename _Tp >
static void cv2eigen (const Mat &src, Eigen::Matrix< _Tp, 1, Eigen::Dynamic > &dst)
 
template<typename _Tp , int _rows, int _cols, int _options, int _maxRows, int _maxCols>
static void cv2eigen (const Mat &src, Eigen::Matrix< _Tp, _rows, _cols, _options, _maxRows, _maxCols > &dst)
 
template<typename _Tp >
static void cv2eigen (const Mat &src, Eigen::Matrix< _Tp, Eigen::Dynamic, 1 > &dst)
 
template<typename _Tp >
static void cv2eigen (const Mat &src, Eigen::Matrix< _Tp, Eigen::Dynamic, Eigen::Dynamic > &dst)
 
template<typename _Tp , int _layout>
static void cv2eigen (const Mat &src, Eigen::Tensor< _Tp, 3, _layout > &dst)
 Converts a cv::Mat to an Eigen::Tensor.
 
template<typename _Tp , int _cols>
static void cv2eigen (const Matx< _Tp, 1, _cols > &src, Eigen::Matrix< _Tp, 1, Eigen::Dynamic > &dst)
 
template<typename _Tp , int _rows>
static void cv2eigen (const Matx< _Tp, _rows, 1 > &src, Eigen::Matrix< _Tp, Eigen::Dynamic, 1 > &dst)
 
template<typename _Tp , int _rows, int _cols, int _options, int _maxRows, int _maxCols>
static void cv2eigen (const Matx< _Tp, _rows, _cols > &src, Eigen::Matrix< _Tp, _rows, _cols, _options, _maxRows, _maxCols > &dst)
 
template<typename _Tp , int _rows, int _cols>
static void cv2eigen (const Matx< _Tp, _rows, _cols > &src, Eigen::Matrix< _Tp, Eigen::Dynamic, Eigen::Dynamic > &dst)
 
template<typename _Tp >
static Eigen::TensorMap< Eigen::Tensor< _Tp, 3, Eigen::RowMajor > > cv2eigen_tensormap (InputArray src)
 Maps cv::Mat data to an Eigen::TensorMap.
 
template<typename _Tp >
_Tp cv_abs (_Tp x)
 
int cv_abs (schar x)
 
int cv_abs (short x)
 
int cv_abs (uchar x)
 
int cv_abs (ushort x)
 
void cvtColor (InputArray src, OutputArray dst, int code, int dstCn=0)
 Converts an image from one color space to another.
 
void cvtColorTwoPlane (InputArray src1, InputArray src2, OutputArray dst, int code)
 Converts an image from one color space to another where the source image is stored in two planes.
 
void dct (InputArray src, OutputArray dst, int flags=0)
 Performs a forward or inverse discrete Cosine transform of 1D or 2D array.
 
void decolor (InputArray src, OutputArray grayscale, OutputArray color_boost)
 Transforms a color image to a grayscale image. It is a basic tool in digital printing, stylized black-and-white photograph rendering, and in many single channel image processing applications [CL12] .
 
void decomposeEssentialMat (InputArray E, OutputArray R1, OutputArray R2, OutputArray t)
 Decompose an essential matrix to possible rotations and translation.
 
int decomposeHomographyMat (InputArray H, InputArray K, OutputArrayOfArrays rotations, OutputArrayOfArrays translations, OutputArrayOfArrays normals)
 Decompose a homography matrix to rotation(s), translation(s) and plane normal(s).
 
void decomposeProjectionMatrix (InputArray projMatrix, OutputArray cameraMatrix, OutputArray rotMatrix, OutputArray transVect, OutputArray rotMatrixX=noArray(), OutputArray rotMatrixY=noArray(), OutputArray rotMatrixZ=noArray(), OutputArray eulerAngles=noArray())
 Decomposes a projection matrix into a rotation matrix and a camera intrinsic matrix.
 
void demosaicing (InputArray src, OutputArray dst, int code, int dstCn=0)
 main function for all demosaicing processes
 
void denoise_TVL1 (const std::vector< Mat > &observations, Mat &result, double lambda=1.0, int niters=30)
 Primal-dual algorithm is an algorithm for solving special types of variational problems (that is, finding a function to minimize some functional). As the image denoising, in particular, may be seen as the variational problem, primal-dual algorithm then can be used to perform denoising and this is exactly what is implemented.
 
const char * depthToString (int depth)
 
GMatDesc descr_of (const cv::Mat &mat)
 
GScalarDesc descr_of (const cv::Scalar &scalar)
 
GMatDesc descr_of (const cv::UMat &mat)
 
GMetaArg descr_of (const GRunArg &arg)
 
GMetaArg descr_of (const GRunArgP &argp)
 
GMetaArgs descr_of (const GRunArgs &args)
 
GFrameDesc descr_of (const MediaFrame &frame)
 
GMatDesc descr_of (const RMat &mat)
 
template<typename U >
GArrayDesc descr_of (const std::vector< U > &)
 
template<typename U >
GOpaqueDesc descr_of (const U &)
 
cv::GMetaArgs descrs_of (const std::vector< cv::Mat > &vec)
 
cv::GMetaArgs descrs_of (const std::vector< cv::UMat > &vec)
 
void destroyAllWindows ()
 Destroys all of the HighGUI windows.
 
void destroyWindow (const String &winname)
 Destroys the specified window.
 
void detailEnhance (InputArray src, OutputArray dst, float sigma_s=10, float sigma_r=0.15f)
 This filter enhances the details of a particular image.
 
template<typename _Tp , int m>
static double determinant (const Matx< _Tp, m, m > &a)
 
double determinant (InputArray mtx)
 Returns the determinant of a square floating-point matrix.
 
void dft (InputArray src, OutputArray dst, int flags=0, int nonzeroRows=0)
 Performs a forward or inverse Discrete Fourier transform of a 1D or 2D floating-point array.
 
void dilate (InputArray src, OutputArray dst, InputArray kernel, Point anchor=Point(-1,-1), int iterations=1, int borderType=BORDER_CONSTANT, const Scalar &borderValue=morphologyDefaultBorderValue())
 Dilates an image by using a specific structuring element.
 
void displayOverlay (const String &winname, const String &text, int delayms=0)
 Displays a text on a window image as an overlay for a specified duration.
 
void displayStatusBar (const String &winname, const String &text, int delayms=0)
 Displays a text on the window statusbar during the specified period of time.
 
void distanceTransform (InputArray src, OutputArray dst, int distanceType, int maskSize, int dstType=CV_32F)
 
void distanceTransform (InputArray src, OutputArray dst, OutputArray labels, int distanceType, int maskSize, int labelType=DIST_LABEL_CCOMP)
 Calculates the distance to the closest zero pixel for each pixel of the source image.
 
void divide (double scale, InputArray src2, OutputArray dst, int dtype=-1)
 
void divide (InputArray src1, InputArray src2, OutputArray dst, double scale=1, int dtype=-1)
 Performs per-element division of two arrays or a scalar by an array.
 
void divSpectrums (InputArray a, InputArray b, OutputArray c, int flags, bool conjB=false)
 Performs the per-element division of the first Fourier spectrum by the second Fourier spectrum.
 
static int divUp (int a, unsigned int b)
 Integer division with result round up.
 
static size_t divUp (size_t a, unsigned int b)
 
void drawChessboardCorners (InputOutputArray image, Size patternSize, InputArray corners, bool patternWasFound)
 Renders the detected chessboard corners.
 
void drawContours (InputOutputArray image, InputArrayOfArrays contours, int contourIdx, const Scalar &color, int thickness=1, int lineType=LINE_8, InputArray hierarchy=noArray(), int maxLevel=INT_MAX, Point offset=Point())
 Draws contours outlines or filled contours.
 
void drawFrameAxes (InputOutputArray image, InputArray cameraMatrix, InputArray distCoeffs, InputArray rvec, InputArray tvec, float length, int thickness=3)
 Draw axes of the world/object coordinate system from pose estimation.
 
void drawKeypoints (InputArray image, const std::vector< KeyPoint > &keypoints, InputOutputArray outImage, const Scalar &color=Scalar::all(-1), DrawMatchesFlags flags=DrawMatchesFlags::DEFAULT)
 Draws keypoints.
 
void drawMarker (InputOutputArray img, Point position, const Scalar &color, int markerType=MARKER_CROSS, int markerSize=20, int thickness=1, int line_type=8)
 Draws a marker on a predefined position in an image.
 
void drawMatches (InputArray img1, const std::vector< KeyPoint > &keypoints1, InputArray img2, const std::vector< KeyPoint > &keypoints2, const std::vector< DMatch > &matches1to2, InputOutputArray outImg, const int matchesThickness, const Scalar &matchColor=Scalar::all(-1), const Scalar &singlePointColor=Scalar::all(-1), const std::vector< char > &matchesMask=std::vector< char >(), DrawMatchesFlags flags=DrawMatchesFlags::DEFAULT)
 
void drawMatches (InputArray img1, const std::vector< KeyPoint > &keypoints1, InputArray img2, const std::vector< KeyPoint > &keypoints2, const std::vector< DMatch > &matches1to2, InputOutputArray outImg, const Scalar &matchColor=Scalar::all(-1), const Scalar &singlePointColor=Scalar::all(-1), const std::vector< char > &matchesMask=std::vector< char >(), DrawMatchesFlags flags=DrawMatchesFlags::DEFAULT)
 Draws the found matches of keypoints from two images.
 
void drawMatches (InputArray img1, const std::vector< KeyPoint > &keypoints1, InputArray img2, const std::vector< KeyPoint > &keypoints2, const std::vector< std::vector< DMatch > > &matches1to2, InputOutputArray outImg, const Scalar &matchColor=Scalar::all(-1), const Scalar &singlePointColor=Scalar::all(-1), const std::vector< std::vector< char > > &matchesMask=std::vector< std::vector< char > >(), DrawMatchesFlags flags=DrawMatchesFlags::DEFAULT)
 
static void dumpOpenCLInformation ()
 
void edgePreservingFilter (InputArray src, OutputArray dst, int flags=1, float sigma_s=60, float sigma_r=0.4f)
 Filtering is the fundamental operation in image and video processing. Edge-preserving smoothing filters are used in many different applications [EM11] .
 
bool eigen (InputArray src, OutputArray eigenvalues, OutputArray eigenvectors=noArray())
 Calculates eigenvalues and eigenvectors of a symmetric matrix.
 
template<typename _Tp , int _rows, int _cols, int _options, int _maxRows, int _maxCols>
static void eigen2cv (const Eigen::Matrix< _Tp, _rows, _cols, _options, _maxRows, _maxCols > &src, Matx< _Tp, _rows, _cols > &dst)
 
template<typename _Tp , int _rows, int _cols, int _options, int _maxRows, int _maxCols>
static void eigen2cv (const Eigen::Matrix< _Tp, _rows, _cols, _options, _maxRows, _maxCols > &src, OutputArray dst)
 
template<typename _Tp , int _layout>
static void eigen2cv (const Eigen::Tensor< _Tp, 3, _layout > &src, OutputArray dst)
 Converts an Eigen::Tensor to a cv::Mat.
 
void eigenNonSymmetric (InputArray src, OutputArray eigenvalues, OutputArray eigenvectors)
 Calculates eigenvalues and eigenvectors of a non-symmetric matrix (real eigenvalues only).
 
void ellipse (InputOutputArray img, const RotatedRect &box, const Scalar &color, int thickness=1, int lineType=LINE_8)
 
void ellipse (InputOutputArray img, Point center, Size axes, double angle, double startAngle, double endAngle, const Scalar &color, int thickness=1, int lineType=LINE_8, int shift=0)
 Draws a simple or thick elliptic arc or fills an ellipse sector.
 
void ellipse2Poly (Point center, Size axes, int angle, int arcStart, int arcEnd, int delta, std::vector< Point > &pts)
 Approximates an elliptic arc with a polyline.
 
void ellipse2Poly (Point2d center, Size2d axes, int angle, int arcStart, int arcEnd, int delta, std::vector< Point2d > &pts)
 
float EMD (InputArray signature1, InputArray signature2, int distType, InputArray cost=noArray(), float *lowerBound=0, OutputArray flow=noArray())
 Computes the "minimal work" distance between two weighted point configurations.
 
float EMDL1 (InputArray signature1, InputArray signature2)
 Computes the "minimal work" distance between two weighted point configurations base on the papers "EMD-L1: An efficient and Robust Algorithm for comparing histogram-based descriptors", by Haibin Ling and Kazunori Okuda; and "The Earth Mover's Distance is the Mallows Distance: Some Insights from Statistics", by Elizaveta Levina and Peter Bickel.
 
GArrayDesc empty_array_desc ()
 
static GFrameDesc empty_gframe_desc ()
 
static GMatDesc empty_gmat_desc ()
 
GOpaqueDesc empty_gopaque_desc ()
 
GScalarDesc empty_scalar_desc ()
 
void equalizeHist (InputArray src, OutputArray dst)
 Equalizes the histogram of a grayscale image.
 
void erode (InputArray src, OutputArray dst, InputArray kernel, Point anchor=Point(-1,-1), int iterations=1, int borderType=BORDER_CONSTANT, const Scalar &borderValue=morphologyDefaultBorderValue())
 Erodes an image by using a specific structuring element.
 
void error (const Exception &exc)
 Signals an error and raises the exception.
 
void error (int _code, const String &_err, const char *_func, const char *_file, int _line)
 Signals an error and raises the exception.
 
cv::Mat estimateAffine2D (InputArray from, InputArray to, OutputArray inliers=noArray(), int method=RANSAC, double ransacReprojThreshold=3, size_t maxIters=2000, double confidence=0.99, size_t refineIters=10)
 Computes an optimal affine transformation between two 2D point sets.
 
cv::Mat estimateAffine2D (InputArray pts1, InputArray pts2, OutputArray inliers, const UsacParams &params)
 
cv::Mat estimateAffine3D (InputArray src, InputArray dst, double *scale=nullptr, bool force_rotation=true)
 Computes an optimal affine transformation between two 3D point sets.
 
int estimateAffine3D (InputArray src, InputArray dst, OutputArray out, OutputArray inliers, double ransacThreshold=3, double confidence=0.99)
 Computes an optimal affine transformation between two 3D point sets.
 
cv::Mat estimateAffinePartial2D (InputArray from, InputArray to, OutputArray inliers=noArray(), int method=RANSAC, double ransacReprojThreshold=3, size_t maxIters=2000, double confidence=0.99, size_t refineIters=10)
 Computes an optimal limited affine transformation with 4 degrees of freedom between two 2D point sets.
 
Scalar estimateChessboardSharpness (InputArray image, Size patternSize, InputArray corners, float rise_distance=0.8F, bool vertical=false, OutputArray sharpness=noArray())
 Estimates the sharpness of a detected chessboard.
 
Mat estimateRigidTransform (InputArray src, InputArray dst, bool fullAffine)
 Computes an optimal affine transformation between two 2D point sets.
 
int estimateTranslation3D (InputArray src, InputArray dst, OutputArray out, OutputArray inliers, double ransacThreshold=3, double confidence=0.99)
 Computes an optimal translation between two 3D point sets.
 
void evaluateFeatureDetector (const Mat &img1, const Mat &img2, const Mat &H1to2, std::vector< KeyPoint > *keypoints1, std::vector< KeyPoint > *keypoints2, float &repeatability, int &correspCount, const Ptr< FeatureDetector > &fdetector=Ptr< FeatureDetector >())
 
template<typename T >
Quat< T > exp (const Quat< T > &q)
 
softdouble exp (const softdouble &a)
 
softfloat exp (const softfloat &a)
 Exponent.
 
void exp (InputArray src, OutputArray dst)
 Calculates the exponent of every array element.
 
void extractChannel (InputArray src, OutputArray dst, int coi)
 Extracts a single channel from src (coi is 0-based index)
 
void FAST (InputArray image, std::vector< KeyPoint > &keypoints, int threshold, bool nonmaxSuppression, FastFeatureDetector::DetectorType type)
 Detects corners using the FAST algorithm.
 
void FAST (InputArray image, std::vector< KeyPoint > &keypoints, int threshold, bool nonmaxSuppression=true)
 
float fastAtan2 (float y, float x)
 Calculates the angle of a 2D vector in degrees.
 
void fastFree (void *ptr)
 Deallocates a memory buffer.
 
void * fastMalloc (size_t bufSize)
 Allocates an aligned memory buffer.
 
void fastNlMeansDenoising (InputArray src, OutputArray dst, const std::vector< float > &h, int templateWindowSize=7, int searchWindowSize=21, int normType=NORM_L2)
 Perform image denoising using Non-local Means Denoising algorithm http://www.ipol.im/pub/algo/bcm_non_local_means_denoising/ with several computational optimizations. Noise expected to be a gaussian white noise.
 
void fastNlMeansDenoising (InputArray src, OutputArray dst, float h=3, int templateWindowSize=7, int searchWindowSize=21)
 Perform image denoising using Non-local Means Denoising algorithm http://www.ipol.im/pub/algo/bcm_non_local_means_denoising/ with several computational optimizations. Noise expected to be a gaussian white noise.
 
void fastNlMeansDenoisingColored (InputArray src, OutputArray dst, float h=3, float hColor=3, int templateWindowSize=7, int searchWindowSize=21)
 Modification of fastNlMeansDenoising function for colored images.
 
void fastNlMeansDenoisingColoredMulti (InputArrayOfArrays srcImgs, OutputArray dst, int imgToDenoiseIndex, int temporalWindowSize, float h=3, float hColor=3, int templateWindowSize=7, int searchWindowSize=21)
 Modification of fastNlMeansDenoisingMulti function for colored images sequences.
 
void fastNlMeansDenoisingMulti (InputArrayOfArrays srcImgs, OutputArray dst, int imgToDenoiseIndex, int temporalWindowSize, const std::vector< float > &h, int templateWindowSize=7, int searchWindowSize=21, int normType=NORM_L2)
 Modification of fastNlMeansDenoising function for images sequence where consecutive images have been captured in small period of time. For example video. This version of the function is for grayscale images or for manual manipulation with colorspaces. See [Buades2005DenoisingIS] for more details (open access here).
 
void fastNlMeansDenoisingMulti (InputArrayOfArrays srcImgs, OutputArray dst, int imgToDenoiseIndex, int temporalWindowSize, float h=3, int templateWindowSize=7, int searchWindowSize=21)
 Modification of fastNlMeansDenoising function for images sequence where consecutive images have been captured in small period of time. For example video. This version of the function is for grayscale images or for manual manipulation with colorspaces. See [Buades2005DenoisingIS] for more details (open access here).
 
void fillConvexPoly (InputOutputArray img, const Point *pts, int npts, const Scalar &color, int lineType=LINE_8, int shift=0)
 
void fillConvexPoly (InputOutputArray img, InputArray points, const Scalar &color, int lineType=LINE_8, int shift=0)
 Fills a convex polygon.
 
void fillPoly (InputOutputArray img, const Point **pts, const int *npts, int ncontours, const Scalar &color, int lineType=LINE_8, int shift=0, Point offset=Point())
 
void fillPoly (InputOutputArray img, InputArrayOfArrays pts, const Scalar &color, int lineType=LINE_8, int shift=0, Point offset=Point())
 Fills the area bounded by one or more polygons.
 
void filter2D (InputArray src, OutputArray dst, int ddepth, InputArray kernel, Point anchor=Point(-1,-1), double delta=0, int borderType=BORDER_DEFAULT)
 Convolves an image with the kernel.
 
void filterHomographyDecompByVisibleRefpoints (InputArrayOfArrays rotations, InputArrayOfArrays normals, InputArray beforePoints, InputArray afterPoints, OutputArray possibleSolutions, InputArray pointsMask=noArray())
 Filters homography decompositions based on additional information.
 
void filterSpeckles (InputOutputArray img, double newVal, int maxSpeckleSize, double maxDiff, InputOutputArray buf=noArray())
 Filters off small noise blobs (speckles) in the disparity map.
 
bool find4QuadCornerSubpix (InputArray img, InputOutputArray corners, Size region_size)
 finds subpixel-accurate positions of the chessboard corners
 
bool findChessboardCorners (InputArray image, Size patternSize, OutputArray corners, int flags=CALIB_CB_ADAPTIVE_THRESH+CALIB_CB_NORMALIZE_IMAGE)
 Finds the positions of internal corners of the chessboard.
 
bool findChessboardCornersSB (InputArray image, Size patternSize, OutputArray corners, int flags, OutputArray meta)
 Finds the positions of internal corners of the chessboard using a sector based approach.
 
bool findChessboardCornersSB (InputArray image, Size patternSize, OutputArray corners, int flags=0)
 
bool findCirclesGrid (InputArray image, Size patternSize, OutputArray centers, int flags, const Ptr< FeatureDetector > &blobDetector, const CirclesGridFinderParameters &parameters)
 Finds centers in the grid of circles.
 
bool findCirclesGrid (InputArray image, Size patternSize, OutputArray centers, int flags=CALIB_CB_SYMMETRIC_GRID, const Ptr< FeatureDetector > &blobDetector=SimpleBlobDetector::create())
 
void findContours (InputArray image, OutputArrayOfArrays contours, int mode, int method, Point offset=Point())
 
void findContours (InputArray image, OutputArrayOfArrays contours, OutputArray hierarchy, int mode, int method, Point offset=Point())
 Finds contours in a binary image.
 
Mat findEssentialMat (InputArray points1, InputArray points2, double focal, Point2d pp, int method, double prob, double threshold, OutputArray mask)
 
Mat findEssentialMat (InputArray points1, InputArray points2, double focal=1.0, Point2d pp=Point2d(0, 0), int method=RANSAC, double prob=0.999, double threshold=1.0, int maxIters=1000, OutputArray mask=noArray())
 
Mat findEssentialMat (InputArray points1, InputArray points2, InputArray cameraMatrix, int method, double prob, double threshold, OutputArray mask)
 
Mat findEssentialMat (InputArray points1, InputArray points2, InputArray cameraMatrix, int method=RANSAC, double prob=0.999, double threshold=1.0, int maxIters=1000, OutputArray mask=noArray())
 Calculates an essential matrix from the corresponding points in two images.
 
Mat findEssentialMat (InputArray points1, InputArray points2, InputArray cameraMatrix1, InputArray cameraMatrix2, InputArray dist_coeff1, InputArray dist_coeff2, OutputArray mask, const UsacParams &params)
 
Mat findEssentialMat (InputArray points1, InputArray points2, InputArray cameraMatrix1, InputArray distCoeffs1, InputArray cameraMatrix2, InputArray distCoeffs2, int method=RANSAC, double prob=0.999, double threshold=1.0, OutputArray mask=noArray())
 Calculates an essential matrix from the corresponding points in two images from potentially two different cameras.
 
Mat findFundamentalMat (InputArray points1, InputArray points2, int method, double ransacReprojThreshold, double confidence, int maxIters, OutputArray mask=noArray())
 Calculates a fundamental matrix from the corresponding points in two images.
 
Mat findFundamentalMat (InputArray points1, InputArray points2, int method=FM_RANSAC, double ransacReprojThreshold=3., double confidence=0.99, OutputArray mask=noArray())
 
Mat findFundamentalMat (InputArray points1, InputArray points2, OutputArray mask, const UsacParams &params)
 
Mat findFundamentalMat (InputArray points1, InputArray points2, OutputArray mask, int method=FM_RANSAC, double ransacReprojThreshold=3., double confidence=0.99)
 
Mat findHomography (InputArray srcPoints, InputArray dstPoints, int method=0, double ransacReprojThreshold=3, OutputArray mask=noArray(), const int maxIters=2000, const double confidence=0.995)
 Finds a perspective transformation between two planes.
 
Mat findHomography (InputArray srcPoints, InputArray dstPoints, OutputArray mask, const UsacParams &params)
 
Mat findHomography (InputArray srcPoints, InputArray dstPoints, OutputArray mask, int method=0, double ransacReprojThreshold=3)
 
void findNonZero (InputArray src, OutputArray idx)
 Returns the list of locations of non-zero pixels.
 
double findTransformECC (InputArray templateImage, InputArray inputImage, InputOutputArray warpMatrix, int motionType, TermCriteria criteria, InputArray inputMask, int gaussFiltSize)
 Finds the geometric transform (warp) between two images in terms of the ECC criterion [EP08] .
 
double findTransformECC (InputArray templateImage, InputArray inputImage, InputOutputArray warpMatrix, int motionType=MOTION_AFFINE, TermCriteria criteria=TermCriteria(TermCriteria::COUNT+TermCriteria::EPS, 50, 0.001), InputArray inputMask=noArray())
 
RotatedRect fitEllipse (InputArray points)
 Fits an ellipse around a set of 2D points.
 
RotatedRect fitEllipseAMS (InputArray points)
 Fits an ellipse around a set of 2D points.
 
RotatedRect fitEllipseDirect (InputArray points)
 Fits an ellipse around a set of 2D points.
 
void fitLine (InputArray points, OutputArray line, int distType, double param, double reps, double aeps)
 Fits a line to a 2D or 3D point set.
 
void flip (InputArray src, OutputArray dst, int flipCode)
 Flips a 2D array around vertical, horizontal, or both axes.
 
void flipND (InputArray src, OutputArray dst, int axis)
 Flips a n-dimensional at given axis.
 
int floodFill (InputOutputArray image, InputOutputArray mask, Point seedPoint, Scalar newVal, Rect *rect=0, Scalar loDiff=Scalar(), Scalar upDiff=Scalar(), int flags=4)
 Fills a connected component with the given color.
 
int floodFill (InputOutputArray image, Point seedPoint, Scalar newVal, Rect *rect=0, Scalar loDiff=Scalar(), Scalar upDiff=Scalar(), int flags=4)
 
QtFont fontQt (const String &nameFont, int pointSize=-1, Scalar color=Scalar::all(0), int weight=QT_FONT_NORMAL, int style=QT_STYLE_NORMAL, int spacing=0)
 Creates the font to draw a text on an image.
 
String format (const char *fmt,...)
 Returns a text string formatted using the printf-like expression.
 
void GaussianBlur (InputArray src, OutputArray dst, Size ksize, double sigmaX, double sigmaY=0, int borderType=BORDER_DEFAULT)
 Blurs an image using a Gaussian filter.
 
void gemm (InputArray src1, InputArray src2, double alpha, InputArray src3, double beta, OutputArray dst, int flags=0)
 Performs generalized matrix multiplication.
 
Mat getAffineTransform (const Point2f src[], const Point2f dst[])
 Calculates an affine transform from three pairs of the corresponding points.
 
Mat getAffineTransform (InputArray src, InputArray dst)
 
const StringgetBuildInformation ()
 Returns full configuration time cmake output.
 
std::string getCPUFeaturesLine ()
 Returns list of CPU features enabled during compilation.
 
int64 getCPUTickCount ()
 Returns the number of CPU ticks.
 
Mat getDefaultNewCameraMatrix (InputArray cameraMatrix, Size imgsize=Size(), bool centerPrincipalPoint=false)
 Returns the default new camera matrix.
 
void getDerivKernels (OutputArray kx, OutputArray ky, int dx, int dy, int ksize, bool normalize=false, int ktype=CV_32F)
 Returns filter coefficients for computing spatial image derivatives.
 
static size_t getElemSize (int type)
 
double getFontScaleFromHeight (const int fontFace, const int pixelHeight, const int thickness=1)
 Calculates the font-specific size to use to achieve a given height in pixels.
 
Mat getGaborKernel (Size ksize, double sigma, double theta, double lambd, double gamma, double psi=CV_PI *0.5, int ktype=CV_64F)
 Returns Gabor filter coefficients.
 
Mat getGaussianKernel (int ksize, double sigma, int ktype=CV_64F)
 Returns Gaussian filter coefficients.
 
String getHardwareFeatureName (int feature)
 Returns feature name by ID.
 
int getMouseWheelDelta (int flags)
 Gets the mouse-wheel motion delta, when handling mouse-wheel events cv::EVENT_MOUSEWHEEL and cv::EVENT_MOUSEHWHEEL.
 
int getNearestPoint (const std::vector< Point2f > &recallPrecisionCurve, float l_precision)
 
int getNumberOfCPUs ()
 Returns the number of logical CPUs available for the process.
 
int getNumThreads ()
 Returns the number of threads used by OpenCV for parallel regions.
 
int getOptimalDFTSize (int vecsize)
 Returns the optimal DFT size for a given vector size.
 
Mat getOptimalNewCameraMatrix (InputArray cameraMatrix, InputArray distCoeffs, Size imageSize, double alpha, Size newImgSize=Size(), Rect *validPixROI=0, bool centerPrincipalPoint=false)
 Returns the new camera intrinsic matrix based on the free scaling parameter.
 
Mat getPerspectiveTransform (const Point2f src[], const Point2f dst[], int solveMethod=DECOMP_LU)
 
Mat getPerspectiveTransform (InputArray src, InputArray dst, int solveMethod=DECOMP_LU)
 Calculates a perspective transform from four pairs of the corresponding points.
 
float getRecall (const std::vector< Point2f > &recallPrecisionCurve, float l_precision)
 
void getRectSubPix (InputArray image, Size patchSize, Point2f center, OutputArray patch, int patchType=-1)
 Retrieves a pixel rectangle from an image with sub-pixel accuracy.
 
Mat getRotationMatrix2D (Point2f center, double angle, double scale)
 Calculates an affine matrix of 2D rotation.
 
Matx23d getRotationMatrix2D_ (Point2f center, double angle, double scale)
 
Mat getStructuringElement (int shape, Size ksize, Point anchor=Point(-1,-1))
 Returns a structuring element of the specified size and shape for morphological operations.
 
Size getTextSize (const String &text, int fontFace, double fontScale, int thickness, int *baseLine)
 Calculates the width and height of a text string.
 
int getThreadNum ()
 Returns the index of the currently executed thread within the current parallel region. Always returns 0 if called outside of parallel region.
 
int64 getTickCount ()
 Returns the number of ticks.
 
double getTickFrequency ()
 Returns the number of ticks per second.
 
int getTrackbarPos (const String &trackbarname, const String &winname)
 Returns the trackbar position.
 
Rect getValidDisparityROI (Rect roi1, Rect roi2, int minDisparity, int numberOfDisparities, int blockSize)
 computes valid disparity ROI from the valid ROIs of the rectified images (that are returned by stereoRectify)
 
int getVersionMajor ()
 Returns major library version.
 
int getVersionMinor ()
 Returns minor library version.
 
int getVersionRevision ()
 Returns revision field of the library version.
 
String getVersionString ()
 Returns library version string.
 
Rect getWindowImageRect (const String &winname)
 Provides rectangle of image in the window.
 
double getWindowProperty (const String &winname, int prop_id)
 Provides parameters of a window.
 
template<typename... Ts>
GRunArgs gin (const Ts &... args)
 
template<typename... Ts>
GProtoInputArgs GIn (Ts &&... ts)
 
void glob (String pattern, std::vector< String > &result, bool recursive=false)
 
void goodFeaturesToTrack (InputArray image, OutputArray corners, int maxCorners, double qualityLevel, double minDistance, InputArray mask, int blockSize, int gradientSize, bool useHarrisDetector=false, double k=0.04)
 
void goodFeaturesToTrack (InputArray image, OutputArray corners, int maxCorners, double qualityLevel, double minDistance, InputArray mask, OutputArray cornersQuality, int blockSize=3, int gradientSize=3, bool useHarrisDetector=false, double k=0.04)
 Same as above, but returns also quality measure of the detected corners.
 
void goodFeaturesToTrack (InputArray image, OutputArray corners, int maxCorners, double qualityLevel, double minDistance, InputArray mask=noArray(), int blockSize=3, bool useHarrisDetector=false, double k=0.04)
 Determines strong corners on an image.
 
template<typename... Ts>
GProtoOutputArgs GOut (const std::tuple< Ts... > &ts)
 
template<typename T , typename... Ts>
GOptRunArgsP gout (optional< T > &arg, optional< Ts > &... args)
 
template<typename... Ts>
GProtoOutputArgs GOut (std::tuple< Ts... > &&ts)
 
template<typename... Ts>
GProtoOutputArgs GOut (Ts &&... ts)
 
template<typename... Ts>
GRunArgsP gout (Ts &... args)
 
void grabCut (InputArray img, InputOutputArray mask, Rect rect, InputOutputArray bgdModel, InputOutputArray fgdModel, int iterCount, int mode=GC_EVAL)
 Runs the GrabCut algorithm.
 
void groupRectangles (std::vector< Rect > &rectList, int groupThreshold, double eps, std::vector< int > *weights, std::vector< double > *levelWeights)
 
void groupRectangles (std::vector< Rect > &rectList, int groupThreshold, double eps=0.2)
 Groups the object candidate rectangles.
 
void groupRectangles (std::vector< Rect > &rectList, std::vector< int > &rejectLevels, std::vector< double > &levelWeights, int groupThreshold, double eps=0.2)
 
void groupRectangles (std::vector< Rect > &rectList, std::vector< int > &weights, int groupThreshold, double eps=0.2)
 
void groupRectangles_meanshift (std::vector< Rect > &rectList, std::vector< double > &foundWeights, std::vector< double > &foundScales, double detectThreshold=0.0, Size winDetSize=Size(64, 128))
 
bool hasNonZero (InputArray src)
 Checks for the presence of at least one non-zero array element.
 
CV_EXPORTS_W bool haveImageReader (const String &filename)
 Returns true if the specified image can be decoded by OpenCV.
 
CV_EXPORTS_W bool haveImageWriter (const String &filename)
 Returns true if an image with the specified filename can be encoded by OpenCV.
 
bool haveOpenVX ()
 Check if use of OpenVX is possible.
 
void hconcat (const Mat *src, size_t nsrc, OutputArray dst)
 Applies horizontal concatenation to given matrices.
 
void hconcat (InputArray src1, InputArray src2, OutputArray dst)
 
void hconcat (InputArrayOfArrays src, OutputArray dst)
 
void HoughCircles (InputArray image, OutputArray circles, int method, double dp, double minDist, double param1=100, double param2=100, int minRadius=0, int maxRadius=0)
 Finds circles in a grayscale image using the Hough transform.
 
void HoughLines (InputArray image, OutputArray lines, double rho, double theta, int threshold, double srn=0, double stn=0, double min_theta=0, double max_theta=CV_PI)
 Finds lines in a binary image using the standard Hough transform.
 
void HoughLinesP (InputArray image, OutputArray lines, double rho, double theta, int threshold, double minLineLength=0, double maxLineGap=0)
 Finds line segments in a binary image using the probabilistic Hough transform.
 
void HoughLinesPointSet (InputArray point, OutputArray lines, int lines_max, int threshold, double min_rho, double max_rho, double rho_step, double min_theta, double max_theta, double theta_step)
 Finds lines in a set of points using the standard Hough transform.
 
static void HoughLinesWithAccumulator (InputArray image, OutputArray lines, double rho, double theta, int threshold, double srn=0, double stn=0, double min_theta=0, double max_theta=CV_PI)
 Finds lines in a binary image using the standard Hough transform and get accumulator.
 
void HuMoments (const Moments &m, OutputArray hu)
 
void HuMoments (const Moments &moments, double hu[7])
 Calculates seven Hu invariants.
 
std::string icvExtractPattern (const std::string &filename, unsigned *offset)
 
void idct (InputArray src, OutputArray dst, int flags=0)
 Calculates the inverse Discrete Cosine Transform of a 1D or 2D array.
 
void idft (InputArray src, OutputArray dst, int flags=0, int nonzeroRows=0)
 Calculates the inverse Discrete Fourier Transform of a 1D or 2D array.
 
void illuminationChange (InputArray src, InputArray mask, OutputArray dst, float alpha=0.2f, float beta=0.4f)
 Applying an appropriate non-linear transformation to the gradient field inside the selection and then integrating back with a Poisson solver, modifies locally the apparent illumination of an image.
 
CV_EXPORTS_W size_t imcount (const String &filename, int flags=IMREAD_ANYCOLOR)
 Returns the number of images inside the give file.
 
CV_EXPORTS_W Mat imdecode (InputArray buf, int flags)
 Reads an image from a buffer in memory.
 
CV_EXPORTS Mat imdecode (InputArray buf, int flags, Mat *dst)
 
CV_EXPORTS_W bool imdecodemulti (InputArray buf, int flags, CV_OUT std::vector< Mat > &mats)
 Reads a multi-page image from a buffer in memory.
 
CV_EXPORTS_W bool imencode (const String &ext, InputArray img, CV_OUT std::vector< uchar > &buf, const std::vector< int > &params=std::vector< int >())
 Encodes an image into a memory buffer.
 
CV_EXPORTS_W Mat imread (const String &filename, int flags=IMREAD_COLOR)
 Loads an image from a file.
 
CV_EXPORTS_W bool imreadmulti (const String &filename, CV_OUT std::vector< Mat > &mats, int flags=IMREAD_ANYCOLOR)
 Loads a multi-page image from a file.
 
CV_EXPORTS_W bool imreadmulti (const String &filename, CV_OUT std::vector< Mat > &mats, int start, int count, int flags=IMREAD_ANYCOLOR)
 Loads a of images of a multi-page image from a file.
 
void imshow (const String &winname, const ogl::Texture2D &tex)
 Displays OpenGL 2D texture in the specified window.
 
void imshow (const String &winname, InputArray mat)
 Displays an image in the specified window.
 
CV_EXPORTS_W bool imwrite (const String &filename, InputArray img, const std::vector< int > &params=std::vector< int >())
 Saves an image to a specified file.
 
static CV_WRAP bool imwritemulti (const String &filename, InputArrayOfArrays img, const std::vector< int > &params=std::vector< int >())
 
Mat initCameraMatrix2D (InputArrayOfArrays objectPoints, InputArrayOfArrays imagePoints, Size imageSize, double aspectRatio=1.0)
 Finds an initial camera intrinsic matrix from 3D-2D point correspondences.
 
void initInverseRectificationMap (InputArray cameraMatrix, InputArray distCoeffs, InputArray R, InputArray newCameraMatrix, const Size &size, int m1type, OutputArray map1, OutputArray map2)
 Computes the projection and inverse-rectification transformation map. In essense, this is the inverse of initUndistortRectifyMap to accomodate stereo-rectification of projectors ('inverse-cameras') in projector-camera pairs.
 
void initUndistortRectifyMap (InputArray cameraMatrix, InputArray distCoeffs, InputArray R, InputArray newCameraMatrix, Size size, int m1type, OutputArray map1, OutputArray map2)
 Computes the undistortion and rectification transformation map.
 
float initWideAngleProjMap (InputArray cameraMatrix, InputArray distCoeffs, Size imageSize, int destImageWidth, int m1type, OutputArray map1, OutputArray map2, enum UndistortTypes projType=PROJ_SPHERICAL_EQRECT, double alpha=0)
 initializes maps for remap for wide-angle
 
static float initWideAngleProjMap (InputArray cameraMatrix, InputArray distCoeffs, Size imageSize, int destImageWidth, int m1type, OutputArray map1, OutputArray map2, int projType, double alpha=0)
 
void inpaint (InputArray src, InputArray inpaintMask, OutputArray dst, double inpaintRadius, int flags)
 Restores the selected region in an image using the region neighborhood.
 
void inRange (InputArray src, InputArray lowerb, InputArray upperb, OutputArray dst)
 Checks if array elements lie between the elements of two other arrays.
 
void insertChannel (InputArray src, InputOutputArray dst, int coi)
 Inserts a single channel to dst (coi is 0-based index)
 
void integral (InputArray src, OutputArray sum, int sdepth=-1)
 
void integral (InputArray src, OutputArray sum, OutputArray sqsum, int sdepth=-1, int sqdepth=-1)
 
void integral (InputArray src, OutputArray sum, OutputArray sqsum, OutputArray tilted, int sdepth=-1, int sqdepth=-1)
 Calculates the integral of an image.
 
float intersectConvexConvex (InputArray p1, InputArray p2, OutputArray p12, bool handleNested=true)
 Finds intersection of two convex polygons.
 
template<typename T >
Quat< T > inv (const Quat< T > &q, QuatAssumeType assumeUnit=QUAT_ASSUME_NOT_UNIT)
 
double invert (InputArray src, OutputArray dst, int flags=DECOMP_LU)
 Finds the inverse or pseudo-inverse of a matrix.
 
void invertAffineTransform (InputArray M, OutputArray iM)
 Inverts an affine transformation.
 
template<int N, typename T >
static bool isAligned (const T &data)
 Alignment check of passed values.
 
template<int N>
static bool isAligned (const void *p1)
 
template<int N>
static bool isAligned (const void *p1, const void *p2)
 
template<int N>
static bool isAligned (const void *p1, const void *p2, const void *p3)
 
template<int N>
static bool isAligned (const void *p1, const void *p2, const void *p3, const void *p4)
 
bool isContourConvex (InputArray contour)
 Tests a contour convexity.
 
double kmeans (InputArray data, int K, InputOutputArray bestLabels, TermCriteria criteria, int attempts, int flags, OutputArray centers=noArray())
 Finds centers of clusters and groups input samples around the clusters.
 
void Laplacian (InputArray src, OutputArray dst, int ddepth, int ksize=1, double scale=1, double delta=0, int borderType=BORDER_DEFAULT)
 Calculates the Laplacian of an image.
 
void line (InputOutputArray img, Point pt1, Point pt2, const Scalar &color, int thickness=1, int lineType=LINE_8, int shift=0)
 Draws a line segment connecting two points.
 
void linearPolar (InputArray src, OutputArray dst, Point2f center, double maxRadius, int flags)
 Remaps an image to polar coordinates space.
 
void loadWindowParameters (const String &windowName)
 Loads parameters of the specified window.
 
template<typename T >
Quat< T > log (const Quat< T > &q, QuatAssumeType assumeUnit=QUAT_ASSUME_NOT_UNIT)
 
softdouble log (const softdouble &a)
 
softfloat log (const softfloat &a)
 Natural logarithm.
 
void log (InputArray src, OutputArray dst)
 Calculates the natural logarithm of every array element.
 
void logPolar (InputArray src, OutputArray dst, Point2f center, double M, int flags)
 Remaps an image to semilog-polar coordinates space.
 
int LU (double *A, size_t astep, int m, double *b, size_t bstep, int n)
 
int LU (float *A, size_t astep, int m, float *b, size_t bstep, int n)
 
void LUT (InputArray src, InputArray lut, OutputArray dst)
 Performs a look-up table transform of an array.
 
void magnitude (InputArray x, InputArray y, OutputArray magnitude)
 Calculates the magnitude of 2D vectors.
 
double Mahalanobis (InputArray v1, InputArray v2, InputArray icovar)
 Calculates the Mahalanobis distance between two vectors.
 
template<typename T , typename... Ts>
RMat make_rmat (Ts &&... args)
 
template<typename _Tp , typename ... A1>
static Ptr< _TpmakePtr (const A1 &... a1)
 
double matchShapes (InputArray contour1, InputArray contour2, int method, double parameter)
 Compares two shapes.
 
void matchTemplate (InputArray image, InputArray templ, OutputArray result, int method, InputArray mask=noArray())
 Compares a template against overlapped image regions.
 
void matMulDeriv (InputArray A, InputArray B, OutputArray dABdA, OutputArray dABdB)
 Computes partial derivatives of the matrix product for each multiplied matrix.
 
void max (const Mat &src1, const Mat &src2, Mat &dst)
 
softdouble max (const softdouble &a, const softdouble &b)
 
softfloat max (const softfloat &a, const softfloat &b)
 
void max (const UMat &src1, const UMat &src2, UMat &dst)
 
void max (InputArray src1, InputArray src2, OutputArray dst)
 Calculates per-element maximum of two arrays or an array and a scalar.
 
Scalar mean (InputArray src, InputArray mask=noArray())
 Calculates an average (mean) of array elements.
 
int meanShift (InputArray probImage, Rect &window, TermCriteria criteria)
 Finds an object on a back projection image.
 
void meanStdDev (InputArray src, OutputArray mean, OutputArray stddev, InputArray mask=noArray())
 
void medianBlur (InputArray src, OutputArray dst, int ksize)
 Blurs an image using the median filter.
 
void merge (const Mat *mv, size_t count, OutputArray dst)
 Creates one multi-channel array out of several single-channel ones.
 
void merge (InputArrayOfArrays mv, OutputArray dst)
 
void min (const Mat &src1, const Mat &src2, Mat &dst)
 
softdouble min (const softdouble &a, const softdouble &b)
 
softfloat min (const softfloat &a, const softfloat &b)
 Min and Max functions.
 
void min (const UMat &src1, const UMat &src2, UMat &dst)
 
void min (InputArray src1, InputArray src2, OutputArray dst)
 Calculates per-element minimum of two arrays or an array and a scalar.
 
RotatedRect minAreaRect (InputArray points)
 Finds a rotated rectangle of the minimum area enclosing the input 2D point set.
 
void minEnclosingCircle (InputArray points, Point2f &center, float &radius)
 Finds a circle of the minimum area enclosing a 2D point set.
 
double minEnclosingTriangle (InputArray points, OutputArray triangle)
 Finds a triangle of minimum area enclosing a 2D point set and returns its area.
 
void minMaxIdx (InputArray src, double *minVal, double *maxVal=0, int *minIdx=0, int *maxIdx=0, InputArray mask=noArray())
 Finds the global minimum and maximum in an array.
 
void minMaxLoc (const SparseMat &a, double *minVal, double *maxVal, int *minIdx=0, int *maxIdx=0)
 
void minMaxLoc (InputArray src, double *minVal, double *maxVal=0, Point *minLoc=0, Point *maxLoc=0, InputArray mask=noArray())
 Finds the global minimum and maximum in an array.
 
void mixChannels (const Mat *src, size_t nsrcs, Mat *dst, size_t ndsts, const int *fromTo, size_t npairs)
 Copies specified channels from input arrays to the specified channels of output arrays.
 
void mixChannels (InputArrayOfArrays src, InputOutputArrayOfArrays dst, const int *fromTo, size_t npairs)
 
void mixChannels (InputArrayOfArrays src, InputOutputArrayOfArrays dst, const std::vector< int > &fromTo)
 
Moments moments (InputArray array, bool binaryImage=false)
 Calculates all of the moments up to the third order of a polygon or rasterized shape.
 
static Scalar morphologyDefaultBorderValue ()
 returns "magic" border value for erosion and dilation. It is automatically transformed to Scalar::all(-DBL_MAX) for dilation.
 
void morphologyEx (InputArray src, OutputArray dst, int op, InputArray kernel, Point anchor=Point(-1,-1), int iterations=1, int borderType=BORDER_CONSTANT, const Scalar &borderValue=morphologyDefaultBorderValue())
 Performs advanced morphological transformations.
 
void moveWindow (const String &winname, int x, int y)
 Moves the window to the specified position.
 
softdouble mulAdd (const softdouble &a, const softdouble &b, const softdouble &c)
 
softfloat mulAdd (const softfloat &a, const softfloat &b, const softfloat &c)
 Fused Multiplication and Addition.
 
void mulSpectrums (InputArray a, InputArray b, OutputArray c, int flags, bool conjB=false)
 Performs the per-element multiplication of two Fourier spectrums.
 
void multiply (InputArray src1, InputArray src2, OutputArray dst, double scale=1, int dtype=-1)
 Calculates the per-element scaled product of two arrays.
 
void mulTransposed (InputArray src, OutputArray dst, bool aTa, InputArray delta=noArray(), double scale=1, int dtype=-1)
 Calculates the product of a matrix and its transposition.
 
void namedWindow (const String &winname, int flags=WINDOW_AUTOSIZE)
 Creates a window.
 
InputOutputArray noArray ()
 
template<typename _Tp , int m, int n>
static double norm (const Matx< _Tp, m, n > &M)
 
template<typename _Tp , int m, int n>
static double norm (const Matx< _Tp, m, n > &M, int normType)
 
double norm (const SparseMat &src, int normType)
 
double norm (InputArray src1, InputArray src2, int normType=NORM_L2, InputArray mask=noArray())
 Calculates an absolute difference norm or a relative difference norm.
 
double norm (InputArray src1, int normType=NORM_L2, InputArray mask=noArray())
 Calculates the absolute norm of an array.
 
void normalize (const SparseMat &src, SparseMat &dst, double alpha, int normType)
 
template<typename _Tp , int cn>
static Vec< _Tp, cn > normalize (const Vec< _Tp, cn > &v)
 
void normalize (InputArray src, InputOutputArray dst, double alpha=1, double beta=0, int norm_type=NORM_L2, int dtype=-1, InputArray mask=noArray())
 Normalizes the norm or value range of an array.
 
template<typename _Tp , typename _AccTp >
static _AccTp normInf (const _Tp *a, const _Tp *b, int n)
 
template<typename _Tp , typename _AccTp >
static _AccTp normInf (const _Tp *a, int n)
 
template<typename _Tp , typename _AccTp >
static _AccTp normL1 (const _Tp *a, const _Tp *b, int n)
 
template<typename _Tp , typename _AccTp >
static _AccTp normL1 (const _Tp *a, int n)
 
float normL1 (const float *a, const float *b, int n)
 
int normL1 (const uchar *a, const uchar *b, int n)
 
template<typename _Tp , typename _AccTp >
static _AccTp normL2Sqr (const _Tp *a, const _Tp *b, int n)
 
template<typename _Tp , typename _AccTp >
static _AccTp normL2Sqr (const _Tp *a, int n)
 
static float normL2Sqr (const float *a, const float *b, int n)
 
cv::GMat operator!= (const cv::GMat &lhs, const cv::GMat &rhs)
 
cv::GMat operator!= (const cv::GMat &lhs, const cv::GScalar &rhs)
 
cv::GMat operator!= (const cv::GScalar &lhs, const cv::GMat &rhs)
 
v_float32x4 operator!= (const v_float32x4 &a, const v_float32x4 &b)
 
v_float64x2 operator!= (const v_float64x2 &a, const v_float64x2 &b)
 
v_int16x8 operator!= (const v_int16x8 &a, const v_int16x8 &b)
 
v_int32x4 operator!= (const v_int32x4 &a, const v_int32x4 &b)
 
v_int64x2 operator!= (const v_int64x2 &a, const v_int64x2 &b)
 
v_int8x16 operator!= (const v_int8x16 &a, const v_int8x16 &b)
 
template<typename _Tp , int n>
v_reg< _Tp, n > operator!= (const v_reg< _Tp, n > &a, const v_reg< _Tp, n > &b)
 Not equal comparison.
 
v_uint16x8 operator!= (const v_uint16x8 &a, const v_uint16x8 &b)
 
v_uint32x4 operator!= (const v_uint32x4 &a, const v_uint32x4 &b)
 
v_uint64x2 operator!= (const v_uint64x2 &a, const v_uint64x2 &b)
 
v_uint8x16 operator!= (const v_uint8x16 &a, const v_uint8x16 &b)
 
cv::GMat operator& (const cv::GMat &lhs, const cv::GMat &rhs)
 
cv::GMat operator& (const cv::GMat &lhs, const cv::GScalar &rhs)
 
cv::GMat operator& (const cv::GScalar &lhs, const cv::GMat &rhs)
 
v_float32x4 operator& (const v_float32x4 &a, const v_float32x4 &b)
 
v_float64x2 operator& (const v_float64x2 &a, const v_float64x2 &b)
 
v_int16x8 operator& (const v_int16x8 &a, const v_int16x8 &b)
 
v_int32x4 operator& (const v_int32x4 &a, const v_int32x4 &b)
 
v_int64x2 operator& (const v_int64x2 &a, const v_int64x2 &b)
 
v_int8x16 operator& (const v_int8x16 &a, const v_int8x16 &b)
 
template<typename _Tp , int n>
v_reg< _Tp, n > operator& (const v_reg< _Tp, n > &a, const v_reg< _Tp, n > &b)
 Bitwise AND.
 
v_uint16x8 operator& (const v_uint16x8 &a, const v_uint16x8 &b)
 
v_uint32x4 operator& (const v_uint32x4 &a, const v_uint32x4 &b)
 
v_uint64x2 operator& (const v_uint64x2 &a, const v_uint64x2 &b)
 
v_uint8x16 operator& (const v_uint8x16 &a, const v_uint8x16 &b)
 
v_float32x4operator&= (v_float32x4 &a, const v_float32x4 &b)
 
v_float64x2operator&= (v_float64x2 &a, const v_float64x2 &b)
 
v_int16x8operator&= (v_int16x8 &a, const v_int16x8 &b)
 
v_int32x4operator&= (v_int32x4 &a, const v_int32x4 &b)
 
v_int64x2operator&= (v_int64x2 &a, const v_int64x2 &b)
 
v_int8x16operator&= (v_int8x16 &a, const v_int8x16 &b)
 
template<typename _Tp , int n>
v_reg< _Tp, n > & operator&= (v_reg< _Tp, n > &a, const v_reg< _Tp, n > &b)
 
v_uint16x8operator&= (v_uint16x8 &a, const v_uint16x8 &b)
 
v_uint32x4operator&= (v_uint32x4 &a, const v_uint32x4 &b)
 
v_uint64x2operator&= (v_uint64x2 &a, const v_uint64x2 &b)
 
v_uint8x16operator&= (v_uint8x16 &a, const v_uint8x16 &b)
 
template<typename T , typename V >
static V operator* (const Affine3< T > &affine, const V &vector)
 V is a 3-element vector with member fields x, y and z.
 
template<typename T >
static Affine3< T > operator* (const Affine3< T > &affine1, const Affine3< T > &affine2)
 
static Vec3d operator* (const Affine3d &affine, const Vec3d &vector)
 
static Vec3f operator* (const Affine3f &affine, const Vec3f &vector)
 
cv::GMat operator* (const cv::GMat &lhs, const cv::GScalar &rhs)
 
cv::GMat operator* (const cv::GMat &lhs, float rhs)
 
cv::GMat operator* (const cv::GScalar &lhs, const cv::GMat &rhs)
 
template<typename T >
Quat< T > operator* (const Quat< T > &, const T)
 
template<typename T >
Quat< T > operator* (const T, const Quat< T > &)
 
v_float32x4 operator* (const v_float32x4 &a, const v_float32x4 &b)
 
v_float64x2 operator* (const v_float64x2 &a, const v_float64x2 &b)
 
v_int16x8 operator* (const v_int16x8 &a, const v_int16x8 &b)
 
v_int32x4 operator* (const v_int32x4 &a, const v_int32x4 &b)
 
v_int64x2 operator* (const v_int64x2 &a, const v_int64x2 &b)
 
v_int8x16 operator* (const v_int8x16 &a, const v_int8x16 &b)
 
template<typename _Tp , int n>
v_reg< _Tp, n > operator* (const v_reg< _Tp, n > &a, const v_reg< _Tp, n > &b)
 Multiply values.
 
v_uint16x8 operator* (const v_uint16x8 &a, const v_uint16x8 &b)
 
v_uint32x4 operator* (const v_uint32x4 &a, const v_uint32x4 &b)
 
v_uint64x2 operator* (const v_uint64x2 &a, const v_uint64x2 &b)
 
v_uint8x16 operator* (const v_uint8x16 &a, const v_uint8x16 &b)
 
cv::GMat operator* (float lhs, const cv::GMat &rhs)
 
v_float32x4operator*= (v_float32x4 &a, const v_float32x4 &b)
 
v_float64x2operator*= (v_float64x2 &a, const v_float64x2 &b)
 
v_int16x8operator*= (v_int16x8 &a, const v_int16x8 &b)
 
v_int32x4operator*= (v_int32x4 &a, const v_int32x4 &b)
 
v_int64x2operator*= (v_int64x2 &a, const v_int64x2 &b)
 
v_int8x16operator*= (v_int8x16 &a, const v_int8x16 &b)
 
template<typename _Tp , int n>
v_reg< _Tp, n > & operator*= (v_reg< _Tp, n > &a, const v_reg< _Tp, n > &b)
 
v_uint16x8operator*= (v_uint16x8 &a, const v_uint16x8 &b)
 
v_uint32x4operator*= (v_uint32x4 &a, const v_uint32x4 &b)
 
v_uint64x2operator*= (v_uint64x2 &a, const v_uint64x2 &b)
 
v_uint8x16operator*= (v_uint8x16 &a, const v_uint8x16 &b)
 
cv::GMat operator+ (const cv::GMat &lhs, const cv::GMat &rhs)
 
cv::GMat operator+ (const cv::GMat &lhs, const cv::GScalar &rhs)
 
cv::GMat operator+ (const cv::GScalar &lhs, const cv::GMat &rhs)
 
v_float32x4 operator+ (const v_float32x4 &a, const v_float32x4 &b)
 
v_float64x2 operator+ (const v_float64x2 &a, const v_float64x2 &b)
 
v_int16x8 operator+ (const v_int16x8 &a, const v_int16x8 &b)
 
v_int32x4 operator+ (const v_int32x4 &a, const v_int32x4 &b)
 
v_int64x2 operator+ (const v_int64x2 &a, const v_int64x2 &b)
 
v_int8x16 operator+ (const v_int8x16 &a, const v_int8x16 &b)
 
template<typename _Tp , int n>
v_reg< _Tp, n > operator+ (const v_reg< _Tp, n > &a, const v_reg< _Tp, n > &b)
 Add values.
 
v_uint16x8 operator+ (const v_uint16x8 &a, const v_uint16x8 &b)
 
v_uint32x4 operator+ (const v_uint32x4 &a, const v_uint32x4 &b)
 
v_uint64x2 operator+ (const v_uint64x2 &a, const v_uint64x2 &b)
 
v_uint8x16 operator+ (const v_uint8x16 &a, const v_uint8x16 &b)
 
cv::GCompileArgsoperator+= (cv::GCompileArgs &lhs, const cv::GCompileArgs &rhs)
 
template<typename Tg >
cv::GIOProtoArgs< Tg > & operator+= (cv::GIOProtoArgs< Tg > &lhs, const cv::GIOProtoArgs< Tg > &rhs)
 
GRunArgsoperator+= (GRunArgs &lhs, const GRunArgs &rhs)
 This operator allows to complement the input vector at runtime.
 
GRunArgsPoperator+= (GRunArgsP &lhs, const GRunArgsP &rhs)
 This operator allows to complement the output vector at runtime.
 
v_float32x4operator+= (v_float32x4 &a, const v_float32x4 &b)
 
v_float64x2operator+= (v_float64x2 &a, const v_float64x2 &b)
 
v_int16x8operator+= (v_int16x8 &a, const v_int16x8 &b)
 
v_int32x4operator+= (v_int32x4 &a, const v_int32x4 &b)
 
v_int64x2operator+= (v_int64x2 &a, const v_int64x2 &b)
 
v_int8x16operator+= (v_int8x16 &a, const v_int8x16 &b)
 
template<typename _Tp , int n>
v_reg< _Tp, n > & operator+= (v_reg< _Tp, n > &a, const v_reg< _Tp, n > &b)
 
v_uint16x8operator+= (v_uint16x8 &a, const v_uint16x8 &b)
 
v_uint32x4operator+= (v_uint32x4 &a, const v_uint32x4 &b)
 
v_uint64x2operator+= (v_uint64x2 &a, const v_uint64x2 &b)
 
v_uint8x16operator+= (v_uint8x16 &a, const v_uint8x16 &b)
 
cv::GMat operator- (const cv::GMat &lhs, const cv::GMat &rhs)
 
cv::GMat operator- (const cv::GMat &lhs, const cv::GScalar &rhs)
 
cv::GMat operator- (const cv::GScalar &lhs, const cv::GMat &rhs)
 
v_float32x4 operator- (const v_float32x4 &a, const v_float32x4 &b)
 
v_float64x2 operator- (const v_float64x2 &a, const v_float64x2 &b)
 
v_int16x8 operator- (const v_int16x8 &a, const v_int16x8 &b)
 
v_int32x4 operator- (const v_int32x4 &a, const v_int32x4 &b)
 
v_int64x2 operator- (const v_int64x2 &a, const v_int64x2 &b)
 
v_int8x16 operator- (const v_int8x16 &a, const v_int8x16 &b)
 
template<typename _Tp , int n>
v_reg< _Tp, n > operator- (const v_reg< _Tp, n > &a, const v_reg< _Tp, n > &b)
 Subtract values.
 
v_uint16x8 operator- (const v_uint16x8 &a, const v_uint16x8 &b)
 
v_uint32x4 operator- (const v_uint32x4 &a, const v_uint32x4 &b)
 
v_uint64x2 operator- (const v_uint64x2 &a, const v_uint64x2 &b)
 
v_uint8x16 operator- (const v_uint8x16 &a, const v_uint8x16 &b)
 
v_float32x4operator-= (v_float32x4 &a, const v_float32x4 &b)
 
v_float64x2operator-= (v_float64x2 &a, const v_float64x2 &b)
 
v_int16x8operator-= (v_int16x8 &a, const v_int16x8 &b)
 
v_int32x4operator-= (v_int32x4 &a, const v_int32x4 &b)
 
v_int64x2operator-= (v_int64x2 &a, const v_int64x2 &b)
 
v_int8x16operator-= (v_int8x16 &a, const v_int8x16 &b)
 
template<typename _Tp , int n>
v_reg< _Tp, n > & operator-= (v_reg< _Tp, n > &a, const v_reg< _Tp, n > &b)
 
v_uint16x8operator-= (v_uint16x8 &a, const v_uint16x8 &b)
 
v_uint32x4operator-= (v_uint32x4 &a, const v_uint32x4 &b)
 
v_uint64x2operator-= (v_uint64x2 &a, const v_uint64x2 &b)
 
v_uint8x16operator-= (v_uint8x16 &a, const v_uint8x16 &b)
 
cv::GMat operator/ (const cv::GMat &lhs, const cv::GMat &rhs)
 
cv::GMat operator/ (const cv::GMat &lhs, const cv::GScalar &rhs)
 
cv::GMat operator/ (const cv::GScalar &lhs, const cv::GMat &rhs)
 
v_float32x4 operator/ (const v_float32x4 &a, const v_float32x4 &b)
 
v_float64x2 operator/ (const v_float64x2 &a, const v_float64x2 &b)
 
v_int16x8 operator/ (const v_int16x8 &a, const v_int16x8 &b)
 
v_int32x4 operator/ (const v_int32x4 &a, const v_int32x4 &b)
 
v_int64x2 operator/ (const v_int64x2 &a, const v_int64x2 &b)
 
v_int8x16 operator/ (const v_int8x16 &a, const v_int8x16 &b)
 
template<typename _Tp , int n>
v_reg< _Tp, n > operator/ (const v_reg< _Tp, n > &a, const v_reg< _Tp, n > &b)
 Divide values.
 
v_uint16x8 operator/ (const v_uint16x8 &a, const v_uint16x8 &b)
 
v_uint32x4 operator/ (const v_uint32x4 &a, const v_uint32x4 &b)
 
v_uint64x2 operator/ (const v_uint64x2 &a, const v_uint64x2 &b)
 
v_uint8x16 operator/ (const v_uint8x16 &a, const v_uint8x16 &b)
 
v_float32x4operator/= (v_float32x4 &a, const v_float32x4 &b)
 
v_float64x2operator/= (v_float64x2 &a, const v_float64x2 &b)
 
v_int16x8operator/= (v_int16x8 &a, const v_int16x8 &b)
 
v_int32x4operator/= (v_int32x4 &a, const v_int32x4 &b)
 
v_int64x2operator/= (v_int64x2 &a, const v_int64x2 &b)
 
v_int8x16operator/= (v_int8x16 &a, const v_int8x16 &b)
 
template<typename _Tp , int n>
v_reg< _Tp, n > & operator/= (v_reg< _Tp, n > &a, const v_reg< _Tp, n > &b)
 
v_uint16x8operator/= (v_uint16x8 &a, const v_uint16x8 &b)
 
v_uint32x4operator/= (v_uint32x4 &a, const v_uint32x4 &b)
 
v_uint64x2operator/= (v_uint64x2 &a, const v_uint64x2 &b)
 
v_uint8x16operator/= (v_uint8x16 &a, const v_uint8x16 &b)
 
cv::GMat operator< (const cv::GMat &lhs, const cv::GMat &rhs)
 
cv::GMat operator< (const cv::GMat &lhs, const cv::GScalar &rhs)
 
cv::GMat operator< (const cv::GScalar &lhs, const cv::GMat &rhs)
 
v_float32x4 operator< (const v_float32x4 &a, const v_float32x4 &b)
 
v_float64x2 operator< (const v_float64x2 &a, const v_float64x2 &b)
 
v_int16x8 operator< (const v_int16x8 &a, const v_int16x8 &b)
 
v_int32x4 operator< (const v_int32x4 &a, const v_int32x4 &b)
 
v_int64x2 operator< (const v_int64x2 &a, const v_int64x2 &b)
 
v_int8x16 operator< (const v_int8x16 &a, const v_int8x16 &b)
 
template<typename _Tp , int n>
v_reg< _Tp, n > operator< (const v_reg< _Tp, n > &a, const v_reg< _Tp, n > &b)
 Less-than comparison.
 
v_uint16x8 operator< (const v_uint16x8 &a, const v_uint16x8 &b)
 
v_uint32x4 operator< (const v_uint32x4 &a, const v_uint32x4 &b)
 
v_uint64x2 operator< (const v_uint64x2 &a, const v_uint64x2 &b)
 
v_uint8x16 operator< (const v_uint8x16 &a, const v_uint8x16 &b)
 
v_int16x8 operator<< (const v_int16x8 &a, int n)
 
v_int32x4 operator<< (const v_int32x4 &a, int n)
 
v_int64x2 operator<< (const v_int64x2 &a, int n)
 
v_int8x16 operator<< (const v_int8x16 &a, int n)
 
template<typename _Tp , int n>
v_reg< _Tp, n > operator<< (const v_reg< _Tp, n > &a, int imm)
 Bitwise shift left.
 
v_uint16x8 operator<< (const v_uint16x8 &a, int n)
 
v_uint32x4 operator<< (const v_uint32x4 &a, int n)
 
v_uint64x2 operator<< (const v_uint64x2 &a, int n)
 
v_uint8x16 operator<< (const v_uint8x16 &a, int n)
 
template<typename _Tp >
std::ostream & operator<< (std::ostream &, const DualQuat< _Tp > &)
 
template<typename _Tp >
std::ostream & operator<< (std::ostream &, const Quat< _Tp > &)
 
template<typename S >
std::ostream & operator<< (std::ostream &, const Quat< S > &)
 
std::ostream & operator<< (std::ostream &os, const cv::GArrayDesc &desc)
 
std::ostream & operator<< (std::ostream &os, const cv::GFrameDesc &desc)
 
std::ostream & operator<< (std::ostream &os, const cv::GMatDesc &desc)
 
std::ostream & operator<< (std::ostream &os, const cv::GOpaqueDesc &desc)
 
std::ostream & operator<< (std::ostream &os, const cv::GScalarDesc &desc)
 
std::ostream & operator<< (std::ostream &os, const GMetaArg &)
 
static std::ostream & operator<< (std::ostream &out, const TickMeter &tm)
 output operator
 
static Stringoperator<< (String &out, const Mat &mtx)
 
static Stringoperator<< (String &out, Ptr< Formatted > fmtd)
 
cv::GMat operator<= (const cv::GMat &lhs, const cv::GMat &rhs)
 
cv::GMat operator<= (const cv::GMat &lhs, const cv::GScalar &rhs)
 
cv::GMat operator<= (const cv::GScalar &lhs, const cv::GMat &rhs)
 
v_float32x4 operator<= (const v_float32x4 &a, const v_float32x4 &b)
 
v_float64x2 operator<= (const v_float64x2 &a, const v_float64x2 &b)
 
v_int16x8 operator<= (const v_int16x8 &a, const v_int16x8 &b)
 
v_int32x4 operator<= (const v_int32x4 &a, const v_int32x4 &b)
 
v_int64x2 operator<= (const v_int64x2 &a, const v_int64x2 &b)
 
v_int8x16 operator<= (const v_int8x16 &a, const v_int8x16 &b)
 
template<typename _Tp , int n>
v_reg< _Tp, n > operator<= (const v_reg< _Tp, n > &a, const v_reg< _Tp, n > &b)
 Less-than or equal comparison.
 
v_uint16x8 operator<= (const v_uint16x8 &a, const v_uint16x8 &b)
 
v_uint32x4 operator<= (const v_uint32x4 &a, const v_uint32x4 &b)
 
v_uint64x2 operator<= (const v_uint64x2 &a, const v_uint64x2 &b)
 
v_uint8x16 operator<= (const v_uint8x16 &a, const v_uint8x16 &b)
 
cv::GMat operator== (const cv::GMat &lhs, const cv::GMat &rhs)
 
cv::GMat operator== (const cv::GMat &lhs, const cv::GScalar &rhs)
 
cv::GMat operator== (const cv::GScalar &lhs, const cv::GMat &rhs)
 
v_float32x4 operator== (const v_float32x4 &a, const v_float32x4 &b)
 
v_float64x2 operator== (const v_float64x2 &a, const v_float64x2 &b)
 
v_int16x8 operator== (const v_int16x8 &a, const v_int16x8 &b)
 
v_int32x4 operator== (const v_int32x4 &a, const v_int32x4 &b)
 
v_int64x2 operator== (const v_int64x2 &a, const v_int64x2 &b)
 
v_int8x16 operator== (const v_int8x16 &a, const v_int8x16 &b)
 
template<typename _Tp , int n>
v_reg< _Tp, n > operator== (const v_reg< _Tp, n > &a, const v_reg< _Tp, n > &b)
 Equal comparison.
 
v_uint16x8 operator== (const v_uint16x8 &a, const v_uint16x8 &b)
 
v_uint32x4 operator== (const v_uint32x4 &a, const v_uint32x4 &b)
 
v_uint64x2 operator== (const v_uint64x2 &a, const v_uint64x2 &b)
 
v_uint8x16 operator== (const v_uint8x16 &a, const v_uint8x16 &b)
 
cv::GMat operator> (const cv::GMat &lhs, const cv::GMat &rhs)
 
cv::GMat operator> (const cv::GMat &lhs, const cv::GScalar &rhs)
 
cv::GMat operator> (const cv::GScalar &lhs, const cv::GMat &rhs)
 
v_float32x4 operator> (const v_float32x4 &a, const v_float32x4 &b)
 
v_float64x2 operator> (const v_float64x2 &a, const v_float64x2 &b)
 
v_int16x8 operator> (const v_int16x8 &a, const v_int16x8 &b)
 
v_int32x4 operator> (const v_int32x4 &a, const v_int32x4 &b)
 
v_int64x2 operator> (const v_int64x2 &a, const v_int64x2 &b)
 
v_int8x16 operator> (const v_int8x16 &a, const v_int8x16 &b)
 
template<typename _Tp , int n>
v_reg< _Tp, n > operator> (const v_reg< _Tp, n > &a, const v_reg< _Tp, n > &b)
 Greater-than comparison.
 
v_uint16x8 operator> (const v_uint16x8 &a, const v_uint16x8 &b)
 
v_uint32x4 operator> (const v_uint32x4 &a, const v_uint32x4 &b)
 
v_uint64x2 operator> (const v_uint64x2 &a, const v_uint64x2 &b)
 
v_uint8x16 operator> (const v_uint8x16 &a, const v_uint8x16 &b)
 
cv::GMat operator>= (const cv::GMat &lhs, const cv::GMat &rhs)
 
cv::GMat operator>= (const cv::GMat &lhs, const cv::GScalar &rhs)
 
cv::GMat operator>= (const cv::GScalar &lhs, const cv::GMat &rhs)
 
v_float32x4 operator>= (const v_float32x4 &a, const v_float32x4 &b)
 
v_float64x2 operator>= (const v_float64x2 &a, const v_float64x2 &b)
 
v_int16x8 operator>= (const v_int16x8 &a, const v_int16x8 &b)
 
v_int32x4 operator>= (const v_int32x4 &a, const v_int32x4 &b)
 
v_int64x2 operator>= (const v_int64x2 &a, const v_int64x2 &b)
 
v_int8x16 operator>= (const v_int8x16 &a, const v_int8x16 &b)
 
template<typename _Tp , int n>
v_reg< _Tp, n > operator>= (const v_reg< _Tp, n > &a, const v_reg< _Tp, n > &b)
 Greater-than or equal comparison.
 
v_uint16x8 operator>= (const v_uint16x8 &a, const v_uint16x8 &b)
 
v_uint32x4 operator>= (const v_uint32x4 &a, const v_uint32x4 &b)
 
v_uint64x2 operator>= (const v_uint64x2 &a, const v_uint64x2 &b)
 
v_uint8x16 operator>= (const v_uint8x16 &a, const v_uint8x16 &b)
 
v_int16x8 operator>> (const v_int16x8 &a, int n)
 
v_int32x4 operator>> (const v_int32x4 &a, int n)
 
v_int64x2 operator>> (const v_int64x2 &a, int n)
 
v_int8x16 operator>> (const v_int8x16 &a, int n)
 
template<typename _Tp , int n>
v_reg< _Tp, n > operator>> (const v_reg< _Tp, n > &a, int imm)
 Bitwise shift right.
 
v_uint16x8 operator>> (const v_uint16x8 &a, int n)
 
v_uint32x4 operator>> (const v_uint32x4 &a, int n)
 
v_uint64x2 operator>> (const v_uint64x2 &a, int n)
 
v_uint8x16 operator>> (const v_uint8x16 &a, int n)
 
cv::GMat operator^ (const cv::GMat &lhs, const cv::GMat &rhs)
 
cv::GMat operator^ (const cv::GMat &lhs, const cv::GScalar &rhs)
 
cv::GMat operator^ (const cv::GScalar &lhs, const cv::GMat &rhs)
 
v_float32x4 operator^ (const v_float32x4 &a, const v_float32x4 &b)
 
v_float64x2 operator^ (const v_float64x2 &a, const v_float64x2 &b)
 
v_int16x8 operator^ (const v_int16x8 &a, const v_int16x8 &b)
 
v_int32x4 operator^ (const v_int32x4 &a, const v_int32x4 &b)
 
v_int64x2 operator^ (const v_int64x2 &a, const v_int64x2 &b)
 
v_int8x16 operator^ (const v_int8x16 &a, const v_int8x16 &b)
 
template<typename _Tp , int n>
v_reg< _Tp, n > operator^ (const v_reg< _Tp, n > &a, const v_reg< _Tp, n > &b)
 Bitwise XOR.
 
v_uint16x8 operator^ (const v_uint16x8 &a, const v_uint16x8 &b)
 
v_uint32x4 operator^ (const v_uint32x4 &a, const v_uint32x4 &b)
 
v_uint64x2 operator^ (const v_uint64x2 &a, const v_uint64x2 &b)
 
v_uint8x16 operator^ (const v_uint8x16 &a, const v_uint8x16 &b)
 
v_float32x4operator^= (v_float32x4 &a, const v_float32x4 &b)
 
v_float64x2operator^= (v_float64x2 &a, const v_float64x2 &b)
 
v_int16x8operator^= (v_int16x8 &a, const v_int16x8 &b)
 
v_int32x4operator^= (v_int32x4 &a, const v_int32x4 &b)
 
v_int64x2operator^= (v_int64x2 &a, const v_int64x2 &b)
 
v_int8x16operator^= (v_int8x16 &a, const v_int8x16 &b)
 
template<typename _Tp , int n>
v_reg< _Tp, n > & operator^= (v_reg< _Tp, n > &a, const v_reg< _Tp, n > &b)
 
v_uint16x8operator^= (v_uint16x8 &a, const v_uint16x8 &b)
 
v_uint32x4operator^= (v_uint32x4 &a, const v_uint32x4 &b)
 
v_uint64x2operator^= (v_uint64x2 &a, const v_uint64x2 &b)
 
v_uint8x16operator^= (v_uint8x16 &a, const v_uint8x16 &b)
 
cv::GMat operator| (const cv::GMat &lhs, const cv::GMat &rhs)
 
cv::GMat operator| (const cv::GMat &lhs, const cv::GScalar &rhs)
 
cv::GMat operator| (const cv::GScalar &lhs, const cv::GMat &rhs)
 
v_float32x4 operator| (const v_float32x4 &a, const v_float32x4 &b)
 
v_float64x2 operator| (const v_float64x2 &a, const v_float64x2 &b)
 
v_int16x8 operator| (const v_int16x8 &a, const v_int16x8 &b)
 
v_int32x4 operator| (const v_int32x4 &a, const v_int32x4 &b)
 
v_int64x2 operator| (const v_int64x2 &a, const v_int64x2 &b)
 
v_int8x16 operator| (const v_int8x16 &a, const v_int8x16 &b)
 
template<typename _Tp , int n>
v_reg< _Tp, n > operator| (const v_reg< _Tp, n > &a, const v_reg< _Tp, n > &b)
 Bitwise OR.
 
v_uint16x8 operator| (const v_uint16x8 &a, const v_uint16x8 &b)
 
v_uint32x4 operator| (const v_uint32x4 &a, const v_uint32x4 &b)
 
v_uint64x2 operator| (const v_uint64x2 &a, const v_uint64x2 &b)
 
v_uint8x16 operator| (const v_uint8x16 &a, const v_uint8x16 &b)
 
v_float32x4operator|= (v_float32x4 &a, const v_float32x4 &b)
 
v_float64x2operator|= (v_float64x2 &a, const v_float64x2 &b)
 
v_int16x8operator|= (v_int16x8 &a, const v_int16x8 &b)
 
v_int32x4operator|= (v_int32x4 &a, const v_int32x4 &b)
 
v_int64x2operator|= (v_int64x2 &a, const v_int64x2 &b)
 
v_int8x16operator|= (v_int8x16 &a, const v_int8x16 &b)
 
template<typename _Tp , int n>
v_reg< _Tp, n > & operator|= (v_reg< _Tp, n > &a, const v_reg< _Tp, n > &b)
 
v_uint16x8operator|= (v_uint16x8 &a, const v_uint16x8 &b)
 
v_uint32x4operator|= (v_uint32x4 &a, const v_uint32x4 &b)
 
v_uint64x2operator|= (v_uint64x2 &a, const v_uint64x2 &b)
 
v_uint8x16operator|= (v_uint8x16 &a, const v_uint8x16 &b)
 
cv::GMat operator~ (const cv::GMat &lhs)
 
v_float32x4 operator~ (const v_float32x4 &a)
 
v_float64x2 operator~ (const v_float64x2 &a)
 
v_int16x8 operator~ (const v_int16x8 &a)
 
v_int32x4 operator~ (const v_int32x4 &a)
 
v_int64x2 operator~ (const v_int64x2 &a)
 
v_int8x16 operator~ (const v_int8x16 &a)
 
template<typename _Tp , int n>
v_reg< _Tp, n > operator~ (const v_reg< _Tp, n > &a)
 Bitwise NOT.
 
v_uint16x8 operator~ (const v_uint16x8 &a)
 
v_uint32x4 operator~ (const v_uint32x4 &a)
 
v_uint64x2 operator~ (const v_uint64x2 &a)
 
v_uint8x16 operator~ (const v_uint8x16 &a)
 
void parallel_for_ (const Range &range, const ParallelLoopBody &body, double nstripes=-1.)
 Parallel data processor.
 
static void parallel_for_ (const Range &range, std::function< void(const Range &)> functor, double nstripes=-1.)
 
template<typename _Tp , class _EqPredicate >
int partition (const std::vector< _Tp > &_vec, std::vector< int > &labels, _EqPredicate predicate=_EqPredicate())
 Splits an element set into equivalency classes.
 
void patchNaNs (InputOutputArray a, double val=0)
 converts NaNs to the given number
 
void PCABackProject (InputArray data, InputArray mean, InputArray eigenvectors, OutputArray result)
 
void PCACompute (InputArray data, InputOutputArray mean, OutputArray eigenvectors, double retainedVariance)
 
void PCACompute (InputArray data, InputOutputArray mean, OutputArray eigenvectors, int maxComponents=0)
 
void PCACompute (InputArray data, InputOutputArray mean, OutputArray eigenvectors, OutputArray eigenvalues, double retainedVariance)
 
void PCACompute (InputArray data, InputOutputArray mean, OutputArray eigenvectors, OutputArray eigenvalues, int maxComponents=0)
 
void PCAProject (InputArray data, InputArray mean, InputArray eigenvectors, OutputArray result)
 
void pencilSketch (InputArray src, OutputArray dst1, OutputArray dst2, float sigma_s=60, float sigma_r=0.07f, float shade_factor=0.02f)
 Pencil-like non-photorealistic line drawing.
 
void perspectiveTransform (InputArray src, OutputArray dst, InputArray m)
 Performs the perspective matrix transformation of vectors.
 
void phase (InputArray x, InputArray y, OutputArray angle, bool angleInDegrees=false)
 Calculates the rotation angle of 2D vectors.
 
Point2d phaseCorrelate (InputArray src1, InputArray src2, InputArray window=noArray(), double *response=0)
 The function is used to detect translational shifts that occur between two images.
 
double pointPolygonTest (InputArray contour, Point2f pt, bool measureDist)
 Performs a point-in-contour test.
 
void polarToCart (InputArray magnitude, InputArray angle, OutputArray x, OutputArray y, bool angleInDegrees=false)
 Calculates x and y coordinates of 2D vectors from their magnitude and angle.
 
int pollKey ()
 Polls for a pressed key.
 
void polylines (InputOutputArray img, const Point *const *pts, const int *npts, int ncontours, bool isClosed, const Scalar &color, int thickness=1, int lineType=LINE_8, int shift=0)
 
void polylines (InputOutputArray img, InputArrayOfArrays pts, bool isClosed, const Scalar &color, int thickness=1, int lineType=LINE_8, int shift=0)
 Draws several polygonal curves.
 
softdouble pow (const softdouble &a, const softdouble &b)
 
softfloat pow (const softfloat &a, const softfloat &b)
 Raising to the power.
 
void pow (InputArray src, double power, OutputArray dst)
 Raises every array element to a power.
 
template<typename T >
Quat< T > power (const Quat< T > &q, const Quat< T > &p, QuatAssumeType assumeUnit=QUAT_ASSUME_NOT_UNIT)
 
template<typename T >
Quat< T > power (const Quat< T > &q, const T x, QuatAssumeType assumeUnit=QUAT_ASSUME_NOT_UNIT)
 
void preCornerDetect (InputArray src, OutputArray dst, int ksize, int borderType=BORDER_DEFAULT)
 Calculates a feature map for corner detection.
 
void projectPoints (InputArray objectPoints, InputArray rvec, InputArray tvec, InputArray cameraMatrix, InputArray distCoeffs, OutputArray imagePoints, OutputArray jacobian=noArray(), double aspectRatio=0)
 Projects 3D points to an image plane.
 
double PSNR (InputArray src1, InputArray src2, double R=255.)
 Computes the Peak Signal-to-Noise Ratio (PSNR) image quality metric.
 
void putText (InputOutputArray img, const String &text, Point org, int fontFace, double fontScale, Scalar color, int thickness=1, int lineType=LINE_8, bool bottomLeftOrigin=false)
 Draws a text string.
 
void pyrDown (InputArray src, OutputArray dst, const Size &dstsize=Size(), int borderType=BORDER_DEFAULT)
 Blurs an image and downsamples it.
 
void pyrMeanShiftFiltering (InputArray src, OutputArray dst, double sp, double sr, int maxLevel=1, TermCriteria termcrit=TermCriteria(TermCriteria::MAX_ITER+TermCriteria::EPS, 5, 1))
 Performs initial step of meanshift segmentation of an image.
 
void pyrUp (InputArray src, OutputArray dst, const Size &dstsize=Size(), int borderType=BORDER_DEFAULT)
 Upsamples an image and then blurs it.
 
void randn (InputOutputArray dst, InputArray mean, InputArray stddev)
 Fills the array with normally distributed random numbers.
 
void randShuffle (InputOutputArray dst, double iterFactor=1., RNG *rng=0)
 Shuffles the array elements randomly.
 
void randu (InputOutputArray dst, InputArray low, InputArray high)
 Generates a single uniformly-distributed random number or an array of random numbers.
 
template<typename _Tp >
static _InputArray rawIn (_Tp &v)
 
template<typename _Tp >
static _InputOutputArray rawInOut (_Tp &v)
 
template<typename _Tp >
static _OutputArray rawOut (_Tp &v)
 
void read (const FileNode &fn, optflow::GPCTree::Node &node, optflow::GPCTree::Node)
 
Mat readOpticalFlow (const String &path)
 Read a .flo file.
 
int recoverPose (InputArray E, InputArray points1, InputArray points2, InputArray cameraMatrix, OutputArray R, OutputArray t, double distanceThresh, InputOutputArray mask=noArray(), OutputArray triangulatedPoints=noArray())
 
int recoverPose (InputArray E, InputArray points1, InputArray points2, InputArray cameraMatrix, OutputArray R, OutputArray t, InputOutputArray mask=noArray())
 Recovers the relative camera rotation and the translation from an estimated essential matrix and the corresponding points in two images, using chirality check. Returns the number of inliers that pass the check.
 
int recoverPose (InputArray E, InputArray points1, InputArray points2, OutputArray R, OutputArray t, double focal=1.0, Point2d pp=Point2d(0, 0), InputOutputArray mask=noArray())
 
int recoverPose (InputArray points1, InputArray points2, InputArray cameraMatrix1, InputArray distCoeffs1, InputArray cameraMatrix2, InputArray distCoeffs2, OutputArray E, OutputArray R, OutputArray t, int method=cv::RANSAC, double prob=0.999, double threshold=1.0, InputOutputArray mask=noArray())
 Recovers the relative camera rotation and the translation from corresponding points in two images from two different cameras, using cheirality check. Returns the number of inliers that pass the check.
 
void rectangle (InputOutputArray img, Point pt1, Point pt2, const Scalar &color, int thickness=1, int lineType=LINE_8, int shift=0)
 Draws a simple, thick, or filled up-right rectangle.
 
void rectangle (InputOutputArray img, Rect rec, const Scalar &color, int thickness=1, int lineType=LINE_8, int shift=0)
 
float rectify3Collinear (InputArray cameraMatrix1, InputArray distCoeffs1, InputArray cameraMatrix2, InputArray distCoeffs2, InputArray cameraMatrix3, InputArray distCoeffs3, InputArrayOfArrays imgpt1, InputArrayOfArrays imgpt3, Size imageSize, InputArray R12, InputArray T12, InputArray R13, InputArray T13, OutputArray R1, OutputArray R2, OutputArray R3, OutputArray P1, OutputArray P2, OutputArray P3, OutputArray Q, double alpha, Size newImgSize, Rect *roi1, Rect *roi2, int flags)
 computes the rectification transformations for 3-head camera, where all the heads are on the same line.
 
ErrorCallback redirectError (ErrorCallback errCallback, void *userdata=0, void **prevUserdata=0)
 Sets the new error handler and the optional user data.
 
void reduce (InputArray src, OutputArray dst, int dim, int rtype, int dtype=-1)
 Reduces a matrix to a vector.
 
void reduceArgMax (InputArray src, OutputArray dst, int axis, bool lastIndex=false)
 Finds indices of max elements along provided axis.
 
void reduceArgMin (InputArray src, OutputArray dst, int axis, bool lastIndex=false)
 Finds indices of min elements along provided axis.
 
void remap (InputArray src, OutputArray dst, InputArray map1, InputArray map2, int interpolation, int borderMode=BORDER_CONSTANT, const Scalar &borderValue=Scalar())
 Applies a generic geometrical transformation to an image.
 
Mat repeat (const Mat &src, int ny, int nx)
 
void repeat (InputArray src, int ny, int nx, OutputArray dst)
 Fills the output array with repeated copies of the input array.
 
void reprojectImageTo3D (InputArray disparity, OutputArray _3dImage, InputArray Q, bool handleMissingValues=false, int ddepth=-1)
 Reprojects a disparity image to 3D space.
 
void resize (InputArray src, OutputArray dst, Size dsize, double fx=0, double fy=0, int interpolation=INTER_LINEAR)
 Resizes an image.
 
void resizeWindow (const String &winname, const cv::Size &size)
 
void resizeWindow (const String &winname, int width, int height)
 Resizes the window to the specified size.
 
void Rodrigues (InputArray src, OutputArray dst, OutputArray jacobian=noArray())
 Converts a rotation matrix to a rotation vector or vice versa.
 
void rotate (InputArray src, OutputArray dst, int rotateCode)
 Rotates a 2D array in multiples of 90 degrees. The function cv::rotate rotates the array in one of three different ways: Rotate by 90 degrees clockwise (rotateCode = ROTATE_90_CLOCKWISE). Rotate by 180 degrees clockwise (rotateCode = ROTATE_180). Rotate by 270 degrees clockwise (rotateCode = ROTATE_90_COUNTERCLOCKWISE).
 
int rotatedRectangleIntersection (const RotatedRect &rect1, const RotatedRect &rect2, OutputArray intersectingRegion)
 Finds out if there is any intersection between two rotated rectangles.
 
static int roundUp (int a, unsigned int b)
 Round first value up to the nearest multiple of second value.
 
static size_t roundUp (size_t a, unsigned int b)
 
Vec3d RQDecomp3x3 (InputArray src, OutputArray mtxR, OutputArray mtxQ, OutputArray Qx=noArray(), OutputArray Qy=noArray(), OutputArray Qz=noArray())
 Computes an RQ decomposition of 3x3 matrices.
 
double sampsonDistance (InputArray pt1, InputArray pt2, InputArray F)
 Calculates the Sampson Distance between two points.
 
template<typename _Tp >
static _Tp saturate_cast (double v)
 
template<typename _Tp >
static _Tp saturate_cast (float v)
 
template<typename _Tp >
static _Tp saturate_cast (float16_t v)
 
template<typename _Tp >
static _Tp saturate_cast (int v)
 
template<typename _Tp >
static _Tp saturate_cast (int64 v)
 
template<typename _Tp >
static _Tp saturate_cast (schar v)
 
template<typename _Tp >
static _Tp saturate_cast (short v)
 
template<typename _Tp >
static _Tp saturate_cast (softdouble a)
 
template<typename _Tp >
static _Tp saturate_cast (softfloat a)
 Saturate casts.
 
template<typename _Tp >
static _Tp saturate_cast (uchar v)
 Template function for accurate conversion from one primitive type to another.
 
template<typename _Tp >
static _Tp saturate_cast (uint64 v)
 
template<typename _Tp >
static _Tp saturate_cast (unsigned v)
 
template<typename _Tp >
static _Tp saturate_cast (ushort v)
 
template<>
float16_t saturate_cast< float16_t > (double v)
 
template<>
float16_t saturate_cast< float16_t > (float v)
 
template<>
float16_t saturate_cast< float16_t > (int v)
 
template<>
float16_t saturate_cast< float16_t > (int64 v)
 
template<>
float16_t saturate_cast< float16_t > (schar v)
 
template<>
float16_t saturate_cast< float16_t > (short v)
 
template<>
float16_t saturate_cast< float16_t > (uchar v)
 
template<>
float16_t saturate_cast< float16_t > (uint64 v)
 
template<>
float16_t saturate_cast< float16_t > (unsigned v)
 
template<>
float16_t saturate_cast< float16_t > (ushort v)
 
template<>
int64 saturate_cast< int64 > (uint64 v)
 
template<>
int64_t saturate_cast< int64_t > (softdouble a)
 
template<>
int64_t saturate_cast< int64_t > (softfloat a)
 
template<>
schar saturate_cast< schar > (double v)
 
template<>
schar saturate_cast< schar > (float v)
 
template<>
schar saturate_cast< schar > (int v)
 
template<>
schar saturate_cast< schar > (int64 v)
 
template<>
schar saturate_cast< schar > (short v)
 
template<>
schar saturate_cast< schar > (softdouble a)
 
template<>
schar saturate_cast< schar > (softfloat a)
 
template<>
schar saturate_cast< schar > (uchar v)
 
template<>
schar saturate_cast< schar > (uint64 v)
 
template<>
schar saturate_cast< schar > (unsigned v)
 
template<>
schar saturate_cast< schar > (ushort v)
 
template<>
short saturate_cast< short > (double v)
 
template<>
short saturate_cast< short > (float v)
 
template<>
short saturate_cast< short > (int v)
 
template<>
short saturate_cast< short > (int64 v)
 
template<>
short saturate_cast< short > (softdouble a)
 
template<>
short saturate_cast< short > (softfloat a)
 
template<>
short saturate_cast< short > (uint64 v)
 
template<>
short saturate_cast< short > (unsigned v)
 
template<>
short saturate_cast< short > (ushort v)
 
template<>
uchar saturate_cast< uchar > (double v)
 
template<>
uchar saturate_cast< uchar > (float v)
 
template<>
uchar saturate_cast< uchar > (int v)
 
template<>
uchar saturate_cast< uchar > (int64 v)
 
template<>
uchar saturate_cast< uchar > (schar v)
 
template<>
uchar saturate_cast< uchar > (short v)
 
template<>
uchar saturate_cast< uchar > (softdouble a)
 
template<>
uchar saturate_cast< uchar > (softfloat a)
 
template<>
uchar saturate_cast< uchar > (uint64 v)
 
template<>
uchar saturate_cast< uchar > (unsigned v)
 
template<>
uchar saturate_cast< uchar > (ushort v)
 
template<>
uint64 saturate_cast< uint64 > (int v)
 
template<>
uint64 saturate_cast< uint64 > (int64 v)
 
template<>
uint64 saturate_cast< uint64 > (schar v)
 
template<>
uint64 saturate_cast< uint64 > (short v)
 
template<>
uint64_t saturate_cast< uint64_t > (softdouble a)
 
template<>
uint64_t saturate_cast< uint64_t > (softfloat a)
 
template<>
unsigned saturate_cast< unsigned > (double v)
 
template<>
unsigned saturate_cast< unsigned > (float v)
 
template<>
unsigned saturate_cast< unsigned > (int v)
 
template<>
unsigned saturate_cast< unsigned > (int64 v)
 
template<>
unsigned saturate_cast< unsigned > (schar v)
 
template<>
unsigned saturate_cast< unsigned > (short v)
 
template<>
unsigned saturate_cast< unsigned > (softdouble a)
 
template<>
unsigned saturate_cast< unsigned > (softfloat a)
 Saturate cast to unsigned integer and unsigned long long integer We intentionally do not clip negative numbers, to make -1 become 0xffffffff etc.
 
template<>
unsigned saturate_cast< unsigned > (uint64 v)
 
template<>
ushort saturate_cast< ushort > (double v)
 
template<>
ushort saturate_cast< ushort > (float v)
 
template<>
ushort saturate_cast< ushort > (int v)
 
template<>
ushort saturate_cast< ushort > (int64 v)
 
template<>
ushort saturate_cast< ushort > (schar v)
 
template<>
ushort saturate_cast< ushort > (short v)
 
template<>
ushort saturate_cast< ushort > (softdouble a)
 
template<>
ushort saturate_cast< ushort > (softfloat a)
 
template<>
ushort saturate_cast< ushort > (uint64 v)
 
template<>
ushort saturate_cast< ushort > (unsigned v)
 
void saveWindowParameters (const String &windowName)
 Saves parameters of the specified window.
 
void scaleAdd (InputArray src1, double alpha, InputArray src2, OutputArray dst)
 Calculates the sum of a scaled array and another array.
 
void Scharr (InputArray src, OutputArray dst, int ddepth, int dx, int dy, double scale=1, double delta=0, int borderType=BORDER_DEFAULT)
 Calculates the first x- or y- image derivative using Scharr operator.
 
void seamlessClone (InputArray src, InputArray dst, InputArray mask, Point p, OutputArray blend, int flags)
 Image editing tasks concern either global changes (color/intensity corrections, filters, deformations) or local changes concerned to a selection. Here we are interested in achieving local changes, ones that are restricted to a region manually selected (ROI), in a seamless and effortless manner. The extent of the changes ranges from slight distortions to complete replacement by novel content [PM03] .
 
Rect selectROI (const String &windowName, InputArray img, bool showCrosshair=true, bool fromCenter=false, bool printNotice=true)
 Allows users to select a ROI on the given image.
 
Rect selectROI (InputArray img, bool showCrosshair=true, bool fromCenter=false, bool printNotice=true)
 
void selectROIs (const String &windowName, InputArray img, std::vector< Rect > &boundingBoxes, bool showCrosshair=true, bool fromCenter=false, bool printNotice=true)
 Allows users to select multiple ROIs on the given image.
 
void sepFilter2D (InputArray src, OutputArray dst, int ddepth, InputArray kernelX, InputArray kernelY, Point anchor=Point(-1,-1), double delta=0, int borderType=BORDER_DEFAULT)
 Applies a separable linear filter to an image.
 
bool setBreakOnError (bool flag)
 Sets/resets the break-on-error mode.
 
void setIdentity (InputOutputArray mtx, const Scalar &s=Scalar(1))
 Initializes a scaled identity matrix.
 
void setMouseCallback (const String &winname, MouseCallback onMouse, void *userdata=0)
 Sets mouse handler for the specified window.
 
void setNumThreads (int nthreads)
 OpenCV will try to set the number of threads for subsequent parallel regions.
 
void setOpenGlContext (const String &winname)
 Sets the specified window as current OpenGL context.
 
void setOpenGlDrawCallback (const String &winname, OpenGlDrawCallback onOpenGlDraw, void *userdata=0)
 Sets a callback function to be called to draw on top of displayed image.
 
void setRNGSeed (int seed)
 Sets state of default random number generator.
 
void setTrackbarMax (const String &trackbarname, const String &winname, int maxval)
 Sets the trackbar maximum position.
 
void setTrackbarMin (const String &trackbarname, const String &winname, int minval)
 Sets the trackbar minimum position.
 
void setTrackbarPos (const String &trackbarname, const String &winname, int pos)
 Sets the trackbar position.
 
void setUseOpenVX (bool flag)
 Enable/disable use of OpenVX.
 
void setUseOptimized (bool onoff)
 Enables or disables the optimized code.
 
void setWindowProperty (const String &winname, int prop_id, double prop_value)
 Changes parameters of a window dynamically.
 
void setWindowTitle (const String &winname, const String &title)
 Updates window title.
 
template<typename T >
Quat< T > sin (const Quat< T > &q)
 
softdouble sin (const softdouble &a)
 Sine.
 
template<typename T >
Quat< T > sinh (const Quat< T > &q)
 
void Sobel (InputArray src, OutputArray dst, int ddepth, int dx, int dy, int ksize=3, double scale=1, double delta=0, int borderType=BORDER_DEFAULT)
 Calculates the first, second, third, or mixed image derivatives using an extended Sobel operator.
 
bool solve (InputArray src1, InputArray src2, OutputArray dst, int flags=DECOMP_LU)
 Solves one or more linear systems or least-squares problems.
 
int solveCubic (InputArray coeffs, OutputArray roots)
 Finds the real roots of a cubic equation.
 
int solveLP (InputArray Func, InputArray Constr, OutputArray z)
 
int solveLP (InputArray Func, InputArray Constr, OutputArray z, double constr_eps)
 Solve given (non-integer) linear programming problem using the Simplex Algorithm (Simplex Method).
 
int solveP3P (InputArray objectPoints, InputArray imagePoints, InputArray cameraMatrix, InputArray distCoeffs, OutputArrayOfArrays rvecs, OutputArrayOfArrays tvecs, int flags)
 Finds an object pose from 3 3D-2D point correspondences.
 
bool solvePnP (InputArray objectPoints, InputArray imagePoints, InputArray cameraMatrix, InputArray distCoeffs, OutputArray rvec, OutputArray tvec, bool useExtrinsicGuess=false, int flags=SOLVEPNP_ITERATIVE)
 Finds an object pose from 3D-2D point correspondences.
 
int solvePnPGeneric (InputArray objectPoints, InputArray imagePoints, InputArray cameraMatrix, InputArray distCoeffs, OutputArrayOfArrays rvecs, OutputArrayOfArrays tvecs, bool useExtrinsicGuess=false, SolvePnPMethod flags=SOLVEPNP_ITERATIVE, InputArray rvec=noArray(), InputArray tvec=noArray(), OutputArray reprojectionError=noArray())
 Finds an object pose from 3D-2D point correspondences.
 
bool solvePnPRansac (InputArray objectPoints, InputArray imagePoints, InputArray cameraMatrix, InputArray distCoeffs, OutputArray rvec, OutputArray tvec, bool useExtrinsicGuess=false, int iterationsCount=100, float reprojectionError=8.0, double confidence=0.99, OutputArray inliers=noArray(), int flags=SOLVEPNP_ITERATIVE)
 Finds an object pose from 3D-2D point correspondences using the RANSAC scheme.
 
bool solvePnPRansac (InputArray objectPoints, InputArray imagePoints, InputOutputArray cameraMatrix, InputArray distCoeffs, OutputArray rvec, OutputArray tvec, OutputArray inliers, const UsacParams &params=UsacParams())
 
void solvePnPRefineLM (InputArray objectPoints, InputArray imagePoints, InputArray cameraMatrix, InputArray distCoeffs, InputOutputArray rvec, InputOutputArray tvec, TermCriteria criteria=TermCriteria(TermCriteria::EPS+TermCriteria::COUNT, 20, FLT_EPSILON))
 Refine a pose (the translation and the rotation that transform a 3D point expressed in the object coordinate frame to the camera coordinate frame) from a 3D-2D point correspondences and starting from an initial solution.
 
void solvePnPRefineVVS (InputArray objectPoints, InputArray imagePoints, InputArray cameraMatrix, InputArray distCoeffs, InputOutputArray rvec, InputOutputArray tvec, TermCriteria criteria=TermCriteria(TermCriteria::EPS+TermCriteria::COUNT, 20, FLT_EPSILON), double VVSlambda=1)
 Refine a pose (the translation and the rotation that transform a 3D point expressed in the object coordinate frame to the camera coordinate frame) from a 3D-2D point correspondences and starting from an initial solution.
 
double solvePoly (InputArray coeffs, OutputArray roots, int maxIters=300)
 Finds the real or complex roots of a polynomial equation.
 
void sort (InputArray src, OutputArray dst, int flags)
 Sorts each row or each column of a matrix.
 
void sortIdx (InputArray src, OutputArray dst, int flags)
 Sorts each row or each column of a matrix.
 
void spatialGradient (InputArray src, OutputArray dx, OutputArray dy, int ksize=3, int borderType=BORDER_DEFAULT)
 Calculates the first order image derivative in both x and y using a Sobel operator.
 
void split (const Mat &src, Mat *mvbegin)
 Divides a multi-channel array into several single-channel arrays.
 
void split (InputArray m, OutputArrayOfArrays mv)
 
void sqrBoxFilter (InputArray src, OutputArray dst, int ddepth, Size ksize, Point anchor=Point(-1, -1), bool normalize=true, int borderType=BORDER_DEFAULT)
 Calculates the normalized sum of squares of the pixel values overlapping the filter.
 
template<typename S >
Quat< S > sqrt (const Quat< S > &q, QuatAssumeType assumeUnit=QUAT_ASSUME_NOT_UNIT)
 
softdouble sqrt (const softdouble &a)
 
softfloat sqrt (const softfloat &a)
 Square root.
 
void sqrt (InputArray src, OutputArray dst)
 Calculates a square root of array elements.
 
void stackBlur (InputArray src, OutputArray dst, Size ksize)
 Blurs an image using the stackBlur.
 
int startLoop (int(*pt2Func)(int argc, char *argv[]), int argc, char *argv[])
 
int startWindowThread ()
 
double stereoCalibrate (InputArrayOfArrays objectPoints, InputArrayOfArrays imagePoints1, InputArrayOfArrays imagePoints2, InputOutputArray cameraMatrix1, InputOutputArray distCoeffs1, InputOutputArray cameraMatrix2, InputOutputArray distCoeffs2, Size imageSize, InputOutputArray R, InputOutputArray T, OutputArray E, OutputArray F, OutputArray perViewErrors, int flags=CALIB_FIX_INTRINSIC, TermCriteria criteria=TermCriteria(TermCriteria::COUNT+TermCriteria::EPS, 30, 1e-6))
 This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
 
double stereoCalibrate (InputArrayOfArrays objectPoints, InputArrayOfArrays imagePoints1, InputArrayOfArrays imagePoints2, InputOutputArray cameraMatrix1, InputOutputArray distCoeffs1, InputOutputArray cameraMatrix2, InputOutputArray distCoeffs2, Size imageSize, InputOutputArray R, InputOutputArray T, OutputArray E, OutputArray F, OutputArrayOfArrays rvecs, OutputArrayOfArrays tvecs, OutputArray perViewErrors, int flags=CALIB_FIX_INTRINSIC, TermCriteria criteria=TermCriteria(TermCriteria::COUNT+TermCriteria::EPS, 30, 1e-6))
 Calibrates a stereo camera set up. This function finds the intrinsic parameters for each of the two cameras and the extrinsic parameters between the two cameras.
 
double stereoCalibrate (InputArrayOfArrays objectPoints, InputArrayOfArrays imagePoints1, InputArrayOfArrays imagePoints2, InputOutputArray cameraMatrix1, InputOutputArray distCoeffs1, InputOutputArray cameraMatrix2, InputOutputArray distCoeffs2, Size imageSize, OutputArray R, OutputArray T, OutputArray E, OutputArray F, int flags=CALIB_FIX_INTRINSIC, TermCriteria criteria=TermCriteria(TermCriteria::COUNT+TermCriteria::EPS, 30, 1e-6))
 This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
 
void stereoRectify (InputArray cameraMatrix1, InputArray distCoeffs1, InputArray cameraMatrix2, InputArray distCoeffs2, Size imageSize, InputArray R, InputArray T, OutputArray R1, OutputArray R2, OutputArray P1, OutputArray P2, OutputArray Q, int flags=CALIB_ZERO_DISPARITY, double alpha=-1, Size newImageSize=Size(), Rect *validPixROI1=0, Rect *validPixROI2=0)
 Computes rectification transforms for each head of a calibrated stereo camera.
 
bool stereoRectifyUncalibrated (InputArray points1, InputArray points2, InputArray F, Size imgSize, OutputArray H1, OutputArray H2, double threshold=5)
 Computes a rectification transform for an uncalibrated stereo camera.
 
void stopLoop ()
 
void stylization (InputArray src, OutputArray dst, float sigma_s=60, float sigma_r=0.45f)
 Stylization aims to produce digital imagery with a wide variety of effects not focused on photorealism. Edge-aware filters are ideal for stylization, as they can abstract regions of low contrast while preserving, or enhancing, high-contrast features.
 
void subtract (InputArray src1, InputArray src2, OutputArray dst, InputArray mask=noArray(), int dtype=-1)
 Calculates the per-element difference between two arrays or array and a scalar.
 
Scalar sum (InputArray src)
 Calculates the sum of array elements.
 
void SVBackSubst (InputArray w, InputArray u, InputArray vt, InputArray rhs, OutputArray dst)
 
void SVDecomp (InputArray src, OutputArray w, OutputArray u, OutputArray vt, int flags=0)
 
void swap (Mat &a, Mat &b)
 Swaps two matrices.
 
void swap (UMat &a, UMat &b)
 
template<typename T >
Quat< T > tan (const Quat< T > &q)
 
template<typename T >
Quat< T > tanh (const Quat< T > &q)
 
String tempfile (const char *suffix=0)
 
void textureFlattening (InputArray src, InputArray mask, OutputArray dst, float low_threshold=30, float high_threshold=45, int kernel_size=3)
 By retaining only the gradients at edge locations, before integrating with the Poisson solver, one washes out the texture of the selected region, giving its contents a flat aspect. Here Canny Edge Detector is used.
 
RNGtheRNG ()
 Returns the default random number generator.
 
double threshold (InputArray src, OutputArray dst, double thresh, double maxval, int type)
 Applies a fixed-level threshold to each array element.
 
template<typename T >
std::vector< T > to_own (const cv::MatSize &sz)
 
cv::gapi::own::Mat to_own (Mat &&)=delete
 
cv::gapi::own::Mat to_own (Mat const &m)
 
static std::string toLowerCase (const std::string &str)
 
static std::string toUpperCase (const std::string &str)
 
template<typename _Tp , int m, int n>
static double trace (const Matx< _Tp, m, n > &a)
 
Scalar trace (InputArray mtx)
 Returns the trace of a matrix.
 
void transform (InputArray src, OutputArray dst, InputArray m)
 Performs the matrix transformation of every array element.
 
void transpose (InputArray src, OutputArray dst)
 Transposes a matrix.
 
void transposeND (InputArray src, const std::vector< int > &order, OutputArray dst)
 Transpose for n-dimensional matrices.
 
void triangulatePoints (InputArray projMatr1, InputArray projMatr2, InputArray projPoints1, InputArray projPoints2, OutputArray points4D)
 This function reconstructs 3-dimensional points (in homogeneous coordinates) by using their observations with a stereo camera.
 
String typeToString (int type)
 
void undistort (InputArray src, OutputArray dst, InputArray cameraMatrix, InputArray distCoeffs, InputArray newCameraMatrix=noArray())
 Transforms an image to compensate for lens distortion.
 
void undistortImagePoints (InputArray src, OutputArray dst, InputArray cameraMatrix, InputArray distCoeffs, TermCriteria=TermCriteria(TermCriteria::MAX_ITER+TermCriteria::EPS, 5, 0.01))
 Compute undistorted image points position.
 
void undistortPoints (InputArray src, OutputArray dst, InputArray cameraMatrix, InputArray distCoeffs, InputArray R, InputArray P, TermCriteria criteria)
 
void undistortPoints (InputArray src, OutputArray dst, InputArray cameraMatrix, InputArray distCoeffs, InputArray R=noArray(), InputArray P=noArray())
 Computes the ideal point coordinates from the observed point coordinates.
 
void updateWindow (const String &winname)
 Force window to redraw its context and call draw callback ( See cv::setOpenGlDrawCallback ).
 
bool useOpenVX ()
 Check if use of OpenVX is enabled.
 
bool useOptimized ()
 Returns the status of optimized code usage.
 
void v256_cleanup ()
 
template<typename _Tp >
v_reg< _Tp, simd256_width/sizeof(_Tp)> v256_load (const _Tp *ptr)
 Load 256-bit length register contents from memory.
 
template<typename _Tp >
v_reg< _Tp, simd256_width/sizeof(_Tp)> v256_load_aligned (const _Tp *ptr)
 Load register contents from memory (aligned)
 
template<typename _Tp >
v_reg< typename V_TypeTraits< _Tp >::w_type, simd256_width/sizeof(typename V_TypeTraits< _Tp >::w_type)> v256_load_expand (const _Tp *ptr)
 Load register contents from memory with double expand.
 
v_reg< float, simd256_width/sizeof(float)> v256_load_expand (const float16_t *ptr)
 
template<typename _Tp >
v_reg< typename V_TypeTraits< _Tp >::q_type, simd256_width/sizeof(typename V_TypeTraits< _Tp >::q_type)> v256_load_expand_q (const _Tp *ptr)
 Load register contents from memory with quad expand.
 
template<typename _Tp >
v_reg< _Tp, simd256_width/sizeof(_Tp)> v256_load_halves (const _Tp *loptr, const _Tp *hiptr)
 Load register contents from two memory blocks.
 
template<typename _Tp >
v_reg< _Tp, simd256_width/sizeof(_Tp)> v256_load_low (const _Tp *ptr)
 Load 128-bits of data to lower part (high part is undefined).
 
void v512_cleanup ()
 
template<typename _Tp >
v_reg< _Tp, simd512_width/sizeof(_Tp)> v512_load (const _Tp *ptr)
 Load 512-bit length register contents from memory.
 
template<typename _Tp >
v_reg< _Tp, simd512_width/sizeof(_Tp)> v512_load_aligned (const _Tp *ptr)
 Load register contents from memory (aligned)
 
template<typename _Tp >
v_reg< typename V_TypeTraits< _Tp >::w_type, simd512_width/sizeof(typename V_TypeTraits< _Tp >::w_type)> v512_load_expand (const _Tp *ptr)
 Load register contents from memory with double expand.
 
v_reg< float, simd512_width/sizeof(float)> v512_load_expand (const float16_t *ptr)
 
template<typename _Tp >
v_reg< typename V_TypeTraits< _Tp >::q_type, simd512_width/sizeof(typename V_TypeTraits< _Tp >::q_type)> v512_load_expand_q (const _Tp *ptr)
 Load register contents from memory with quad expand.
 
template<typename _Tp >
v_reg< _Tp, simd512_width/sizeof(_Tp)> v512_load_halves (const _Tp *loptr, const _Tp *hiptr)
 Load register contents from two memory blocks.
 
template<typename _Tp >
v_reg< _Tp, simd512_width/sizeof(_Tp)> v512_load_low (const _Tp *ptr)
 Load 256-bits of data to lower part (high part is undefined).
 
v_float32 v_abs (const v_float32 &a)
 
v_float32x4 v_abs (const v_float32x4 &a)
 
v_float64 v_abs (const v_float64 &a)
 
v_float64x2 v_abs (const v_float64x2 &a)
 
v_uint16 v_abs (const v_int16 &a)
 
v_uint16x8 v_abs (const v_int16x8 &a)
 
v_uint32 v_abs (const v_int32 &a)
 
v_uint32x4 v_abs (const v_int32x4 &a)
 
v_uint8 v_abs (const v_int8 &a)
 
v_uint8x16 v_abs (const v_int8x16 &a)
 
template<typename _Tp , int n>
v_reg< typename V_TypeTraits< _Tp >::abs_type, n > v_abs (const v_reg< _Tp, n > &a)
 Absolute value of elements.
 
v_float32 v_absdiff (const v_float32 &a, const v_float32 &b)
 
v_float32x4 v_absdiff (const v_float32x4 &a, const v_float32x4 &b)
 
v_float64 v_absdiff (const v_float64 &a, const v_float64 &b)
 
v_float64x2 v_absdiff (const v_float64x2 &a, const v_float64x2 &b)
 
v_uint16 v_absdiff (const v_int16 &a, const v_int16 &b)
 
v_uint16x8 v_absdiff (const v_int16x8 &a, const v_int16x8 &b)
 
v_uint32 v_absdiff (const v_int32 &a, const v_int32 &b)
 
v_uint32x4 v_absdiff (const v_int32x4 &a, const v_int32x4 &b)
 
v_uint8 v_absdiff (const v_int8 &a, const v_int8 &b)
 
v_uint8x16 v_absdiff (const v_int8x16 &a, const v_int8x16 &b)
 
template<typename _Tp , int n>
v_reg< typename V_TypeTraits< _Tp >::abs_type, n > v_absdiff (const v_reg< _Tp, n > &a, const v_reg< _Tp, n > &b)
 Absolute difference.
 
template<int n>
v_reg< double, n > v_absdiff (const v_reg< double, n > &a, const v_reg< double, n > &b)
 
template<int n>
v_reg< float, n > v_absdiff (const v_reg< float, n > &a, const v_reg< float, n > &b)
 
v_uint16 v_absdiff (const v_uint16 &a, const v_uint16 &b)
 
v_uint16x8 v_absdiff (const v_uint16x8 &a, const v_uint16x8 &b)
 
v_uint32 v_absdiff (const v_uint32 &a, const v_uint32 &b)
 
v_uint32x4 v_absdiff (const v_uint32x4 &a, const v_uint32x4 &b)
 
v_uint8 v_absdiff (const v_uint8 &a, const v_uint8 &b)
 
v_uint8x16 v_absdiff (const v_uint8x16 &a, const v_uint8x16 &b)
 
v_int16 v_absdiffs (const v_int16 &a, const v_int16 &b)
 
v_int16x8 v_absdiffs (const v_int16x8 &a, const v_int16x8 &b)
 
v_int8 v_absdiffs (const v_int8 &a, const v_int8 &b)
 
v_int8x16 v_absdiffs (const v_int8x16 &a, const v_int8x16 &b)
 
template<typename _Tp , int n>
v_reg< _Tp, n > v_absdiffs (const v_reg< _Tp, n > &a, const v_reg< _Tp, n > &b)
 Saturating absolute difference.
 
v_float32 v_add (const v_float32 &a, const v_float32 &b)
 
template<typename... Args>
v_float32 v_add (const v_float32 &f1, const v_float32 &f2, const Args &... vf)
 
v_float64 v_add (const v_float64 &a, const v_float64 &b)
 
template<typename... Args>
v_float64 v_add (const v_float64 &f1, const v_float64 &f2, const Args &... vf)
 
v_int16 v_add (const v_int16 &a, const v_int16 &b)
 
template<typename... Args>
v_int16 v_add (const v_int16 &f1, const v_int16 &f2, const Args &... vf)
 
v_int32 v_add (const v_int32 &a, const v_int32 &b)
 
template<typename... Args>
v_int32 v_add (const v_int32 &f1, const v_int32 &f2, const Args &... vf)
 
v_int64 v_add (const v_int64 &a, const v_int64 &b)
 
template<typename... Args>
v_int64 v_add (const v_int64 &f1, const v_int64 &f2, const Args &... vf)
 
v_int8 v_add (const v_int8 &a, const v_int8 &b)
 
template<typename... Args>
v_int8 v_add (const v_int8 &f1, const v_int8 &f2, const Args &... vf)
 
v_uint16 v_add (const v_uint16 &a, const v_uint16 &b)
 
template<typename... Args>
v_uint16 v_add (const v_uint16 &f1, const v_uint16 &f2, const Args &... vf)
 
v_uint32 v_add (const v_uint32 &a, const v_uint32 &b)
 
template<typename... Args>
v_uint32 v_add (const v_uint32 &f1, const v_uint32 &f2, const Args &... vf)
 
v_uint64 v_add (const v_uint64 &a, const v_uint64 &b)
 
template<typename... Args>
v_uint64 v_add (const v_uint64 &f1, const v_uint64 &f2, const Args &... vf)
 
v_uint8 v_add (const v_uint8 &a, const v_uint8 &b)
 
template<typename... Args>
v_uint8 v_add (const v_uint8 &f1, const v_uint8 &f2, const Args &... vf)
 
v_int16 v_add_wrap (const v_int16 &a, const v_int16 &b)
 
v_int16x8 v_add_wrap (const v_int16x8 &a, const v_int16x8 &b)
 
v_int8 v_add_wrap (const v_int8 &a, const v_int8 &b)
 
v_int8x16 v_add_wrap (const v_int8x16 &a, const v_int8x16 &b)
 
template<typename _Tp , int n>
v_reg< _Tp, n > v_add_wrap (const v_reg< _Tp, n > &a, const v_reg< _Tp, n > &b)
 Add values without saturation.
 
v_uint16 v_add_wrap (const v_uint16 &a, const v_uint16 &b)
 
v_uint16x8 v_add_wrap (const v_uint16x8 &a, const v_uint16x8 &b)
 
v_uint8 v_add_wrap (const v_uint8 &a, const v_uint8 &b)
 
v_uint8x16 v_add_wrap (const v_uint8x16 &a, const v_uint8x16 &b)
 
v_float32 v_and (const v_float32 &a, const v_float32 &b)
 
v_float64 v_and (const v_float64 &a, const v_float64 &b)
 
v_int16 v_and (const v_int16 &a, const v_int16 &b)
 
v_int32 v_and (const v_int32 &a, const v_int32 &b)
 
v_int64 v_and (const v_int64 &a, const v_int64 &b)
 
v_int8 v_and (const v_int8 &a, const v_int8 &b)
 
v_uint16 v_and (const v_uint16 &a, const v_uint16 &b)
 
v_uint32 v_and (const v_uint32 &a, const v_uint32 &b)
 
v_uint64 v_and (const v_uint64 &a, const v_uint64 &b)
 
v_uint8 v_and (const v_uint8 &a, const v_uint8 &b)
 
template<int i, typename _Tp , int n>
v_reg< _Tp, n > v_broadcast_element (const v_reg< _Tp, n > &a)
 Broadcast i-th element of vector.
 
template<int s = 0>
v_float32 v_broadcast_element (v_float32 v, int i=s)
 
template<int i>
v_float32x4 v_broadcast_element (v_float32x4 v)
 
template<int i>
v_float64x2 v_broadcast_element (v_float64x2 v)
 
template<int i>
v_int16x8 v_broadcast_element (v_int16x8 v)
 
template<int s = 0>
v_int32 v_broadcast_element (v_int32 v, int i=s)
 
template<int i>
v_int32x4 v_broadcast_element (v_int32x4 v)
 
template<int i>
v_int64x2 v_broadcast_element (v_int64x2 v)
 
template<int i>
v_int8x16 v_broadcast_element (v_int8x16 v)
 
template<int i>
v_uint16x8 v_broadcast_element (v_uint16x8 v)
 
template<int s = 0>
v_uint32 v_broadcast_element (v_uint32 v, int i=s)
 
template<int i>
v_uint32x4 v_broadcast_element (v_uint32x4 v)
 
template<int i>
v_uint64x2 v_broadcast_element (v_uint64x2 v)
 
template<int i>
v_uint8x16 v_broadcast_element (v_uint8x16 v)
 
v_float32 v_broadcast_highest (v_float32 v)
 
v_int32 v_broadcast_highest (v_int32 v)
 
v_uint32 v_broadcast_highest (v_uint32 v)
 
v_int32 v_ceil (const v_float32 &a)
 
v_int32x4 v_ceil (const v_float32x4 &a)
 
v_int32 v_ceil (const v_float64 &a)
 
v_int32x4 v_ceil (const v_float64x2 &a)
 
template<int n>
v_reg< int, n *2 > v_ceil (const v_reg< double, n > &a)
 
template<int n>
v_reg< int, n > v_ceil (const v_reg< float, n > &a)
 Ceil elements.
 
bool v_check_all (const v_float32 &a)
 
bool v_check_all (const v_float32x4 &a)
 
bool v_check_all (const v_float64 &a)
 
bool v_check_all (const v_float64x2 &a)
 
bool v_check_all (const v_int16 &a)
 
bool v_check_all (const v_int16x8 &a)
 
bool v_check_all (const v_int32 &a)
 
bool v_check_all (const v_int32x4 &a)
 
bool v_check_all (const v_int64 &a)
 
bool v_check_all (const v_int64x2 &a)
 
bool v_check_all (const v_int8 &a)
 
bool v_check_all (const v_int8x16 &a)
 
template<typename _Tp , int n>
bool v_check_all (const v_reg< _Tp, n > &a)
 Check if all packed values are less than zero.
 
bool v_check_all (const v_uint16 &a)
 
bool v_check_all (const v_uint16x8 &a)
 
bool v_check_all (const v_uint32 &a)
 
bool v_check_all (const v_uint32x4 &a)
 
bool v_check_all (const v_uint64 &a)
 
bool v_check_all (const v_uint64x2 &a)
 
bool v_check_all (const v_uint8 &a)
 
bool v_check_all (const v_uint8x16 &a)
 
bool v_check_any (const v_float32 &a)
 
bool v_check_any (const v_float32x4 &a)
 
bool v_check_any (const v_float64 &a)
 
bool v_check_any (const v_float64x2 &a)
 
bool v_check_any (const v_int16 &a)
 
bool v_check_any (const v_int16x8 &a)
 
bool v_check_any (const v_int32 &a)
 
bool v_check_any (const v_int32x4 &a)
 
bool v_check_any (const v_int64 &a)
 
bool v_check_any (const v_int64x2 &a)
 
bool v_check_any (const v_int8 &a)
 
bool v_check_any (const v_int8x16 &a)
 
template<typename _Tp , int n>
bool v_check_any (const v_reg< _Tp, n > &a)
 Check if any of packed values is less than zero.
 
bool v_check_any (const v_uint16 &a)
 
bool v_check_any (const v_uint16x8 &a)
 
bool v_check_any (const v_uint32 &a)
 
bool v_check_any (const v_uint32x4 &a)
 
bool v_check_any (const v_uint64 &a)
 
bool v_check_any (const v_uint64x2 &a)
 
bool v_check_any (const v_uint8 &a)
 
bool v_check_any (const v_uint8x16 &a)
 
void v_cleanup ()
 
v_float32 v_combine_high (const v_float32 &a, const v_float32 &b)
 
v_float32x4 v_combine_high (const v_float32x4 &a, const v_float32x4 &b)
 
v_float64 v_combine_high (const v_float64 &a, const v_float64 &b)
 
v_float64x2 v_combine_high (const v_float64x2 &a, const v_float64x2 &b)
 
v_int16 v_combine_high (const v_int16 &a, const v_int16 &b)
 
v_int16x8 v_combine_high (const v_int16x8 &a, const v_int16x8 &b)
 
v_int32 v_combine_high (const v_int32 &a, const v_int32 &b)
 
v_int32x4 v_combine_high (const v_int32x4 &a, const v_int32x4 &b)
 
v_int8 v_combine_high (const v_int8 &a, const v_int8 &b)
 
v_int8x16 v_combine_high (const v_int8x16 &a, const v_int8x16 &b)
 
template<typename _Tp , int n>
v_reg< _Tp, n > v_combine_high (const v_reg< _Tp, n > &a, const v_reg< _Tp, n > &b)
 Combine vector from last elements of two vectors.
 
v_uint16 v_combine_high (const v_uint16 &a, const v_uint16 &b)
 
v_uint16x8 v_combine_high (const v_uint16x8 &a, const v_uint16x8 &b)
 
v_uint32 v_combine_high (const v_uint32 &a, const v_uint32 &b)
 
v_uint32x4 v_combine_high (const v_uint32x4 &a, const v_uint32x4 &b)
 
v_uint8 v_combine_high (const v_uint8 &a, const v_uint8 &b)
 
v_uint8x16 v_combine_high (const v_uint8x16 &a, const v_uint8x16 &b)
 
v_float32 v_combine_low (const v_float32 &a, const v_float32 &b)
 
v_float32x4 v_combine_low (const v_float32x4 &a, const v_float32x4 &b)
 
v_float64 v_combine_low (const v_float64 &a, const v_float64 &b)
 
v_float64x2 v_combine_low (const v_float64x2 &a, const v_float64x2 &b)
 
v_int16 v_combine_low (const v_int16 &a, const v_int16 &b)
 
v_int16x8 v_combine_low (const v_int16x8 &a, const v_int16x8 &b)
 
v_int32 v_combine_low (const v_int32 &a, const v_int32 &b)
 
v_int32x4 v_combine_low (const v_int32x4 &a, const v_int32x4 &b)
 
v_int8 v_combine_low (const v_int8 &a, const v_int8 &b)
 
v_int8x16 v_combine_low (const v_int8x16 &a, const v_int8x16 &b)
 
template<typename _Tp , int n>
v_reg< _Tp, n > v_combine_low (const v_reg< _Tp, n > &a, const v_reg< _Tp, n > &b)
 Combine vector from first elements of two vectors.
 
v_uint16 v_combine_low (const v_uint16 &a, const v_uint16 &b)
 
v_uint16x8 v_combine_low (const v_uint16x8 &a, const v_uint16x8 &b)
 
v_uint32 v_combine_low (const v_uint32 &a, const v_uint32 &b)
 
v_uint32x4 v_combine_low (const v_uint32x4 &a, const v_uint32x4 &b)
 
v_uint8 v_combine_low (const v_uint8 &a, const v_uint8 &b)
 
v_uint8x16 v_combine_low (const v_uint8x16 &a, const v_uint8x16 &b)
 
v_float32 v_cvt_f32 (const v_float64 &a)
 
v_float32 v_cvt_f32 (const v_float64 &a, const v_float64 &b)
 
v_float32x4 v_cvt_f32 (const v_float64x2 &a)
 
v_float32x4 v_cvt_f32 (const v_float64x2 &a, const v_float64x2 &b)
 
v_float32 v_cvt_f32 (const v_int32 &a)
 
v_float32x4 v_cvt_f32 (const v_int32x4 &a)
 
template<int n>
v_reg< float, n *2 > v_cvt_f32 (const v_reg< double, n > &a)
 Convert lower half to float.
 
template<int n>
v_reg< float, n *2 > v_cvt_f32 (const v_reg< double, n > &a, const v_reg< double, n > &b)
 Convert to float.
 
template<int n>
v_reg< float, n > v_cvt_f32 (const v_reg< int, n > &a)
 Convert to float.
 
v_float64 v_cvt_f64 (const v_float32 &a)
 
v_float64x2 v_cvt_f64 (const v_float32x4 &a)
 
v_float64 v_cvt_f64 (const v_int32 &a)
 
v_float64x2 v_cvt_f64 (const v_int32x4 &a)
 
v_float64 v_cvt_f64 (const v_int64 &a)
 
v_float64x2 v_cvt_f64 (const v_int64x2 &a)
 
template<int n>
v_reg< double,(n/2)> v_cvt_f64 (const v_reg< float, n > &a)
 Convert lower half to double.
 
template<int n>
v_reg< double, n/2 > v_cvt_f64 (const v_reg< int, n > &a)
 Convert lower half to double.
 
template<int n>
v_reg< double, n > v_cvt_f64 (const v_reg< int64, n > &a)
 Convert to double.
 
v_float64 v_cvt_f64_high (const v_float32 &a)
 
v_float64x2 v_cvt_f64_high (const v_float32x4 &a)
 
v_float64 v_cvt_f64_high (const v_int32 &a)
 
v_float64x2 v_cvt_f64_high (const v_int32x4 &a)
 
template<int n>
v_reg< double,(n/2)> v_cvt_f64_high (const v_reg< float, n > &a)
 Convert to double high part of vector.
 
template<int n>
v_reg< double,(n/2)> v_cvt_f64_high (const v_reg< int, n > &a)
 Convert to double high part of vector.
 
v_float32 v_div (const v_float32 &a, const v_float32 &b)
 
v_float64 v_div (const v_float64 &a, const v_float64 &b)
 
v_int32 v_dotprod (const v_int16 &a, const v_int16 &b)
 
v_int32 v_dotprod (const v_int16 &a, const v_int16 &b, const v_int32 &c)
 
v_int32x4 v_dotprod (const v_int16x8 &a, const v_int16x8 &b)
 
v_int32x4 v_dotprod (const v_int16x8 &a, const v_int16x8 &b, const v_int32x4 &c)
 
v_int64 v_dotprod (const v_int32 &a, const v_int32 &b)
 
v_int64 v_dotprod (const v_int32 &a, const v_int32 &b, const v_int64 &c)
 
v_int64x2 v_dotprod (const v_int32x4 &a, const v_int32x4 &b)
 
v_int64x2 v_dotprod (const v_int32x4 &a, const v_int32x4 &b, const v_int64x2 &c)
 
template<typename _Tp , int n>
v_reg< typename V_TypeTraits< _Tp >::w_type, n/2 > 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 > 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.
 
v_int64 v_dotprod_expand (const v_int16 &a, const v_int16 &b)
 
v_int64 v_dotprod_expand (const v_int16 &a, const v_int16 &b, const v_int64 &c)
 
v_int64x2 v_dotprod_expand (const v_int16x8 &a, const v_int16x8 &b)
 
v_int64x2 v_dotprod_expand (const v_int16x8 &a, const v_int16x8 &b, const v_int64x2 &c)
 
v_float64 v_dotprod_expand (const v_int32 &a, const v_int32 &b)
 
v_float64 v_dotprod_expand (const v_int32 &a, const v_int32 &b, const v_float64 &c)
 
v_float64x2 v_dotprod_expand (const v_int32x4 &a, const v_int32x4 &b)
 
v_float64x2 v_dotprod_expand (const v_int32x4 &a, const v_int32x4 &b, const v_float64x2 &c)
 
v_int32 v_dotprod_expand (const v_int8 &a, const v_int8 &b)
 
v_int32 v_dotprod_expand (const v_int8 &a, const v_int8 &b, const v_int32 &c)
 
v_int32x4 v_dotprod_expand (const v_int8x16 &a, const v_int8x16 &b)
 
v_int32x4 v_dotprod_expand (const v_int8x16 &a, const v_int8x16 &b, const v_int32x4 &c)
 
template<typename _Tp , int n>
v_reg< typename V_TypeTraits< _Tp >::q_type, n/4 > v_dotprod_expand (const v_reg< _Tp, n > &a, const v_reg< _Tp, n > &b)
 Dot product of elements and expand.
 
template<typename _Tp , int n>
v_reg< typename V_TypeTraits< _Tp >::q_type, n/4 > 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)
 Dot product of elements.
 
template<int n>
v_reg< double, n/2 > v_dotprod_expand (const v_reg< int, n > &a, const v_reg< int, n > &b)
 
template<int n>
v_reg< double, n/2 > v_dotprod_expand (const v_reg< int, n > &a, const v_reg< int, n > &b, const v_reg< double, n/2 > &c)
 
v_uint64 v_dotprod_expand (const v_uint16 &a, const v_uint16 &b)
 
v_uint64 v_dotprod_expand (const v_uint16 &a, const v_uint16 &b, const v_uint64 &c)
 
v_uint64x2 v_dotprod_expand (const v_uint16x8 &a, const v_uint16x8 &b)
 
v_uint64x2 v_dotprod_expand (const v_uint16x8 &a, const v_uint16x8 &b, const v_uint64x2 &c)
 
v_uint32 v_dotprod_expand (const v_uint8 &a, const v_uint8 &b)
 
v_uint32 v_dotprod_expand (const v_uint8 &a, const v_uint8 &b, const v_uint32 &c)
 
v_uint32x4 v_dotprod_expand (const v_uint8x16 &a, const v_uint8x16 &b)
 
v_uint32x4 v_dotprod_expand (const v_uint8x16 &a, const v_uint8x16 &b, const v_uint32x4 &c)
 
v_int64 v_dotprod_expand_fast (const v_int16 &a, const v_int16 &b)
 
v_int64 v_dotprod_expand_fast (const v_int16 &a, const v_int16 &b, const v_int64 &c)
 
v_int64x2 v_dotprod_expand_fast (const v_int16x8 &a, const v_int16x8 &b)
 
v_int64x2 v_dotprod_expand_fast (const v_int16x8 &a, const v_int16x8 &b, const v_int64x2 &c)
 
v_float64 v_dotprod_expand_fast (const v_int32 &a, const v_int32 &b)
 
v_float64 v_dotprod_expand_fast (const v_int32 &a, const v_int32 &b, const v_float64 &c)
 
v_float64x2 v_dotprod_expand_fast (const v_int32x4 &a, const v_int32x4 &b)
 
v_float64x2 v_dotprod_expand_fast (const v_int32x4 &a, const v_int32x4 &b, const v_float64x2 &c)
 
v_int32 v_dotprod_expand_fast (const v_int8 &a, const v_int8 &b)
 
v_int32 v_dotprod_expand_fast (const v_int8 &a, const v_int8 &b, const v_int32 &c)
 
v_int32x4 v_dotprod_expand_fast (const v_int8x16 &a, const v_int8x16 &b)
 
v_int32x4 v_dotprod_expand_fast (const v_int8x16 &a, const v_int8x16 &b, const v_int32x4 &c)
 
template<typename _Tp , int n>
v_reg< typename V_TypeTraits< _Tp >::q_type, n/4 > v_dotprod_expand_fast (const v_reg< _Tp, n > &a, const v_reg< _Tp, n > &b)
 Fast Dot product of elements and expand.
 
template<typename _Tp , int n>
v_reg< typename V_TypeTraits< _Tp >::q_type, n/4 > 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)
 Fast Dot product of elements.
 
template<int n>
v_reg< double, n/2 > v_dotprod_expand_fast (const v_reg< int, n > &a, const v_reg< int, n > &b)
 
template<int n>
v_reg< double, n/2 > v_dotprod_expand_fast (const v_reg< int, n > &a, const v_reg< int, n > &b, const v_reg< double, n/2 > &c)
 
v_uint64 v_dotprod_expand_fast (const v_uint16 &a, const v_uint16 &b)
 
v_uint64 v_dotprod_expand_fast (const v_uint16 &a, const v_uint16 &b, const v_uint64 &c)
 
v_uint64x2 v_dotprod_expand_fast (const v_uint16x8 &a, const v_uint16x8 &b)
 
v_uint64x2 v_dotprod_expand_fast (const v_uint16x8 &a, const v_uint16x8 &b, const v_uint64x2 &c)
 
v_uint32 v_dotprod_expand_fast (const v_uint8 &a, const v_uint8 &b)
 
v_uint32 v_dotprod_expand_fast (const v_uint8 &a, const v_uint8 &b, const v_uint32 &c)
 
v_uint32x4 v_dotprod_expand_fast (const v_uint8x16 &a, const v_uint8x16 &b)
 
v_uint32x4 v_dotprod_expand_fast (const v_uint8x16 &a, const v_uint8x16 &b, const v_uint32x4 &c)
 
v_int32 v_dotprod_fast (const v_int16 &a, const v_int16 &b)
 
v_int32 v_dotprod_fast (const v_int16 &a, const v_int16 &b, const v_int32 &c)
 
v_int32x4 v_dotprod_fast (const v_int16x8 &a, const v_int16x8 &b)
 
v_int32x4 v_dotprod_fast (const v_int16x8 &a, const v_int16x8 &b, const v_int32x4 &c)
 
v_int64 v_dotprod_fast (const v_int32 &a, const v_int32 &b)
 
v_int64 v_dotprod_fast (const v_int32 &a, const v_int32 &b, const v_int64 &c)
 
v_int64x2 v_dotprod_fast (const v_int32x4 &a, const v_int32x4 &b)
 
v_int64x2 v_dotprod_fast (const v_int32x4 &a, const v_int32x4 &b, const v_int64x2 &c)
 
template<typename _Tp , int n>
v_reg< typename V_TypeTraits< _Tp >::w_type, n/2 > v_dotprod_fast (const v_reg< _Tp, n > &a, const v_reg< _Tp, n > &b)
 Fast Dot product of elements.
 
template<typename _Tp , int n>
v_reg< typename V_TypeTraits< _Tp >::w_type, n/2 > 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)
 Fast Dot product of elements.
 
v_float32 v_eq (const v_float32 &a, const v_float32 &b)
 
v_float64 v_eq (const v_float64 &a, const v_float64 &b)
 
v_int16 v_eq (const v_int16 &a, const v_int16 &b)
 
v_int32 v_eq (const v_int32 &a, const v_int32 &b)
 
v_int64 v_eq (const v_int64 &a, const v_int64 &b)
 
v_int8 v_eq (const v_int8 &a, const v_int8 &b)
 
v_uint16 v_eq (const v_uint16 &a, const v_uint16 &b)
 
v_uint32 v_eq (const v_uint32 &a, const v_uint32 &b)
 
v_uint64 v_eq (const v_uint64 &a, const v_uint64 &b)
 
v_uint8 v_eq (const v_uint8 &a, const v_uint8 &b)
 
void v_expand (const v_int16 &a, v_int32 &b0, v_int32 &b1)
 
void v_expand (const v_int16x8 &a, v_int32x4 &b0, v_int32x4 &b1)
 
void v_expand (const v_int32 &a, v_int64 &b0, v_int64 &b1)
 
void v_expand (const v_int32x4 &a, v_int64x2 &b0, v_int64x2 &b1)
 
void v_expand (const v_int8 &a, v_int16 &b0, v_int16 &b1)
 
void v_expand (const v_int8x16 &a, v_int16x8 &b0, v_int16x8 &b1)
 
template<typename _Tp , int n>
void 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.
 
void v_expand (const v_uint16 &a, v_uint32 &b0, v_uint32 &b1)
 
void v_expand (const v_uint16x8 &a, v_uint32x4 &b0, v_uint32x4 &b1)
 
void v_expand (const v_uint32 &a, v_uint64 &b0, v_uint64 &b1)
 
void v_expand (const v_uint32x4 &a, v_uint64x2 &b0, v_uint64x2 &b1)
 
void v_expand (const v_uint8 &a, v_uint16 &b0, v_uint16 &b1)
 
void v_expand (const v_uint8x16 &a, v_uint16x8 &b0, v_uint16x8 &b1)
 
v_int32 v_expand_high (const v_int16 &a)
 
v_int32x4 v_expand_high (const v_int16x8 &a)
 
v_int64 v_expand_high (const v_int32 &a)
 
v_int64x2 v_expand_high (const v_int32x4 &a)
 
v_int16 v_expand_high (const v_int8 &a)
 
v_int16x8 v_expand_high (const v_int8x16 &a)
 
template<typename _Tp , int n>
v_reg< typename V_TypeTraits< _Tp >::w_type, n/2 > v_expand_high (const v_reg< _Tp, n > &a)
 Expand higher values to the wider pack type.
 
v_uint32 v_expand_high (const v_uint16 &a)
 
v_uint32x4 v_expand_high (const v_uint16x8 &a)
 
v_uint64 v_expand_high (const v_uint32 &a)
 
v_uint64x2 v_expand_high (const v_uint32x4 &a)
 
v_uint16 v_expand_high (const v_uint8 &a)
 
v_uint16x8 v_expand_high (const v_uint8x16 &a)
 
v_int32 v_expand_low (const v_int16 &a)
 
v_int32x4 v_expand_low (const v_int16x8 &a)
 
v_int64 v_expand_low (const v_int32 &a)
 
v_int64x2 v_expand_low (const v_int32x4 &a)
 
v_int16 v_expand_low (const v_int8 &a)
 
v_int16x8 v_expand_low (const v_int8x16 &a)
 
template<typename _Tp , int n>
v_reg< typename V_TypeTraits< _Tp >::w_type, n/2 > v_expand_low (const v_reg< _Tp, n > &a)
 Expand lower values to the wider pack type.
 
v_uint32 v_expand_low (const v_uint16 &a)
 
v_uint32x4 v_expand_low (const v_uint16x8 &a)
 
v_uint64 v_expand_low (const v_uint32 &a)
 
v_uint64x2 v_expand_low (const v_uint32x4 &a)
 
v_uint16 v_expand_low (const v_uint8 &a)
 
v_uint16x8 v_expand_low (const v_uint8x16 &a)
 
template<int s = 0>
v_float32 v_extract (const v_float32 &a, const v_float32 &b, int i=s)
 
template<int s>
v_float32x4 v_extract (const v_float32x4 &a, const v_float32x4 &b)
 
template<int s = 0>
v_float64 v_extract (const v_float64 &a, const v_float64 &b, int i=s)
 
template<int s>
v_float64x2 v_extract (const v_float64x2 &a, const v_float64x2 &b)
 
template<int s = 0>
v_int16 v_extract (const v_int16 &a, const v_int16 &b, int i=s)
 
template<int s>
v_int16x8 v_extract (const v_int16x8 &a, const v_int16x8 &b)
 
template<int s = 0>
v_int32 v_extract (const v_int32 &a, const v_int32 &b, int i=s)
 
template<int s>
v_int32x4 v_extract (const v_int32x4 &a, const v_int32x4 &b)
 
template<int s = 0>
v_int64 v_extract (const v_int64 &a, const v_int64 &b, int i=s)
 
template<int s>
v_int64x2 v_extract (const v_int64x2 &a, const v_int64x2 &b)
 
template<int s = 0>
v_int8 v_extract (const v_int8 &a, const v_int8 &b, int i=s)
 
template<int s>
v_int8x16 v_extract (const v_int8x16 &a, const v_int8x16 &b)
 
template<int s, typename _Tp , int n>
v_reg< _Tp, n > v_extract (const v_reg< _Tp, n > &a, const v_reg< _Tp, n > &b)
 Vector extract.
 
template<int s = 0>
v_uint16 v_extract (const v_uint16 &a, const v_uint16 &b, int i=s)
 
template<int s>
v_uint16x8 v_extract (const v_uint16x8 &a, const v_uint16x8 &b)
 
template<int s = 0>
v_uint32 v_extract (const v_uint32 &a, const v_uint32 &b, int i=s)
 
template<int s>
v_uint32x4 v_extract (const v_uint32x4 &a, const v_uint32x4 &b)
 
template<int s = 0>
v_uint64 v_extract (const v_uint64 &a, const v_uint64 &b, int i=s)
 
template<int s>
v_uint64x2 v_extract (const v_uint64x2 &a, const v_uint64x2 &b)
 
template<int s = 0>
v_uint8 v_extract (const v_uint8 &a, const v_uint8 &b, int i=s)
 
template<int s>
v_uint8x16 v_extract (const v_uint8x16 &a, const v_uint8x16 &b)
 
float v_extract_highest (v_float32 v)
 
double v_extract_highest (v_float64 v)
 
short v_extract_highest (v_int16 v)
 
int v_extract_highest (v_int32 v)
 
int64 v_extract_highest (v_int64 v)
 
schar v_extract_highest (v_int8 v)
 
ushort v_extract_highest (v_uint16 v)
 
unsigned int v_extract_highest (v_uint32 v)
 
uint64 v_extract_highest (v_uint64 v)
 
uchar v_extract_highest (v_uint8 v)
 
template<int s, typename _Tp , int n>
_Tp v_extract_n (const v_reg< _Tp, n > &v)
 Vector extract.
 
template<int s = 0>
float v_extract_n (v_float32 v, int i=s)
 
template<int i>
float v_extract_n (v_float32x4 v)
 
template<int s = 0>
double v_extract_n (v_float64 v, int i=s)
 
template<int i>
double v_extract_n (v_float64x2 v)
 
template<int s = 0>
short v_extract_n (v_int16 v, int i=s)
 
template<int i>
short v_extract_n (v_int16x8 v)
 
template<int s = 0>
int v_extract_n (v_int32 v, int i=s)
 
template<int i>
int v_extract_n (v_int32x4 v)
 
template<int s = 0>
int64 v_extract_n (v_int64 v, int i=s)
 
template<int i>
int64 v_extract_n (v_int64x2 v)
 
template<int s = 0>
schar v_extract_n (v_int8 v, int i=s)
 
template<int i>
schar v_extract_n (v_int8x16 v)
 
template<int s = 0>
ushort v_extract_n (v_uint16 v, int i=s)
 
template<int i>
ushort v_extract_n (v_uint16x8 v)
 
template<int s = 0>
unsigned int v_extract_n (v_uint32 v, int i=s)
 
template<int i>
uint v_extract_n (v_uint32x4 v)
 
template<int s = 0>
uint64 v_extract_n (v_uint64 v, int i=s)
 
template<int i>
uint64 v_extract_n (v_uint64x2 v)
 
template<int s = 0>
uchar v_extract_n (v_uint8 v, int i=s)
 
template<int i>
uchar v_extract_n (v_uint8x16 v)
 
v_int32 v_floor (const v_float32 &a)
 
v_int32x4 v_floor (const v_float32x4 &a)
 
v_int32 v_floor (const v_float64 &a)
 
v_int32x4 v_floor (const v_float64x2 &a)
 
template<int n>
v_reg< int, n *2 > v_floor (const v_reg< double, n > &a)
 
template<int n>
v_reg< int, n > v_floor (const v_reg< float, n > &a)
 Floor elements.
 
v_float32 v_fma (const v_float32 &a, const v_float32 &b, const v_float32 &c)
 
v_float32x4 v_fma (const v_float32x4 &a, const v_float32x4 &b, const v_float32x4 &c)
 
v_float64 v_fma (const v_float64 &a, const v_float64 &b, const v_float64 &c)
 
v_float64x2 v_fma (const v_float64x2 &a, const v_float64x2 &b, const v_float64x2 &c)
 
v_int32 v_fma (const v_int32 &a, const v_int32 &b, const v_int32 &c)
 
v_int32x4 v_fma (const v_int32x4 &a, const v_int32x4 &b, const v_int32x4 &c)
 
template<typename _Tp , int n>
v_reg< _Tp, n > v_fma (const v_reg< _Tp, n > &a, const v_reg< _Tp, n > &b, const v_reg< _Tp, n > &c)
 Multiply and add.
 
v_float32 v_ge (const v_float32 &a, const v_float32 &b)
 
v_float64 v_ge (const v_float64 &a, const v_float64 &b)
 
v_int16 v_ge (const v_int16 &a, const v_int16 &b)
 
v_int32 v_ge (const v_int32 &a, const v_int32 &b)
 
v_int64 v_ge (const v_int64 &a, const v_int64 &b)
 
v_int8 v_ge (const v_int8 &a, const v_int8 &b)
 
v_uint16 v_ge (const v_uint16 &a, const v_uint16 &b)
 
v_uint32 v_ge (const v_uint32 &a, const v_uint32 &b)
 
v_uint64 v_ge (const v_uint64 &a, const v_uint64 &b)
 
v_uint8 v_ge (const v_uint8 &a, const v_uint8 &b)
 
float v_get0 (const v_float32 &v)
 
double v_get0 (const v_float64 &v)
 
short v_get0 (const v_int16 &v)
 
int v_get0 (const v_int32 &v)
 
int64 v_get0 (const v_int64 &v)
 
schar v_get0 (const v_int8 &v)
 
ushort v_get0 (const v_uint16 &v)
 
unsigned v_get0 (const v_uint32 &v)
 
uint64 v_get0 (const v_uint64 &v)
 
uchar v_get0 (const v_uint8 &v)
 
v_float32 v_gt (const v_float32 &a, const v_float32 &b)
 
v_float64 v_gt (const v_float64 &a, const v_float64 &b)
 
v_int16 v_gt (const v_int16 &a, const v_int16 &b)
 
v_int32 v_gt (const v_int32 &a, const v_int32 &b)
 
v_int64 v_gt (const v_int64 &a, const v_int64 &b)
 
v_int8 v_gt (const v_int8 &a, const v_int8 &b)
 
v_uint16 v_gt (const v_uint16 &a, const v_uint16 &b)
 
v_uint32 v_gt (const v_uint32 &a, const v_uint32 &b)
 
v_uint64 v_gt (const v_uint64 &a, const v_uint64 &b)
 
v_uint8 v_gt (const v_uint8 &a, const v_uint8 &b)
 
static v_int32 v_hadd (v_int16 a)
 
static v_int64 v_hadd (v_int32 a)
 
static v_int16 v_hadd (v_int8 a)
 
static v_uint32 v_hadd (v_uint16 a)
 
static v_uint64 v_hadd (v_uint32 a)
 
static v_uint16 v_hadd (v_uint8 a)
 
static v_int32 v_hadd (vint32m2_t a)
 
static v_int64 v_hadd (vint64m2_t a)
 
v_float32 v_interleave_pairs (const v_float32 &vec)
 
v_float32x4 v_interleave_pairs (const v_float32x4 &vec)
 
v_float64x2 v_interleave_pairs (const v_float64x2 &vec)
 
v_int16 v_interleave_pairs (const v_int16 &vec)
 
v_int16x8 v_interleave_pairs (const v_int16x8 &vec)
 
v_int32 v_interleave_pairs (const v_int32 &vec)
 
v_int32x4 v_interleave_pairs (const v_int32x4 &vec)
 
v_int64x2 v_interleave_pairs (const v_int64x2 &vec)
 
v_int8 v_interleave_pairs (const v_int8 &vec)
 
v_int8x16 v_interleave_pairs (const v_int8x16 &vec)
 
template<typename _Tp , int n>
v_reg< _Tp, n > v_interleave_pairs (const v_reg< _Tp, n > &vec)
 
v_uint16 v_interleave_pairs (const v_uint16 &vec)
 
v_uint16x8 v_interleave_pairs (const v_uint16x8 &vec)
 
v_uint32 v_interleave_pairs (const v_uint32 &vec)
 
v_uint32x4 v_interleave_pairs (const v_uint32x4 &vec)
 
v_uint64x2 v_interleave_pairs (const v_uint64x2 &vec)
 
v_uint8 v_interleave_pairs (const v_uint8 &vec)
 
v_uint8x16 v_interleave_pairs (const v_uint8x16 &vec)
 
v_float32 v_interleave_quads (const v_float32 &vec)
 
v_float32x4 v_interleave_quads (const v_float32x4 &vec)
 
v_float64x2 v_interleave_quads (const v_float64x2 &vec)
 
v_int16 v_interleave_quads (const v_int16 &vec)
 
v_int16x8 v_interleave_quads (const v_int16x8 &vec)
 
v_int32 v_interleave_quads (const v_int32 &vec)
 
v_int32x4 v_interleave_quads (const v_int32x4 &vec)
 
v_int64x2 v_interleave_quads (const v_int64x2 &vec)
 
v_int8 v_interleave_quads (const v_int8 &vec)
 
v_int8x16 v_interleave_quads (const v_int8x16 &vec)
 
template<typename _Tp , int n>
v_reg< _Tp, n > v_interleave_quads (const v_reg< _Tp, n > &vec)
 
v_uint16 v_interleave_quads (const v_uint16 &vec)
 
v_uint16x8 v_interleave_quads (const v_uint16x8 &vec)
 
v_uint32 v_interleave_quads (const v_uint32 &vec)
 
v_uint32x4 v_interleave_quads (const v_uint32x4 &vec)
 
v_uint64x2 v_interleave_quads (const v_uint64x2 &vec)
 
v_uint8 v_interleave_quads (const v_uint8 &vec)
 
v_uint8x16 v_interleave_quads (const v_uint8x16 &vec)
 
v_float32 v_invsqrt (const v_float32 &x)
 
v_float32x4 v_invsqrt (const v_float32x4 &x)
 
v_float64 v_invsqrt (const v_float64 &x)
 
v_float64x2 v_invsqrt (const v_float64x2 &x)
 
template<typename _Tp , int n>
v_reg< _Tp, n > v_invsqrt (const v_reg< _Tp, n > &a)
 Inversed square root.
 
v_float32 v_le (const v_float32 &a, const v_float32 &b)
 
v_float64 v_le (const v_float64 &a, const v_float64 &b)
 
v_int16 v_le (const v_int16 &a, const v_int16 &b)
 
v_int32 v_le (const v_int32 &a, const v_int32 &b)
 
v_int64 v_le (const v_int64 &a, const v_int64 &b)
 
v_int8 v_le (const v_int8 &a, const v_int8 &b)
 
v_uint16 v_le (const v_uint16 &a, const v_uint16 &b)
 
v_uint32 v_le (const v_uint32 &a, const v_uint32 &b)
 
v_uint64 v_le (const v_uint64 &a, const v_uint64 &b)
 
v_uint8 v_le (const v_uint8 &a, const v_uint8 &b)
 
template<typename _Tp >
v_reg< _Tp, simd128_width/sizeof(_Tp)> v_load (const _Tp *ptr)
 Load register contents from memory.
 
v_float64x2 v_load (const double *ptr)
 
v_float32x4 v_load (const float *ptr)
 
v_int32x4 v_load (const int *ptr)
 
v_int64x2 v_load (const int64 *ptr)
 
v_int8x16 v_load (const schar *ptr)
 
v_int16x8 v_load (const short *ptr)
 
v_uint8x16 v_load (const uchar *ptr)
 
v_uint64x2 v_load (const uint64 *ptr)
 
v_uint32x4 v_load (const unsigned *ptr)
 
v_uint32 v_load (const unsigned int *ptr)
 
v_uint16x8 v_load (const ushort *ptr)
 
v_float64 v_load (std::initializer_list< double > nScalars)
 
v_float32 v_load (std::initializer_list< float > nScalars)
 
v_int32 v_load (std::initializer_list< int > nScalars)
 
v_int64 v_load (std::initializer_list< int64 > nScalars)
 
v_int8 v_load (std::initializer_list< schar > nScalars)
 
v_int16 v_load (std::initializer_list< short > nScalars)
 
v_uint8 v_load (std::initializer_list< uchar > nScalars)
 
v_uint64 v_load (std::initializer_list< uint64 > nScalars)
 
v_uint32 v_load (std::initializer_list< unsigned int > nScalars)
 
v_uint16 v_load (std::initializer_list< ushort > nScalars)
 
template<typename _Tp >
v_reg< _Tp, simd128_width/sizeof(_Tp)> v_load_aligned (const _Tp *ptr)
 Load register contents from memory (aligned)
 
v_float64x2 v_load_aligned (const double *ptr)
 
v_float32x4 v_load_aligned (const float *ptr)
 
v_int32x4 v_load_aligned (const int *ptr)
 
v_int64x2 v_load_aligned (const int64 *ptr)
 
v_int8x16 v_load_aligned (const schar *ptr)
 
v_int16x8 v_load_aligned (const short *ptr)
 
v_uint8x16 v_load_aligned (const uchar *ptr)
 
v_uint64x2 v_load_aligned (const uint64 *ptr)
 
v_uint32x4 v_load_aligned (const unsigned *ptr)
 
v_uint32 v_load_aligned (const unsigned int *ptr)
 
v_uint16x8 v_load_aligned (const ushort *ptr)
 
template<typename _Tp , int n>
void 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 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 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)
 
void v_load_deinterleave (const double *ptr, v_float64 &a, v_float64 &b)
 
void v_load_deinterleave (const double *ptr, v_float64 &a, v_float64 &b, v_float64 &c)
 
void v_load_deinterleave (const double *ptr, v_float64 &a, v_float64 &b, v_float64 &c, v_float64 &d)
 
void v_load_deinterleave (const double *ptr, v_float64x2 &a, v_float64x2 &b)
 
void v_load_deinterleave (const double *ptr, v_float64x2 &a, v_float64x2 &b, v_float64x2 &c)
 
void v_load_deinterleave (const double *ptr, v_float64x2 &a, v_float64x2 &b, v_float64x2 &c, v_float64x2 &d)
 
void v_load_deinterleave (const float *ptr, v_float32 &a, v_float32 &b)
 
void v_load_deinterleave (const float *ptr, v_float32 &a, v_float32 &b, v_float32 &c)
 
void v_load_deinterleave (const float *ptr, v_float32 &a, v_float32 &b, v_float32 &c, v_float32 &d)
 
void v_load_deinterleave (const float *ptr, v_float32x4 &a, v_float32x4 &b)
 
void v_load_deinterleave (const float *ptr, v_float32x4 &a, v_float32x4 &b, v_float32x4 &c)
 
void v_load_deinterleave (const float *ptr, v_float32x4 &a, v_float32x4 &b, v_float32x4 &c, v_float32x4 &d)
 
void v_load_deinterleave (const int *ptr, v_int32 &a, v_int32 &b)
 
void v_load_deinterleave (const int *ptr, v_int32 &a, v_int32 &b, v_int32 &c)
 
void v_load_deinterleave (const int *ptr, v_int32 &a, v_int32 &b, v_int32 &c, v_int32 &d)
 
void v_load_deinterleave (const int *ptr, v_int32x4 &a, v_int32x4 &b)
 
void v_load_deinterleave (const int *ptr, v_int32x4 &a, v_int32x4 &b, v_int32x4 &c)
 
void v_load_deinterleave (const int *ptr, v_int32x4 &a, v_int32x4 &b, v_int32x4 &c, v_int32x4 &d)
 
void v_load_deinterleave (const int64 *ptr, v_int64 &a, v_int64 &b)
 
void v_load_deinterleave (const int64 *ptr, v_int64 &a, v_int64 &b, v_int64 &c)
 
void v_load_deinterleave (const int64 *ptr, v_int64 &a, v_int64 &b, v_int64 &c, v_int64 &d)
 
void v_load_deinterleave (const int64 *ptr, v_int64x2 &a, v_int64x2 &b)
 
void v_load_deinterleave (const int64 *ptr, v_int64x2 &a, v_int64x2 &b, v_int64x2 &c)
 
void v_load_deinterleave (const int64 *ptr, v_int64x2 &a, v_int64x2 &b, v_int64x2 &c, v_int64x2 &d)
 
void v_load_deinterleave (const schar *ptr, v_int8 &a, v_int8 &b)
 
void v_load_deinterleave (const schar *ptr, v_int8 &a, v_int8 &b, v_int8 &c)
 
void v_load_deinterleave (const schar *ptr, v_int8 &a, v_int8 &b, v_int8 &c, v_int8 &d)
 
void v_load_deinterleave (const schar *ptr, v_int8x16 &a, v_int8x16 &b)
 
void v_load_deinterleave (const schar *ptr, v_int8x16 &a, v_int8x16 &b, v_int8x16 &c)
 
void v_load_deinterleave (const schar *ptr, v_int8x16 &a, v_int8x16 &b, v_int8x16 &c, v_int8x16 &d)
 
void v_load_deinterleave (const short *ptr, v_int16 &a, v_int16 &b)
 
void v_load_deinterleave (const short *ptr, v_int16 &a, v_int16 &b, v_int16 &c)
 
void v_load_deinterleave (const short *ptr, v_int16 &a, v_int16 &b, v_int16 &c, v_int16 &d)
 
void v_load_deinterleave (const short *ptr, v_int16x8 &a, v_int16x8 &b)
 
void v_load_deinterleave (const short *ptr, v_int16x8 &a, v_int16x8 &b, v_int16x8 &c)
 
void v_load_deinterleave (const short *ptr, v_int16x8 &a, v_int16x8 &b, v_int16x8 &c, v_int16x8 &d)
 
void v_load_deinterleave (const uchar *ptr, v_uint8 &a, v_uint8 &b)
 
void v_load_deinterleave (const uchar *ptr, v_uint8 &a, v_uint8 &b, v_uint8 &c)
 
void v_load_deinterleave (const uchar *ptr, v_uint8 &a, v_uint8 &b, v_uint8 &c, v_uint8 &d)
 
void v_load_deinterleave (const uchar *ptr, v_uint8x16 &a, v_uint8x16 &b)
 
void v_load_deinterleave (const uchar *ptr, v_uint8x16 &a, v_uint8x16 &b, v_uint8x16 &c)
 
void v_load_deinterleave (const uchar *ptr, v_uint8x16 &a, v_uint8x16 &b, v_uint8x16 &c, v_uint8x16 &d)
 
void v_load_deinterleave (const uint64 *ptr, v_uint64 &a, v_uint64 &b)
 
void v_load_deinterleave (const uint64 *ptr, v_uint64 &a, v_uint64 &b, v_uint64 &c)
 
void v_load_deinterleave (const uint64 *ptr, v_uint64 &a, v_uint64 &b, v_uint64 &c, v_uint64 &d)
 
void v_load_deinterleave (const uint64 *ptr, v_uint64x2 &a, v_uint64x2 &b)
 
void v_load_deinterleave (const uint64 *ptr, v_uint64x2 &a, v_uint64x2 &b, v_uint64x2 &c)
 
void v_load_deinterleave (const uint64 *ptr, v_uint64x2 &a, v_uint64x2 &b, v_uint64x2 &c, v_uint64x2 &d)
 
void v_load_deinterleave (const unsigned *ptr, v_uint32 &a, v_uint32 &b)
 
void v_load_deinterleave (const unsigned *ptr, v_uint32 &a, v_uint32 &b, v_uint32 &c)
 
void v_load_deinterleave (const unsigned *ptr, v_uint32 &a, v_uint32 &b, v_uint32 &c, v_uint32 &d)
 
void v_load_deinterleave (const unsigned *ptr, v_uint32x4 &a, v_uint32x4 &b)
 
void v_load_deinterleave (const unsigned *ptr, v_uint32x4 &a, v_uint32x4 &b, v_uint32x4 &c)
 
void v_load_deinterleave (const unsigned *ptr, v_uint32x4 &a, v_uint32x4 &b, v_uint32x4 &c, v_uint32x4 &d)
 
void v_load_deinterleave (const ushort *ptr, v_uint16 &a, v_uint16 &b)
 
void v_load_deinterleave (const ushort *ptr, v_uint16 &a, v_uint16 &b, v_uint16 &c)
 
void v_load_deinterleave (const ushort *ptr, v_uint16 &a, v_uint16 &b, v_uint16 &c, v_uint16 &d)
 
void v_load_deinterleave (const ushort *ptr, v_uint16x8 &a, v_uint16x8 &b)
 
void v_load_deinterleave (const ushort *ptr, v_uint16x8 &a, v_uint16x8 &b, v_uint16x8 &c)
 
void v_load_deinterleave (const ushort *ptr, v_uint16x8 &a, v_uint16x8 &b, v_uint16x8 &c, v_uint16x8 &d)
 
template<typename _Tp >
v_reg< typename V_TypeTraits< _Tp >::w_type, simd128_width/sizeof(typename V_TypeTraits< _Tp >::w_type)> v_load_expand (const _Tp *ptr)
 Load register contents from memory with double expand.
 
v_reg< float, simd128_width/sizeof(float)> v_load_expand (const float16_t *ptr)
 
v_int64x2 v_load_expand (const int *ptr)
 
v_int16x8 v_load_expand (const schar *ptr)
 
v_int32x4 v_load_expand (const short *ptr)
 
v_uint16x8 v_load_expand (const uchar *ptr)
 
v_uint64x2 v_load_expand (const uint *ptr)
 
v_uint32x4 v_load_expand (const ushort *ptr)
 
template<typename _Tp >
v_reg< typename V_TypeTraits< _Tp >::q_type, simd128_width/sizeof(typename V_TypeTraits< _Tp >::q_type)> v_load_expand_q (const _Tp *ptr)
 Load register contents from memory with quad expand.
 
v_int32x4 v_load_expand_q (const schar *ptr)
 
v_uint32x4 v_load_expand_q (const uchar *ptr)
 
template<typename... Targs>
v_float32 v_load_f32 (Targs... nScalars)
 
template<typename... Targs>
v_float64 v_load_f64 (Targs... nScalars)
 
template<typename _Tp >
v_reg< _Tp, simd128_width/sizeof(_Tp)> v_load_halves (const _Tp *loptr, const _Tp *hiptr)
 Load register contents from two memory blocks.
 
v_float64x2 v_load_halves (const double *ptr0, const double *ptr1)
 
v_float32x4 v_load_halves (const float *ptr0, const float *ptr1)
 
v_int32x4 v_load_halves (const int *ptr0, const int *ptr1)
 
v_int64x2 v_load_halves (const int64 *ptr0, const int64 *ptr1)
 
v_int8x16 v_load_halves (const schar *ptr0, const schar *ptr1)
 
v_int16x8 v_load_halves (const short *ptr0, const short *ptr1)
 
v_uint8x16 v_load_halves (const uchar *ptr0, const uchar *ptr1)
 
v_uint64x2 v_load_halves (const uint64 *ptr0, const uint64 *ptr1)
 
v_uint32x4 v_load_halves (const unsigned *ptr0, const unsigned *ptr1)
 
v_uint32 v_load_halves (const unsigned int *ptr0, const unsigned int *ptr1)
 
v_uint16x8 v_load_halves (const ushort *ptr0, const ushort *ptr1)
 
template<typename... Targs>
v_int16 v_load_i16 (Targs... nScalars)
 
template<typename... Targs>
v_int32 v_load_i32 (Targs... nScalars)
 
template<typename... Targs>
v_int64 v_load_i64 (Targs... nScalars)
 
template<typename... Targs>
v_int8 v_load_i8 (Targs... nScalars)
 
template<typename _Tp >
v_reg< _Tp, simd128_width/sizeof(_Tp)> v_load_low (const _Tp *ptr)
 Load 64-bits of data to lower part (high part is undefined).
 
v_float64x2 v_load_low (const double *ptr)
 
v_float32x4 v_load_low (const float *ptr)
 
v_int32x4 v_load_low (const int *ptr)
 
v_int64x2 v_load_low (const int64 *ptr)
 
v_int8x16 v_load_low (const schar *ptr)
 
v_int16x8 v_load_low (const short *ptr)
 
v_uint8x16 v_load_low (const uchar *ptr)
 
v_uint64x2 v_load_low (const uint64 *ptr)
 
v_uint32x4 v_load_low (const unsigned *ptr)
 
v_uint32 v_load_low (const unsigned int *ptr)
 
v_uint16x8 v_load_low (const ushort *ptr)
 
template<typename... Targs>
v_uint16 v_load_u16 (Targs... nScalars)
 
template<typename... Targs>
v_uint32 v_load_u32 (Targs... nScalars)
 
template<typename... Targs>
v_uint64 v_load_u64 (Targs... nScalars)
 
template<typename... Targs>
v_uint8 v_load_u8 (Targs... nScalars)
 
v_float32 v_lt (const v_float32 &a, const v_float32 &b)
 
v_float64 v_lt (const v_float64 &a, const v_float64 &b)
 
v_int16 v_lt (const v_int16 &a, const v_int16 &b)
 
v_int32 v_lt (const v_int32 &a, const v_int32 &b)
 
v_int64 v_lt (const v_int64 &a, const v_int64 &b)
 
v_int8 v_lt (const v_int8 &a, const v_int8 &b)
 
v_uint16 v_lt (const v_uint16 &a, const v_uint16 &b)
 
v_uint32 v_lt (const v_uint32 &a, const v_uint32 &b)
 
v_uint64 v_lt (const v_uint64 &a, const v_uint64 &b)
 
v_uint8 v_lt (const v_uint8 &a, const v_uint8 &b)
 
template<typename _Tp >
v_reg< _Tp, simd128_width/sizeof(_Tp)> v_lut (const _Tp *tab, const int *idx)
 
v_float64x2 v_lut (const double *tab, const int *idx)
 
v_float64 v_lut (const double *tab, const v_int32 &vidx)
 
v_float64x2 v_lut (const double *tab, const v_int32x4 &idxvec)
 
template<int n>
v_reg< double, n/2 > v_lut (const double *tab, const v_reg< int, n > &idx)
 
v_float32x4 v_lut (const float *tab, const int *idx)
 
v_float32 v_lut (const float *tab, const v_int32 &vidx)
 
v_float32x4 v_lut (const float *tab, const v_int32x4 &idxvec)
 
template<int n>
v_reg< float, n > v_lut (const float *tab, const v_reg< int, n > &idx)
 
v_int32x4 v_lut (const int *tab, const int *idx)
 
v_int32 v_lut (const int *tab, const v_int32 &vidx)
 
v_int32x4 v_lut (const int *tab, const v_int32x4 &idxvec)
 
template<int n>
v_reg< int, n > v_lut (const int *tab, const v_reg< int, n > &idx)
 
v_int64x2 v_lut (const int64_t *tab, const int *idx)
 
v_int8x16 v_lut (const schar *tab, const int *idx)
 
v_int16x8 v_lut (const short *tab, const int *idx)
 
v_uint8x16 v_lut (const uchar *tab, const int *idx)
 
v_uint64x2 v_lut (const uint64 *tab, const int *idx)
 
v_uint32x4 v_lut (const unsigned *tab, const int *idx)
 
v_uint32 v_lut (const unsigned *tab, const v_int32 &vidx)
 
v_uint32x4 v_lut (const unsigned *tab, const v_int32x4 &idxvec)
 
template<int n>
v_reg< unsigned, n > v_lut (const unsigned *tab, const v_reg< int, n > &idx)
 
v_uint16x8 v_lut (const ushort *tab, const int *idx)
 
void v_lut_deinterleave (const double *tab, const v_int32x4 &idxvec, v_float64x2 &x, v_float64x2 &y)
 
template<int n>
void v_lut_deinterleave (const double *tab, const v_reg< int, n *2 > &idx, v_reg< double, n > &x, v_reg< double, n > &y)
 
void v_lut_deinterleave (const float *tab, const v_int32x4 &idxvec, v_float32x4 &x, v_float32x4 &y)
 
template<int n>
void 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)> v_lut_pairs (const _Tp *tab, const int *idx)
 
v_float64x2 v_lut_pairs (const double *tab, const int *idx)
 
v_float32x4 v_lut_pairs (const float *tab, const int *idx)
 
v_int32x4 v_lut_pairs (const int *tab, const int *idx)
 
v_int64x2 v_lut_pairs (const int64 *tab, const int *idx)
 
v_int64 v_lut_pairs (const int64_t *tab, const int *idx)
 
v_int8x16 v_lut_pairs (const schar *tab, const int *idx)
 
v_int16x8 v_lut_pairs (const short *tab, const int *idx)
 
v_uint8x16 v_lut_pairs (const uchar *tab, const int *idx)
 
v_uint64x2 v_lut_pairs (const uint64 *tab, const int *idx)
 
v_uint32x4 v_lut_pairs (const unsigned *tab, const int *idx)
 
v_uint16x8 v_lut_pairs (const ushort *tab, const int *idx)
 
template<typename _Tp >
v_reg< _Tp, simd128_width/sizeof(_Tp)> v_lut_quads (const _Tp *tab, const int *idx)
 
v_float64 v_lut_quads (const double *tab, const int *idx)
 
v_float32x4 v_lut_quads (const float *tab, const int *idx)
 
v_int32x4 v_lut_quads (const int *tab, const int *idx)
 
v_int64 v_lut_quads (const int64_t *tab, const int *idx)
 
v_int8x16 v_lut_quads (const schar *tab, const int *idx)
 
v_int16x8 v_lut_quads (const short *tab, const int *idx)
 
v_uint8x16 v_lut_quads (const uchar *tab, const int *idx)
 
v_uint64 v_lut_quads (const uint64 *tab, const int *idx)
 
v_uint32x4 v_lut_quads (const unsigned *tab, const int *idx)
 
v_uint16x8 v_lut_quads (const ushort *tab, const int *idx)
 
v_float32 v_magnitude (const v_float32 &a, const v_float32 &b)
 
v_float32x4 v_magnitude (const v_float32x4 &a, const v_float32x4 &b)
 
v_float64 v_magnitude (const v_float64 &a, const v_float64 &b)
 
v_float64x2 v_magnitude (const v_float64x2 &a, const v_float64x2 &b)
 
template<typename _Tp , int n>
v_reg< _Tp, n > v_magnitude (const v_reg< _Tp, n > &a, const v_reg< _Tp, n > &b)
 Magnitude.
 
v_float32 v_matmul (const v_float32 &v, const v_float32 &m0, const v_float32 &m1, const v_float32 &m2, const v_float32 &m3)
 
v_float32x4 v_matmul (const v_float32x4 &v, const v_float32x4 &m0, const v_float32x4 &m1, const v_float32x4 &m2, const v_float32x4 &m3)
 
template<int n>
v_reg< float, n > 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)
 Matrix multiplication.
 
v_float32 v_matmuladd (const v_float32 &v, const v_float32 &m0, const v_float32 &m1, const v_float32 &m2, const v_float32 &a)
 
v_float32x4 v_matmuladd (const v_float32x4 &v, const v_float32x4 &m0, const v_float32x4 &m1, const v_float32x4 &m2, const v_float32x4 &a)
 
template<int n>
v_reg< float, n > 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)
 Matrix multiplication and add.
 
v_float32 v_max (const v_float32 &a, const v_float32 &b)
 
v_float32x4 v_max (const v_float32x4 &a, const v_float32x4 &b)
 
v_float64 v_max (const v_float64 &a, const v_float64 &b)
 
v_float64x2 v_max (const v_float64x2 &a, const v_float64x2 &b)
 
v_int16 v_max (const v_int16 &a, const v_int16 &b)
 
v_int16x8 v_max (const v_int16x8 &a, const v_int16x8 &b)
 
v_int32 v_max (const v_int32 &a, const v_int32 &b)
 
v_int32x4 v_max (const v_int32x4 &a, const v_int32x4 &b)
 
v_int64x2 v_max (const v_int64x2 &a, const v_int64x2 &b)
 
v_int8 v_max (const v_int8 &a, const v_int8 &b)
 
v_int8x16 v_max (const v_int8x16 &a, const v_int8x16 &b)
 
template<typename _Tp , int n>
v_reg< _Tp, n > v_max (const v_reg< _Tp, n > &a, const v_reg< _Tp, n > &b)
 Choose max values for each pair.
 
v_uint16 v_max (const v_uint16 &a, const v_uint16 &b)
 
v_uint16x8 v_max (const v_uint16x8 &a, const v_uint16x8 &b)
 
v_uint32 v_max (const v_uint32 &a, const v_uint32 &b)
 
v_uint32x4 v_max (const v_uint32x4 &a, const v_uint32x4 &b)
 
v_uint64x2 v_max (const v_uint64x2 &a, const v_uint64x2 &b)
 
v_uint8 v_max (const v_uint8 &a, const v_uint8 &b)
 
v_uint8x16 v_max (const v_uint8x16 &a, const v_uint8x16 &b)
 
v_float32 v_min (const v_float32 &a, const v_float32 &b)
 
v_float32x4 v_min (const v_float32x4 &a, const v_float32x4 &b)
 
v_float64 v_min (const v_float64 &a, const v_float64 &b)
 
v_float64x2 v_min (const v_float64x2 &a, const v_float64x2 &b)
 
v_int16 v_min (const v_int16 &a, const v_int16 &b)
 
v_int16x8 v_min (const v_int16x8 &a, const v_int16x8 &b)
 
v_int32 v_min (const v_int32 &a, const v_int32 &b)
 
v_int32x4 v_min (const v_int32x4 &a, const v_int32x4 &b)
 
v_int64x2 v_min (const v_int64x2 &a, const v_int64x2 &b)
 
v_int8 v_min (const v_int8 &a, const v_int8 &b)
 
v_int8x16 v_min (const v_int8x16 &a, const v_int8x16 &b)
 
template<typename _Tp , int n>
v_reg< _Tp, n > v_min (const v_reg< _Tp, n > &a, const v_reg< _Tp, n > &b)
 Choose min values for each pair.
 
v_uint16 v_min (const v_uint16 &a, const v_uint16 &b)
 
v_uint16x8 v_min (const v_uint16x8 &a, const v_uint16x8 &b)
 
v_uint32 v_min (const v_uint32 &a, const v_uint32 &b)
 
v_uint32x4 v_min (const v_uint32x4 &a, const v_uint32x4 &b)
 
v_uint64x2 v_min (const v_uint64x2 &a, const v_uint64x2 &b)
 
v_uint8 v_min (const v_uint8 &a, const v_uint8 &b)
 
v_uint8x16 v_min (const v_uint8x16 &a, const v_uint8x16 &b)
 
v_float32 v_mul (const v_float32 &a, const v_float32 &b)
 
template<typename... Args>
v_float32 v_mul (const v_float32 &f1, const v_float32 &f2, const Args &... vf)
 
v_float64 v_mul (const v_float64 &a, const v_float64 &b)
 
template<typename... Args>
v_float64 v_mul (const v_float64 &f1, const v_float64 &f2, const Args &... vf)
 
v_int16 v_mul (const v_int16 &a, const v_int16 &b)
 
template<typename... Args>
v_int16 v_mul (const v_int16 &a1, const v_int16 &a2, const Args &... va)
 
v_int32 v_mul (const v_int32 &a, const v_int32 &b)
 
template<typename... Args>
v_int32 v_mul (const v_int32 &f1, const v_int32 &f2, const Args &... vf)
 
v_int8 v_mul (const v_int8 &a, const v_int8 &b)
 
template<typename... Args>
v_int8 v_mul (const v_int8 &a1, const v_int8 &a2, const Args &... va)
 
v_uint16 v_mul (const v_uint16 &a, const v_uint16 &b)
 
template<typename... Args>
v_uint16 v_mul (const v_uint16 &a1, const v_uint16 &a2, const Args &... va)
 
v_uint32 v_mul (const v_uint32 &a, const v_uint32 &b)
 
template<typename... Args>
v_uint32 v_mul (const v_uint32 &f1, const v_uint32 &f2, const Args &... vf)
 
v_uint8 v_mul (const v_uint8 &a, const v_uint8 &b)
 
template<typename... Args>
v_uint8 v_mul (const v_uint8 &a1, const v_uint8 &a2, const Args &... va)
 
void v_mul_expand (const v_int16 &a, const v_int16 &b, v_int32 &c, v_int32 &d)
 
void v_mul_expand (const v_int16x8 &a, const v_int16x8 &b, v_int32x4 &c, v_int32x4 &d)
 
void v_mul_expand (const v_int8 &a, const v_int8 &b, v_int16 &c, v_int16 &d)
 
void v_mul_expand (const v_int8x16 &a, const v_int8x16 &b, v_int16x8 &c, v_int16x8 &d)
 
template<typename _Tp , int n>
void 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.
 
void v_mul_expand (const v_uint16 &a, const v_uint16 &b, v_uint32 &c, v_uint32 &d)
 
void v_mul_expand (const v_uint16x8 &a, const v_uint16x8 &b, v_uint32x4 &c, v_uint32x4 &d)
 
void v_mul_expand (const v_uint32 &a, const v_uint32 &b, v_uint64 &c, v_uint64 &d)
 
void v_mul_expand (const v_uint32x4 &a, const v_uint32x4 &b, v_uint64x2 &c, v_uint64x2 &d)
 
void v_mul_expand (const v_uint8 &a, const v_uint8 &b, v_uint16 &c, v_uint16 &d)
 
void v_mul_expand (const v_uint8x16 &a, const v_uint8x16 &b, v_uint16x8 &c, v_uint16x8 &d)
 
v_int16 v_mul_hi (const v_int16 &a, const v_int16 &b)
 
v_int16x8 v_mul_hi (const v_int16x8 &a, const v_int16x8 &b)
 
template<typename _Tp , int n>
v_reg< _Tp, n > v_mul_hi (const v_reg< _Tp, n > &a, const v_reg< _Tp, n > &b)
 Multiply and extract high part.
 
v_uint16 v_mul_hi (const v_uint16 &a, const v_uint16 &b)
 
v_uint16x8 v_mul_hi (const v_uint16x8 &a, const v_uint16x8 &b)
 
v_int16 v_mul_wrap (const v_int16 &a, const v_int16 &b)
 
v_int16x8 v_mul_wrap (const v_int16x8 &a, const v_int16x8 &b)
 
v_int8 v_mul_wrap (const v_int8 &a, const v_int8 &b)
 
v_int8x16 v_mul_wrap (const v_int8x16 &a, const v_int8x16 &b)
 
template<typename _Tp , int n>
v_reg< _Tp, n > v_mul_wrap (const v_reg< _Tp, n > &a, const v_reg< _Tp, n > &b)
 Multiply values without saturation.
 
v_uint16 v_mul_wrap (const v_uint16 &a, const v_uint16 &b)
 
v_uint16x8 v_mul_wrap (const v_uint16x8 &a, const v_uint16x8 &b)
 
v_uint8 v_mul_wrap (const v_uint8 &a, const v_uint8 &b)
 
v_uint8x16 v_mul_wrap (const v_uint8x16 &a, const v_uint8x16 &b)
 
v_float32 v_muladd (const v_float32 &a, const v_float32 &b, const v_float32 &c)
 
v_float32x4 v_muladd (const v_float32x4 &a, const v_float32x4 &b, const v_float32x4 &c)
 
v_float64 v_muladd (const v_float64 &a, const v_float64 &b, const v_float64 &c)
 
v_float64x2 v_muladd (const v_float64x2 &a, const v_float64x2 &b, const v_float64x2 &c)
 
v_int32 v_muladd (const v_int32 &a, const v_int32 &b, const v_int32 &c)
 
v_int32x4 v_muladd (const v_int32x4 &a, const v_int32x4 &b, const v_int32x4 &c)
 
template<typename _Tp , int n>
v_reg< _Tp, n > 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.
 
v_float32 v_ne (const v_float32 &a, const v_float32 &b)
 
v_float64 v_ne (const v_float64 &a, const v_float64 &b)
 
v_int16 v_ne (const v_int16 &a, const v_int16 &b)
 
v_int32 v_ne (const v_int32 &a, const v_int32 &b)
 
v_int64 v_ne (const v_int64 &a, const v_int64 &b)
 
v_int8 v_ne (const v_int8 &a, const v_int8 &b)
 
v_uint16 v_ne (const v_uint16 &a, const v_uint16 &b)
 
v_uint32 v_ne (const v_uint32 &a, const v_uint32 &b)
 
v_uint64 v_ne (const v_uint64 &a, const v_uint64 &b)
 
v_uint8 v_ne (const v_uint8 &a, const v_uint8 &b)
 
v_float32 v_not (const v_float32 &a)
 
v_float64 v_not (const v_float64 &a)
 
v_int16 v_not (const v_int16 &a)
 
v_int32 v_not (const v_int32 &a)
 
v_int64 v_not (const v_int64 &a)
 
v_int8 v_not (const v_int8 &a)
 
v_uint16 v_not (const v_uint16 &a)
 
v_uint32 v_not (const v_uint32 &a)
 
v_uint64 v_not (const v_uint64 &a)
 
v_uint8 v_not (const v_uint8 &a)
 
v_float32 v_not_nan (const v_float32 &a)
 
v_float32x4 v_not_nan (const v_float32x4 &a)
 
v_float64 v_not_nan (const v_float64 &a)
 
v_float64x2 v_not_nan (const v_float64x2 &a)
 
template<int n>
v_reg< double, n > v_not_nan (const v_reg< double, n > &a)
 
template<int n>
v_reg< float, n > v_not_nan (const v_reg< float, n > &a)
 
v_float32 v_or (const v_float32 &a, const v_float32 &b)
 
v_float64 v_or (const v_float64 &a, const v_float64 &b)
 
v_int16 v_or (const v_int16 &a, const v_int16 &b)
 
v_int32 v_or (const v_int32 &a, const v_int32 &b)
 
v_int64 v_or (const v_int64 &a, const v_int64 &b)
 
v_int8 v_or (const v_int8 &a, const v_int8 &b)
 
v_uint16 v_or (const v_uint16 &a, const v_uint16 &b)
 
v_uint32 v_or (const v_uint32 &a, const v_uint32 &b)
 
v_uint64 v_or (const v_uint64 &a, const v_uint64 &b)
 
v_uint8 v_or (const v_uint8 &a, const v_uint8 &b)
 
v_int8 v_pack (const v_int16 &a, const v_int16 &b)
 
v_int8x16 v_pack (const v_int16x8 &a, const v_int16x8 &b)
 
v_int16 v_pack (const v_int32 &a, const v_int32 &b)
 
v_int16x8 v_pack (const v_int32x4 &a, const v_int32x4 &b)
 
v_int32 v_pack (const v_int64 &a, const v_int64 &b)
 
v_int32x4 v_pack (const v_int64x2 &a, const v_int64x2 &b)
 
v_uint8 v_pack (const v_uint16 &a, const v_uint16 &b)
 
v_uint8x16 v_pack (const v_uint16x8 &a, const v_uint16x8 &b)
 
v_uint16 v_pack (const v_uint32 &a, const v_uint32 &b)
 
v_uint16x8 v_pack (const v_uint32x4 &a, const v_uint32x4 &b)
 
v_uint32 v_pack (const v_uint64 &a, const v_uint64 &b)
 
v_uint32x4 v_pack (const v_uint64x2 &a, const v_uint64x2 &b)
 
v_uint8 v_pack_b (const v_uint16 &a, const v_uint16 &b)
 
v_uint8x16 v_pack_b (const v_uint16x8 &a, const v_uint16x8 &b)
 
v_uint8 v_pack_b (const v_uint32 &a, const v_uint32 &b, const v_uint32 &c, const v_uint32 &d)
 
v_uint8x16 v_pack_b (const v_uint32x4 &a, const v_uint32x4 &b, const v_uint32x4 &c, const v_uint32x4 &d)
 
v_uint8 v_pack_b (const v_uint64 &a, const v_uint64 &b, const v_uint64 &c, const v_uint64 &d, const v_uint64 &e, const v_uint64 &f, const v_uint64 &g, const v_uint64 &h)
 
v_uint8x16 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)
 
void v_pack_store (float16_t *ptr, const v_float32 &v)
 
void v_pack_store (float16_t *ptr, const v_float32x4 &v)
 
template<int n>
void v_pack_store (float16_t *ptr, const v_reg< float, n > &v)
 
void v_pack_store (int *ptr, const v_int64 &a)
 
void v_pack_store (int *ptr, const v_int64x2 &a)
 
void v_pack_store (schar *ptr, const v_int16 &a)
 
void v_pack_store (schar *ptr, const v_int16x8 &a)
 
void v_pack_store (short *ptr, const v_int32 &a)
 
void v_pack_store (short *ptr, const v_int32x4 &a)
 
void v_pack_store (uchar *ptr, const v_uint16 &a)
 
void v_pack_store (uchar *ptr, const v_uint16x8 &a)
 
void v_pack_store (unsigned *ptr, const v_uint64 &a)
 
void v_pack_store (unsigned *ptr, const v_uint64x2 &a)
 
void v_pack_store (ushort *ptr, const v_uint32 &a)
 
void v_pack_store (ushort *ptr, const v_uint32x4 &a)
 
v_float32 v_pack_triplets (const v_float32 &vec)
 
v_float32x4 v_pack_triplets (const v_float32x4 &vec)
 
v_float64 v_pack_triplets (const v_float64 &vec)
 
v_int16 v_pack_triplets (const v_int16 &vec)
 
v_int16x8 v_pack_triplets (const v_int16x8 &vec)
 
v_int32 v_pack_triplets (const v_int32 &vec)
 
v_int32x4 v_pack_triplets (const v_int32x4 &vec)
 
v_int64 v_pack_triplets (const v_int64 &vec)
 
v_int8 v_pack_triplets (const v_int8 &vec)
 
v_int8x16 v_pack_triplets (const v_int8x16 &vec)
 
template<typename _Tp , int n>
v_reg< _Tp, n > v_pack_triplets (const v_reg< _Tp, n > &vec)
 
v_uint16 v_pack_triplets (const v_uint16 &vec)
 
v_uint16x8 v_pack_triplets (const v_uint16x8 &vec)
 
v_uint32 v_pack_triplets (const v_uint32 &vec)
 
v_uint32x4 v_pack_triplets (const v_uint32x4 &vec)
 
v_uint64 v_pack_triplets (const v_uint64 &vec)
 
v_uint8 v_pack_triplets (const v_uint8 &vec)
 
v_uint8x16 v_pack_triplets (const v_uint8x16 &vec)
 
v_uint8 v_pack_u (const v_int16 &a, const v_int16 &b)
 
v_uint8x16 v_pack_u (const v_int16x8 &a, const v_int16x8 &b)
 
v_uint16 v_pack_u (const v_int32 &a, const v_int32 &b)
 
v_uint16x8 v_pack_u (const v_int32x4 &a, const v_int32x4 &b)
 
void v_pack_u_store (uchar *ptr, const v_int16 &a)
 
void v_pack_u_store (uchar *ptr, const v_int16x8 &a)
 
void v_pack_u_store (ushort *ptr, const v_int32 &a)
 
void v_pack_u_store (ushort *ptr, const v_int32x4 &a)
 
v_uint16 v_popcount (const v_int16 &a)
 
v_uint16x8 v_popcount (const v_int16x8 &a)
 
v_uint32 v_popcount (const v_int32 &a)
 
v_uint32x4 v_popcount (const v_int32x4 &a)
 
v_uint64 v_popcount (const v_int64 &a)
 
v_uint64x2 v_popcount (const v_int64x2 &a)
 
v_uint8 v_popcount (const v_int8 &a)
 
v_uint8x16 v_popcount (const v_int8x16 &a)
 
template<typename _Tp , int n>
v_reg< typename V_TypeTraits< _Tp >::abs_type, n > v_popcount (const v_reg< _Tp, n > &a)
 Count the 1 bits in the vector lanes and return result as corresponding unsigned type.
 
v_uint16 v_popcount (const v_uint16 &a)
 
v_uint16x8 v_popcount (const v_uint16x8 &a)
 
v_uint32 v_popcount (const v_uint32 &a)
 
v_uint32x4 v_popcount (const v_uint32x4 &a)
 
v_uint64 v_popcount (const v_uint64 &a)
 
v_uint64x2 v_popcount (const v_uint64x2 &a)
 
v_uint8 v_popcount (const v_uint8 &a)
 
v_uint8x16 v_popcount (const v_uint8x16 &a)
 
void v_recombine (const v_float32 &a, const v_float32 &b, v_float32 &c, v_float32 &d)
 
void v_recombine (const v_float32x4 &a, const v_float32x4 &b, v_float32x4 &c, v_float32x4 &d)
 
void v_recombine (const v_float64 &a, const v_float64 &b, v_float64 &c, v_float64 &d)
 
void v_recombine (const v_float64x2 &a, const v_float64x2 &b, v_float64x2 &c, v_float64x2 &d)
 
void v_recombine (const v_int16 &a, const v_int16 &b, v_int16 &c, v_int16 &d)
 
void v_recombine (const v_int16x8 &a, const v_int16x8 &b, v_int16x8 &c, v_int16x8 &d)
 
void v_recombine (const v_int32 &a, const v_int32 &b, v_int32 &c, v_int32 &d)
 
void v_recombine (const v_int32x4 &a, const v_int32x4 &b, v_int32x4 &c, v_int32x4 &d)
 
void v_recombine (const v_int8 &a, const v_int8 &b, v_int8 &c, v_int8 &d)
 
void v_recombine (const v_int8x16 &a, const v_int8x16 &b, v_int8x16 &c, v_int8x16 &d)
 
template<typename _Tp , int n>
void 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.
 
void v_recombine (const v_uint16 &a, const v_uint16 &b, v_uint16 &c, v_uint16 &d)
 
void v_recombine (const v_uint16x8 &a, const v_uint16x8 &b, v_uint16x8 &c, v_uint16x8 &d)
 
void v_recombine (const v_uint32 &a, const v_uint32 &b, v_uint32 &c, v_uint32 &d)
 
void v_recombine (const v_uint32x4 &a, const v_uint32x4 &b, v_uint32x4 &c, v_uint32x4 &d)
 
void v_recombine (const v_uint8 &a, const v_uint8 &b, v_uint8 &c, v_uint8 &d)
 
void v_recombine (const v_uint8x16 &a, const v_uint8x16 &b, v_uint8x16 &c, v_uint8x16 &d)
 
float v_reduce_max (const v_float32 &a)
 
float v_reduce_max (const v_float32x4 &a)
 
short v_reduce_max (const v_int16 &a)
 
short v_reduce_max (const v_int16x8 &a)
 
int v_reduce_max (const v_int32 &a)
 
int v_reduce_max (const v_int32x4 &a)
 
schar v_reduce_max (const v_int8 &a)
 
schar v_reduce_max (const v_int8x16 &a)
 
template<typename _Tp , int n>
_Tp v_reduce_max (const v_reg< _Tp, n > &a)
 Find one max value.
 
ushort v_reduce_max (const v_uint16 &a)
 
ushort v_reduce_max (const v_uint16x8 &a)
 
unsigned v_reduce_max (const v_uint32 &a)
 
unsigned v_reduce_max (const v_uint32x4 &a)
 
uchar v_reduce_max (const v_uint8 &a)
 
uchar v_reduce_max (const v_uint8x16 &a)
 
float v_reduce_min (const v_float32 &a)
 
float v_reduce_min (const v_float32x4 &a)
 
short v_reduce_min (const v_int16 &a)
 
short v_reduce_min (const v_int16x8 &a)
 
int v_reduce_min (const v_int32 &a)
 
int v_reduce_min (const v_int32x4 &a)
 
schar v_reduce_min (const v_int8 &a)
 
schar v_reduce_min (const v_int8x16 &a)
 
template<typename _Tp , int n>
_Tp v_reduce_min (const v_reg< _Tp, n > &a)
 Find one min value.
 
ushort v_reduce_min (const v_uint16 &a)
 
ushort v_reduce_min (const v_uint16x8 &a)
 
unsigned v_reduce_min (const v_uint32 &a)
 
unsigned v_reduce_min (const v_uint32x4 &a)
 
uchar v_reduce_min (const v_uint8 &a)
 
uchar v_reduce_min (const v_uint8x16 &a)
 
float v_reduce_sad (const v_float32 &a, const v_float32 &b)
 
float v_reduce_sad (const v_float32x4 &a, const v_float32x4 &b)
 
unsigned v_reduce_sad (const v_int16 &a, const v_int16 &b)
 
unsigned v_reduce_sad (const v_int16x8 &a, const v_int16x8 &b)
 
unsigned v_reduce_sad (const v_int32 &a, const v_int32 &b)
 
unsigned v_reduce_sad (const v_int32x4 &a, const v_int32x4 &b)
 
unsigned v_reduce_sad (const v_int8 &a, const v_int8 &b)
 
unsigned v_reduce_sad (const v_int8x16 &a, const v_int8x16 &b)
 
template<typename _Tp , int n>
V_TypeTraits< typenameV_TypeTraits< _Tp >::abs_type >::sum_type v_reduce_sad (const v_reg< _Tp, n > &a, const v_reg< _Tp, n > &b)
 Sum absolute differences of values.
 
unsigned v_reduce_sad (const v_uint16 &a, const v_uint16 &b)
 
unsigned v_reduce_sad (const v_uint16x8 &a, const v_uint16x8 &b)
 
unsigned v_reduce_sad (const v_uint32 &a, const v_uint32 &b)
 
unsigned v_reduce_sad (const v_uint32x4 &a, const v_uint32x4 &b)
 
unsigned v_reduce_sad (const v_uint8 &a, const v_uint8 &b)
 
unsigned v_reduce_sad (const v_uint8x16 &a, const v_uint8x16 &b)
 
float v_reduce_sum (const v_float32 &a)
 
float v_reduce_sum (const v_float32x4 &a)
 
float v_reduce_sum (const v_float64 &a)
 
double v_reduce_sum (const v_float64x2 &a)
 
int v_reduce_sum (const v_int16 &a)
 
int v_reduce_sum (const v_int16x8 &a)
 
int v_reduce_sum (const v_int32 &a)
 
int v_reduce_sum (const v_int32x4 &a)
 
int64 v_reduce_sum (const v_int64 &a)
 
int64 v_reduce_sum (const v_int64x2 &a)
 
int v_reduce_sum (const v_int8 &a)
 
int v_reduce_sum (const v_int8x16 &a)
 
template<typename _Tp , int n>
V_TypeTraits< _Tp >::sum_type v_reduce_sum (const v_reg< _Tp, n > &a)
 Sum packed values.
 
unsigned v_reduce_sum (const v_uint16 &a)
 
unsigned v_reduce_sum (const v_uint16x8 &a)
 
unsigned v_reduce_sum (const v_uint32 &a)
 
unsigned v_reduce_sum (const v_uint32x4 &a)
 
uint64 v_reduce_sum (const v_uint64 &a)
 
uint64 v_reduce_sum (const v_uint64x2 &a)
 
unsigned v_reduce_sum (const v_uint8 &a)
 
unsigned v_reduce_sum (const v_uint8x16 &a)
 
v_float32 v_reduce_sum4 (const v_float32 &a, const v_float32 &b, const v_float32 &c, const v_float32 &d)
 
v_float32x4 v_reduce_sum4 (const v_float32x4 &a, const v_float32x4 &b, const v_float32x4 &c, const v_float32x4 &d)
 
template<int n>
v_reg< float, n > 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)
 Sums all elements of each input vector, returns the vector of sums.
 
v_float32 v_reinterpret_as_f32 (const v_float32 &v)
 
v_float32x4 v_reinterpret_as_f32 (const v_float32x4 &v)
 
v_float32 v_reinterpret_as_f32 (const v_float64 &v)
 
v_float32x4 v_reinterpret_as_f32 (const v_float64x2 &v)
 
v_float32 v_reinterpret_as_f32 (const v_int16 &v)
 
v_float32x4 v_reinterpret_as_f32 (const v_int16x8 &v)
 
v_float32 v_reinterpret_as_f32 (const v_int32 &v)
 
v_float32x4 v_reinterpret_as_f32 (const v_int32x4 &v)
 
v_float32 v_reinterpret_as_f32 (const v_int64 &v)
 
v_float32x4 v_reinterpret_as_f32 (const v_int64x2 &v)
 
v_float32 v_reinterpret_as_f32 (const v_int8 &v)
 
v_float32x4 v_reinterpret_as_f32 (const v_int8x16 &v)
 
v_float32 v_reinterpret_as_f32 (const v_uint16 &v)
 
v_float32x4 v_reinterpret_as_f32 (const v_uint16x8 &v)
 
v_float32 v_reinterpret_as_f32 (const v_uint32 &v)
 
v_float32x4 v_reinterpret_as_f32 (const v_uint32x4 &v)
 
v_float32 v_reinterpret_as_f32 (const v_uint64 &v)
 
v_float32x4 v_reinterpret_as_f32 (const v_uint64x2 &v)
 
v_float32 v_reinterpret_as_f32 (const v_uint8 &v)
 
v_float32x4 v_reinterpret_as_f32 (const v_uint8x16 &v)
 
v_float64 v_reinterpret_as_f64 (const v_float32 &v)
 
v_float64x2 v_reinterpret_as_f64 (const v_float32x4 &v)
 
v_float64 v_reinterpret_as_f64 (const v_float64 &v)
 
v_float64x2 v_reinterpret_as_f64 (const v_float64x2 &v)
 
v_float64 v_reinterpret_as_f64 (const v_int16 &v)
 
v_float64x2 v_reinterpret_as_f64 (const v_int16x8 &v)
 
v_float64 v_reinterpret_as_f64 (const v_int32 &v)
 
v_float64x2 v_reinterpret_as_f64 (const v_int32x4 &v)
 
v_float64 v_reinterpret_as_f64 (const v_int64 &v)
 
v_float64x2 v_reinterpret_as_f64 (const v_int64x2 &v)
 
v_float64 v_reinterpret_as_f64 (const v_int8 &v)
 
v_float64x2 v_reinterpret_as_f64 (const v_int8x16 &v)
 
v_float64 v_reinterpret_as_f64 (const v_uint16 &v)
 
v_float64x2 v_reinterpret_as_f64 (const v_uint16x8 &v)
 
v_float64 v_reinterpret_as_f64 (const v_uint32 &v)
 
v_float64x2 v_reinterpret_as_f64 (const v_uint32x4 &v)
 
v_float64 v_reinterpret_as_f64 (const v_uint64 &v)
 
v_float64x2 v_reinterpret_as_f64 (const v_uint64x2 &v)
 
v_float64 v_reinterpret_as_f64 (const v_uint8 &v)
 
v_float64x2 v_reinterpret_as_f64 (const v_uint8x16 &v)
 
v_int16 v_reinterpret_as_s16 (const v_float32 &v)
 
v_int16x8 v_reinterpret_as_s16 (const v_float32x4 &v)
 
v_int16 v_reinterpret_as_s16 (const v_float64 &v)
 
v_int16x8 v_reinterpret_as_s16 (const v_float64x2 &v)
 
v_int16 v_reinterpret_as_s16 (const v_int16 &v)
 
v_int16x8 v_reinterpret_as_s16 (const v_int16x8 &v)
 
v_int16 v_reinterpret_as_s16 (const v_int32 &v)
 
v_int16x8 v_reinterpret_as_s16 (const v_int32x4 &v)
 
v_int16 v_reinterpret_as_s16 (const v_int64 &v)
 
v_int16x8 v_reinterpret_as_s16 (const v_int64x2 &v)
 
v_int16 v_reinterpret_as_s16 (const v_int8 &v)
 
v_int16x8 v_reinterpret_as_s16 (const v_int8x16 &v)
 
v_int16 v_reinterpret_as_s16 (const v_uint16 &v)
 
v_int16x8 v_reinterpret_as_s16 (const v_uint16x8 &v)
 
v_int16 v_reinterpret_as_s16 (const v_uint32 &v)
 
v_int16x8 v_reinterpret_as_s16 (const v_uint32x4 &v)
 
v_int16 v_reinterpret_as_s16 (const v_uint64 &v)
 
v_int16x8 v_reinterpret_as_s16 (const v_uint64x2 &v)
 
v_int16 v_reinterpret_as_s16 (const v_uint8 &v)
 
v_int16x8 v_reinterpret_as_s16 (const v_uint8x16 &v)
 
v_int32 v_reinterpret_as_s32 (const v_float32 &v)
 
v_int32x4 v_reinterpret_as_s32 (const v_float32x4 &v)
 
v_int32 v_reinterpret_as_s32 (const v_float64 &v)
 
v_int32x4 v_reinterpret_as_s32 (const v_float64x2 &v)
 
v_int32 v_reinterpret_as_s32 (const v_int16 &v)
 
v_int32x4 v_reinterpret_as_s32 (const v_int16x8 &v)
 
v_int32 v_reinterpret_as_s32 (const v_int32 &v)
 
v_int32x4 v_reinterpret_as_s32 (const v_int32x4 &v)
 
v_int32 v_reinterpret_as_s32 (const v_int64 &v)
 
v_int32x4 v_reinterpret_as_s32 (const v_int64x2 &v)
 
v_int32 v_reinterpret_as_s32 (const v_int8 &v)
 
v_int32x4 v_reinterpret_as_s32 (const v_int8x16 &v)
 
v_int32 v_reinterpret_as_s32 (const v_uint16 &v)
 
v_int32x4 v_reinterpret_as_s32 (const v_uint16x8 &v)
 
v_int32 v_reinterpret_as_s32 (const v_uint32 &v)
 
v_int32x4 v_reinterpret_as_s32 (const v_uint32x4 &v)
 
v_int32 v_reinterpret_as_s32 (const v_uint64 &v)
 
v_int32x4 v_reinterpret_as_s32 (const v_uint64x2 &v)
 
v_int32 v_reinterpret_as_s32 (const v_uint8 &v)
 
v_int32x4 v_reinterpret_as_s32 (const v_uint8x16 &v)
 
v_int64 v_reinterpret_as_s64 (const v_float32 &v)
 
v_int64x2 v_reinterpret_as_s64 (const v_float32x4 &v)
 
v_int64 v_reinterpret_as_s64 (const v_float64 &v)
 
v_int64x2 v_reinterpret_as_s64 (const v_float64x2 &v)
 
v_int64 v_reinterpret_as_s64 (const v_int16 &v)
 
v_int64x2 v_reinterpret_as_s64 (const v_int16x8 &v)
 
v_int64 v_reinterpret_as_s64 (const v_int32 &v)
 
v_int64x2 v_reinterpret_as_s64 (const v_int32x4 &v)
 
v_int64 v_reinterpret_as_s64 (const v_int64 &v)
 
v_int64x2 v_reinterpret_as_s64 (const v_int64x2 &v)
 
v_int64 v_reinterpret_as_s64 (const v_int8 &v)
 
v_int64x2 v_reinterpret_as_s64 (const v_int8x16 &v)
 
v_int64 v_reinterpret_as_s64 (const v_uint16 &v)
 
v_int64x2 v_reinterpret_as_s64 (const v_uint16x8 &v)
 
v_int64 v_reinterpret_as_s64 (const v_uint32 &v)
 
v_int64x2 v_reinterpret_as_s64 (const v_uint32x4 &v)
 
v_int64 v_reinterpret_as_s64 (const v_uint64 &v)
 
v_int64x2 v_reinterpret_as_s64 (const v_uint64x2 &v)
 
v_int64 v_reinterpret_as_s64 (const v_uint8 &v)
 
v_int64x2 v_reinterpret_as_s64 (const v_uint8x16 &v)
 
v_int8 v_reinterpret_as_s8 (const v_float32 &v)
 
v_int8x16 v_reinterpret_as_s8 (const v_float32x4 &v)
 
v_int8 v_reinterpret_as_s8 (const v_float64 &v)
 
v_int8x16 v_reinterpret_as_s8 (const v_float64x2 &v)
 
v_int8 v_reinterpret_as_s8 (const v_int16 &v)
 
v_int8x16 v_reinterpret_as_s8 (const v_int16x8 &v)
 
v_int8 v_reinterpret_as_s8 (const v_int32 &v)
 
v_int8x16 v_reinterpret_as_s8 (const v_int32x4 &v)
 
v_int8 v_reinterpret_as_s8 (const v_int64 &v)
 
v_int8x16 v_reinterpret_as_s8 (const v_int64x2 &v)
 
v_int8 v_reinterpret_as_s8 (const v_int8 &v)
 
v_int8x16 v_reinterpret_as_s8 (const v_int8x16 &v)
 
v_int8 v_reinterpret_as_s8 (const v_uint16 &v)
 
v_int8x16 v_reinterpret_as_s8 (const v_uint16x8 &v)
 
v_int8 v_reinterpret_as_s8 (const v_uint32 &v)
 
v_int8x16 v_reinterpret_as_s8 (const v_uint32x4 &v)
 
v_int8 v_reinterpret_as_s8 (const v_uint64 &v)
 
v_int8x16 v_reinterpret_as_s8 (const v_uint64x2 &v)
 
v_int8 v_reinterpret_as_s8 (const v_uint8 &v)
 
v_int8x16 v_reinterpret_as_s8 (const v_uint8x16 &v)
 
v_uint16 v_reinterpret_as_u16 (const v_float32 &v)
 
v_uint16x8 v_reinterpret_as_u16 (const v_float32x4 &v)
 
v_uint16 v_reinterpret_as_u16 (const v_float64 &v)
 
v_uint16x8 v_reinterpret_as_u16 (const v_float64x2 &v)
 
v_uint16 v_reinterpret_as_u16 (const v_int16 &v)
 
v_uint16x8 v_reinterpret_as_u16 (const v_int16x8 &v)
 
v_uint16 v_reinterpret_as_u16 (const v_int32 &v)
 
v_uint16x8 v_reinterpret_as_u16 (const v_int32x4 &v)
 
v_uint16 v_reinterpret_as_u16 (const v_int64 &v)
 
v_uint16x8 v_reinterpret_as_u16 (const v_int64x2 &v)
 
v_uint16 v_reinterpret_as_u16 (const v_int8 &v)
 
v_uint16x8 v_reinterpret_as_u16 (const v_int8x16 &v)
 
v_uint16 v_reinterpret_as_u16 (const v_uint16 &v)
 
v_uint16x8 v_reinterpret_as_u16 (const v_uint16x8 &v)
 
v_uint16 v_reinterpret_as_u16 (const v_uint32 &v)
 
v_uint16x8 v_reinterpret_as_u16 (const v_uint32x4 &v)
 
v_uint16 v_reinterpret_as_u16 (const v_uint64 &v)
 
v_uint16x8 v_reinterpret_as_u16 (const v_uint64x2 &v)
 
v_uint16 v_reinterpret_as_u16 (const v_uint8 &v)
 
v_uint16x8 v_reinterpret_as_u16 (const v_uint8x16 &v)
 
v_uint32 v_reinterpret_as_u32 (const v_float32 &v)
 
v_uint32x4 v_reinterpret_as_u32 (const v_float32x4 &v)
 
v_uint32 v_reinterpret_as_u32 (const v_float64 &v)
 
v_uint32x4 v_reinterpret_as_u32 (const v_float64x2 &v)
 
v_uint32 v_reinterpret_as_u32 (const v_int16 &v)
 
v_uint32x4 v_reinterpret_as_u32 (const v_int16x8 &v)
 
v_uint32 v_reinterpret_as_u32 (const v_int32 &v)
 
v_uint32x4 v_reinterpret_as_u32 (const v_int32x4 &v)
 
v_uint32 v_reinterpret_as_u32 (const v_int64 &v)
 
v_uint32x4 v_reinterpret_as_u32 (const v_int64x2 &v)
 
v_uint32 v_reinterpret_as_u32 (const v_int8 &v)
 
v_uint32x4 v_reinterpret_as_u32 (const v_int8x16 &v)
 
v_uint32 v_reinterpret_as_u32 (const v_uint16 &v)
 
v_uint32x4 v_reinterpret_as_u32 (const v_uint16x8 &v)
 
v_uint32 v_reinterpret_as_u32 (const v_uint32 &v)
 
v_uint32x4 v_reinterpret_as_u32 (const v_uint32x4 &v)
 
v_uint32 v_reinterpret_as_u32 (const v_uint64 &v)
 
v_uint32x4 v_reinterpret_as_u32 (const v_uint64x2 &v)
 
v_uint32 v_reinterpret_as_u32 (const v_uint8 &v)
 
v_uint32x4 v_reinterpret_as_u32 (const v_uint8x16 &v)
 
v_uint64 v_reinterpret_as_u64 (const v_float32 &v)
 
v_uint64x2 v_reinterpret_as_u64 (const v_float32x4 &v)
 
v_uint64 v_reinterpret_as_u64 (const v_float64 &v)
 
v_uint64x2 v_reinterpret_as_u64 (const v_float64x2 &v)
 
v_uint64 v_reinterpret_as_u64 (const v_int16 &v)
 
v_uint64x2 v_reinterpret_as_u64 (const v_int16x8 &v)
 
v_uint64 v_reinterpret_as_u64 (const v_int32 &v)
 
v_uint64x2 v_reinterpret_as_u64 (const v_int32x4 &v)
 
v_uint64 v_reinterpret_as_u64 (const v_int64 &v)
 
v_uint64x2 v_reinterpret_as_u64 (const v_int64x2 &v)
 
v_uint64 v_reinterpret_as_u64 (const v_int8 &v)
 
v_uint64x2 v_reinterpret_as_u64 (const v_int8x16 &v)
 
v_uint64 v_reinterpret_as_u64 (const v_uint16 &v)
 
v_uint64x2 v_reinterpret_as_u64 (const v_uint16x8 &v)
 
v_uint64 v_reinterpret_as_u64 (const v_uint32 &v)
 
v_uint64x2 v_reinterpret_as_u64 (const v_uint32x4 &v)
 
v_uint64 v_reinterpret_as_u64 (const v_uint64 &v)
 
v_uint64x2 v_reinterpret_as_u64 (const v_uint64x2 &v)
 
v_uint64 v_reinterpret_as_u64 (const v_uint8 &v)
 
v_uint64x2 v_reinterpret_as_u64 (const v_uint8x16 &v)
 
v_uint8 v_reinterpret_as_u8 (const v_float32 &v)
 
v_uint8x16 v_reinterpret_as_u8 (const v_float32x4 &v)
 
v_uint8 v_reinterpret_as_u8 (const v_float64 &v)
 
v_uint8x16 v_reinterpret_as_u8 (const v_float64x2 &v)
 
v_uint8 v_reinterpret_as_u8 (const v_int16 &v)
 
v_uint8x16 v_reinterpret_as_u8 (const v_int16x8 &v)
 
v_uint8 v_reinterpret_as_u8 (const v_int32 &v)
 
v_uint8x16 v_reinterpret_as_u8 (const v_int32x4 &v)
 
v_uint8 v_reinterpret_as_u8 (const v_int64 &v)
 
v_uint8x16 v_reinterpret_as_u8 (const v_int64x2 &v)
 
v_uint8 v_reinterpret_as_u8 (const v_int8 &v)
 
v_uint8x16 v_reinterpret_as_u8 (const v_int8x16 &v)
 
v_uint8 v_reinterpret_as_u8 (const v_uint16 &v)
 
v_uint8x16 v_reinterpret_as_u8 (const v_uint16x8 &v)
 
v_uint8 v_reinterpret_as_u8 (const v_uint32 &v)
 
v_uint8x16 v_reinterpret_as_u8 (const v_uint32x4 &v)
 
v_uint8 v_reinterpret_as_u8 (const v_uint64 &v)
 
v_uint8x16 v_reinterpret_as_u8 (const v_uint64x2 &v)
 
v_uint8 v_reinterpret_as_u8 (const v_uint8 &v)
 
v_uint8x16 v_reinterpret_as_u8 (const v_uint8x16 &v)
 
v_float32 v_reverse (const v_float32 &a)
 
v_float32x4 v_reverse (const v_float32x4 &a)
 
v_float64 v_reverse (const v_float64 &a)
 
v_float64x2 v_reverse (const v_float64x2 &a)
 
v_int16 v_reverse (const v_int16 &a)
 
v_int16x8 v_reverse (const v_int16x8 &a)
 
v_int32 v_reverse (const v_int32 &a)
 
v_int32x4 v_reverse (const v_int32x4 &a)
 
v_int64 v_reverse (const v_int64 &a)
 
v_int64x2 v_reverse (const v_int64x2 &a)
 
v_int8 v_reverse (const v_int8 &a)
 
v_int8x16 v_reverse (const v_int8x16 &a)
 
template<typename _Tp , int n>
v_reg< _Tp, n > v_reverse (const v_reg< _Tp, n > &a)
 Vector reverse order.
 
v_uint16 v_reverse (const v_uint16 &a)
 
v_uint16x8 v_reverse (const v_uint16x8 &a)
 
v_uint32 v_reverse (const v_uint32 &a)
 
v_uint32x4 v_reverse (const v_uint32x4 &a)
 
v_uint64 v_reverse (const v_uint64 &a)
 
v_uint64x2 v_reverse (const v_uint64x2 &a)
 
v_uint8 v_reverse (const v_uint8 &a)
 
v_uint8x16 v_reverse (const v_uint8x16 &a)
 
template<int n>
v_float32 v_rotate_left (const v_float32 &a)
 
template<int n>
v_float32 v_rotate_left (const v_float32 &a, const v_float32 &b)
 
template<int n>
v_float32x4 v_rotate_left (const v_float32x4 &a)
 
template<int n>
v_float32x4 v_rotate_left (const v_float32x4 &a, const v_float32x4 &b)
 
template<int n>
v_float64 v_rotate_left (const v_float64 &a)
 
template<int n>
v_float64 v_rotate_left (const v_float64 &a, const v_float64 &b)
 
template<int n>
v_float64x2 v_rotate_left (const v_float64x2 &a)
 
template<int n>
v_float64x2 v_rotate_left (const v_float64x2 &a, const v_float64x2 &b)
 
template<int n>
v_int16 v_rotate_left (const v_int16 &a)
 
template<int n>
v_int16 v_rotate_left (const v_int16 &a, const v_int16 &b)
 
template<int n>
v_int16x8 v_rotate_left (const v_int16x8 &a)
 
template<int n>
v_int16x8 v_rotate_left (const v_int16x8 &a, const v_int16x8 &b)
 
template<int n>
v_int32 v_rotate_left (const v_int32 &a)
 
template<int n>
v_int32 v_rotate_left (const v_int32 &a, const v_int32 &b)
 
template<int n>
v_int32x4 v_rotate_left (const v_int32x4 &a)
 
template<int n>
v_int32x4 v_rotate_left (const v_int32x4 &a, const v_int32x4 &b)
 
template<int n>
v_int64 v_rotate_left (const v_int64 &a)
 
template<int n>
v_int64 v_rotate_left (const v_int64 &a, const v_int64 &b)
 
template<int n>
v_int64x2 v_rotate_left (const v_int64x2 &a)
 
template<int n>
v_int64x2 v_rotate_left (const v_int64x2 &a, const v_int64x2 &b)
 
template<int n>
v_int8 v_rotate_left (const v_int8 &a)
 
template<int n>
v_int8 v_rotate_left (const v_int8 &a, const v_int8 &b)
 
template<int n>
v_int8x16 v_rotate_left (const v_int8x16 &a)
 
template<int n>
v_int8x16 v_rotate_left (const v_int8x16 &a, const v_int8x16 &b)
 
template<int imm, typename _Tp , int n>
v_reg< _Tp, n > v_rotate_left (const v_reg< _Tp, n > &a)
 Element shift left among vector.
 
template<int imm, typename _Tp , int n>
v_reg< _Tp, n > v_rotate_left (const v_reg< _Tp, n > &a, const v_reg< _Tp, n > &b)
 
template<int n>
v_uint16 v_rotate_left (const v_uint16 &a)
 
template<int n>
v_uint16 v_rotate_left (const v_uint16 &a, const v_uint16 &b)
 
template<int n>
v_uint16x8 v_rotate_left (const v_uint16x8 &a)
 
template<int n>
v_uint16x8 v_rotate_left (const v_uint16x8 &a, const v_uint16x8 &b)
 
template<int n>
v_uint32 v_rotate_left (const v_uint32 &a)
 
template<int n>
v_uint32 v_rotate_left (const v_uint32 &a, const v_uint32 &b)
 
template<int n>
v_uint32x4 v_rotate_left (const v_uint32x4 &a)
 
template<int n>
v_uint32x4 v_rotate_left (const v_uint32x4 &a, const v_uint32x4 &b)
 
template<int n>
v_uint64 v_rotate_left (const v_uint64 &a)
 
template<int n>
v_uint64 v_rotate_left (const v_uint64 &a, const v_uint64 &b)
 
template<int n>
v_uint64x2 v_rotate_left (const v_uint64x2 &a)
 
template<int n>
v_uint64x2 v_rotate_left (const v_uint64x2 &a, const v_uint64x2 &b)
 
template<int n>
v_uint8 v_rotate_left (const v_uint8 &a)
 
template<int n>
v_uint8 v_rotate_left (const v_uint8 &a, const v_uint8 &b)
 
template<int n>
v_uint8x16 v_rotate_left (const v_uint8x16 &a)
 
template<int n>
v_uint8x16 v_rotate_left (const v_uint8x16 &a, const v_uint8x16 &b)
 
template<>
v_float32 v_rotate_left< 0 > (const v_float32 &a)
 
template<>
v_float32 v_rotate_left< 0 > (const v_float32 &a, const v_float32 &b)
 
template<>
v_float32x4 v_rotate_left< 0 > (const v_float32x4 &a)
 
template<>
v_float32x4 v_rotate_left< 0 > (const v_float32x4 &a, const v_float32x4 &b)
 
template<>
v_float64 v_rotate_left< 0 > (const v_float64 &a)
 
template<>
v_float64 v_rotate_left< 0 > (const v_float64 &a, const v_float64 &b)
 
template<>
v_float64x2 v_rotate_left< 0 > (const v_float64x2 &a)
 
template<>
v_float64x2 v_rotate_left< 0 > (const v_float64x2 &a, const v_float64x2 &b)
 
template<>
v_int16 v_rotate_left< 0 > (const v_int16 &a)
 
template<>
v_int16 v_rotate_left< 0 > (const v_int16 &a, const v_int16 &b)
 
template<>
v_int16x8 v_rotate_left< 0 > (const v_int16x8 &a)
 
template<>
v_int16x8 v_rotate_left< 0 > (const v_int16x8 &a, const v_int16x8 &b)
 
template<>
v_int32 v_rotate_left< 0 > (const v_int32 &a)
 
template<>
v_int32 v_rotate_left< 0 > (const v_int32 &a, const v_int32 &b)
 
template<>
v_int32x4 v_rotate_left< 0 > (const v_int32x4 &a)
 
template<>
v_int32x4 v_rotate_left< 0 > (const v_int32x4 &a, const v_int32x4 &b)
 
template<>
v_int64 v_rotate_left< 0 > (const v_int64 &a)
 
template<>
v_int64 v_rotate_left< 0 > (const v_int64 &a, const v_int64 &b)
 
template<>
v_int64x2 v_rotate_left< 0 > (const v_int64x2 &a)
 
template<>
v_int64x2 v_rotate_left< 0 > (const v_int64x2 &a, const v_int64x2 &b)
 
template<>
v_int8 v_rotate_left< 0 > (const v_int8 &a)
 
template<>
v_int8 v_rotate_left< 0 > (const v_int8 &a, const v_int8 &b)
 
template<>
v_int8x16 v_rotate_left< 0 > (const v_int8x16 &a)
 
template<>
v_int8x16 v_rotate_left< 0 > (const v_int8x16 &a, const v_int8x16 &b)
 
template<>
v_uint16 v_rotate_left< 0 > (const v_uint16 &a)
 
template<>
v_uint16 v_rotate_left< 0 > (const v_uint16 &a, const v_uint16 &b)
 
template<>
v_uint16x8 v_rotate_left< 0 > (const v_uint16x8 &a)
 
template<>
v_uint16x8 v_rotate_left< 0 > (const v_uint16x8 &a, const v_uint16x8 &b)
 
template<>
v_uint32 v_rotate_left< 0 > (const v_uint32 &a)
 
template<>
v_uint32 v_rotate_left< 0 > (const v_uint32 &a, const v_uint32 &b)
 
template<>
v_uint32x4 v_rotate_left< 0 > (const v_uint32x4 &a)
 
template<>
v_uint32x4 v_rotate_left< 0 > (const v_uint32x4 &a, const v_uint32x4 &b)
 
template<>
v_uint64 v_rotate_left< 0 > (const v_uint64 &a)
 
template<>
v_uint64 v_rotate_left< 0 > (const v_uint64 &a, const v_uint64 &b)
 
template<>
v_uint64x2 v_rotate_left< 0 > (const v_uint64x2 &a)
 
template<>
v_uint64x2 v_rotate_left< 0 > (const v_uint64x2 &a, const v_uint64x2 &b)
 
template<>
v_uint8 v_rotate_left< 0 > (const v_uint8 &a)
 
template<>
v_uint8 v_rotate_left< 0 > (const v_uint8 &a, const v_uint8 &b)
 
template<>
v_uint8x16 v_rotate_left< 0 > (const v_uint8x16 &a)
 
template<>
v_uint8x16 v_rotate_left< 0 > (const v_uint8x16 &a, const v_uint8x16 &b)
 
template<int n>
v_float32 v_rotate_right (const v_float32 &a)
 
template<int n>
v_float32 v_rotate_right (const v_float32 &a, const v_float32 &b)
 
template<int n>
v_float32x4 v_rotate_right (const v_float32x4 &a)
 
template<int n>
v_float32x4 v_rotate_right (const v_float32x4 &a, const v_float32x4 &b)
 
template<int n>
v_float64 v_rotate_right (const v_float64 &a)
 
template<int n>
v_float64 v_rotate_right (const v_float64 &a, const v_float64 &b)
 
template<int n>
v_float64x2 v_rotate_right (const v_float64x2 &a)
 
template<int n>
v_float64x2 v_rotate_right (const v_float64x2 &a, const v_float64x2 &b)
 
template<int n>
v_int16 v_rotate_right (const v_int16 &a)
 
template<int n>
v_int16 v_rotate_right (const v_int16 &a, const v_int16 &b)
 
template<int n>
v_int16x8 v_rotate_right (const v_int16x8 &a)
 
template<int n>
v_int16x8 v_rotate_right (const v_int16x8 &a, const v_int16x8 &b)
 
template<int n>
v_int32 v_rotate_right (const v_int32 &a)
 
template<int n>
v_int32 v_rotate_right (const v_int32 &a, const v_int32 &b)
 
template<int n>
v_int32x4 v_rotate_right (const v_int32x4 &a)
 
template<int n>
v_int32x4 v_rotate_right (const v_int32x4 &a, const v_int32x4 &b)
 
template<int n>
v_int64 v_rotate_right (const v_int64 &a)
 
template<int n>
v_int64 v_rotate_right (const v_int64 &a, const v_int64 &b)
 
template<int n>
v_int64x2 v_rotate_right (const v_int64x2 &a)
 
template<int n>
v_int64x2 v_rotate_right (const v_int64x2 &a, const v_int64x2 &b)
 
template<int n>
v_int8 v_rotate_right (const v_int8 &a)
 
template<int n>
v_int8 v_rotate_right (const v_int8 &a, const v_int8 &b)
 
template<int n>
v_int8x16 v_rotate_right (const v_int8x16 &a)
 
template<int n>
v_int8x16 v_rotate_right (const v_int8x16 &a, const v_int8x16 &b)
 
template<int imm, typename _Tp , int n>
v_reg< _Tp, n > v_rotate_right (const v_reg< _Tp, n > &a)
 Element shift right among vector.
 
template<int imm, typename _Tp , int n>
v_reg< _Tp, n > v_rotate_right (const v_reg< _Tp, n > &a, const v_reg< _Tp, n > &b)
 
template<int n>
v_uint16 v_rotate_right (const v_uint16 &a)
 
template<int n>
v_uint16 v_rotate_right (const v_uint16 &a, const v_uint16 &b)
 
template<int n>
v_uint16x8 v_rotate_right (const v_uint16x8 &a)
 
template<int n>
v_uint16x8 v_rotate_right (const v_uint16x8 &a, const v_uint16x8 &b)
 
template<int n>
v_uint32 v_rotate_right (const v_uint32 &a)
 
template<int n>
v_uint32 v_rotate_right (const v_uint32 &a, const v_uint32 &b)
 
template<int n>
v_uint32x4 v_rotate_right (const v_uint32x4 &a)
 
template<int n>
v_uint32x4 v_rotate_right (const v_uint32x4 &a, const v_uint32x4 &b)
 
template<int n>
v_uint64 v_rotate_right (const v_uint64 &a)
 
template<int n>
v_uint64 v_rotate_right (const v_uint64 &a, const v_uint64 &b)
 
template<int n>
v_uint64x2 v_rotate_right (const v_uint64x2 &a)
 
template<int n>
v_uint64x2 v_rotate_right (const v_uint64x2 &a, const v_uint64x2 &b)
 
template<int n>
v_uint8 v_rotate_right (const v_uint8 &a)
 
template<int n>
v_uint8 v_rotate_right (const v_uint8 &a, const v_uint8 &b)
 
template<int n>
v_uint8x16 v_rotate_right (const v_uint8x16 &a)
 
template<int n>
v_uint8x16 v_rotate_right (const v_uint8x16 &a, const v_uint8x16 &b)
 
v_int32 v_round (const v_float32 &a)
 
v_int32x4 v_round (const v_float32x4 &a)
 
v_int32 v_round (const v_float64 &a)
 
v_int32 v_round (const v_float64 &a, const v_float64 &b)
 
v_int32x4 v_round (const v_float64x2 &a)
 
v_int32x4 v_round (const v_float64x2 &a, const v_float64x2 &b)
 
template<int n>
v_reg< int, n *2 > v_round (const v_reg< double, n > &a)
 
template<int n>
v_reg< int, n *2 > v_round (const v_reg< double, n > &a, const v_reg< double, n > &b)
 
template<int n>
v_reg< int, n > v_round (const v_reg< float, n > &a)
 Round elements.
 
template<int n = 0>
v_int8 v_rshr_pack (const v_int16 &a, const v_int16 &b, int N=n)
 
template<int n>
v_int8x16 v_rshr_pack (const v_int16x8 &a, const v_int16x8 &b)
 
template<int n = 0>
v_int16 v_rshr_pack (const v_int32 &a, const v_int32 &b, int N=n)
 
template<int n>
v_int16x8 v_rshr_pack (const v_int32x4 &a, const v_int32x4 &b)
 
template<int n = 0>
v_int32 v_rshr_pack (const v_int64 &a, const v_int64 &b, int N=n)
 
template<int n>
v_int32x4 v_rshr_pack (const v_int64x2 &a, const v_int64x2 &b)
 
template<int n = 0>
v_uint8 v_rshr_pack (const v_uint16 &a, const v_uint16 &b, int N=n)
 
template<int n>
v_uint8x16 v_rshr_pack (const v_uint16x8 &a, const v_uint16x8 &b)
 
template<int n = 0>
v_uint16 v_rshr_pack (const v_uint32 &a, const v_uint32 &b, int N=n)
 
template<int n>
v_uint16x8 v_rshr_pack (const v_uint32x4 &a, const v_uint32x4 &b)
 
template<int n = 0>
v_uint32 v_rshr_pack (const v_uint64 &a, const v_uint64 &b, int N=n)
 
template<int n>
v_uint32x4 v_rshr_pack (const v_uint64x2 &a, const v_uint64x2 &b)
 
template<int n = 0>
void v_rshr_pack_store (int *ptr, const v_int64 &a, int N=n)
 
template<int n>
void v_rshr_pack_store (int *ptr, const v_int64x2 &a)
 
template<int n = 0>
void v_rshr_pack_store (schar *ptr, const v_int16 &a, int N=n)
 
template<int n>
void v_rshr_pack_store (schar *ptr, const v_int16x8 &a)
 
template<int n = 0>
void v_rshr_pack_store (short *ptr, const v_int32 &a, int N=n)
 
template<int n>
void v_rshr_pack_store (short *ptr, const v_int32x4 &a)
 
template<int n = 0>
void v_rshr_pack_store (uchar *ptr, const v_uint16 &a, int N=n)
 
template<int n>
void v_rshr_pack_store (uchar *ptr, const v_uint16x8 &a)
 
template<int n = 0>
void v_rshr_pack_store (unsigned *ptr, const v_uint64 &a, int N=n)
 
template<int n>
void v_rshr_pack_store (unsigned *ptr, const v_uint64x2 &a)
 
template<int n = 0>
void v_rshr_pack_store (ushort *ptr, const v_uint32 &a, int N=n)
 
template<int n>
void v_rshr_pack_store (ushort *ptr, const v_uint32x4 &a)
 
template<int N = 0>
v_uint8 v_rshr_pack_u (const v_int16 &a, const v_int16 &b, int n=N)
 
template<int n>
v_uint8x16 v_rshr_pack_u (const v_int16x8 &a, const v_int16x8 &b)
 
template<int N = 0>
v_uint16 v_rshr_pack_u (const v_int32 &a, const v_int32 &b, int n=N)
 
template<int n>
v_uint16x8 v_rshr_pack_u (const v_int32x4 &a, const v_int32x4 &b)
 
template<int N = 0>
void v_rshr_pack_u_store (uchar *ptr, const v_int16 &a, int n=N)
 
template<int n>
void v_rshr_pack_u_store (uchar *ptr, const v_int16x8 &a)
 
template<int N = 0>
void v_rshr_pack_u_store (ushort *ptr, const v_int32 &a, int n=N)
 
template<int n>
void v_rshr_pack_u_store (ushort *ptr, const v_int32x4 &a)
 
int v_scan_forward (const v_float32 &a)
 
int v_scan_forward (const v_float32x4 &a)
 
int v_scan_forward (const v_float64 &a)
 
int v_scan_forward (const v_float64x2 &a)
 
int v_scan_forward (const v_int16 &a)
 
int v_scan_forward (const v_int16x8 &a)
 
int v_scan_forward (const v_int32 &a)
 
int v_scan_forward (const v_int32x4 &a)
 
int v_scan_forward (const v_int64 &a)
 
int v_scan_forward (const v_int64x2 &a)
 
int v_scan_forward (const v_int8 &a)
 
int v_scan_forward (const v_int8x16 &a)
 
template<typename _Tp , int n>
int v_scan_forward (const v_reg< _Tp, n > &a)
 Get first negative lane index.
 
int v_scan_forward (const v_uint16 &a)
 
int v_scan_forward (const v_uint16x8 &a)
 
int v_scan_forward (const v_uint32 &a)
 
int v_scan_forward (const v_uint32x4 &a)
 
int v_scan_forward (const v_uint64 &a)
 
int v_scan_forward (const v_uint64x2 &a)
 
int v_scan_forward (const v_uint8 &a)
 
int v_scan_forward (const v_uint8x16 &a)
 
v_float32 v_select (const v_float32 &mask, const v_float32 &a, const v_float32 &b)
 
v_float32x4 v_select (const v_float32x4 &mask, const v_float32x4 &a, const v_float32x4 &b)
 
v_float64 v_select (const v_float64 &mask, const v_float64 &a, const v_float64 &b)
 
v_float64x2 v_select (const v_float64x2 &mask, const v_float64x2 &a, const v_float64x2 &b)
 
v_int16 v_select (const v_int16 &mask, const v_int16 &a, const v_int16 &b)
 
v_int16x8 v_select (const v_int16x8 &mask, const v_int16x8 &a, const v_int16x8 &b)
 
v_int32 v_select (const v_int32 &mask, const v_int32 &a, const v_int32 &b)
 
v_int32x4 v_select (const v_int32x4 &mask, const v_int32x4 &a, const v_int32x4 &b)
 
v_int8 v_select (const v_int8 &mask, const v_int8 &a, const v_int8 &b)
 
v_int8x16 v_select (const v_int8x16 &mask, const v_int8x16 &a, const v_int8x16 &b)
 
template<typename _Tp , int n>
v_reg< _Tp, n > 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)
 
v_uint16 v_select (const v_uint16 &mask, const v_uint16 &a, const v_uint16 &b)
 
v_uint16x8 v_select (const v_uint16x8 &mask, const v_uint16x8 &a, const v_uint16x8 &b)
 
v_uint32 v_select (const v_uint32 &mask, const v_uint32 &a, const v_uint32 &b)
 
v_uint32x4 v_select (const v_uint32x4 &mask, const v_uint32x4 &a, const v_uint32x4 &b)
 
v_uint8 v_select (const v_uint8 &mask, const v_uint8 &a, const v_uint8 &b)
 
v_uint8x16 v_select (const v_uint8x16 &mask, const v_uint8x16 &a, const v_uint8x16 &b)
 
v_uint32 v_setall_u32 (uint v)
 
template<int s = 0>
v_int16 v_shl (const v_int16 &a, int n=s)
 
template<int n>
v_int16x8 v_shl (const v_int16x8 &a)
 
template<int s = 0>
v_int32 v_shl (const v_int32 &a, int n=s)
 
template<int n>
v_int32x4 v_shl (const v_int32x4 &a)
 
template<int s = 0>
v_int64 v_shl (const v_int64 &a, int n=s)
 
template<int n>
v_int64x2 v_shl (const v_int64x2 &a)
 
template<int n>
v_int8x16 v_shl (const v_int8x16 &a)
 
template<int s = 0>
v_uint16 v_shl (const v_uint16 &a, int n=s)
 
template<int n>
v_uint16x8 v_shl (const v_uint16x8 &a)
 
template<int s = 0>
v_uint32 v_shl (const v_uint32 &a, int n=s)
 
template<int n>
v_uint32x4 v_shl (const v_uint32x4 &a)
 
template<int s = 0>
v_uint64 v_shl (const v_uint64 &a, int n=s)
 
template<int n>
v_uint64x2 v_shl (const v_uint64x2 &a)
 
template<int n>
v_uint8x16 v_shl (const v_uint8x16 &a)
 
template<int s = 0>
v_int16 v_shr (const v_int16 &a, int n=s)
 
template<int n>
v_int16x8 v_shr (const v_int16x8 &a)
 
template<int s = 0>
v_int32 v_shr (const v_int32 &a, int n=s)
 
template<int n>
v_int32x4 v_shr (const v_int32x4 &a)
 
template<int s = 0>
v_int64 v_shr (const v_int64 &a, int n=s)
 
template<int n>
v_int64x2 v_shr (const v_int64x2 &a)
 
template<int n>
v_int8x16 v_shr (const v_int8x16 &a)
 
template<int s = 0>
v_uint16 v_shr (const v_uint16 &a, int n=s)
 
template<int n>
v_uint16x8 v_shr (const v_uint16x8 &a)
 
template<int s = 0>
v_uint32 v_shr (const v_uint32 &a, int n=s)
 
template<int n>
v_uint32x4 v_shr (const v_uint32x4 &a)
 
template<int s = 0>
v_uint64 v_shr (const v_uint64 &a, int n=s)
 
template<int n>
v_uint64x2 v_shr (const v_uint64x2 &a)
 
template<int n>
v_uint8x16 v_shr (const v_uint8x16 &a)
 
int v_signmask (const v_float32 &a)
 
int v_signmask (const v_float32x4 &a)
 
int v_signmask (const v_float64 &a)
 
int v_signmask (const v_float64x2 &a)
 
int v_signmask (const v_int16 &a)
 
int v_signmask (const v_int16x8 &a)
 
int v_signmask (const v_int32 &a)
 
int v_signmask (const v_int32x4 &a)
 
int v_signmask (const v_int64 &a)
 
int v_signmask (const v_int64x2 &a)
 
int v_signmask (const v_int8 &a)
 
int v_signmask (const v_int8x16 &a)
 
template<typename _Tp , int n>
int v_signmask (const v_reg< _Tp, n > &a)
 Get negative values mask.
 
int64 v_signmask (const v_uint16 &a)
 
int v_signmask (const v_uint16x8 &a)
 
int v_signmask (const v_uint32 &a)
 
int v_signmask (const v_uint32x4 &a)
 
int v_signmask (const v_uint64 &a)
 
int v_signmask (const v_uint64x2 &a)
 
int64 v_signmask (const v_uint8 &a)
 
int v_signmask (const v_uint8x16 &a)
 
v_float32 v_sqr_magnitude (const v_float32 &a, const v_float32 &b)
 
v_float32x4 v_sqr_magnitude (const v_float32x4 &a, const v_float32x4 &b)
 
v_float64 v_sqr_magnitude (const v_float64 &a, const v_float64 &b)
 
v_float64x2 v_sqr_magnitude (const v_float64x2 &a, const v_float64x2 &b)
 
template<typename _Tp , int n>
v_reg< _Tp, n > v_sqr_magnitude (const v_reg< _Tp, n > &a, const v_reg< _Tp, n > &b)
 Square of the magnitude.
 
v_float32 v_sqrt (const v_float32 &x)
 
v_float32x4 v_sqrt (const v_float32x4 &x)
 
v_float64 v_sqrt (const v_float64 &x)
 
v_float64x2 v_sqrt (const v_float64x2 &x)
 
template<typename _Tp , int n>
v_reg< _Tp, n > v_sqrt (const v_reg< _Tp, n > &a)
 Square root of elements.
 
template<typename _Tp , int n>
void v_store (_Tp *ptr, const v_reg< _Tp, n > &a)
 Store data to memory.
 
template<typename _Tp , int n>
void v_store (_Tp *ptr, const v_reg< _Tp, n > &a, hal::StoreMode)
 
void v_store (double *ptr, const v_float64 &a)
 
void v_store (double *ptr, const v_float64 &a, hal::StoreMode)
 
void v_store (double *ptr, const v_float64x2 &a)
 
void v_store (double *ptr, const v_float64x2 &a, hal::StoreMode)
 
void v_store (float *ptr, const v_float32 &a)
 
void v_store (float *ptr, const v_float32 &a, hal::StoreMode)
 
void v_store (float *ptr, const v_float32x4 &a)
 
void v_store (float *ptr, const v_float32x4 &a, hal::StoreMode)
 
void v_store (int *ptr, const v_int32 &a)
 
void v_store (int *ptr, const v_int32 &a, hal::StoreMode)
 
void v_store (int *ptr, const v_int32x4 &a)
 
void v_store (int *ptr, const v_int32x4 &a, hal::StoreMode)
 
void v_store (int64 *ptr, const v_int64 &a)
 
void v_store (int64 *ptr, const v_int64 &a, hal::StoreMode)
 
void v_store (int64 *ptr, const v_int64x2 &a)
 
void v_store (int64 *ptr, const v_int64x2 &a, hal::StoreMode)
 
void v_store (schar *ptr, const v_int8 &a)
 
void v_store (schar *ptr, const v_int8 &a, hal::StoreMode)
 
void v_store (schar *ptr, const v_int8x16 &a)
 
void v_store (schar *ptr, const v_int8x16 &a, hal::StoreMode)
 
void v_store (short *ptr, const v_int16 &a)
 
void v_store (short *ptr, const v_int16 &a, hal::StoreMode)
 
void v_store (short *ptr, const v_int16x8 &a)
 
void v_store (short *ptr, const v_int16x8 &a, hal::StoreMode)
 
void v_store (uchar *ptr, const v_uint8 &a)
 
void v_store (uchar *ptr, const v_uint8 &a, hal::StoreMode)
 
void v_store (uchar *ptr, const v_uint8x16 &a)
 
void v_store (uchar *ptr, const v_uint8x16 &a, hal::StoreMode)
 
void v_store (uint64 *ptr, const v_uint64 &a)
 
void v_store (uint64 *ptr, const v_uint64 &a, hal::StoreMode)
 
void v_store (uint64 *ptr, const v_uint64x2 &a)
 
void v_store (uint64 *ptr, const v_uint64x2 &a, hal::StoreMode)
 
void v_store (unsigned *ptr, const v_uint32x4 &a)
 
void v_store (unsigned *ptr, const v_uint32x4 &a, hal::StoreMode)
 
void v_store (unsigned int *ptr, const v_uint32 &a)
 
void v_store (unsigned int *ptr, const v_uint32 &a, hal::StoreMode)
 
void v_store (ushort *ptr, const v_uint16 &a)
 
void v_store (ushort *ptr, const v_uint16 &a, hal::StoreMode)
 
void v_store (ushort *ptr, const v_uint16x8 &a)
 
void v_store (ushort *ptr, const v_uint16x8 &a, hal::StoreMode)
 
template<typename _Tp , int n>
void v_store_aligned (_Tp *ptr, const v_reg< _Tp, n > &a)
 Store data to memory (aligned)
 
template<typename _Tp , int n>
void v_store_aligned (_Tp *ptr, const v_reg< _Tp, n > &a, hal::StoreMode)
 
void v_store_aligned (double *ptr, const v_float64 &a)
 
void v_store_aligned (double *ptr, const v_float64x2 &a)
 
void v_store_aligned (float *ptr, const v_float32 &a)
 
void v_store_aligned (float *ptr, const v_float32x4 &a)
 
void v_store_aligned (int *ptr, const v_int32 &a)
 
void v_store_aligned (int *ptr, const v_int32x4 &a)
 
void v_store_aligned (int64 *ptr, const v_int64 &a)
 
void v_store_aligned (int64 *ptr, const v_int64x2 &a)
 
void v_store_aligned (schar *ptr, const v_int8 &a)
 
void v_store_aligned (schar *ptr, const v_int8x16 &a)
 
void v_store_aligned (short *ptr, const v_int16 &a)
 
void v_store_aligned (short *ptr, const v_int16x8 &a)
 
void v_store_aligned (uchar *ptr, const v_uint8 &a)
 
void v_store_aligned (uchar *ptr, const v_uint8x16 &a)
 
void v_store_aligned (uint64 *ptr, const v_uint64 &a)
 
void v_store_aligned (uint64 *ptr, const v_uint64x2 &a)
 
void v_store_aligned (unsigned *ptr, const v_uint32x4 &a)
 
void v_store_aligned (unsigned int *ptr, const v_uint32 &a)
 
void v_store_aligned (ushort *ptr, const v_uint16 &a)
 
void v_store_aligned (ushort *ptr, const v_uint16x8 &a)
 
template<typename _Tp , int n>
void v_store_aligned_nocache (_Tp *ptr, const v_reg< _Tp, n > &a)
 
void v_store_aligned_nocache (double *ptr, const v_float64 &a)
 
void v_store_aligned_nocache (double *ptr, const v_float64x2 &a)
 
void v_store_aligned_nocache (float *ptr, const v_float32 &a)
 
void v_store_aligned_nocache (float *ptr, const v_float32x4 &a)
 
void v_store_aligned_nocache (int *ptr, const v_int32 &a)
 
void v_store_aligned_nocache (int *ptr, const v_int32x4 &a)
 
void v_store_aligned_nocache (int64 *ptr, const v_int64 &a)
 
void v_store_aligned_nocache (int64 *ptr, const v_int64x2 &a)
 
void v_store_aligned_nocache (schar *ptr, const v_int8 &a)
 
void v_store_aligned_nocache (schar *ptr, const v_int8x16 &a)
 
void v_store_aligned_nocache (short *ptr, const v_int16 &a)
 
void v_store_aligned_nocache (short *ptr, const v_int16x8 &a)
 
void v_store_aligned_nocache (uchar *ptr, const v_uint8 &a)
 
void v_store_aligned_nocache (uchar *ptr, const v_uint8x16 &a)
 
void v_store_aligned_nocache (uint64 *ptr, const v_uint64 &a)
 
void v_store_aligned_nocache (uint64 *ptr, const v_uint64x2 &a)
 
void v_store_aligned_nocache (unsigned *ptr, const v_uint32x4 &a)
 
void v_store_aligned_nocache (unsigned int *ptr, const v_uint32 &a)
 
void v_store_aligned_nocache (ushort *ptr, const v_uint16 &a)
 
void v_store_aligned_nocache (ushort *ptr, const v_uint16x8 &a)
 
template<typename _Tp , int n>
void v_store_high (_Tp *ptr, const v_reg< _Tp, n > &a)
 Store data to memory (higher half)
 
void v_store_high (double *ptr, const v_float64 &a)
 
void v_store_high (double *ptr, const v_float64x2 &a)
 
void v_store_high (float *ptr, const v_float32 &a)
 
void v_store_high (float *ptr, const v_float32x4 &a)
 
void v_store_high (int *ptr, const v_int32 &a)
 
void v_store_high (int *ptr, const v_int32x4 &a)
 
void v_store_high (int64 *ptr, const v_int64 &a)
 
void v_store_high (int64 *ptr, const v_int64x2 &a)
 
void v_store_high (schar *ptr, const v_int8 &a)
 
void v_store_high (schar *ptr, const v_int8x16 &a)
 
void v_store_high (short *ptr, const v_int16 &a)
 
void v_store_high (short *ptr, const v_int16x8 &a)
 
void v_store_high (uchar *ptr, const v_uint8 &a)
 
void v_store_high (uchar *ptr, const v_uint8x16 &a)
 
void v_store_high (uint64 *ptr, const v_uint64 &a)
 
void v_store_high (uint64 *ptr, const v_uint64x2 &a)
 
void v_store_high (unsigned *ptr, const v_uint32x4 &a)
 
void v_store_high (unsigned int *ptr, const v_uint32 &a)
 
void v_store_high (ushort *ptr, const v_uint16 &a)
 
void v_store_high (ushort *ptr, const v_uint16x8 &a)
 
template<typename _Tp , int n>
void 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 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 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)
 
void v_store_interleave (double *ptr, const v_float64 &a, const v_float64 &b, const v_float64 &c, const v_float64 &d, hal::StoreMode=hal::STORE_UNALIGNED)
 
void v_store_interleave (double *ptr, const v_float64 &a, const v_float64 &b, const v_float64 &c, hal::StoreMode=hal::STORE_UNALIGNED)
 
void v_store_interleave (double *ptr, const v_float64 &a, const v_float64 &b, hal::StoreMode=hal::STORE_UNALIGNED)
 
void v_store_interleave (double *ptr, const v_float64x2 &a, const v_float64x2 &b, const v_float64x2 &c, const v_float64x2 &d, hal::StoreMode=hal::STORE_UNALIGNED)
 
void v_store_interleave (double *ptr, const v_float64x2 &a, const v_float64x2 &b, const v_float64x2 &c, hal::StoreMode=hal::STORE_UNALIGNED)
 
void v_store_interleave (double *ptr, const v_float64x2 &a, const v_float64x2 &b, hal::StoreMode=hal::STORE_UNALIGNED)
 
void v_store_interleave (float *ptr, const v_float32 &a, const v_float32 &b, const v_float32 &c, const v_float32 &d, hal::StoreMode=hal::STORE_UNALIGNED)
 
void v_store_interleave (float *ptr, const v_float32 &a, const v_float32 &b, const v_float32 &c, hal::StoreMode=hal::STORE_UNALIGNED)
 
void v_store_interleave (float *ptr, const v_float32 &a, const v_float32 &b, hal::StoreMode=hal::STORE_UNALIGNED)
 
void v_store_interleave (float *ptr, const v_float32x4 &a, const v_float32x4 &b, const v_float32x4 &c, const v_float32x4 &d, hal::StoreMode=hal::STORE_UNALIGNED)
 
void v_store_interleave (float *ptr, const v_float32x4 &a, const v_float32x4 &b, const v_float32x4 &c, hal::StoreMode=hal::STORE_UNALIGNED)
 
void v_store_interleave (float *ptr, const v_float32x4 &a, const v_float32x4 &b, hal::StoreMode=hal::STORE_UNALIGNED)
 
void v_store_interleave (int *ptr, const v_int32 &a, const v_int32 &b, const v_int32 &c, const v_int32 &d, hal::StoreMode=hal::STORE_UNALIGNED)
 
void v_store_interleave (int *ptr, const v_int32 &a, const v_int32 &b, const v_int32 &c, hal::StoreMode=hal::STORE_UNALIGNED)
 
void v_store_interleave (int *ptr, const v_int32 &a, const v_int32 &b, hal::StoreMode=hal::STORE_UNALIGNED)
 
void v_store_interleave (int *ptr, const v_int32x4 &a, const v_int32x4 &b, const v_int32x4 &c, const v_int32x4 &d, hal::StoreMode=hal::STORE_UNALIGNED)
 
void v_store_interleave (int *ptr, const v_int32x4 &a, const v_int32x4 &b, const v_int32x4 &c, hal::StoreMode=hal::STORE_UNALIGNED)
 
void v_store_interleave (int *ptr, const v_int32x4 &a, const v_int32x4 &b, hal::StoreMode=hal::STORE_UNALIGNED)
 
void v_store_interleave (int64 *ptr, const v_int64 &a, const v_int64 &b, const v_int64 &c, const v_int64 &d, hal::StoreMode=hal::STORE_UNALIGNED)
 
void v_store_interleave (int64 *ptr, const v_int64 &a, const v_int64 &b, const v_int64 &c, hal::StoreMode=hal::STORE_UNALIGNED)
 
void v_store_interleave (int64 *ptr, const v_int64 &a, const v_int64 &b, hal::StoreMode=hal::STORE_UNALIGNED)
 
void v_store_interleave (int64 *ptr, const v_int64x2 &a, const v_int64x2 &b, const v_int64x2 &c, const v_int64x2 &d, hal::StoreMode=hal::STORE_UNALIGNED)
 
void v_store_interleave (int64 *ptr, const v_int64x2 &a, const v_int64x2 &b, const v_int64x2 &c, hal::StoreMode=hal::STORE_UNALIGNED)
 
void v_store_interleave (int64 *ptr, const v_int64x2 &a, const v_int64x2 &b, hal::StoreMode=hal::STORE_UNALIGNED)
 
void v_store_interleave (schar *ptr, const v_int8 &a, const v_int8 &b, const v_int8 &c, const v_int8 &d, hal::StoreMode=hal::STORE_UNALIGNED)
 
void v_store_interleave (schar *ptr, const v_int8 &a, const v_int8 &b, const v_int8 &c, hal::StoreMode=hal::STORE_UNALIGNED)
 
void v_store_interleave (schar *ptr, const v_int8 &a, const v_int8 &b, hal::StoreMode=hal::STORE_UNALIGNED)
 
void v_store_interleave (schar *ptr, const v_int8x16 &a, const v_int8x16 &b, const v_int8x16 &c, const v_int8x16 &d, hal::StoreMode=hal::STORE_UNALIGNED)
 
void v_store_interleave (schar *ptr, const v_int8x16 &a, const v_int8x16 &b, const v_int8x16 &c, hal::StoreMode=hal::STORE_UNALIGNED)
 
void v_store_interleave (schar *ptr, const v_int8x16 &a, const v_int8x16 &b, hal::StoreMode=hal::STORE_UNALIGNED)
 
void v_store_interleave (short *ptr, const v_int16 &a, const v_int16 &b, const v_int16 &c, const v_int16 &d, hal::StoreMode=hal::STORE_UNALIGNED)
 
void v_store_interleave (short *ptr, const v_int16 &a, const v_int16 &b, const v_int16 &c, hal::StoreMode=hal::STORE_UNALIGNED)
 
void v_store_interleave (short *ptr, const v_int16 &a, const v_int16 &b, hal::StoreMode=hal::STORE_UNALIGNED)
 
void v_store_interleave (short *ptr, const v_int16x8 &a, const v_int16x8 &b, const v_int16x8 &c, const v_int16x8 &d, hal::StoreMode=hal::STORE_UNALIGNED)
 
void v_store_interleave (short *ptr, const v_int16x8 &a, const v_int16x8 &b, const v_int16x8 &c, hal::StoreMode=hal::STORE_UNALIGNED)
 
void v_store_interleave (short *ptr, const v_int16x8 &a, const v_int16x8 &b, hal::StoreMode=hal::STORE_UNALIGNED)
 
void v_store_interleave (uchar *ptr, const v_uint8 &a, const v_uint8 &b, const v_uint8 &c, const v_uint8 &d, hal::StoreMode=hal::STORE_UNALIGNED)
 
void v_store_interleave (uchar *ptr, const v_uint8 &a, const v_uint8 &b, const v_uint8 &c, hal::StoreMode=hal::STORE_UNALIGNED)
 
void v_store_interleave (uchar *ptr, const v_uint8 &a, const v_uint8 &b, hal::StoreMode=hal::STORE_UNALIGNED)
 
void v_store_interleave (uchar *ptr, const v_uint8x16 &a, const v_uint8x16 &b, const v_uint8x16 &c, const v_uint8x16 &d, hal::StoreMode=hal::STORE_UNALIGNED)
 
void v_store_interleave (uchar *ptr, const v_uint8x16 &a, const v_uint8x16 &b, const v_uint8x16 &c, hal::StoreMode=hal::STORE_UNALIGNED)
 
void v_store_interleave (uchar *ptr, const v_uint8x16 &a, const v_uint8x16 &b, hal::StoreMode=hal::STORE_UNALIGNED)
 
void v_store_interleave (uint64 *ptr, const v_uint64 &a, const v_uint64 &b, const v_uint64 &c, const v_uint64 &d, hal::StoreMode=hal::STORE_UNALIGNED)
 
void v_store_interleave (uint64 *ptr, const v_uint64 &a, const v_uint64 &b, const v_uint64 &c, hal::StoreMode=hal::STORE_UNALIGNED)
 
void v_store_interleave (uint64 *ptr, const v_uint64 &a, const v_uint64 &b, hal::StoreMode=hal::STORE_UNALIGNED)
 
void v_store_interleave (uint64 *ptr, const v_uint64x2 &a, const v_uint64x2 &b, const v_uint64x2 &c, const v_uint64x2 &d, hal::StoreMode=hal::STORE_UNALIGNED)
 
void v_store_interleave (uint64 *ptr, const v_uint64x2 &a, const v_uint64x2 &b, const v_uint64x2 &c, hal::StoreMode=hal::STORE_UNALIGNED)
 
void v_store_interleave (uint64 *ptr, const v_uint64x2 &a, const v_uint64x2 &b, hal::StoreMode=hal::STORE_UNALIGNED)
 
void v_store_interleave (unsigned *ptr, const v_uint32 &a, const v_uint32 &b, const v_uint32 &c, const v_uint32 &d, hal::StoreMode=hal::STORE_UNALIGNED)
 
void v_store_interleave (unsigned *ptr, const v_uint32 &a, const v_uint32 &b, const v_uint32 &c, hal::StoreMode=hal::STORE_UNALIGNED)
 
void v_store_interleave (unsigned *ptr, const v_uint32 &a, const v_uint32 &b, hal::StoreMode=hal::STORE_UNALIGNED)
 
void v_store_interleave (unsigned *ptr, const v_uint32x4 &a, const v_uint32x4 &b, const v_uint32x4 &c, const v_uint32x4 &d, hal::StoreMode=hal::STORE_UNALIGNED)
 
void v_store_interleave (unsigned *ptr, const v_uint32x4 &a, const v_uint32x4 &b, const v_uint32x4 &c, hal::StoreMode=hal::STORE_UNALIGNED)
 
void v_store_interleave (unsigned *ptr, const v_uint32x4 &a, const v_uint32x4 &b, hal::StoreMode=hal::STORE_UNALIGNED)
 
void v_store_interleave (ushort *ptr, const v_uint16 &a, const v_uint16 &b, const v_uint16 &c, const v_uint16 &d, hal::StoreMode=hal::STORE_UNALIGNED)
 
void v_store_interleave (ushort *ptr, const v_uint16 &a, const v_uint16 &b, const v_uint16 &c, hal::StoreMode=hal::STORE_UNALIGNED)
 
void v_store_interleave (ushort *ptr, const v_uint16 &a, const v_uint16 &b, hal::StoreMode=hal::STORE_UNALIGNED)
 
void v_store_interleave (ushort *ptr, const v_uint16x8 &a, const v_uint16x8 &b, const v_uint16x8 &c, const v_uint16x8 &d, hal::StoreMode=hal::STORE_UNALIGNED)
 
void v_store_interleave (ushort *ptr, const v_uint16x8 &a, const v_uint16x8 &b, const v_uint16x8 &c, hal::StoreMode=hal::STORE_UNALIGNED)
 
void v_store_interleave (ushort *ptr, const v_uint16x8 &a, const v_uint16x8 &b, hal::StoreMode=hal::STORE_UNALIGNED)
 
template<typename _Tp , int n>
void v_store_low (_Tp *ptr, const v_reg< _Tp, n > &a)
 Store data to memory (lower half)
 
void v_store_low (double *ptr, const v_float64 &a)
 
void v_store_low (double *ptr, const v_float64x2 &a)
 
void v_store_low (float *ptr, const v_float32 &a)
 
void v_store_low (float *ptr, const v_float32x4 &a)
 
void v_store_low (int *ptr, const v_int32 &a)
 
void v_store_low (int *ptr, const v_int32x4 &a)
 
void v_store_low (int64 *ptr, const v_int64 &a)
 
void v_store_low (int64 *ptr, const v_int64x2 &a)
 
void v_store_low (schar *ptr, const v_int8 &a)
 
void v_store_low (schar *ptr, const v_int8x16 &a)
 
void v_store_low (short *ptr, const v_int16 &a)
 
void v_store_low (short *ptr, const v_int16x8 &a)
 
void v_store_low (uchar *ptr, const v_uint8 &a)
 
void v_store_low (uchar *ptr, const v_uint8x16 &a)
 
void v_store_low (uint64 *ptr, const v_uint64 &a)
 
void v_store_low (uint64 *ptr, const v_uint64x2 &a)
 
void v_store_low (unsigned *ptr, const v_uint32x4 &a)
 
void v_store_low (unsigned int *ptr, const v_uint32 &a)
 
void v_store_low (ushort *ptr, const v_uint16 &a)
 
void v_store_low (ushort *ptr, const v_uint16x8 &a)
 
v_float32 v_sub (const v_float32 &a, const v_float32 &b)
 
v_float64 v_sub (const v_float64 &a, const v_float64 &b)
 
v_int16 v_sub (const v_int16 &a, const v_int16 &b)
 
v_int32 v_sub (const v_int32 &a, const v_int32 &b)
 
v_int64 v_sub (const v_int64 &a, const v_int64 &b)
 
v_int8 v_sub (const v_int8 &a, const v_int8 &b)
 
v_uint16 v_sub (const v_uint16 &a, const v_uint16 &b)
 
v_uint32 v_sub (const v_uint32 &a, const v_uint32 &b)
 
v_uint64 v_sub (const v_uint64 &a, const v_uint64 &b)
 
v_uint8 v_sub (const v_uint8 &a, const v_uint8 &b)
 
v_int16 v_sub_wrap (const v_int16 &a, const v_int16 &b)
 
v_int16x8 v_sub_wrap (const v_int16x8 &a, const v_int16x8 &b)
 
v_int8 v_sub_wrap (const v_int8 &a, const v_int8 &b)
 
v_int8x16 v_sub_wrap (const v_int8x16 &a, const v_int8x16 &b)
 
template<typename _Tp , int n>
v_reg< _Tp, n > v_sub_wrap (const v_reg< _Tp, n > &a, const v_reg< _Tp, n > &b)
 Subtract values without saturation.
 
v_uint16 v_sub_wrap (const v_uint16 &a, const v_uint16 &b)
 
v_uint16x8 v_sub_wrap (const v_uint16x8 &a, const v_uint16x8 &b)
 
v_uint8 v_sub_wrap (const v_uint8 &a, const v_uint8 &b)
 
v_uint8x16 v_sub_wrap (const v_uint8x16 &a, const v_uint8x16 &b)
 
void v_transpose4x4 (const v_float32 &a0, const v_float32 &a1, const v_float32 &a2, const v_float32 &a3, v_float32 &b0, v_float32 &b1, v_float32 &b2, v_float32 &b3)
 
void v_transpose4x4 (const v_float32x4 &a0, const v_float32x4 &a1, const v_float32x4 &a2, const v_float32x4 &a3, v_float32x4 &b0, v_float32x4 &b1, v_float32x4 &b2, v_float32x4 &b3)
 
void v_transpose4x4 (const v_int32 &a0, const v_int32 &a1, const v_int32 &a2, const v_int32 &a3, v_int32 &b0, v_int32 &b1, v_int32 &b2, v_int32 &b3)
 
void v_transpose4x4 (const v_int32x4 &a0, const v_int32x4 &a1, const v_int32x4 &a2, const v_int32x4 &a3, v_int32x4 &b0, v_int32x4 &b1, v_int32x4 &b2, v_int32x4 &b3)
 
void v_transpose4x4 (const v_uint32 &a0, const v_uint32 &a1, const v_uint32 &a2, const v_uint32 &a3, v_uint32 &b0, v_uint32 &b1, v_uint32 &b2, v_uint32 &b3)
 
void v_transpose4x4 (const v_uint32x4 &a0, const v_uint32x4 &a1, const v_uint32x4 &a2, const v_uint32x4 &a3, v_uint32x4 &b0, v_uint32x4 &b1, v_uint32x4 &b2, v_uint32x4 &b3)
 
template<typename _Tp , int n>
void 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)
 Transpose 4x4 matrix.
 
v_int32 v_trunc (const v_float32 &a)
 
v_int32x4 v_trunc (const v_float32x4 &a)
 
v_int32 v_trunc (const v_float64 &a)
 
v_int32x4 v_trunc (const v_float64x2 &a)
 
template<int n>
v_reg< int, n *2 > v_trunc (const v_reg< double, n > &a)
 
template<int n>
v_reg< int, n > v_trunc (const v_reg< float, n > &a)
 Truncate elements.
 
v_float32 v_xor (const v_float32 &a, const v_float32 &b)
 
v_float64 v_xor (const v_float64 &a, const v_float64 &b)
 
v_int16 v_xor (const v_int16 &a, const v_int16 &b)
 
v_int32 v_xor (const v_int32 &a, const v_int32 &b)
 
v_int64 v_xor (const v_int64 &a, const v_int64 &b)
 
v_int8 v_xor (const v_int8 &a, const v_int8 &b)
 
v_uint16 v_xor (const v_uint16 &a, const v_uint16 &b)
 
v_uint32 v_xor (const v_uint32 &a, const v_uint32 &b)
 
v_uint64 v_xor (const v_uint64 &a, const v_uint64 &b)
 
v_uint8 v_xor (const v_uint8 &a, const v_uint8 &b)
 
void v_zip (const v_float32 &a0, const v_float32 &a1, v_float32 &b0, v_float32 &b1)
 
void v_zip (const v_float32x4 &a0, const v_float32x4 &a1, v_float32x4 &b0, v_float32x4 &b1)
 
void v_zip (const v_float64x2 &a0, const v_float64x2 &a1, v_float64x2 &b0, v_float64x2 &b1)
 
void v_zip (const v_int16 &a0, const v_int16 &a1, v_int16 &b0, v_int16 &b1)
 
void v_zip (const v_int16x8 &a0, const v_int16x8 &a1, v_int16x8 &b0, v_int16x8 &b1)
 
void v_zip (const v_int32 &a0, const v_int32 &a1, v_int32 &b0, v_int32 &b1)
 
void v_zip (const v_int32x4 &a0, const v_int32x4 &a1, v_int32x4 &b0, v_int32x4 &b1)
 
void v_zip (const v_int8 &a0, const v_int8 &a1, v_int8 &b0, v_int8 &b1)
 
void v_zip (const v_int8x16 &a0, const v_int8x16 &a1, v_int8x16 &b0, v_int8x16 &b1)
 
template<typename _Tp , int n>
void 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.
 
void v_zip (const v_uint16 &a0, const v_uint16 &a1, v_uint16 &b0, v_uint16 &b1)
 
void v_zip (const v_uint16x8 &a0, const v_uint16x8 &a1, v_uint16x8 &b0, v_uint16x8 &b1)
 
void v_zip (const v_uint32 &a0, const v_uint32 &a1, v_uint32 &b0, v_uint32 &b1)
 
void v_zip (const v_uint32x4 &a0, const v_uint32x4 &a1, v_uint32x4 &b0, v_uint32x4 &b1)
 
void v_zip (const v_uint8 &a0, const v_uint8 &a1, v_uint8 &b0, v_uint8 &b1)
 
void v_zip (const v_uint8x16 &a0, const v_uint8x16 &a1, v_uint8x16 &b0, v_uint8x16 &b1)
 
void v_zip4 (const v_float32 &a0, const v_float32 &a1, v_float32 &b0, v_float32 &b1)
 
void v_zip4 (const v_int32 &a0, const v_int32 &a1, v_int32 &b0, v_int32 &b1)
 
void v_zip4 (const v_uint32 &a0, const v_uint32 &a1, v_uint32 &b0, v_uint32 &b1)
 
void validate_input_arg (const GRunArg &arg)
 
void validate_input_args (const GRunArgs &args)
 
void validateDisparity (InputOutputArray disparity, InputArray cost, int minDisparity, int numberOfDisparities, int disp12MaxDisp=1)
 validates disparity using the left-right check. The matrix "cost" should be computed by the stereo correspondence algorithm
 
GRunArg value_of (const GOrigin &origin)
 
void vconcat (const Mat *src, size_t nsrc, OutputArray dst)
 Applies vertical concatenation to given matrices.
 
void vconcat (InputArray src1, InputArray src2, OutputArray dst)
 
void vconcat (InputArrayOfArrays src, OutputArray dst)
 
vint16mf2_t vle16_v_i16mf2 (const int16_t *ptr, size_t vl)
 
vuint16mf2_t vle16_v_u16mf2 (const uint16_t *ptr, size_t vl)
 
vfloat32mf2_t vle32_v_f32mf2 (const float32_t *ptr, size_t vl)
 
vint32mf2_t vle32_v_i32mf2 (const int32_t *ptr, size_t vl)
 
vuint32mf2_t vle32_v_u32mf2 (const uint32_t *ptr, size_t vl)
 
vfloat64mf2_t vle64_v_f64mf2 (const float64_t *ptr, size_t vl)
 
vint64mf2_t vle64_v_i64mf2 (const int64_t *ptr, size_t vl)
 
vuint64mf2_t vle64_v_u64mf2 (const uint64_t *ptr, size_t vl)
 
vint8mf2_t vle8_v_i8mf2 (const int8_t *ptr, size_t vl)
 
vint8mf4_t vle8_v_i8mf4 (const int8_t *base, size_t vl)
 
vuint8mf2_t vle8_v_u8mf2 (const uint8_t *ptr, size_t vl)
 
vuint8mf4_t vle8_v_u8mf4 (const uint8_t *base, size_t vl)
 
void vse16_v_i16mf2 (int16_t *ptr, vint16mf2_t v, size_t vl)
 
void vse16_v_u16mf2 (uint16_t *ptr, vuint16mf2_t v, size_t vl)
 
void vse32_v_f32mf2 (float32_t *ptr, vfloat32mf2_t v, size_t vl)
 
void vse32_v_i32mf2 (int32_t *ptr, vint32mf2_t v, size_t vl)
 
void vse32_v_u32mf2 (uint32_t *ptr, vuint32mf2_t v, size_t vl)
 
void vse64_v_f64mf2 (float64_t *ptr, vfloat64mf2_t v, size_t vl)
 
void vse64_v_i64mf2 (int64_t *ptr, vint64mf2_t v, size_t vl)
 
void vse64_v_u64mf2 (uint64_t *ptr, vuint64mf2_t v, size_t vl)
 
void vse8_v_i8mf2 (int8_t *ptr, vint8mf2_t v, size_t vl)
 
void vse8_v_u8mf2 (uint8_t *ptr, vuint8mf2_t v, size_t vl)
 
vint16m1_t vwcvt_x_x_v_i16m1 (vint8mf2_t v, size_t vl)
 
vint16mf2_t vwcvt_x_x_v_i16mf2 (vint8mf4_t src, size_t vl)
 
vint32m1_t vwcvt_x_x_v_i32m1 (vint16mf2_t v, size_t vl)
 
vint64m1_t vwcvt_x_x_v_i64m1 (vint32mf2_t v, size_t vl)
 
vuint16m1_t vwcvtu_x_x_v_u16m1 (vuint8mf2_t v, size_t vl)
 
vuint16mf2_t vwcvtu_x_x_v_u16mf2 (vuint8mf4_t src, size_t vl)
 
vuint32m1_t vwcvtu_x_x_v_u32m1 (vuint16mf2_t v, size_t vl)
 
vuint64m1_t vwcvtu_x_x_v_u64m1 (vuint32mf2_t v, size_t vl)
 
int waitKey (int delay=0)
 Waits for a pressed key.
 
int waitKeyEx (int delay=0)
 Similar to waitKey, but returns full key code.
 
void warpAffine (InputArray src, OutputArray dst, InputArray M, Size dsize, int flags=INTER_LINEAR, int borderMode=BORDER_CONSTANT, const Scalar &borderValue=Scalar())
 Applies an affine transformation to an image.
 
void warpPerspective (InputArray src, OutputArray dst, InputArray M, Size dsize, int flags=INTER_LINEAR, int borderMode=BORDER_CONSTANT, const Scalar &borderValue=Scalar())
 Applies a perspective transformation to an image.
 
void warpPolar (InputArray src, OutputArray dst, Size dsize, Point2f center, double maxRadius, int flags)
 Remaps an image to polar or semilog-polar coordinates space.
 
void watershed (InputArray image, InputOutputArray markers)
 Performs a marker-based image segmentation using the watershed algorithm.
 
void winrt_imshow ()
 
void winrt_initContainer (::Windows::UI::Xaml::Controls::Panel^ container)
 Initializes container component that will be used to hold generated window content.
 
void winrt_onVisibilityChanged (bool visible)
 
void winrt_setFrameContainer (::Windows::UI::Xaml::Controls::Image^ image)
 
template<typename ... Args>
void winrt_startMessageLoop (std::function< void(Args...)> &&callback, Args... args)
 
template<typename ... Args>
void winrt_startMessageLoop (void callback(Args...), Args... args)
 
template void winrt_startMessageLoop (void callback(void))
 
float wrapperEMD (InputArray signature1, InputArray signature2, int distType, InputArray cost=noArray(), Ptr< float > lowerBound=Ptr< float >(), OutputArray flow=noArray())
 
void write (FileStorage &fs, const String &name, const optflow::GPCTree::Node &node)
 
bool writeOpticalFlow (const String &path, InputArray flow)
 Write a .flo to disk.
 
Init with zero

Create new vector with zero elements

v_uint8x16 v_setzero_u8 ()
 
v_int8x16 v_setzero_s8 ()
 
v_uint16x8 v_setzero_u16 ()
 
v_int16x8 v_setzero_s16 ()
 
v_uint32x4 v_setzero_u32 ()
 
v_int32x4 v_setzero_s32 ()
 
v_float32x4 v_setzero_f32 ()
 
v_float64x2 v_setzero_f64 ()
 
v_uint64x2 v_setzero_u64 ()
 
v_int64x2 v_setzero_s64 ()
 
v_uint8x32 v256_setzero_u8 ()
 
v_int8x32 v256_setzero_s8 ()
 
v_uint16x16 v256_setzero_u16 ()
 
v_int16x16 v256_setzero_s16 ()
 
v_uint32x8 v256_setzero_u32 ()
 
v_int32x8 v256_setzero_s32 ()
 
v_float32x8 v256_setzero_f32 ()
 
v_float64x4 v256_setzero_f64 ()
 
v_uint64x4 v256_setzero_u64 ()
 
v_int64x4 v256_setzero_s64 ()
 
v_uint8x64 v512_setzero_u8 ()
 
v_int8x64 v512_setzero_s8 ()
 
v_uint16x32 v512_setzero_u16 ()
 
v_int16x32 v512_setzero_s16 ()
 
v_uint32x16 v512_setzero_u32 ()
 
v_int32x16 v512_setzero_s32 ()
 
v_float32x16 v512_setzero_f32 ()
 
v_float64x8 v512_setzero_f64 ()
 
v_uint64x8 v512_setzero_u64 ()
 
v_int64x8 v512_setzero_s64 ()
 
Init with value

Create new vector with elements set to a specific value

v_uint8x16 v_setall_u8 (uchar val)
 
v_int8x16 v_setall_s8 (schar val)
 
v_uint16x8 v_setall_u16 (ushort val)
 
v_int16x8 v_setall_s16 (short val)
 
v_uint32x4 v_setall_u32 (unsigned val)
 
v_int32x4 v_setall_s32 (int val)
 
v_float32x4 v_setall_f32 (float val)
 
v_float64x2 v_setall_f64 (double val)
 
v_uint64x2 v_setall_u64 (uint64 val)
 
v_int64x2 v_setall_s64 (int64 val)
 
v_uint8x32 v256_setall_u8 (uchar val)
 
v_int8x32 v256_setall_s8 (schar val)
 
v_uint16x16 v256_setall_u16 (ushort val)
 
v_int16x16 v256_setall_s16 (short val)
 
v_uint32x8 v256_setall_u32 (unsigned val)
 
v_int32x8 v256_setall_s32 (int val)
 
v_float32x8 v256_setall_f32 (float val)
 
v_float64x4 v256_setall_f64 (double val)
 
v_uint64x4 v256_setall_u64 (uint64 val)
 
v_int64x4 v256_setall_s64 (int64 val)
 
v_uint8x64 v512_setall_u8 (uchar val)
 
v_int8x64 v512_setall_s8 (schar val)
 
v_uint16x32 v512_setall_u16 (ushort val)
 
v_int16x32 v512_setall_s16 (short val)
 
v_uint32x16 v512_setall_u32 (unsigned val)
 
v_int32x16 v512_setall_s32 (int val)
 
v_float32x16 v512_setall_f32 (float val)
 
v_float64x8 v512_setall_f64 (double val)
 
v_uint64x8 v512_setall_u64 (uint64 val)
 
v_int64x8 v512_setall_s64 (int64 val)
 
Reinterpret

Convert vector to different type without modifying underlying data.

template<typename _Tp0 , int n0>
v_reg< uchar, n0 *sizeof(_Tp0)/sizeof(uchar)> v_reinterpret_as_u8 (const v_reg< _Tp0, n0 > &a)
 
template<typename _Tp0 , int n0>
v_reg< schar, n0 *sizeof(_Tp0)/sizeof(schar)> v_reinterpret_as_s8 (const v_reg< _Tp0, n0 > &a)
 
template<typename _Tp0 , int n0>
v_reg< ushort, n0 *sizeof(_Tp0)/sizeof(ushort)> v_reinterpret_as_u16 (const v_reg< _Tp0, n0 > &a)
 
template<typename _Tp0 , int n0>
v_reg< short, n0 *sizeof(_Tp0)/sizeof(short)> v_reinterpret_as_s16 (const v_reg< _Tp0, n0 > &a)
 
template<typename _Tp0 , int n0>
v_reg< unsigned, n0 *sizeof(_Tp0)/sizeof(unsigned)> v_reinterpret_as_u32 (const v_reg< _Tp0, n0 > &a)
 
template<typename _Tp0 , int n0>
v_reg< int, n0 *sizeof(_Tp0)/sizeof(int)> v_reinterpret_as_s32 (const v_reg< _Tp0, n0 > &a)
 
template<typename _Tp0 , int n0>
v_reg< float, n0 *sizeof(_Tp0)/sizeof(float)> v_reinterpret_as_f32 (const v_reg< _Tp0, n0 > &a)
 
template<typename _Tp0 , int n0>
v_reg< double, n0 *sizeof(_Tp0)/sizeof(double)> v_reinterpret_as_f64 (const v_reg< _Tp0, n0 > &a)
 
template<typename _Tp0 , int n0>
v_reg< uint64, n0 *sizeof(_Tp0)/sizeof(uint64)> v_reinterpret_as_u64 (const v_reg< _Tp0, n0 > &a)
 
template<typename _Tp0 , int n0>
v_reg< int64, n0 *sizeof(_Tp0)/sizeof(int64)> v_reinterpret_as_s64 (const v_reg< _Tp0, n0 > &a)
 
Left shift

Shift left

template<int shift, int n>
v_reg< ushort, n > v_shl (const v_reg< ushort, n > &a)
 
template<int shift, int n>
v_reg< short, n > v_shl (const v_reg< short, n > &a)
 
template<int shift, int n>
v_reg< unsigned, n > v_shl (const v_reg< unsigned, n > &a)
 
template<int shift, int n>
v_reg< int, n > v_shl (const v_reg< int, n > &a)
 
template<int shift, int n>
v_reg< uint64, n > v_shl (const v_reg< uint64, n > &a)
 
template<int shift, int n>
v_reg< int64, n > v_shl (const v_reg< int64, n > &a)
 
Right shift

Shift right

template<int shift, int n>
v_reg< ushort, n > v_shr (const v_reg< ushort, n > &a)
 
template<int shift, int n>
v_reg< short, n > v_shr (const v_reg< short, n > &a)
 
template<int shift, int n>
v_reg< unsigned, n > v_shr (const v_reg< unsigned, n > &a)
 
template<int shift, int n>
v_reg< int, n > v_shr (const v_reg< int, n > &a)
 
template<int shift, int n>
v_reg< uint64, n > v_shr (const v_reg< uint64, n > &a)
 
template<int shift, int n>
v_reg< int64, n > v_shr (const v_reg< int64, n > &a)
 
Rounding shift

Rounding shift right

template<int shift, int n>
v_reg< ushort, n > v_rshr (const v_reg< ushort, n > &a)
 
template<int shift, int n>
v_reg< short, n > v_rshr (const v_reg< short, n > &a)
 
template<int shift, int n>
v_reg< unsigned, n > v_rshr (const v_reg< unsigned, n > &a)
 
template<int shift, int n>
v_reg< int, n > v_rshr (const v_reg< int, n > &a)
 
template<int shift, int n>
v_reg< uint64, n > v_rshr (const v_reg< uint64, n > &a)
 
template<int shift, int n>
v_reg< int64, n > v_rshr (const v_reg< int64, n > &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.
template<int n>
v_reg< uchar, 2 *n > v_pack (const v_reg< ushort, n > &a, const v_reg< ushort, n > &b)
 
template<int n>
v_reg< schar, 2 *n > v_pack (const v_reg< short, n > &a, const v_reg< short, n > &b)
 
template<int n>
v_reg< ushort, 2 *n > v_pack (const v_reg< unsigned, n > &a, const v_reg< unsigned, n > &b)
 
template<int n>
v_reg< short, 2 *n > v_pack (const v_reg< int, n > &a, const v_reg< int, n > &b)
 
template<int n>
v_reg< unsigned, 2 *n > v_pack (const v_reg< uint64, n > &a, const v_reg< uint64, n > &b)
 
template<int n>
v_reg< int, 2 *n > v_pack (const v_reg< int64, n > &a, const v_reg< int64, n > &b)
 
template<int n>
v_reg< uchar, 2 *n > v_pack_u (const v_reg< short, n > &a, const v_reg< short, n > &b)
 
template<int n>
v_reg< ushort, 2 *n > v_pack_u (const v_reg< int, n > &a, const v_reg< int, n > &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 shift, int n>
v_reg< uchar, 2 *n > 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 > 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 > 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 > 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 > 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 > 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 > 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 > v_rshr_pack_u (const v_reg< int, n > &a, const v_reg< int, n > &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.
template<int n>
void v_pack_store (uchar *ptr, const v_reg< ushort, n > &a)
 
template<int n>
void v_pack_store (schar *ptr, const v_reg< short, n > &a)
 
template<int n>
void v_pack_store (ushort *ptr, const v_reg< unsigned, n > &a)
 
template<int n>
void v_pack_store (short *ptr, const v_reg< int, n > &a)
 
template<int n>
void v_pack_store (unsigned *ptr, const v_reg< uint64, n > &a)
 
template<int n>
void v_pack_store (int *ptr, const v_reg< int64, n > &a)
 
template<int n>
void v_pack_u_store (uchar *ptr, const v_reg< short, n > &a)
 
template<int n>
void v_pack_u_store (ushort *ptr, const v_reg< int, n > &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 shift, int n>
void v_rshr_pack_store (uchar *ptr, const v_reg< ushort, n > &a)
 
template<int shift, int n>
void v_rshr_pack_store (schar *ptr, const v_reg< short, n > &a)
 
template<int shift, int n>
void v_rshr_pack_store (ushort *ptr, const v_reg< unsigned, n > &a)
 
template<int shift, int n>
void v_rshr_pack_store (short *ptr, const v_reg< int, n > &a)
 
template<int shift, int n>
void v_rshr_pack_store (unsigned *ptr, const v_reg< uint64, n > &a)
 
template<int shift, int n>
void v_rshr_pack_store (int *ptr, const v_reg< int64, n > &a)
 
template<int shift, int n>
void v_rshr_pack_u_store (uchar *ptr, const v_reg< short, n > &a)
 
template<int shift, int n>
void v_rshr_pack_u_store (ushort *ptr, const v_reg< int, n > &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.
template<int n>
v_reg< uchar, 2 *n > v_pack_b (const v_reg< ushort, n > &a, const v_reg< ushort, n > &b)
 ! For 16-bit boolean values
 
template<int n>
v_reg< uchar, 4 *n > 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 > 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)
 

Variables

static const int __cv_rvv_e16m1_nlanes = vsetvlmax_e16m1()
 
static const int __cv_rvv_e16m2_nlanes = vsetvlmax_e16m2()
 
static const int __cv_rvv_e16m4_nlanes = vsetvlmax_e16m4()
 
static const int __cv_rvv_e16m8_nlanes = vsetvlmax_e16m8()
 
static const int __cv_rvv_e32m1_nlanes = vsetvlmax_e32m1()
 
static const int __cv_rvv_e32m2_nlanes = vsetvlmax_e32m2()
 
static const int __cv_rvv_e32m4_nlanes = vsetvlmax_e32m4()
 
static const int __cv_rvv_e32m8_nlanes = vsetvlmax_e32m8()
 
static const int __cv_rvv_e64m1_nlanes = vsetvlmax_e64m1()
 
static const int __cv_rvv_e64m2_nlanes = vsetvlmax_e64m2()
 
static const int __cv_rvv_e64m4_nlanes = vsetvlmax_e64m4()
 
static const int __cv_rvv_e64m8_nlanes = vsetvlmax_e64m8()
 
static const int __cv_rvv_e8m1_nlanes = vsetvlmax_e8m1()
 
static const int __cv_rvv_e8m2_nlanes = vsetvlmax_e8m2()
 
static const int __cv_rvv_e8m4_nlanes = vsetvlmax_e8m4()
 
static const int __cv_rvv_e8m8_nlanes = vsetvlmax_e8m8()
 
class GAPI_EXPORTS_W_SIMPLE GKernelPackage
 
static uint64_t idx_interleave_pairs []
 
static uint64_t idx_interleave_quads []
 
static const unsigned char popCountTable [256]
 
static const unsigned char popCountTable []
 
static const unsigned char popCountTable []
 

Detailed Description

"black box" representation of the file storage associated with a file on disk.

Several functions that are described below take CvFileStorage* as inputs and allow the user to save or to load hierarchical collections that consist of scalar values, standard CXCore objects (such as matrices, sequences, graphs), and user-defined objects.

OpenCV can read and write data in XML (http://www.w3c.org/XML), YAML (http://www.yaml.org) or JSON (http://www.json.org/) formats. Below is an example of 3x3 floating-point identity matrix A, stored in XML and YAML files using CXCore functions: XML:

<?xml version="1.0">
<opencv_storage>
<A type_id="opencv-matrix">
<rows>3</rows>
<cols>3</cols>
<dt>f</dt>
<data>1. 0. 0. 0. 1. 0. 0. 0. 1.</data>
</A>
</opencv_storage>

YAML:

%YAML:1.0
A: !!opencv-matrix
rows: 3
cols: 3
dt: f
data: [ 1., 0., 0., 0., 1., 0., 0., 0., 1.]

As it can be seen from the examples, XML uses nested tags to represent hierarchy, while YAML uses indentation for that purpose (similar to the Python programming language).

The same functions can read and write data in both formats; the particular format is determined by the extension of the opened file, ".xml" for XML files, ".yml" or ".yaml" for YAML and ".json" for JSON.

YOUR ATTENTION PLEASE!

This is a header-only implementation of cv::VideoCapture-based Stream source. It is not built by default with G-API as G-API doesn't depend on videoio module.

If you want to use it in your application, please make sure videioio is available in your OpenCV package and is linked to your application.

Note for developers: please don't put videoio dependency in G-API because of this file.

OpenCV namespace

Typedef Documentation

◆ FPDenormalsIgnoreHintScope

◆ frame_iterator

typedef frame_list::iterator cv::frame_iterator

◆ frame_list

typedef std::deque< std::pair<uint64_t, uint32_t> > cv::frame_list

◆ GArgs

using cv::GArgs = typedef std::vector<GArg>

◆ GCtors

using cv::GCtors = typedef std::vector<detail::HostCtor>

◆ GInferInputs

G-API object used to collect network inputs.

◆ GInferListInputs

G-API object used to collect the list of network inputs.

◆ GInferListOutputs

G-API object used to collect the list of network outputs.

◆ GInferOutputs

G-API object used to collect network outputs.

◆ GKinds

using cv::GKinds = typedef std::vector<cv::detail::OpaqueKind>

◆ GMetaArg

◆ GMetaArgs

using cv::GMetaArgs = typedef std::vector<GMetaArg>

◆ GOptRunArg

◆ GOptRunArgP

◆ GOptRunArgs

using cv::GOptRunArgs = typedef std::vector<GOptRunArg>

◆ GOptRunArgsP

using cv::GOptRunArgsP = typedef std::vector<GOptRunArgP>

◆ GProtoArg

◆ GProtoArgs

using cv::GProtoArgs = typedef std::vector<GProtoArg>

◆ GProtoInputArgs

◆ GProtoOutputArgs

◆ GRunArgBase

◆ GRunArgP

◆ GRunArgs

using cv::GRunArgs = typedef std::vector<GRunArg>

◆ GRunArgsP

using cv::GRunArgsP = typedef std::vector<GRunArgP>

◆ GShapes

using cv::GShapes = typedef std::vector<GShape>

◆ GTypesInfo

typedef std::vector< GTypeInfo > cv::GTypesInfo

◆ int16_t

typedef ::int16_t cv::int16_t

◆ int32_t

typedef ::int32_t cv::int32_t

◆ int64

using cv::int64 = typedef long int

◆ int64_t

typedef ::int64_t cv::int64_t

◆ int8_t

typedef ::int8_t cv::int8_t

◆ optional

template<class T >
using cv::optional = typedef cv::util::optional<T>

◆ schar

using cv::schar = typedef signed char

◆ uchar

using cv::uchar = typedef unsigned char

◆ uint

using cv::uint = typedef unsigned int

◆ uint16_t

typedef ::uint16_t cv::uint16_t

◆ uint32_t

typedef ::uint32_t cv::uint32_t

◆ uint64

using cv::uint64 = typedef unsigned long int

◆ uint64_t

typedef ::uint64_t cv::uint64_t

◆ uint8_t

typedef ::uint8_t cv::uint8_t

◆ ushort

using cv::ushort = typedef unsigned short

◆ v_float32

using cv::v_float32 = typedef vfloat32m1_t

◆ v_float64

using cv::v_float64 = typedef vfloat64m1_t

◆ v_int16

using cv::v_int16 = typedef vint16m1_t

◆ v_int32

using cv::v_int32 = typedef vint32m1_t

◆ v_int64

using cv::v_int64 = typedef vint64m1_t

◆ v_int8

using cv::v_int8 = typedef vint8m1_t

◆ v_uint16

using cv::v_uint16 = typedef vuint16m1_t

◆ v_uint32

using cv::v_uint32 = typedef vuint32m1_t

◆ v_uint64

using cv::v_uint64 = typedef vuint64m1_t

◆ v_uint8

using cv::v_uint8 = typedef vuint8m1_t

Enumeration Type Documentation

◆ anonymous enum

anonymous enum
Enumerator
COLORSPACE_GRAY 
COLORSPACE_RGBA 
COLORSPACE_BGR 
COLORSPACE_YUV444P 

◆ Codecs

enum cv::Codecs
Enumerator
MJPEG 

◆ GShape

enum class cv::GShape : int
strong
Enumerator
GMAT 
GSCALAR 
GARRAY 
GOPAQUE 
GFRAME 

◆ MediaFormat

enum class cv::MediaFormat : int
strong
Enumerator
BGR 
NV12 
GRAY 

◆ StreamType

Enumerator
db 
dc 
pc 
wb 

Function Documentation

◆ abs() [1/4]

static uchar cv::abs ( uchar  a)
inlinestatic

◆ abs() [2/4]

static uint64 cv::abs ( uint64  a)
inlinestatic

◆ abs() [3/4]

static unsigned cv::abs ( unsigned  a)
inlinestatic

◆ abs() [4/4]

static ushort cv::abs ( ushort  a)
inlinestatic

◆ can_describe() [1/3]

bool cv::can_describe ( const GMetaArg meta,
const GRunArg arg 
)

◆ can_describe() [2/3]

bool cv::can_describe ( const GMetaArg meta,
const GRunArgP argp 
)

◆ can_describe() [3/3]

bool cv::can_describe ( const GMetaArgs metas,
const GRunArgs args 
)

◆ computeRecallPrecisionCurve()

void cv::computeRecallPrecisionCurve ( const std::vector< std::vector< DMatch > > &  matches1to2,
const std::vector< std::vector< uchar > > &  correctMatches1to2Mask,
std::vector< Point2f > &  recallPrecisionCurve 
)

◆ depthToString()

const char * cv::depthToString ( int  depth)

Returns string of cv::Mat depth value: CV_8U -> "CV_8U" or "<invalid depth>"

◆ descr_of() [1/4]

GMetaArg cv::descr_of ( const GRunArg arg)

◆ descr_of() [2/4]

GMetaArg cv::descr_of ( const GRunArgP argp)

◆ descr_of() [3/4]

GMetaArgs cv::descr_of ( const GRunArgs args)

◆ descr_of() [4/4]

GFrameDesc cv::descr_of ( const MediaFrame frame)

◆ descrs_of() [1/2]

cv::GMetaArgs cv::descrs_of ( const std::vector< cv::Mat > &  vec)

◆ descrs_of() [2/2]

cv::GMetaArgs cv::descrs_of ( const std::vector< cv::UMat > &  vec)

◆ dumpOpenCLInformation()

static void cv::dumpOpenCLInformation ( )
static

◆ evaluateFeatureDetector()

void cv::evaluateFeatureDetector ( const Mat img1,
const Mat img2,
const Mat H1to2,
std::vector< KeyPoint > *  keypoints1,
std::vector< KeyPoint > *  keypoints2,
float &  repeatability,
int &  correspCount,
const Ptr< FeatureDetector > &  fdetector = PtrFeatureDetector >() 
)

◆ getNearestPoint()

int cv::getNearestPoint ( const std::vector< Point2f > &  recallPrecisionCurve,
float  l_precision 
)

◆ getRecall()

float cv::getRecall ( const std::vector< Point2f > &  recallPrecisionCurve,
float  l_precision 
)

◆ gin()

template<typename... Ts>
GRunArgs cv::gin ( const Ts &...  args)
inline

◆ GIn()

template<typename... Ts>
GProtoInputArgs cv::GIn ( Ts &&...  ts)
inline

◆ GOut() [1/3]

template<typename... Ts>
GProtoOutputArgs cv::GOut ( const std::tuple< Ts... > &  ts)
inline

◆ gout() [1/2]

template<typename T , typename... Ts>
GOptRunArgsP cv::gout ( optional< T > &  arg,
optional< Ts > &...  args 
)
inline

◆ GOut() [2/3]

template<typename... Ts>
GProtoOutputArgs cv::GOut ( std::tuple< Ts... > &&  ts)
inline

◆ GOut() [3/3]

template<typename... Ts>
GProtoOutputArgs cv::GOut ( Ts &&...  ts)
inline

◆ gout() [2/2]

template<typename... Ts>
GRunArgsP cv::gout ( Ts &...  args)
inline

◆ haveOpenVX()

bool cv::haveOpenVX ( )

Check if use of OpenVX is possible.

◆ HoughLinesWithAccumulator()

static void cv::HoughLinesWithAccumulator ( InputArray  image,
OutputArray  lines,
double  rho,
double  theta,
int  threshold,
double  srn = 0,
double  stn = 0,
double  min_theta = 0,
double  max_theta = CV_PI 
)
inlinestatic

Finds lines in a binary image using the standard Hough transform and get accumulator.

Note
This function is for bindings use only. Use original function in C++ code
See also
HoughLines

◆ icvExtractPattern()

std::string cv::icvExtractPattern ( const std::string &  filename,
unsigned *  offset 
)

◆ operator!=() [1/13]

cv::GMat cv::operator!= ( const cv::GMat lhs,
const cv::GMat rhs 
)

◆ operator!=() [2/13]

cv::GMat cv::operator!= ( const cv::GMat lhs,
const cv::GScalar rhs 
)

◆ operator!=() [3/13]

cv::GMat cv::operator!= ( const cv::GScalar lhs,
const cv::GMat rhs 
)

◆ operator!=() [4/13]

v_float32x4 cv::operator!= ( const v_float32x4 a,
const v_float32x4 b 
)
inline

◆ operator!=() [5/13]

v_float64x2 cv::operator!= ( const v_float64x2 a,
const v_float64x2 b 
)
inline

◆ operator!=() [6/13]

v_int16x8 cv::operator!= ( const v_int16x8 a,
const v_int16x8 b 
)
inline

◆ operator!=() [7/13]

v_int32x4 cv::operator!= ( const v_int32x4 a,
const v_int32x4 b 
)
inline

◆ operator!=() [8/13]

v_int64x2 cv::operator!= ( const v_int64x2 a,
const v_int64x2 b 
)
inline

◆ operator!=() [9/13]

v_int8x16 cv::operator!= ( const v_int8x16 a,
const v_int8x16 b 
)
inline

◆ operator!=() [10/13]

v_uint16x8 cv::operator!= ( const v_uint16x8 a,
const v_uint16x8 b 
)
inline

◆ operator!=() [11/13]

v_uint32x4 cv::operator!= ( const v_uint32x4 a,
const v_uint32x4 b 
)
inline

◆ operator!=() [12/13]

v_uint64x2 cv::operator!= ( const v_uint64x2 a,
const v_uint64x2 b 
)
inline

◆ operator!=() [13/13]

v_uint8x16 cv::operator!= ( const v_uint8x16 a,
const v_uint8x16 b 
)
inline

◆ operator&() [1/13]

cv::GMat cv::operator& ( const cv::GMat lhs,
const cv::GMat rhs 
)

◆ operator&() [2/13]

cv::GMat cv::operator& ( const cv::GMat lhs,
const cv::GScalar rhs 
)

◆ operator&() [3/13]

cv::GMat cv::operator& ( const cv::GScalar lhs,
const cv::GMat rhs 
)

◆ operator&() [4/13]

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

◆ operator&() [5/13]

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

◆ operator&() [6/13]

v_int16x8 cv::operator& ( const v_int16x8 a,
const v_int16x8 b 
)
inline

◆ operator&() [7/13]

v_int32x4 cv::operator& ( const v_int32x4 a,
const v_int32x4 b 
)
inline

◆ operator&() [8/13]

v_int64x2 cv::operator& ( const v_int64x2 a,
const v_int64x2 b 
)
inline

◆ operator&() [9/13]

v_int8x16 cv::operator& ( const v_int8x16 a,
const v_int8x16 b 
)
inline

◆ operator&() [10/13]

v_uint16x8 cv::operator& ( const v_uint16x8 a,
const v_uint16x8 b 
)
inline

◆ operator&() [11/13]

v_uint32x4 cv::operator& ( const v_uint32x4 a,
const v_uint32x4 b 
)
inline

◆ operator&() [12/13]

v_uint64x2 cv::operator& ( const v_uint64x2 a,
const v_uint64x2 b 
)
inline

◆ operator&() [13/13]

v_uint8x16 cv::operator& ( const v_uint8x16 a,
const v_uint8x16 b 
)
inline

◆ operator&=() [1/10]

v_float32x4 & cv::operator&= ( v_float32x4 a,
const v_float32x4 b 
)
inline

◆ operator&=() [2/10]

v_float64x2 & cv::operator&= ( v_float64x2 a,
const v_float64x2 b 
)
inline

◆ operator&=() [3/10]

v_int16x8 & cv::operator&= ( v_int16x8 a,
const v_int16x8 b 
)
inline

◆ operator&=() [4/10]

v_int32x4 & cv::operator&= ( v_int32x4 a,
const v_int32x4 b 
)
inline

◆ operator&=() [5/10]

v_int64x2 & cv::operator&= ( v_int64x2 a,
const v_int64x2 b 
)
inline

◆ operator&=() [6/10]

v_int8x16 & cv::operator&= ( v_int8x16 a,
const v_int8x16 b 
)
inline

◆ operator&=() [7/10]

v_uint16x8 & cv::operator&= ( v_uint16x8 a,
const v_uint16x8 b 
)
inline

◆ operator&=() [8/10]

v_uint32x4 & cv::operator&= ( v_uint32x4 a,
const v_uint32x4 b 
)
inline

◆ operator&=() [9/10]

v_uint64x2 & cv::operator&= ( v_uint64x2 a,
const v_uint64x2 b 
)
inline

◆ operator&=() [10/10]

v_uint8x16 & cv::operator&= ( v_uint8x16 a,
const v_uint8x16 b 
)
inline

◆ operator*() [1/14]

cv::GMat cv::operator* ( const cv::GMat lhs,
const cv::GScalar rhs 
)

◆ operator*() [2/14]

cv::GMat cv::operator* ( const cv::GMat lhs,
float  rhs 
)

◆ operator*() [3/14]

cv::GMat cv::operator* ( const cv::GScalar lhs,
const cv::GMat rhs 
)

◆ operator*() [4/14]

v_float32x4 cv::operator* ( const v_float32x4 a,
const v_float32x4 b 
)
inline

◆ operator*() [5/14]

v_float64x2 cv::operator* ( const v_float64x2 a,
const v_float64x2 b 
)
inline

◆ operator*() [6/14]

v_int16x8 cv::operator* ( const v_int16x8 a,
const v_int16x8 b 
)
inline

◆ operator*() [7/14]

v_int32x4 cv::operator* ( const v_int32x4 a,
const v_int32x4 b 
)
inline

◆ operator*() [8/14]

v_int64x2 cv::operator* ( const v_int64x2 a,
const v_int64x2 b 
)
inline

◆ operator*() [9/14]

v_int8x16 cv::operator* ( const v_int8x16 a,
const v_int8x16 b 
)
inline

◆ operator*() [10/14]

v_uint16x8 cv::operator* ( const v_uint16x8 a,
const v_uint16x8 b 
)
inline

◆ operator*() [11/14]

v_uint32x4 cv::operator* ( const v_uint32x4 a,
const v_uint32x4 b 
)
inline

◆ operator*() [12/14]

v_uint64x2 cv::operator* ( const v_uint64x2 a,
const v_uint64x2 b 
)
inline

◆ operator*() [13/14]

v_uint8x16 cv::operator* ( const v_uint8x16 a,
const v_uint8x16 b 
)
inline

◆ operator*() [14/14]

cv::GMat cv::operator* ( float  lhs,
const cv::GMat rhs 
)

◆ operator*=() [1/10]

v_float32x4 & cv::operator*= ( v_float32x4 a,
const v_float32x4 b 
)
inline

◆ operator*=() [2/10]

v_float64x2 & cv::operator*= ( v_float64x2 a,
const v_float64x2 b 
)
inline

◆ operator*=() [3/10]

v_int16x8 & cv::operator*= ( v_int16x8 a,
const v_int16x8 b 
)
inline

◆ operator*=() [4/10]

v_int32x4 & cv::operator*= ( v_int32x4 a,
const v_int32x4 b 
)
inline

◆ operator*=() [5/10]

v_int64x2 & cv::operator*= ( v_int64x2 a,
const v_int64x2 b 
)
inline

◆ operator*=() [6/10]

v_int8x16 & cv::operator*= ( v_int8x16 a,
const v_int8x16 b 
)
inline

◆ operator*=() [7/10]

v_uint16x8 & cv::operator*= ( v_uint16x8 a,
const v_uint16x8 b 
)
inline

◆ operator*=() [8/10]

v_uint32x4 & cv::operator*= ( v_uint32x4 a,
const v_uint32x4 b 
)
inline

◆ operator*=() [9/10]

v_uint64x2 & cv::operator*= ( v_uint64x2 a,
const v_uint64x2 b 
)
inline

◆ operator*=() [10/10]

v_uint8x16 & cv::operator*= ( v_uint8x16 a,
const v_uint8x16 b 
)
inline

◆ operator+() [1/13]

cv::GMat cv::operator+ ( const cv::GMat lhs,
const cv::GMat rhs 
)

◆ operator+() [2/13]

cv::GMat cv::operator+ ( const cv::GMat lhs,
const cv::GScalar rhs 
)

◆ operator+() [3/13]

cv::GMat cv::operator+ ( const cv::GScalar lhs,
const cv::GMat rhs 
)

◆ operator+() [4/13]

v_float32x4 cv::operator+ ( const v_float32x4 a,
const v_float32x4 b 
)
inline

◆ operator+() [5/13]

v_float64x2 cv::operator+ ( const v_float64x2 a,
const v_float64x2 b 
)
inline

◆ operator+() [6/13]

v_int16x8 cv::operator+ ( const v_int16x8 a,
const v_int16x8 b 
)
inline

◆ operator+() [7/13]

v_int32x4 cv::operator+ ( const v_int32x4 a,
const v_int32x4 b 
)
inline

◆ operator+() [8/13]

v_int64x2 cv::operator+ ( const v_int64x2 a,
const v_int64x2 b 
)
inline

◆ operator+() [9/13]

v_int8x16 cv::operator+ ( const v_int8x16 a,
const v_int8x16 b 
)
inline

◆ operator+() [10/13]

v_uint16x8 cv::operator+ ( const v_uint16x8 a,
const v_uint16x8 b 
)
inline

◆ operator+() [11/13]

v_uint32x4 cv::operator+ ( const v_uint32x4 a,
const v_uint32x4 b 
)
inline

◆ operator+() [12/13]

v_uint64x2 cv::operator+ ( const v_uint64x2 a,
const v_uint64x2 b 
)
inline

◆ operator+() [13/13]

v_uint8x16 cv::operator+ ( const v_uint8x16 a,
const v_uint8x16 b 
)
inline

◆ operator+=() [1/13]

template<typename Tg >
cv::GIOProtoArgs< Tg > & cv::operator+= ( cv::GIOProtoArgs< Tg > &  lhs,
const cv::GIOProtoArgs< Tg > &  rhs 
)

It's an ordinary overload of addition assignment operator.

Example of usage:

auto ins = cv::GIn();
cv::GMat in1;
if (need_first_conversion)
ins += cv::GIn(in1);
cv::GMat in2;
if (need_second_conversion)
ins += cv::GIn(in2);
auto outs = cv::GOut();
cv::GMat out1 = cv::gapi::resize(in1, szOut);
if (need_first_conversion)
outs += cv::GOut(out1);
cv::GMat out2 = cv::gapi::resize(in2, szOut);
if (need_second_conversion)
outs += cv::GOut(out2);
GMat class represents image or tensor data in the graph.
Definition: gmat.hpp:67
GMat resize(const GMat &src, const Size &dsize, double fx=0, double fy=0, int interpolation=INTER_LINEAR)
Resizes an image.
GProtoInputArgs GIn(Ts &&... ts)
Definition: gproto.hpp:96
GProtoOutputArgs GOut(Ts &&... ts)
Definition: gproto.hpp:101

◆ operator+=() [2/13]

GRunArgs & cv::operator+= ( GRunArgs lhs,
const GRunArgs rhs 
)
inline

This operator allows to complement the input vector at runtime.

It's an ordinary overload of addition assignment operator.

Example of usage:

auto in_vector = cv::gin();
cv::Mat in_mat1( 8, 8, CV_8UC3);
cv::Mat in_mat2(16, 16, CV_8UC3);
if (need_first_conversion)
in_vector += cv::gin(in_mat1);
if (need_second_conversion)
in_vector += cv::gin(in_mat2);
n-dimensional dense array class
Definition: mat.hpp:811
static Scalar_< double > all(double v0)
returns a scalar with all elements set to v0
void randu(InputOutputArray dst, InputArray low, InputArray high)
Generates a single uniformly-distributed random number or an array of random numbers.
#define CV_8UC3
Definition: interface.h:90
GRunArgs gin(const Ts &... args)
Definition: garg.hpp:273

◆ operator+=() [3/13]

GRunArgsP & cv::operator+= ( GRunArgsP lhs,
const GRunArgsP rhs 
)
inline

This operator allows to complement the output vector at runtime.

It's an ordinary overload of addition assignment operator.

Example of usage:

auto out_vector = cv::gout();
cv::Mat out_mat1, out_mat2;
if (need_first_conversion)
out_vector += cv::gout(out_mat1);
if (need_second_conversion)
out_vector += cv::gout(out_mat2);
GRunArgsP gout(Ts &... args)
Definition: garg.hpp:278

◆ operator+=() [4/13]

v_float32x4 & cv::operator+= ( v_float32x4 a,
const v_float32x4 b 
)
inline

◆ operator+=() [5/13]

v_float64x2 & cv::operator+= ( v_float64x2 a,
const v_float64x2 b 
)
inline

◆ operator+=() [6/13]

v_int16x8 & cv::operator+= ( v_int16x8 a,
const v_int16x8 b 
)
inline

◆ operator+=() [7/13]

v_int32x4 & cv::operator+= ( v_int32x4 a,
const v_int32x4 b 
)
inline

◆ operator+=() [8/13]

v_int64x2 & cv::operator+= ( v_int64x2 a,
const v_int64x2 b 
)
inline

◆ operator+=() [9/13]

v_int8x16 & cv::operator+= ( v_int8x16 a,
const v_int8x16 b 
)
inline

◆ operator+=() [10/13]

v_uint16x8 & cv::operator+= ( v_uint16x8 a,
const v_uint16x8 b 
)
inline

◆ operator+=() [11/13]

v_uint32x4 & cv::operator+= ( v_uint32x4 a,
const v_uint32x4 b 
)
inline

◆ operator+=() [12/13]

v_uint64x2 & cv::operator+= ( v_uint64x2 a,
const v_uint64x2 b 
)
inline

◆ operator+=() [13/13]

v_uint8x16 & cv::operator+= ( v_uint8x16 a,
const v_uint8x16 b 
)
inline

◆ operator-() [1/13]

cv::GMat cv::operator- ( const cv::GMat lhs,
const cv::GMat rhs 
)

◆ operator-() [2/13]

cv::GMat cv::operator- ( const cv::GMat lhs,
const cv::GScalar rhs 
)

◆ operator-() [3/13]

cv::GMat cv::operator- ( const cv::GScalar lhs,
const cv::GMat rhs 
)

◆ operator-() [4/13]

v_float32x4 cv::operator- ( const v_float32x4 a,
const v_float32x4 b 
)
inline

◆ operator-() [5/13]

v_float64x2 cv::operator- ( const v_float64x2 a,
const v_float64x2 b 
)
inline

◆ operator-() [6/13]

v_int16x8 cv::operator- ( const v_int16x8 a,
const v_int16x8 b 
)
inline

◆ operator-() [7/13]

v_int32x4 cv::operator- ( const v_int32x4 a,
const v_int32x4 b 
)
inline

◆ operator-() [8/13]

v_int64x2 cv::operator- ( const v_int64x2 a,
const v_int64x2 b 
)
inline

◆ operator-() [9/13]

v_int8x16 cv::operator- ( const v_int8x16 a,
const v_int8x16 b 
)
inline

◆ operator-() [10/13]

v_uint16x8 cv::operator- ( const v_uint16x8 a,
const v_uint16x8 b 
)
inline

◆ operator-() [11/13]

v_uint32x4 cv::operator- ( const v_uint32x4 a,
const v_uint32x4 b 
)
inline

◆ operator-() [12/13]

v_uint64x2 cv::operator- ( const v_uint64x2 a,
const v_uint64x2 b 
)
inline

◆ operator-() [13/13]

v_uint8x16 cv::operator- ( const v_uint8x16 a,
const v_uint8x16 b 
)
inline

◆ operator-=() [1/10]

v_float32x4 & cv::operator-= ( v_float32x4 a,
const v_float32x4 b 
)
inline

◆ operator-=() [2/10]

v_float64x2 & cv::operator-= ( v_float64x2 a,
const v_float64x2 b 
)
inline

◆ operator-=() [3/10]

v_int16x8 & cv::operator-= ( v_int16x8 a,
const v_int16x8 b 
)
inline

◆ operator-=() [4/10]

v_int32x4 & cv::operator-= ( v_int32x4 a,
const v_int32x4 b 
)
inline

◆ operator-=() [5/10]

v_int64x2 & cv::operator-= ( v_int64x2 a,
const v_int64x2 b 
)
inline

◆ operator-=() [6/10]

v_int8x16 & cv::operator-= ( v_int8x16 a,
const v_int8x16 b 
)
inline

◆ operator-=() [7/10]

v_uint16x8 & cv::operator-= ( v_uint16x8 a,
const v_uint16x8 b 
)
inline

◆ operator-=() [8/10]

v_uint32x4 & cv::operator-= ( v_uint32x4 a,
const v_uint32x4 b 
)
inline

◆ operator-=() [9/10]

v_uint64x2 & cv::operator-= ( v_uint64x2 a,
const v_uint64x2 b 
)
inline

◆ operator-=() [10/10]

v_uint8x16 & cv::operator-= ( v_uint8x16 a,
const v_uint8x16 b 
)
inline

◆ operator/() [1/13]

cv::GMat cv::operator/ ( const cv::GMat lhs,
const cv::GMat rhs 
)

◆ operator/() [2/13]

cv::GMat cv::operator/ ( const cv::GMat lhs,
const cv::GScalar rhs 
)

◆ operator/() [3/13]

cv::GMat cv::operator/ ( const cv::GScalar lhs,
const cv::GMat rhs 
)

◆ operator/() [4/13]

v_float32x4 cv::operator/ ( const v_float32x4 a,
const v_float32x4 b 
)
inline

◆ operator/() [5/13]

v_float64x2 cv::operator/ ( const v_float64x2 a,
const v_float64x2 b 
)
inline

◆ operator/() [6/13]

v_int16x8 cv::operator/ ( const v_int16x8 a,
const v_int16x8 b 
)
inline

◆ operator/() [7/13]

v_int32x4 cv::operator/ ( const v_int32x4 a,
const v_int32x4 b 
)
inline

◆ operator/() [8/13]

v_int64x2 cv::operator/ ( const v_int64x2 a,
const v_int64x2 b 
)
inline

◆ operator/() [9/13]

v_int8x16 cv::operator/ ( const v_int8x16 a,
const v_int8x16 b 
)
inline

◆ operator/() [10/13]

v_uint16x8 cv::operator/ ( const v_uint16x8 a,
const v_uint16x8 b 
)
inline

◆ operator/() [11/13]

v_uint32x4 cv::operator/ ( const v_uint32x4 a,
const v_uint32x4 b 
)
inline

◆ operator/() [12/13]

v_uint64x2 cv::operator/ ( const v_uint64x2 a,
const v_uint64x2 b 
)
inline

◆ operator/() [13/13]

v_uint8x16 cv::operator/ ( const v_uint8x16 a,
const v_uint8x16 b 
)
inline

◆ operator/=() [1/10]

v_float32x4 & cv::operator/= ( v_float32x4 a,
const v_float32x4 b 
)
inline

◆ operator/=() [2/10]

v_float64x2 & cv::operator/= ( v_float64x2 a,
const v_float64x2 b 
)
inline

◆ operator/=() [3/10]

v_int16x8 & cv::operator/= ( v_int16x8 a,
const v_int16x8 b 
)
inline

◆ operator/=() [4/10]

v_int32x4 & cv::operator/= ( v_int32x4 a,
const v_int32x4 b 
)
inline

◆ operator/=() [5/10]

v_int64x2 & cv::operator/= ( v_int64x2 a,
const v_int64x2 b 
)
inline

◆ operator/=() [6/10]

v_int8x16 & cv::operator/= ( v_int8x16 a,
const v_int8x16 b 
)
inline

◆ operator/=() [7/10]

v_uint16x8 & cv::operator/= ( v_uint16x8 a,
const v_uint16x8 b 
)
inline

◆ operator/=() [8/10]

v_uint32x4 & cv::operator/= ( v_uint32x4 a,
const v_uint32x4 b 
)
inline

◆ operator/=() [9/10]

v_uint64x2 & cv::operator/= ( v_uint64x2 a,
const v_uint64x2 b 
)
inline

◆ operator/=() [10/10]

v_uint8x16 & cv::operator/= ( v_uint8x16 a,
const v_uint8x16 b 
)
inline

◆ operator<() [1/13]

cv::GMat cv::operator< ( const cv::GMat lhs,
const cv::GMat rhs 
)

◆ operator<() [2/13]

cv::GMat cv::operator< ( const cv::GMat lhs,
const cv::GScalar rhs 
)

◆ operator<() [3/13]

cv::GMat cv::operator< ( const cv::GScalar lhs,
const cv::GMat rhs 
)

◆ operator<() [4/13]

v_float32x4 cv::operator< ( const v_float32x4 a,
const v_float32x4 b 
)
inline

◆ operator<() [5/13]

v_float64x2 cv::operator< ( const v_float64x2 a,
const v_float64x2 b 
)
inline

◆ operator<() [6/13]

v_int16x8 cv::operator< ( const v_int16x8 a,
const v_int16x8 b 
)
inline

◆ operator<() [7/13]

v_int32x4 cv::operator< ( const v_int32x4 a,
const v_int32x4 b 
)
inline

◆ operator<() [8/13]

v_int64x2 cv::operator< ( const v_int64x2 a,
const v_int64x2 b 
)
inline

◆ operator<() [9/13]

v_int8x16 cv::operator< ( const v_int8x16 a,
const v_int8x16 b 
)
inline

◆ operator<() [10/13]

v_uint16x8 cv::operator< ( const v_uint16x8 a,
const v_uint16x8 b 
)
inline

◆ operator<() [11/13]

v_uint32x4 cv::operator< ( const v_uint32x4 a,
const v_uint32x4 b 
)
inline

◆ operator<() [12/13]

v_uint64x2 cv::operator< ( const v_uint64x2 a,
const v_uint64x2 b 
)
inline

◆ operator<() [13/13]

v_uint8x16 cv::operator< ( const v_uint8x16 a,
const v_uint8x16 b 
)
inline

◆ operator<<() [1/13]

v_int16x8 cv::operator<< ( const v_int16x8 a,
int  n 
)
inline

◆ operator<<() [2/13]

v_int32x4 cv::operator<< ( const v_int32x4 a,
int  n 
)
inline

◆ operator<<() [3/13]

v_int64x2 cv::operator<< ( const v_int64x2 a,
int  n 
)
inline

◆ operator<<() [4/13]

v_int8x16 cv::operator<< ( const v_int8x16 a,
int  n 
)
inline

◆ operator<<() [5/13]

v_uint16x8 cv::operator<< ( const v_uint16x8 a,
int  n 
)
inline

◆ operator<<() [6/13]

v_uint32x4 cv::operator<< ( const v_uint32x4 a,
int  n 
)
inline

◆ operator<<() [7/13]

v_uint64x2 cv::operator<< ( const v_uint64x2 a,
int  n 
)
inline

◆ operator<<() [8/13]

v_uint8x16 cv::operator<< ( const v_uint8x16 a,
int  n 
)
inline

◆ operator<<() [9/13]

std::ostream & cv::operator<< ( std::ostream &  os,
const cv::GArrayDesc desc 
)

◆ operator<<() [10/13]

std::ostream & cv::operator<< ( std::ostream &  os,
const cv::GFrameDesc desc 
)

◆ operator<<() [11/13]

std::ostream & cv::operator<< ( std::ostream &  os,
const cv::GMatDesc desc 
)

◆ operator<<() [12/13]

std::ostream & cv::operator<< ( std::ostream &  os,
const cv::GOpaqueDesc desc 
)

◆ operator<<() [13/13]

std::ostream & cv::operator<< ( std::ostream &  os,
const GMetaArg  
)

◆ operator<=() [1/13]

cv::GMat cv::operator<= ( const cv::GMat lhs,
const cv::GMat rhs 
)

◆ operator<=() [2/13]

cv::GMat cv::operator<= ( const cv::GMat lhs,
const cv::GScalar rhs 
)

◆ operator<=() [3/13]

cv::GMat cv::operator<= ( const cv::GScalar lhs,
const cv::GMat rhs 
)

◆ operator<=() [4/13]

v_float32x4 cv::operator<= ( const v_float32x4 a,
const v_float32x4 b 
)
inline

◆ operator<=() [5/13]

v_float64x2 cv::operator<= ( const v_float64x2 a,
const v_float64x2 b 
)
inline

◆ operator<=() [6/13]

v_int16x8 cv::operator<= ( const v_int16x8 a,
const v_int16x8 b 
)
inline

◆ operator<=() [7/13]

v_int32x4 cv::operator<= ( const v_int32x4 a,
const v_int32x4 b 
)
inline

◆ operator<=() [8/13]

v_int64x2 cv::operator<= ( const v_int64x2 a,
const v_int64x2 b 
)
inline

◆ operator<=() [9/13]

v_int8x16 cv::operator<= ( const v_int8x16 a,
const v_int8x16 b 
)
inline

◆ operator<=() [10/13]

v_uint16x8 cv::operator<= ( const v_uint16x8 a,
const v_uint16x8 b 
)
inline

◆ operator<=() [11/13]

v_uint32x4 cv::operator<= ( const v_uint32x4 a,
const v_uint32x4 b 
)
inline

◆ operator<=() [12/13]

v_uint64x2 cv::operator<= ( const v_uint64x2 a,
const v_uint64x2 b 
)
inline

◆ operator<=() [13/13]

v_uint8x16 cv::operator<= ( const v_uint8x16 a,
const v_uint8x16 b 
)
inline

◆ operator==() [1/13]

cv::GMat cv::operator== ( const cv::GMat lhs,
const cv::GMat rhs 
)

◆ operator==() [2/13]

cv::GMat cv::operator== ( const cv::GMat lhs,
const cv::GScalar rhs 
)

◆ operator==() [3/13]

cv::GMat cv::operator== ( const cv::GScalar lhs,
const cv::GMat rhs 
)

◆ operator==() [4/13]

v_float32x4 cv::operator== ( const v_float32x4 a,
const v_float32x4 b 
)
inline

◆ operator==() [5/13]

v_float64x2 cv::operator== ( const v_float64x2 a,
const v_float64x2 b 
)
inline

◆ operator==() [6/13]

v_int16x8 cv::operator== ( const v_int16x8 a,
const v_int16x8 b 
)
inline

◆ operator==() [7/13]

v_int32x4 cv::operator== ( const v_int32x4 a,
const v_int32x4 b 
)
inline

◆ operator==() [8/13]

v_int64x2 cv::operator== ( const v_int64x2 a,
const v_int64x2 b 
)
inline

◆ operator==() [9/13]

v_int8x16 cv::operator== ( const v_int8x16 a,
const v_int8x16 b 
)
inline

◆ operator==() [10/13]

v_uint16x8 cv::operator== ( const v_uint16x8 a,
const v_uint16x8 b 
)
inline

◆ operator==() [11/13]

v_uint32x4 cv::operator== ( const v_uint32x4 a,
const v_uint32x4 b 
)
inline

◆ operator==() [12/13]

v_uint64x2 cv::operator== ( const v_uint64x2 a,
const v_uint64x2 b 
)
inline

◆ operator==() [13/13]

v_uint8x16 cv::operator== ( const v_uint8x16 a,
const v_uint8x16 b 
)
inline

◆ operator>() [1/13]

cv::GMat cv::operator> ( const cv::GMat lhs,
const cv::GMat rhs 
)

◆ operator>() [2/13]

cv::GMat cv::operator> ( const cv::GMat lhs,
const cv::GScalar rhs 
)

◆ operator>() [3/13]

cv::GMat cv::operator> ( const cv::GScalar lhs,
const cv::GMat rhs 
)

◆ operator>() [4/13]

v_float32x4 cv::operator> ( const v_float32x4 a,
const v_float32x4 b 
)
inline

◆ operator>() [5/13]

v_float64x2 cv::operator> ( const v_float64x2 a,
const v_float64x2 b 
)
inline

◆ operator>() [6/13]

v_int16x8 cv::operator> ( const v_int16x8 a,
const v_int16x8 b 
)
inline

◆ operator>() [7/13]

v_int32x4 cv::operator> ( const v_int32x4 a,
const v_int32x4 b 
)
inline

◆ operator>() [8/13]

v_int64x2 cv::operator> ( const v_int64x2 a,
const v_int64x2 b 
)
inline

◆ operator>() [9/13]

v_int8x16 cv::operator> ( const v_int8x16 a,
const v_int8x16 b 
)
inline

◆ operator>() [10/13]

v_uint16x8 cv::operator> ( const v_uint16x8 a,
const v_uint16x8 b 
)
inline

◆ operator>() [11/13]

v_uint32x4 cv::operator> ( const v_uint32x4 a,
const v_uint32x4 b 
)
inline

◆ operator>() [12/13]

v_uint64x2 cv::operator> ( const v_uint64x2 a,
const v_uint64x2 b 
)
inline

◆ operator>() [13/13]

v_uint8x16 cv::operator> ( const v_uint8x16 a,
const v_uint8x16 b 
)
inline

◆ operator>=() [1/13]

cv::GMat cv::operator>= ( const cv::GMat lhs,
const cv::GMat rhs 
)

◆ operator>=() [2/13]

cv::GMat cv::operator>= ( const cv::GMat lhs,
const cv::GScalar rhs 
)

◆ operator>=() [3/13]

cv::GMat cv::operator>= ( const cv::GScalar lhs,
const cv::GMat rhs 
)

◆ operator>=() [4/13]

v_float32x4 cv::operator>= ( const v_float32x4 a,
const v_float32x4 b 
)
inline

◆ operator>=() [5/13]

v_float64x2 cv::operator>= ( const v_float64x2 a,
const v_float64x2 b 
)
inline

◆ operator>=() [6/13]

v_int16x8 cv::operator>= ( const v_int16x8 a,
const v_int16x8 b 
)
inline

◆ operator>=() [7/13]

v_int32x4 cv::operator>= ( const v_int32x4 a,
const v_int32x4 b 
)
inline

◆ operator>=() [8/13]

v_int64x2 cv::operator>= ( const v_int64x2 a,
const v_int64x2 b 
)
inline

◆ operator>=() [9/13]

v_int8x16 cv::operator>= ( const v_int8x16 a,
const v_int8x16 b 
)
inline

◆ operator>=() [10/13]

v_uint16x8 cv::operator>= ( const v_uint16x8 a,
const v_uint16x8 b 
)
inline

◆ operator>=() [11/13]

v_uint32x4 cv::operator>= ( const v_uint32x4 a,
const v_uint32x4 b 
)
inline

◆ operator>=() [12/13]

v_uint64x2 cv::operator>= ( const v_uint64x2 a,
const v_uint64x2 b 
)
inline

◆ operator>=() [13/13]

v_uint8x16 cv::operator>= ( const v_uint8x16 a,
const v_uint8x16 b 
)
inline

◆ operator>>() [1/8]

v_int16x8 cv::operator>> ( const v_int16x8 a,
int  n 
)
inline

◆ operator>>() [2/8]

v_int32x4 cv::operator>> ( const v_int32x4 a,
int  n 
)
inline

◆ operator>>() [3/8]

v_int64x2 cv::operator>> ( const v_int64x2 a,
int  n 
)
inline

◆ operator>>() [4/8]

v_int8x16 cv::operator>> ( const v_int8x16 a,
int  n 
)
inline

◆ operator>>() [5/8]

v_uint16x8 cv::operator>> ( const v_uint16x8 a,
int  n 
)
inline

◆ operator>>() [6/8]

v_uint32x4 cv::operator>> ( const v_uint32x4 a,
int  n 
)
inline

◆ operator>>() [7/8]

v_uint64x2 cv::operator>> ( const v_uint64x2 a,
int  n 
)
inline

◆ operator>>() [8/8]

v_uint8x16 cv::operator>> ( const v_uint8x16 a,
int  n 
)
inline

◆ operator^() [1/13]

cv::GMat cv::operator^ ( const cv::GMat lhs,
const cv::GMat rhs 
)

◆ operator^() [2/13]

cv::GMat cv::operator^ ( const cv::GMat lhs,
const cv::GScalar rhs 
)

◆ operator^() [3/13]

cv::GMat cv::operator^ ( const cv::GScalar lhs,
const cv::GMat rhs 
)

◆ operator^() [4/13]

v_float32x4 cv::operator^ ( const v_float32x4 a,
const v_float32x4 b 
)
inline

◆ operator^() [5/13]

v_float64x2 cv::operator^ ( const v_float64x2 a,
const v_float64x2 b 
)
inline

◆ operator^() [6/13]

v_int16x8 cv::operator^ ( const v_int16x8 a,
const v_int16x8 b 
)
inline

◆ operator^() [7/13]

v_int32x4 cv::operator^ ( const v_int32x4 a,
const v_int32x4 b 
)
inline

◆ operator^() [8/13]

v_int64x2 cv::operator^ ( const v_int64x2 a,
const v_int64x2 b 
)
inline

◆ operator^() [9/13]

v_int8x16 cv::operator^ ( const v_int8x16 a,
const v_int8x16 b 
)
inline

◆ operator^() [10/13]

v_uint16x8 cv::operator^ ( const v_uint16x8 a,
const v_uint16x8 b 
)
inline

◆ operator^() [11/13]

v_uint32x4 cv::operator^ ( const v_uint32x4 a,
const v_uint32x4 b 
)
inline

◆ operator^() [12/13]

v_uint64x2 cv::operator^ ( const v_uint64x2 a,
const v_uint64x2 b 
)
inline

◆ operator^() [13/13]

v_uint8x16 cv::operator^ ( const v_uint8x16 a,
const v_uint8x16 b 
)
inline

◆ operator^=() [1/10]

v_float32x4 & cv::operator^= ( v_float32x4 a,
const v_float32x4 b 
)
inline

◆ operator^=() [2/10]

v_float64x2 & cv::operator^= ( v_float64x2 a,
const v_float64x2 b 
)
inline

◆ operator^=() [3/10]

v_int16x8 & cv::operator^= ( v_int16x8 a,
const v_int16x8 b 
)
inline

◆ operator^=() [4/10]

v_int32x4 & cv::operator^= ( v_int32x4 a,
const v_int32x4 b 
)
inline

◆ operator^=() [5/10]

v_int64x2 & cv::operator^= ( v_int64x2 a,
const v_int64x2 b 
)
inline

◆ operator^=() [6/10]

v_int8x16 & cv::operator^= ( v_int8x16 a,
const v_int8x16 b 
)
inline

◆ operator^=() [7/10]

v_uint16x8 & cv::operator^= ( v_uint16x8 a,
const v_uint16x8 b 
)
inline

◆ operator^=() [8/10]

v_uint32x4 & cv::operator^= ( v_uint32x4 a,
const v_uint32x4 b 
)
inline

◆ operator^=() [9/10]

v_uint64x2 & cv::operator^= ( v_uint64x2 a,
const v_uint64x2 b 
)
inline

◆ operator^=() [10/10]

v_uint8x16 & cv::operator^= ( v_uint8x16 a,
const v_uint8x16 b 
)
inline

◆ operator|() [1/13]

cv::GMat cv::operator| ( const cv::GMat lhs,
const cv::GMat rhs 
)

◆ operator|() [2/13]

cv::GMat cv::operator| ( const cv::GMat lhs,
const cv::GScalar rhs 
)

◆ operator|() [3/13]

cv::GMat cv::operator| ( const cv::GScalar lhs,
const cv::GMat rhs 
)

◆ operator|() [4/13]

v_float32x4 cv::operator| ( const v_float32x4 a,
const v_float32x4 b 
)
inline

◆ operator|() [5/13]

v_float64x2 cv::operator| ( const v_float64x2 a,
const v_float64x2 b 
)
inline

◆ operator|() [6/13]

v_int16x8 cv::operator| ( const v_int16x8 a,
const v_int16x8 b 
)
inline

◆ operator|() [7/13]

v_int32x4 cv::operator| ( const v_int32x4 a,
const v_int32x4 b 
)
inline

◆ operator|() [8/13]

v_int64x2 cv::operator| ( const v_int64x2 a,
const v_int64x2 b 
)
inline

◆ operator|() [9/13]

v_int8x16 cv::operator| ( const v_int8x16 a,
const v_int8x16 b 
)
inline

◆ operator|() [10/13]

v_uint16x8 cv::operator| ( const v_uint16x8 a,
const v_uint16x8 b 
)
inline

◆ operator|() [11/13]

v_uint32x4 cv::operator| ( const v_uint32x4 a,
const v_uint32x4 b 
)
inline

◆ operator|() [12/13]

v_uint64x2 cv::operator| ( const v_uint64x2 a,
const v_uint64x2 b 
)
inline

◆ operator|() [13/13]

v_uint8x16 cv::operator| ( const v_uint8x16 a,
const v_uint8x16 b 
)
inline

◆ operator|=() [1/10]

v_float32x4 & cv::operator|= ( v_float32x4 a,
const v_float32x4 b 
)
inline

◆ operator|=() [2/10]

v_float64x2 & cv::operator|= ( v_float64x2 a,
const v_float64x2 b 
)
inline

◆ operator|=() [3/10]

v_int16x8 & cv::operator|= ( v_int16x8 a,
const v_int16x8 b 
)
inline

◆ operator|=() [4/10]

v_int32x4 & cv::operator|= ( v_int32x4 a,
const v_int32x4 b 
)
inline

◆ operator|=() [5/10]

v_int64x2 & cv::operator|= ( v_int64x2 a,
const v_int64x2 b 
)
inline

◆ operator|=() [6/10]

v_int8x16 & cv::operator|= ( v_int8x16 a,
const v_int8x16 b 
)
inline

◆ operator|=() [7/10]

v_uint16x8 & cv::operator|= ( v_uint16x8 a,
const v_uint16x8 b 
)
inline

◆ operator|=() [8/10]

v_uint32x4 & cv::operator|= ( v_uint32x4 a,
const v_uint32x4 b 
)
inline

◆ operator|=() [9/10]

v_uint64x2 & cv::operator|= ( v_uint64x2 a,
const v_uint64x2 b 
)
inline

◆ operator|=() [10/10]

v_uint8x16 & cv::operator|= ( v_uint8x16 a,
const v_uint8x16 b 
)
inline

◆ operator~() [1/11]

cv::GMat cv::operator~ ( const cv::GMat lhs)

◆ operator~() [2/11]

v_float32x4 cv::operator~ ( const v_float32x4 a)
inline

◆ operator~() [3/11]

v_float64x2 cv::operator~ ( const v_float64x2 a)
inline

◆ operator~() [4/11]

v_int16x8 cv::operator~ ( const v_int16x8 a)
inline

◆ operator~() [5/11]

v_int32x4 cv::operator~ ( const v_int32x4 a)
inline

◆ operator~() [6/11]

v_int64x2 cv::operator~ ( const v_int64x2 a)
inline

◆ operator~() [7/11]

v_int8x16 cv::operator~ ( const v_int8x16 a)
inline

◆ operator~() [8/11]

v_uint16x8 cv::operator~ ( const v_uint16x8 a)
inline

◆ operator~() [9/11]

v_uint32x4 cv::operator~ ( const v_uint32x4 a)
inline

◆ operator~() [10/11]

v_uint64x2 cv::operator~ ( const v_uint64x2 a)
inline

◆ operator~() [11/11]

v_uint8x16 cv::operator~ ( const v_uint8x16 a)
inline

◆ read()

void cv::read ( const FileNode fn,
optflow::GPCTree::Node node,
optflow::GPCTree::Node   
)

◆ setUseOpenVX()

void cv::setUseOpenVX ( bool  flag)

Enable/disable use of OpenVX.

◆ to_own() [1/3]

template<typename T >
std::vector< T > cv::to_own ( const cv::MatSize sz)

◆ to_own() [2/3]

cv::gapi::own::Mat cv::to_own ( Mat &&  )
delete

◆ to_own() [3/3]

cv::gapi::own::Mat cv::to_own ( Mat const &  m)
inline

◆ typeToString()

String cv::typeToString ( int  type)

Returns string of cv::Mat depth value: CV_8UC3 -> "CV_8UC3" or "<invalid type>"

◆ useOpenVX()

bool cv::useOpenVX ( )

Check if use of OpenVX is enabled.

◆ v_abs() [1/10]

v_float32 cv::v_abs ( const v_float32 a)
inline

◆ v_abs() [2/10]

v_float32x4 cv::v_abs ( const v_float32x4 a)
inline

◆ v_abs() [3/10]

v_float64 cv::v_abs ( const v_float64 a)
inline

◆ v_abs() [4/10]

v_float64x2 cv::v_abs ( const v_float64x2 a)
inline

◆ v_abs() [5/10]

v_uint16 cv::v_abs ( const v_int16 a)
inline

◆ v_abs() [6/10]

v_uint16x8 cv::v_abs ( const v_int16x8 a)
inline

◆ v_abs() [7/10]

v_uint32 cv::v_abs ( const v_int32 a)
inline

◆ v_abs() [8/10]

v_uint32x4 cv::v_abs ( const v_int32x4 a)
inline

◆ v_abs() [9/10]

v_uint8 cv::v_abs ( const v_int8 a)
inline

◆ v_abs() [10/10]

v_uint8x16 cv::v_abs ( const v_int8x16 a)
inline

◆ v_absdiff() [1/16]

v_float32 cv::v_absdiff ( const v_float32 a,
const v_float32 b 
)
inline

◆ v_absdiff() [2/16]

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

◆ v_absdiff() [3/16]

v_float64 cv::v_absdiff ( const v_float64 a,
const v_float64 b 
)
inline

◆ v_absdiff() [4/16]

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

◆ v_absdiff() [5/16]

v_uint16 cv::v_absdiff ( const v_int16 a,
const v_int16 b 
)
inline

◆ v_absdiff() [6/16]

v_uint16x8 cv::v_absdiff ( const v_int16x8 a,
const v_int16x8 b 
)
inline

◆ v_absdiff() [7/16]

v_uint32 cv::v_absdiff ( const v_int32 a,
const v_int32 b 
)
inline

◆ v_absdiff() [8/16]

v_uint32x4 cv::v_absdiff ( const v_int32x4 a,
const v_int32x4 b 
)
inline

◆ v_absdiff() [9/16]

v_uint8 cv::v_absdiff ( const v_int8 a,
const v_int8 b 
)
inline

◆ v_absdiff() [10/16]

v_uint8x16 cv::v_absdiff ( const v_int8x16 a,
const v_int8x16 b 
)
inline

◆ v_absdiff() [11/16]

v_uint16 cv::v_absdiff ( const v_uint16 a,
const v_uint16 b 
)
inline

◆ v_absdiff() [12/16]

v_uint16x8 cv::v_absdiff ( const v_uint16x8 a,
const v_uint16x8 b 
)
inline

◆ v_absdiff() [13/16]

v_uint32 cv::v_absdiff ( const v_uint32 a,
const v_uint32 b 
)
inline

◆ v_absdiff() [14/16]

v_uint32x4 cv::v_absdiff ( const v_uint32x4 a,
const v_uint32x4 b 
)
inline

◆ v_absdiff() [15/16]

v_uint8 cv::v_absdiff ( const v_uint8 a,
const v_uint8 b 
)
inline

◆ v_absdiff() [16/16]

v_uint8x16 cv::v_absdiff ( const v_uint8x16 a,
const v_uint8x16 b 
)
inline

◆ v_absdiffs() [1/4]

v_int16 cv::v_absdiffs ( const v_int16 a,
const v_int16 b 
)
inline

◆ v_absdiffs() [2/4]

v_int16x8 cv::v_absdiffs ( const v_int16x8 a,
const v_int16x8 b 
)
inline

◆ v_absdiffs() [3/4]

v_int8 cv::v_absdiffs ( const v_int8 a,
const v_int8 b 
)
inline

◆ v_absdiffs() [4/4]

v_int8x16 cv::v_absdiffs ( const v_int8x16 a,
const v_int8x16 b 
)
inline

◆ v_add() [1/20]

v_float32 cv::v_add ( const v_float32 a,
const v_float32 b 
)
inline

◆ v_add() [2/20]

template<typename... Args>
v_float32 cv::v_add ( const v_float32 f1,
const v_float32 f2,
const Args &...  vf 
)
inline

◆ v_add() [3/20]

v_float64 cv::v_add ( const v_float64 a,
const v_float64 b 
)
inline

◆ v_add() [4/20]

template<typename... Args>
v_float64 cv::v_add ( const v_float64 f1,
const v_float64 f2,
const Args &...  vf 
)
inline

◆ v_add() [5/20]

v_int16 cv::v_add ( const v_int16 a,
const v_int16 b 
)
inline

◆ v_add() [6/20]

template<typename... Args>
v_int16 cv::v_add ( const v_int16 f1,
const v_int16 f2,
const Args &...  vf 
)
inline

◆ v_add() [7/20]

v_int32 cv::v_add ( const v_int32 a,
const v_int32 b 
)
inline

◆ v_add() [8/20]

template<typename... Args>
v_int32 cv::v_add ( const v_int32 f1,
const v_int32 f2,
const Args &...  vf 
)
inline

◆ v_add() [9/20]

v_int64 cv::v_add ( const v_int64 a,
const v_int64 b 
)
inline

◆ v_add() [10/20]

template<typename... Args>
v_int64 cv::v_add ( const v_int64 f1,
const v_int64 f2,
const Args &...  vf 
)
inline

◆ v_add() [11/20]

v_int8 cv::v_add ( const v_int8 a,
const v_int8 b 
)
inline

◆ v_add() [12/20]

template<typename... Args>
v_int8 cv::v_add ( const v_int8 f1,
const v_int8 f2,
const Args &...  vf 
)
inline

◆ v_add() [13/20]

v_uint16 cv::v_add ( const v_uint16 a,
const v_uint16 b 
)
inline

◆ v_add() [14/20]

template<typename... Args>
v_uint16 cv::v_add ( const v_uint16 f1,
const v_uint16 f2,
const Args &...  vf 
)
inline

◆ v_add() [15/20]

v_uint32 cv::v_add ( const v_uint32 a,
const v_uint32 b 
)
inline

◆ v_add() [16/20]

template<typename... Args>
v_uint32 cv::v_add ( const v_uint32 f1,
const v_uint32 f2,
const Args &...  vf 
)
inline

◆ v_add() [17/20]

v_uint64 cv::v_add ( const v_uint64 a,
const v_uint64 b 
)
inline

◆ v_add() [18/20]

template<typename... Args>
v_uint64 cv::v_add ( const v_uint64 f1,
const v_uint64 f2,
const Args &...  vf 
)
inline

◆ v_add() [19/20]

v_uint8 cv::v_add ( const v_uint8 a,
const v_uint8 b 
)
inline

◆ v_add() [20/20]

template<typename... Args>
v_uint8 cv::v_add ( const v_uint8 f1,
const v_uint8 f2,
const Args &...  vf 
)
inline

◆ v_add_wrap() [1/8]

v_int16 cv::v_add_wrap ( const v_int16 a,
const v_int16 b 
)
inline

◆ v_add_wrap() [2/8]

v_int16x8 cv::v_add_wrap ( const v_int16x8 a,
const v_int16x8 b 
)
inline

◆ v_add_wrap() [3/8]

v_int8 cv::v_add_wrap ( const v_int8 a,
const v_int8 b 
)
inline

◆ v_add_wrap() [4/8]

v_int8x16 cv::v_add_wrap ( const v_int8x16 a,
const v_int8x16 b 
)
inline

◆ v_add_wrap() [5/8]

v_uint16 cv::v_add_wrap ( const v_uint16 a,
const v_uint16 b 
)
inline

◆ v_add_wrap() [6/8]

v_uint16x8 cv::v_add_wrap ( const v_uint16x8 a,
const v_uint16x8 b 
)
inline

◆ v_add_wrap() [7/8]

v_uint8 cv::v_add_wrap ( const v_uint8 a,
const v_uint8 b 
)
inline

◆ v_add_wrap() [8/8]

v_uint8x16 cv::v_add_wrap ( const v_uint8x16 a,
const v_uint8x16 b 
)
inline

◆ v_and() [1/10]

v_float32 cv::v_and ( const v_float32 a,
const v_float32 b 
)
inline

◆ v_and() [2/10]

v_float64 cv::v_and ( const v_float64 a,
const v_float64 b 
)
inline

◆ v_and() [3/10]

v_int16 cv::v_and ( const v_int16 a,
const v_int16 b 
)
inline

◆ v_and() [4/10]

v_int32 cv::v_and ( const v_int32 a,
const v_int32 b 
)
inline

◆ v_and() [5/10]

v_int64 cv::v_and ( const v_int64 a,
const v_int64 b 
)
inline

◆ v_and() [6/10]

v_int8 cv::v_and ( const v_int8 a,
const v_int8 b 
)
inline

◆ v_and() [7/10]

v_uint16 cv::v_and ( const v_uint16 a,
const v_uint16 b 
)
inline

◆ v_and() [8/10]

v_uint32 cv::v_and ( const v_uint32 a,
const v_uint32 b 
)
inline

◆ v_and() [9/10]

v_uint64 cv::v_and ( const v_uint64 a,
const v_uint64 b 
)
inline

◆ v_and() [10/10]

v_uint8 cv::v_and ( const v_uint8 a,
const v_uint8 b 
)
inline

◆ v_broadcast_element() [1/13]

template<int s = 0>
v_float32 cv::v_broadcast_element ( v_float32  v,
int  i = s 
)
inline

◆ v_broadcast_element() [2/13]

template<int i>
v_float32x4 cv::v_broadcast_element ( v_float32x4  v)
inline

◆ v_broadcast_element() [3/13]

template<int i>
v_float64x2 cv::v_broadcast_element ( v_float64x2  v)
inline

◆ v_broadcast_element() [4/13]

template<int i>
v_int16x8 cv::v_broadcast_element ( v_int16x8  v)
inline

◆ v_broadcast_element() [5/13]

template<int s = 0>
v_int32 cv::v_broadcast_element ( v_int32  v,
int  i = s 
)
inline

◆ v_broadcast_element() [6/13]

template<int i>
v_int32x4 cv::v_broadcast_element ( v_int32x4  v)
inline

◆ v_broadcast_element() [7/13]

template<int i>
v_int64x2 cv::v_broadcast_element ( v_int64x2  v)
inline

◆ v_broadcast_element() [8/13]

template<int i>
v_int8x16 cv::v_broadcast_element ( v_int8x16  v)
inline

◆ v_broadcast_element() [9/13]

template<int i>
v_uint16x8 cv::v_broadcast_element ( v_uint16x8  v)
inline

◆ v_broadcast_element() [10/13]

template<int s = 0>
v_uint32 cv::v_broadcast_element ( v_uint32  v,
int  i = s 
)
inline

◆ v_broadcast_element() [11/13]

template<int i>
v_uint32x4 cv::v_broadcast_element ( v_uint32x4  v)
inline

◆ v_broadcast_element() [12/13]

template<int i>
v_uint64x2 cv::v_broadcast_element ( v_uint64x2  v)
inline

◆ v_broadcast_element() [13/13]

template<int i>
v_uint8x16 cv::v_broadcast_element ( v_uint8x16  v)
inline

◆ v_broadcast_highest() [1/3]

v_float32 cv::v_broadcast_highest ( v_float32  v)
inline

◆ v_broadcast_highest() [2/3]

v_int32 cv::v_broadcast_highest ( v_int32  v)
inline

◆ v_broadcast_highest() [3/3]

v_uint32 cv::v_broadcast_highest ( v_uint32  v)
inline

◆ v_ceil() [1/4]

v_int32 cv::v_ceil ( const v_float32 a)
inline

◆ v_ceil() [2/4]

v_int32x4 cv::v_ceil ( const v_float32x4 a)
inline

◆ v_ceil() [3/4]

v_int32 cv::v_ceil ( const v_float64 a)
inline

◆ v_ceil() [4/4]

v_int32x4 cv::v_ceil ( const v_float64x2 a)
inline

◆ v_check_all() [1/20]

bool cv::v_check_all ( const v_float32 a)
inline

◆ v_check_all() [2/20]

bool cv::v_check_all ( const v_float32x4 a)
inline

◆ v_check_all() [3/20]

bool cv::v_check_all ( const v_float64 a)
inline

◆ v_check_all() [4/20]

bool cv::v_check_all ( const v_float64x2 a)
inline

◆ v_check_all() [5/20]

bool cv::v_check_all ( const v_int16 a)
inline

◆ v_check_all() [6/20]

bool cv::v_check_all ( const v_int16x8 a)
inline

◆ v_check_all() [7/20]

bool cv::v_check_all ( const v_int32 a)
inline

◆ v_check_all() [8/20]

bool cv::v_check_all ( const v_int32x4 a)
inline

◆ v_check_all() [9/20]

bool cv::v_check_all ( const v_int64 a)
inline

◆ v_check_all() [10/20]

bool cv::v_check_all ( const v_int64x2 a)
inline

◆ v_check_all() [11/20]

bool cv::v_check_all ( const v_int8 a)
inline

◆ v_check_all() [12/20]

bool cv::v_check_all ( const v_int8x16 a)
inline

◆ v_check_all() [13/20]

bool cv::v_check_all ( const v_uint16 a)
inline

◆ v_check_all() [14/20]

bool cv::v_check_all ( const v_uint16x8 a)
inline

◆ v_check_all() [15/20]

bool cv::v_check_all ( const v_uint32 a)
inline

◆ v_check_all() [16/20]

bool cv::v_check_all ( const v_uint32x4 a)
inline

◆ v_check_all() [17/20]

bool cv::v_check_all ( const v_uint64 a)
inline

◆ v_check_all() [18/20]

bool cv::v_check_all ( const v_uint64x2 a)
inline

◆ v_check_all() [19/20]

bool cv::v_check_all ( const v_uint8 a)
inline

◆ v_check_all() [20/20]

bool cv::v_check_all ( const v_uint8x16 a)
inline

◆ v_check_any() [1/20]

bool cv::v_check_any ( const v_float32 a)
inline

◆ v_check_any() [2/20]

bool cv::v_check_any ( const v_float32x4 a)
inline

◆ v_check_any() [3/20]

bool cv::v_check_any ( const v_float64 a)
inline

◆ v_check_any() [4/20]

bool cv::v_check_any ( const v_float64x2 a)
inline

◆ v_check_any() [5/20]

bool cv::v_check_any ( const v_int16 a)
inline

◆ v_check_any() [6/20]

bool cv::v_check_any ( const v_int16x8 a)
inline

◆ v_check_any() [7/20]

bool cv::v_check_any ( const v_int32 a)
inline

◆ v_check_any() [8/20]

bool cv::v_check_any ( const v_int32x4 a)
inline

◆ v_check_any() [9/20]

bool cv::v_check_any ( const v_int64 a)
inline

◆ v_check_any() [10/20]

bool cv::v_check_any ( const v_int64x2 a)
inline

◆ v_check_any() [11/20]

bool cv::v_check_any ( const v_int8 a)
inline

◆ v_check_any() [12/20]

bool cv::v_check_any ( const v_int8x16 a)
inline

◆ v_check_any() [13/20]

bool cv::v_check_any ( const v_uint16 a)
inline

◆ v_check_any() [14/20]

bool cv::v_check_any ( const v_uint16x8 a)
inline

◆ v_check_any() [15/20]

bool cv::v_check_any ( const v_uint32 a)
inline

◆ v_check_any() [16/20]

bool cv::v_check_any ( const v_uint32x4 a)
inline

◆ v_check_any() [17/20]

bool cv::v_check_any ( const v_uint64 a)
inline

◆ v_check_any() [18/20]

bool cv::v_check_any ( const v_uint64x2 a)
inline

◆ v_check_any() [19/20]

bool cv::v_check_any ( const v_uint8 a)
inline

◆ v_check_any() [20/20]

bool cv::v_check_any ( const v_uint8x16 a)
inline

◆ v_combine_high() [1/16]

v_float32 cv::v_combine_high ( const v_float32 a,
const v_float32 b 
)
inline

◆ v_combine_high() [2/16]

v_float32x4 cv::v_combine_high ( const v_float32x4 a,
const v_float32x4 b 
)
inline

◆ v_combine_high() [3/16]

v_float64 cv::v_combine_high ( const v_float64 a,
const v_float64 b 
)
inline

◆ v_combine_high() [4/16]

v_float64x2 cv::v_combine_high ( const v_float64x2 a,
const v_float64x2 b 
)
inline

◆ v_combine_high() [5/16]

v_int16 cv::v_combine_high ( const v_int16 a,
const v_int16 b 
)
inline

◆ v_combine_high() [6/16]

v_int16x8 cv::v_combine_high ( const v_int16x8 a,
const v_int16x8 b 
)
inline

◆ v_combine_high() [7/16]

v_int32 cv::v_combine_high ( const v_int32 a,
const v_int32 b 
)
inline

◆ v_combine_high() [8/16]

v_int32x4 cv::v_combine_high ( const v_int32x4 a,
const v_int32x4 b 
)
inline

◆ v_combine_high() [9/16]

v_int8 cv::v_combine_high ( const v_int8 a,
const v_int8 b 
)
inline

◆ v_combine_high() [10/16]

v_int8x16 cv::v_combine_high ( const v_int8x16 a,
const v_int8x16 b 
)
inline

◆ v_combine_high() [11/16]

v_uint16 cv::v_combine_high ( const v_uint16 a,
const v_uint16 b 
)
inline

◆ v_combine_high() [12/16]

v_uint16x8 cv::v_combine_high ( const v_uint16x8 a,
const v_uint16x8 b 
)
inline

◆ v_combine_high() [13/16]

v_uint32 cv::v_combine_high ( const v_uint32 a,
const v_uint32 b 
)
inline

◆ v_combine_high() [14/16]

v_uint32x4 cv::v_combine_high ( const v_uint32x4 a,
const v_uint32x4 b 
)
inline

◆ v_combine_high() [15/16]

v_uint8 cv::v_combine_high ( const v_uint8 a,
const v_uint8 b 
)
inline

◆ v_combine_high() [16/16]

v_uint8x16 cv::v_combine_high ( const v_uint8x16 a,
const v_uint8x16 b 
)
inline

◆ v_combine_low() [1/16]

v_float32 cv::v_combine_low ( const v_float32 a,
const v_float32 b 
)
inline

◆ v_combine_low() [2/16]

v_float32x4 cv::v_combine_low ( const v_float32x4 a,
const v_float32x4 b 
)
inline

◆ v_combine_low() [3/16]

v_float64 cv::v_combine_low ( const v_float64 a,
const v_float64 b 
)
inline

◆ v_combine_low() [4/16]

v_float64x2 cv::v_combine_low ( const v_float64x2 a,
const v_float64x2 b 
)
inline

◆ v_combine_low() [5/16]

v_int16 cv::v_combine_low ( const v_int16 a,
const v_int16 b 
)
inline

◆ v_combine_low() [6/16]

v_int16x8 cv::v_combine_low ( const v_int16x8 a,
const v_int16x8 b 
)
inline

◆ v_combine_low() [7/16]

v_int32 cv::v_combine_low ( const v_int32 a,
const v_int32 b 
)
inline

◆ v_combine_low() [8/16]

v_int32x4 cv::v_combine_low ( const v_int32x4 a,
const v_int32x4 b 
)
inline

◆ v_combine_low() [9/16]

v_int8 cv::v_combine_low ( const v_int8 a,
const v_int8 b 
)
inline

◆ v_combine_low() [10/16]

v_int8x16 cv::v_combine_low ( const v_int8x16 a,
const v_int8x16 b 
)
inline

◆ v_combine_low() [11/16]

v_uint16 cv::v_combine_low ( const v_uint16 a,
const v_uint16 b 
)
inline

◆ v_combine_low() [12/16]

v_uint16x8 cv::v_combine_low ( const v_uint16x8 a,
const v_uint16x8 b 
)
inline

◆ v_combine_low() [13/16]

v_uint32 cv::v_combine_low ( const v_uint32 a,
const v_uint32 b 
)
inline

◆ v_combine_low() [14/16]

v_uint32x4 cv::v_combine_low ( const v_uint32x4 a,
const v_uint32x4 b 
)
inline

◆ v_combine_low() [15/16]

v_uint8 cv::v_combine_low ( const v_uint8 a,
const v_uint8 b 
)
inline

◆ v_combine_low() [16/16]

v_uint8x16 cv::v_combine_low ( const v_uint8x16 a,
const v_uint8x16 b 
)
inline

◆ v_cvt_f32() [1/6]

v_float32 cv::v_cvt_f32 ( const v_float64 a)
inline

◆ v_cvt_f32() [2/6]

v_float32 cv::v_cvt_f32 ( const v_float64 a,
const v_float64 b 
)
inline

◆ v_cvt_f32() [3/6]

v_float32x4 cv::v_cvt_f32 ( const v_float64x2 a)
inline

◆ v_cvt_f32() [4/6]

v_float32x4 cv::v_cvt_f32 ( const v_float64x2 a,
const v_float64x2 b 
)
inline

◆ v_cvt_f32() [5/6]

v_float32 cv::v_cvt_f32 ( const v_int32 a)
inline

◆ v_cvt_f32() [6/6]

v_float32x4 cv::v_cvt_f32 ( const v_int32x4 a)
inline

◆ v_cvt_f64() [1/6]

v_float64 cv::v_cvt_f64 ( const v_float32 a)
inline

◆ v_cvt_f64() [2/6]

v_float64x2 cv::v_cvt_f64 ( const v_float32x4 a)
inline

◆ v_cvt_f64() [3/6]

v_float64 cv::v_cvt_f64 ( const v_int32 a)
inline

◆ v_cvt_f64() [4/6]

v_float64x2 cv::v_cvt_f64 ( const v_int32x4 a)
inline

◆ v_cvt_f64() [5/6]

v_float64 cv::v_cvt_f64 ( const v_int64 a)
inline

◆ v_cvt_f64() [6/6]

v_float64x2 cv::v_cvt_f64 ( const v_int64x2 a)
inline

◆ v_cvt_f64_high() [1/4]

v_float64 cv::v_cvt_f64_high ( const v_float32 a)
inline

◆ v_cvt_f64_high() [2/4]

v_float64x2 cv::v_cvt_f64_high ( const v_float32x4 a)
inline

◆ v_cvt_f64_high() [3/4]

v_float64 cv::v_cvt_f64_high ( const v_int32 a)
inline

◆ v_cvt_f64_high() [4/4]

v_float64x2 cv::v_cvt_f64_high ( const v_int32x4 a)
inline

◆ v_div() [1/2]

v_float32 cv::v_div ( const v_float32 a,
const v_float32 b 
)
inline

◆ v_div() [2/2]

v_float64 cv::v_div ( const v_float64 a,
const v_float64 b 
)
inline

◆ v_dotprod() [1/8]

v_int32 cv::v_dotprod ( const v_int16 a,
const v_int16 b 
)
inline

◆ v_dotprod() [2/8]

v_int32 cv::v_dotprod ( const v_int16 a,
const v_int16 b,
const v_int32 c 
)
inline

◆ v_dotprod() [3/8]

v_int32x4 cv::v_dotprod ( const v_int16x8 a,
const v_int16x8 b 
)
inline

◆ v_dotprod() [4/8]

v_int32x4 cv::v_dotprod ( const v_int16x8 a,
const v_int16x8 b,
const v_int32x4 c 
)
inline

◆ v_dotprod() [5/8]

v_int64 cv::v_dotprod ( const v_int32 a,
const v_int32 b 
)
inline

◆ v_dotprod() [6/8]

v_int64 cv::v_dotprod ( const v_int32 a,
const v_int32 b,
const v_int64 c 
)
inline

◆ v_dotprod() [7/8]

v_int64x2 cv::v_dotprod ( const v_int32x4 a,
const v_int32x4 b 
)
inline

◆ v_dotprod() [8/8]

v_int64x2 cv::v_dotprod ( const v_int32x4 a,
const v_int32x4 b,
const v_int64x2 c 
)
inline

◆ v_dotprod_expand() [1/20]

v_int64 cv::v_dotprod_expand ( const v_int16 a,
const v_int16 b 
)
inline

◆ v_dotprod_expand() [2/20]

v_int64 cv::v_dotprod_expand ( const v_int16 a,
const v_int16 b,
const v_int64 c 
)
inline

◆ v_dotprod_expand() [3/20]

v_int64x2 cv::v_dotprod_expand ( const v_int16x8 a,
const v_int16x8 b 
)
inline

◆ v_dotprod_expand() [4/20]

v_int64x2 cv::v_dotprod_expand ( const v_int16x8 a,
const v_int16x8 b,
const v_int64x2 c 
)
inline

◆ v_dotprod_expand() [5/20]

v_float64 cv::v_dotprod_expand ( const v_int32 a,
const v_int32 b 
)
inline

◆ v_dotprod_expand() [6/20]

v_float64 cv::v_dotprod_expand ( const v_int32 a,
const v_int32 b,
const v_float64 c 
)
inline

◆ v_dotprod_expand() [7/20]

v_float64x2 cv::v_dotprod_expand ( const v_int32x4 a,
const v_int32x4 b 
)
inline

◆ v_dotprod_expand() [8/20]

v_float64x2 cv::v_dotprod_expand ( const v_int32x4 a,
const v_int32x4 b,
const v_float64x2 c 
)
inline

◆ v_dotprod_expand() [9/20]

v_int32 cv::v_dotprod_expand ( const v_int8 a,
const v_int8 b 
)
inline

◆ v_dotprod_expand() [10/20]

v_int32 cv::v_dotprod_expand ( const v_int8 a,
const v_int8 b,
const v_int32 c 
)
inline

◆ v_dotprod_expand() [11/20]

v_int32x4 cv::v_dotprod_expand ( const v_int8x16 a,
const v_int8x16 b 
)
inline

◆ v_dotprod_expand() [12/20]

v_int32x4 cv::v_dotprod_expand ( const v_int8x16 a,
const v_int8x16 b,
const v_int32x4 c 
)
inline

◆ v_dotprod_expand() [13/20]

v_uint64 cv::v_dotprod_expand ( const v_uint16 a,
const v_uint16 b 
)
inline

◆ v_dotprod_expand() [14/20]

v_uint64 cv::v_dotprod_expand ( const v_uint16 a,
const v_uint16 b,
const v_uint64 c 
)
inline

◆ v_dotprod_expand() [15/20]

v_uint64x2 cv::v_dotprod_expand ( const v_uint16x8 a,
const v_uint16x8 b 
)
inline

◆ v_dotprod_expand() [16/20]

v_uint64x2 cv::v_dotprod_expand ( const v_uint16x8 a,
const v_uint16x8 b,
const v_uint64x2 c 
)
inline

◆ v_dotprod_expand() [17/20]

v_uint32 cv::v_dotprod_expand ( const v_uint8 a,
const v_uint8 b 
)
inline

◆ v_dotprod_expand() [18/20]

v_uint32 cv::v_dotprod_expand ( const v_uint8 a,
const v_uint8 b,
const v_uint32 c 
)
inline

◆ v_dotprod_expand() [19/20]

v_uint32x4 cv::v_dotprod_expand ( const v_uint8x16 a,
const v_uint8x16 b 
)
inline

◆ v_dotprod_expand() [20/20]

v_uint32x4 cv::v_dotprod_expand ( const v_uint8x16 a,
const v_uint8x16 b,
const v_uint32x4 c 
)
inline

◆ v_dotprod_expand_fast() [1/20]

v_int64 cv::v_dotprod_expand_fast ( const v_int16 a,
const v_int16 b 
)
inline

◆ v_dotprod_expand_fast() [2/20]

v_int64 cv::v_dotprod_expand_fast ( const v_int16 a,
const v_int16 b,
const v_int64 c 
)
inline

◆ v_dotprod_expand_fast() [3/20]

v_int64x2 cv::v_dotprod_expand_fast ( const v_int16x8 a,
const v_int16x8 b 
)
inline

◆ v_dotprod_expand_fast() [4/20]

v_int64x2 cv::v_dotprod_expand_fast ( const v_int16x8 a,
const v_int16x8 b,
const v_int64x2 c 
)
inline

◆ v_dotprod_expand_fast() [5/20]

v_float64 cv::v_dotprod_expand_fast ( const v_int32 a,
const v_int32 b 
)
inline

◆ v_dotprod_expand_fast() [6/20]

v_float64 cv::v_dotprod_expand_fast ( const v_int32 a,
const v_int32 b,
const v_float64 c 
)
inline

◆ v_dotprod_expand_fast() [7/20]

v_float64x2 cv::v_dotprod_expand_fast ( const v_int32x4 a,
const v_int32x4 b 
)
inline

◆ v_dotprod_expand_fast() [8/20]

v_float64x2 cv::v_dotprod_expand_fast ( const v_int32x4 a,
const v_int32x4 b,
const v_float64x2 c 
)
inline

◆ v_dotprod_expand_fast() [9/20]

v_int32 cv::v_dotprod_expand_fast ( const v_int8 a,
const v_int8 b 
)
inline

◆ v_dotprod_expand_fast() [10/20]

v_int32 cv::v_dotprod_expand_fast ( const v_int8 a,
const v_int8 b,
const v_int32 c 
)
inline

◆ v_dotprod_expand_fast() [11/20]

v_int32x4 cv::v_dotprod_expand_fast ( const v_int8x16 a,
const v_int8x16 b 
)
inline

◆ v_dotprod_expand_fast() [12/20]

v_int32x4 cv::v_dotprod_expand_fast ( const v_int8x16 a,
const v_int8x16 b,
const v_int32x4 c 
)
inline

◆ v_dotprod_expand_fast() [13/20]

v_uint64 cv::v_dotprod_expand_fast ( const v_uint16 a,
const v_uint16 b 
)
inline

◆ v_dotprod_expand_fast() [14/20]

v_uint64 cv::v_dotprod_expand_fast ( const v_uint16 a,
const v_uint16 b,
const v_uint64 c 
)
inline

◆ v_dotprod_expand_fast() [15/20]

v_uint64x2 cv::v_dotprod_expand_fast ( const v_uint16x8 a,
const v_uint16x8 b 
)
inline

◆ v_dotprod_expand_fast() [16/20]

v_uint64x2 cv::v_dotprod_expand_fast ( const v_uint16x8 a,
const v_uint16x8 b,
const v_uint64x2 c 
)
inline

◆ v_dotprod_expand_fast() [17/20]

v_uint32 cv::v_dotprod_expand_fast ( const v_uint8 a,
const v_uint8 b 
)
inline

◆ v_dotprod_expand_fast() [18/20]

v_uint32 cv::v_dotprod_expand_fast ( const v_uint8 a,
const v_uint8 b,
const v_uint32 c 
)
inline

◆ v_dotprod_expand_fast() [19/20]

v_uint32x4 cv::v_dotprod_expand_fast ( const v_uint8x16 a,
const v_uint8x16 b 
)
inline

◆ v_dotprod_expand_fast() [20/20]

v_uint32x4 cv::v_dotprod_expand_fast ( const v_uint8x16 a,
const v_uint8x16 b,
const v_uint32x4 c 
)
inline

◆ v_dotprod_fast() [1/8]

v_int32 cv::v_dotprod_fast ( const v_int16 a,
const v_int16 b 
)
inline

◆ v_dotprod_fast() [2/8]

v_int32 cv::v_dotprod_fast ( const v_int16 a,
const v_int16 b,
const v_int32 c 
)
inline

◆ v_dotprod_fast() [3/8]

v_int32x4 cv::v_dotprod_fast ( const v_int16x8 a,
const v_int16x8 b 
)
inline

◆ v_dotprod_fast() [4/8]

v_int32x4 cv::v_dotprod_fast ( const v_int16x8 a,
const v_int16x8 b,
const v_int32x4 c 
)
inline

◆ v_dotprod_fast() [5/8]

v_int64 cv::v_dotprod_fast ( const v_int32 a,
const v_int32 b 
)
inline

◆ v_dotprod_fast() [6/8]

v_int64 cv::v_dotprod_fast ( const v_int32 a,
const v_int32 b,
const v_int64 c 
)
inline

◆ v_dotprod_fast() [7/8]

v_int64x2 cv::v_dotprod_fast ( const v_int32x4 a,
const v_int32x4 b 
)
inline

◆ v_dotprod_fast() [8/8]

v_int64x2 cv::v_dotprod_fast ( const v_int32x4 a,
const v_int32x4 b,
const v_int64x2 c 
)
inline

◆ v_eq() [1/10]

v_float32 cv::v_eq ( const v_float32 a,
const v_float32 b 
)
inline

◆ v_eq() [2/10]

v_float64 cv::v_eq ( const v_float64 a,
const v_float64 b 
)
inline

◆ v_eq() [3/10]

v_int16 cv::v_eq ( const v_int16 a,
const v_int16 b 
)
inline

◆ v_eq() [4/10]

v_int32 cv::v_eq ( const v_int32 a,
const v_int32 b 
)
inline

◆ v_eq() [5/10]

v_int64 cv::v_eq ( const v_int64 a,
const v_int64 b 
)
inline

◆ v_eq() [6/10]

v_int8 cv::v_eq ( const v_int8 a,
const v_int8 b 
)
inline

◆ v_eq() [7/10]

v_uint16 cv::v_eq ( const v_uint16 a,
const v_uint16 b 
)
inline

◆ v_eq() [8/10]

v_uint32 cv::v_eq ( const v_uint32 a,
const v_uint32 b 
)
inline

◆ v_eq() [9/10]

v_uint64 cv::v_eq ( const v_uint64 a,
const v_uint64 b 
)
inline

◆ v_eq() [10/10]

v_uint8 cv::v_eq ( const v_uint8 a,
const v_uint8 b 
)
inline

◆ v_expand() [1/12]

void cv::v_expand ( const v_int16 a,
v_int32 b0,
v_int32 b1 
)
inline

◆ v_expand() [2/12]

void cv::v_expand ( const v_int16x8 a,
v_int32x4 b0,
v_int32x4 b1 
)
inline

◆ v_expand() [3/12]

void cv::v_expand ( const v_int32 a,
v_int64 b0,
v_int64 b1 
)
inline

◆ v_expand() [4/12]

void cv::v_expand ( const v_int32x4 a,
v_int64x2 b0,
v_int64x2 b1 
)
inline

◆ v_expand() [5/12]

void cv::v_expand ( const v_int8 a,
v_int16 b0,
v_int16 b1 
)
inline

◆ v_expand() [6/12]

void cv::v_expand ( const v_int8x16 a,
v_int16x8 b0,
v_int16x8 b1 
)
inline

◆ v_expand() [7/12]

void cv::v_expand ( const v_uint16 a,
v_uint32 b0,
v_uint32 b1 
)
inline

◆ v_expand() [8/12]

void cv::v_expand ( const v_uint16x8 a,
v_uint32x4 b0,
v_uint32x4 b1 
)
inline

◆ v_expand() [9/12]

void cv::v_expand ( const v_uint32 a,
v_uint64 b0,
v_uint64 b1 
)
inline

◆ v_expand() [10/12]

void cv::v_expand ( const v_uint32x4 a,
v_uint64x2 b0,
v_uint64x2 b1 
)
inline

◆ v_expand() [11/12]

void cv::v_expand ( const v_uint8 a,
v_uint16 b0,
v_uint16 b1 
)
inline

◆ v_expand() [12/12]

void cv::v_expand ( const v_uint8x16 a,
v_uint16x8 b0,
v_uint16x8 b1 
)
inline

◆ v_expand_high() [1/12]

v_int32 cv::v_expand_high ( const v_int16 a)
inline

◆ v_expand_high() [2/12]

v_int32x4 cv::v_expand_high ( const v_int16x8 a)
inline

◆ v_expand_high() [3/12]

v_int64 cv::v_expand_high ( const v_int32 a)
inline

◆ v_expand_high() [4/12]

v_int64x2 cv::v_expand_high ( const v_int32x4 a)
inline

◆ v_expand_high() [5/12]

v_int16 cv::v_expand_high ( const v_int8 a)
inline

◆ v_expand_high() [6/12]

v_int16x8 cv::v_expand_high ( const v_int8x16 a)
inline

◆ v_expand_high() [7/12]

v_uint32 cv::v_expand_high ( const v_uint16 a)
inline

◆ v_expand_high() [8/12]

v_uint32x4 cv::v_expand_high ( const v_uint16x8 a)
inline

◆ v_expand_high() [9/12]

v_uint64 cv::v_expand_high ( const v_uint32 a)
inline

◆ v_expand_high() [10/12]

v_uint64x2 cv::v_expand_high ( const v_uint32x4 a)
inline

◆ v_expand_high() [11/12]

v_uint16 cv::v_expand_high ( const v_uint8 a)
inline

◆ v_expand_high() [12/12]

v_uint16x8 cv::v_expand_high ( const v_uint8x16 a)
inline

◆ v_expand_low() [1/12]

v_int32 cv::v_expand_low ( const v_int16 a)
inline

◆ v_expand_low() [2/12]

v_int32x4 cv::v_expand_low ( const v_int16x8 a)
inline

◆ v_expand_low() [3/12]

v_int64 cv::v_expand_low ( const v_int32 a)
inline

◆ v_expand_low() [4/12]

v_int64x2 cv::v_expand_low ( const v_int32x4 a)
inline

◆ v_expand_low() [5/12]

v_int16 cv::v_expand_low ( const v_int8 a)
inline

◆ v_expand_low() [6/12]

v_int16x8 cv::v_expand_low ( const v_int8x16 a)
inline

◆ v_expand_low() [7/12]

v_uint32 cv::v_expand_low ( const v_uint16 a)
inline

◆ v_expand_low() [8/12]

v_uint32x4 cv::v_expand_low ( const v_uint16x8 a)
inline

◆ v_expand_low() [9/12]

v_uint64 cv::v_expand_low ( const v_uint32 a)
inline

◆ v_expand_low() [10/12]

v_uint64x2 cv::v_expand_low ( const v_uint32x4 a)
inline

◆ v_expand_low() [11/12]

v_uint16 cv::v_expand_low ( const v_uint8 a)
inline

◆ v_expand_low() [12/12]

v_uint16x8 cv::v_expand_low ( const v_uint8x16 a)
inline

◆ v_extract() [1/20]

template<int s = 0>
v_float32 cv::v_extract ( const v_float32 a,
const v_float32 b,
int  i = s 
)
inline

◆ v_extract() [2/20]

template<int s>
v_float32x4 cv::v_extract ( const v_float32x4 a,
const v_float32x4 b 
)
inline

◆ v_extract() [3/20]

template<int s = 0>
v_float64 cv::v_extract ( const v_float64 a,
const v_float64 b,
int  i = s 
)
inline

◆ v_extract() [4/20]

template<int s>
v_float64x2 cv::v_extract ( const v_float64x2 a,
const v_float64x2 b 
)
inline

◆ v_extract() [5/20]

template<int s = 0>
v_int16 cv::v_extract ( const v_int16 a,
const v_int16 b,
int  i = s 
)
inline

◆ v_extract() [6/20]

template<int s>
v_int16x8 cv::v_extract ( const v_int16x8 a,
const v_int16x8 b 
)
inline

◆ v_extract() [7/20]

template<int s = 0>
v_int32 cv::v_extract ( const v_int32 a,
const v_int32 b,
int  i = s 
)
inline

◆ v_extract() [8/20]

template<int s>
v_int32x4 cv::v_extract ( const v_int32x4 a,
const v_int32x4 b 
)
inline

◆ v_extract() [9/20]

template<int s = 0>
v_int64 cv::v_extract ( const v_int64 a,
const v_int64 b,
int  i = s 
)
inline

◆ v_extract() [10/20]

template<int s>
v_int64x2 cv::v_extract ( const v_int64x2 a,
const v_int64x2 b 
)
inline

◆ v_extract() [11/20]

template<int s = 0>
v_int8 cv::v_extract ( const v_int8 a,
const v_int8 b,
int  i = s 
)
inline

◆ v_extract() [12/20]

template<int s>
v_int8x16 cv::v_extract ( const v_int8x16 a,
const v_int8x16 b 
)
inline

◆ v_extract() [13/20]

template<int s = 0>
v_uint16 cv::v_extract ( const v_uint16 a,
const v_uint16 b,
int  i = s 
)
inline

◆ v_extract() [14/20]

template<int s>
v_uint16x8 cv::v_extract ( const v_uint16x8 a,
const v_uint16x8 b 
)
inline

◆ v_extract() [15/20]

template<int s = 0>
v_uint32 cv::v_extract ( const v_uint32 a,
const v_uint32 b,
int  i = s 
)
inline

◆ v_extract() [16/20]

template<int s>
v_uint32x4 cv::v_extract ( const v_uint32x4 a,
const v_uint32x4 b 
)
inline

◆ v_extract() [17/20]

template<int s = 0>
v_uint64 cv::v_extract ( const v_uint64 a,
const v_uint64 b,
int  i = s 
)
inline

◆ v_extract() [18/20]

template<int s>
v_uint64x2 cv::v_extract ( const v_uint64x2 a,
const v_uint64x2 b 
)
inline

◆ v_extract() [19/20]

template<int s = 0>
v_uint8 cv::v_extract ( const v_uint8 a,
const v_uint8 b,
int  i = s 
)
inline

◆ v_extract() [20/20]

template<int s>
v_uint8x16 cv::v_extract ( const v_uint8x16 a,
const v_uint8x16 b 
)
inline

◆ v_extract_highest() [1/10]

float cv::v_extract_highest ( v_float32  v)
inline

◆ v_extract_highest() [2/10]

double cv::v_extract_highest ( v_float64  v)
inline

◆ v_extract_highest() [3/10]

short cv::v_extract_highest ( v_int16  v)
inline

◆ v_extract_highest() [4/10]

int cv::v_extract_highest ( v_int32  v)
inline

◆ v_extract_highest() [5/10]

int64 cv::v_extract_highest ( v_int64  v)
inline

◆ v_extract_highest() [6/10]

schar cv::v_extract_highest ( v_int8  v)
inline

◆ v_extract_highest() [7/10]

ushort cv::v_extract_highest ( v_uint16  v)
inline

◆ v_extract_highest() [8/10]

unsigned int cv::v_extract_highest ( v_uint32  v)
inline

◆ v_extract_highest() [9/10]

uint64 cv::v_extract_highest ( v_uint64  v)
inline

◆ v_extract_highest() [10/10]

uchar cv::v_extract_highest ( v_uint8  v)
inline

◆ v_extract_n() [1/20]

template<int s = 0>
float cv::v_extract_n ( v_float32  v,
int  i = s 
)
inline

◆ v_extract_n() [2/20]

template<int i>
float cv::v_extract_n ( v_float32x4  v)
inline

◆ v_extract_n() [3/20]

template<int s = 0>
double cv::v_extract_n ( v_float64  v,
int  i = s 
)
inline

◆ v_extract_n() [4/20]

template<int i>
double cv::v_extract_n ( v_float64x2  v)
inline

◆ v_extract_n() [5/20]

template<int s = 0>
short cv::v_extract_n ( v_int16  v,
int  i = s 
)
inline

◆ v_extract_n() [6/20]

template<int i>
short cv::v_extract_n ( v_int16x8  v)
inline

◆ v_extract_n() [7/20]

template<int s = 0>
int cv::v_extract_n ( v_int32  v,
int  i = s 
)
inline

◆ v_extract_n() [8/20]

template<int i>
int cv::v_extract_n ( v_int32x4  v)
inline

◆ v_extract_n() [9/20]

template<int s = 0>
int64 cv::v_extract_n ( v_int64  v,
int  i = s 
)
inline

◆ v_extract_n() [10/20]

template<int i>
int64 cv::v_extract_n ( v_int64x2  v)
inline

◆ v_extract_n() [11/20]

template<int s = 0>
schar cv::v_extract_n ( v_int8  v,
int  i = s 
)
inline

◆ v_extract_n() [12/20]

template<int i>
schar cv::v_extract_n ( v_int8x16  v)
inline

◆ v_extract_n() [13/20]

template<int s = 0>
ushort cv::v_extract_n ( v_uint16  v,
int  i = s 
)
inline

◆ v_extract_n() [14/20]

template<int i>
ushort cv::v_extract_n ( v_uint16x8  v)
inline

◆ v_extract_n() [15/20]

template<int s = 0>
unsigned int cv::v_extract_n ( v_uint32  v,
int  i = s 
)
inline

◆ v_extract_n() [16/20]

template<int i>
uint cv::v_extract_n ( v_uint32x4  v)
inline

◆ v_extract_n() [17/20]

template<int s = 0>
uint64 cv::v_extract_n ( v_uint64  v,
int  i = s 
)
inline

◆ v_extract_n() [18/20]

template<int i>
uint64 cv::v_extract_n ( v_uint64x2  v)
inline

◆ v_extract_n() [19/20]

template<int s = 0>
uchar cv::v_extract_n ( v_uint8  v,
int  i = s 
)
inline

◆ v_extract_n() [20/20]

template<int i>
uchar cv::v_extract_n ( v_uint8x16  v)
inline

◆ v_floor() [1/4]

v_int32 cv::v_floor ( const v_float32 a)
inline

◆ v_floor() [2/4]

v_int32x4 cv::v_floor ( const v_float32x4 a)
inline

◆ v_floor() [3/4]

v_int32 cv::v_floor ( const v_float64 a)
inline

◆ v_floor() [4/4]

v_int32x4 cv::v_floor ( const v_float64x2 a)
inline

◆ v_fma() [1/6]

v_float32 cv::v_fma ( const v_float32 a,
const v_float32 b,
const v_float32 c 
)
inline

◆ v_fma() [2/6]

v_float32x4 cv::v_fma ( const v_float32x4 a,
const v_float32x4 b,
const v_float32x4 c 
)
inline

◆ v_fma() [3/6]

v_float64 cv::v_fma ( const v_float64 a,
const v_float64 b,
const v_float64 c 
)
inline

◆ v_fma() [4/6]

v_float64x2 cv::v_fma ( const v_float64x2 a,
const v_float64x2 b,
const v_float64x2 c 
)
inline

◆ v_fma() [5/6]

v_int32 cv::v_fma ( const v_int32 a,
const v_int32 b,
const v_int32 c 
)
inline

◆ v_fma() [6/6]

v_int32x4 cv::v_fma ( const v_int32x4 a,
const v_int32x4 b,
const v_int32x4 c 
)
inline

◆ v_ge() [1/10]

v_float32 cv::v_ge ( const v_float32 a,
const v_float32 b 
)
inline

◆ v_ge() [2/10]

v_float64 cv::v_ge ( const v_float64 a,
const v_float64 b 
)
inline

◆ v_ge() [3/10]

v_int16 cv::v_ge ( const v_int16 a,
const v_int16 b 
)
inline

◆ v_ge() [4/10]

v_int32 cv::v_ge ( const v_int32 a,
const v_int32 b 
)
inline

◆ v_ge() [5/10]

v_int64 cv::v_ge ( const v_int64 a,
const v_int64 b 
)
inline

◆ v_ge() [6/10]

v_int8 cv::v_ge ( const v_int8 a,
const v_int8 b 
)
inline

◆ v_ge() [7/10]

v_uint16 cv::v_ge ( const v_uint16 a,
const v_uint16 b 
)
inline

◆ v_ge() [8/10]

v_uint32 cv::v_ge ( const v_uint32 a,
const v_uint32 b 
)
inline

◆ v_ge() [9/10]

v_uint64 cv::v_ge ( const v_uint64 a,
const v_uint64 b 
)
inline

◆ v_ge() [10/10]

v_uint8 cv::v_ge ( const v_uint8 a,
const v_uint8 b 
)
inline

◆ v_get0() [1/10]

float cv::v_get0 ( const v_float32 v)
inline

◆ v_get0() [2/10]

double cv::v_get0 ( const v_float64 v)
inline

◆ v_get0() [3/10]

short cv::v_get0 ( const v_int16 v)
inline

◆ v_get0() [4/10]

int cv::v_get0 ( const v_int32 v)
inline

◆ v_get0() [5/10]

int64 cv::v_get0 ( const v_int64 v)
inline

◆ v_get0() [6/10]

schar cv::v_get0 ( const v_int8 v)
inline

◆ v_get0() [7/10]

ushort cv::v_get0 ( const v_uint16 v)
inline

◆ v_get0() [8/10]

unsigned cv::v_get0 ( const v_uint32 v)
inline

◆ v_get0() [9/10]

uint64 cv::v_get0 ( const v_uint64 v)
inline

◆ v_get0() [10/10]

uchar cv::v_get0 ( const v_uint8 v)
inline

◆ v_gt() [1/10]

v_float32 cv::v_gt ( const v_float32 a,
const v_float32 b 
)
inline

◆ v_gt() [2/10]

v_float64 cv::v_gt ( const v_float64 a,
const v_float64 b 
)
inline

◆ v_gt() [3/10]

v_int16 cv::v_gt ( const v_int16 a,
const v_int16 b 
)
inline

◆ v_gt() [4/10]

v_int32 cv::v_gt ( const v_int32 a,
const v_int32 b 
)
inline

◆ v_gt() [5/10]

v_int64 cv::v_gt ( const v_int64 a,
const v_int64 b 
)
inline

◆ v_gt() [6/10]

v_int8 cv::v_gt ( const v_int8 a,
const v_int8 b 
)
inline

◆ v_gt() [7/10]

v_uint16 cv::v_gt ( const v_uint16 a,
const v_uint16 b 
)
inline

◆ v_gt() [8/10]

v_uint32 cv::v_gt ( const v_uint32 a,
const v_uint32 b 
)
inline

◆ v_gt() [9/10]

v_uint64 cv::v_gt ( const v_uint64 a,
const v_uint64 b 
)
inline

◆ v_gt() [10/10]

v_uint8 cv::v_gt ( const v_uint8 a,
const v_uint8 b 
)
inline

◆ v_hadd() [1/8]

static v_int32 cv::v_hadd ( v_int16  a)
inlinestatic

◆ v_hadd() [2/8]

static v_int64 cv::v_hadd ( v_int32  a)
inlinestatic

◆ v_hadd() [3/8]

static v_int16 cv::v_hadd ( v_int8  a)
inlinestatic

◆ v_hadd() [4/8]

static v_uint32 cv::v_hadd ( v_uint16  a)
inlinestatic

◆ v_hadd() [5/8]

static v_uint64 cv::v_hadd ( v_uint32  a)
inlinestatic

◆ v_hadd() [6/8]

static v_uint16 cv::v_hadd ( v_uint8  a)
inlinestatic

◆ v_hadd() [7/8]

static v_int32 cv::v_hadd ( vint32m2_t  a)
inlinestatic

◆ v_hadd() [8/8]

static v_int64 cv::v_hadd ( vint64m2_t  a)
inlinestatic

◆ v_interleave_pairs() [1/17]

v_float32 cv::v_interleave_pairs ( const v_float32 vec)
inline

◆ v_interleave_pairs() [2/17]

v_float32x4 cv::v_interleave_pairs ( const v_float32x4 vec)
inline

◆ v_interleave_pairs() [3/17]

v_float64x2 cv::v_interleave_pairs ( const v_float64x2 vec)
inline

◆ v_interleave_pairs() [4/17]

v_int16 cv::v_interleave_pairs ( const v_int16 vec)
inline

◆ v_interleave_pairs() [5/17]

v_int16x8 cv::v_interleave_pairs ( const v_int16x8 vec)
inline

◆ v_interleave_pairs() [6/17]

v_int32 cv::v_interleave_pairs ( const v_int32 vec)
inline

◆ v_interleave_pairs() [7/17]

v_int32x4 cv::v_interleave_pairs ( const v_int32x4 vec)
inline

◆ v_interleave_pairs() [8/17]

v_int64x2 cv::v_interleave_pairs ( const v_int64x2 vec)
inline

◆ v_interleave_pairs() [9/17]

v_int8 cv::v_interleave_pairs ( const v_int8 vec)
inline

◆ v_interleave_pairs() [10/17]

v_int8x16 cv::v_interleave_pairs ( const v_int8x16 vec)
inline

◆ v_interleave_pairs() [11/17]

v_uint16 cv::v_interleave_pairs ( const v_uint16 vec)
inline

◆ v_interleave_pairs() [12/17]

v_uint16x8 cv::v_interleave_pairs ( const v_uint16x8 vec)
inline

◆ v_interleave_pairs() [13/17]

v_uint32 cv::v_interleave_pairs ( const v_uint32 vec)
inline

◆ v_interleave_pairs() [14/17]

v_uint32x4 cv::v_interleave_pairs ( const v_uint32x4 vec)
inline

◆ v_interleave_pairs() [15/17]

v_uint64x2 cv::v_interleave_pairs ( const v_uint64x2 vec)
inline

◆ v_interleave_pairs() [16/17]

v_uint8 cv::v_interleave_pairs ( const v_uint8 vec)
inline

◆ v_interleave_pairs() [17/17]

v_uint8x16 cv::v_interleave_pairs ( const v_uint8x16 vec)
inline

◆ v_interleave_quads() [1/17]

v_float32 cv::v_interleave_quads ( const v_float32 vec)
inline

◆ v_interleave_quads() [2/17]

v_float32x4 cv::v_interleave_quads ( const v_float32x4 vec)
inline

◆ v_interleave_quads() [3/17]

v_float64x2 cv::v_interleave_quads ( const v_float64x2 vec)
inline

◆ v_interleave_quads() [4/17]

v_int16 cv::v_interleave_quads ( const v_int16 vec)
inline

◆ v_interleave_quads() [5/17]

v_int16x8 cv::v_interleave_quads ( const v_int16x8 vec)
inline

◆ v_interleave_quads() [6/17]

v_int32 cv::v_interleave_quads ( const v_int32 vec)
inline

◆ v_interleave_quads() [7/17]

v_int32x4 cv::v_interleave_quads ( const v_int32x4 vec)
inline

◆ v_interleave_quads() [8/17]

v_int64x2 cv::v_interleave_quads ( const v_int64x2 vec)
inline

◆ v_interleave_quads() [9/17]

v_int8 cv::v_interleave_quads ( const v_int8 vec)
inline

◆ v_interleave_quads() [10/17]

v_int8x16 cv::v_interleave_quads ( const v_int8x16 vec)
inline

◆ v_interleave_quads() [11/17]

v_uint16 cv::v_interleave_quads ( const v_uint16 vec)
inline

◆ v_interleave_quads() [12/17]

v_uint16x8 cv::v_interleave_quads ( const v_uint16x8 vec)
inline

◆ v_interleave_quads() [13/17]

v_uint32 cv::v_interleave_quads ( const v_uint32 vec)
inline

◆ v_interleave_quads() [14/17]

v_uint32x4 cv::v_interleave_quads ( const v_uint32x4 vec)
inline

◆ v_interleave_quads() [15/17]

v_uint64x2 cv::v_interleave_quads ( const v_uint64x2 vec)
inline

◆ v_interleave_quads() [16/17]

v_uint8 cv::v_interleave_quads ( const v_uint8 vec)
inline

◆ v_interleave_quads() [17/17]

v_uint8x16 cv::v_interleave_quads ( const v_uint8x16 vec)
inline

◆ v_invsqrt() [1/4]

v_float32 cv::v_invsqrt ( const v_float32 x)
inline

◆ v_invsqrt() [2/4]

v_float32x4 cv::v_invsqrt ( const v_float32x4 x)
inline

◆ v_invsqrt() [3/4]

v_float64 cv::v_invsqrt ( const v_float64 x)
inline

◆ v_invsqrt() [4/4]

v_float64x2 cv::v_invsqrt ( const v_float64x2 x)
inline

◆ v_le() [1/10]

v_float32 cv::v_le ( const v_float32 a,
const v_float32 b 
)
inline

◆ v_le() [2/10]

v_float64 cv::v_le ( const v_float64 a,
const v_float64 b 
)
inline

◆ v_le() [3/10]

v_int16 cv::v_le ( const v_int16 a,
const v_int16 b 
)
inline

◆ v_le() [4/10]

v_int32 cv::v_le ( const v_int32 a,
const v_int32 b 
)
inline

◆ v_le() [5/10]

v_int64 cv::v_le ( const v_int64 a,
const v_int64 b 
)
inline

◆ v_le() [6/10]

v_int8 cv::v_le ( const v_int8 a,
const v_int8 b 
)
inline

◆ v_le() [7/10]

v_uint16 cv::v_le ( const v_uint16 a,
const v_uint16 b 
)
inline

◆ v_le() [8/10]

v_uint32 cv::v_le ( const v_uint32 a,
const v_uint32 b 
)
inline

◆ v_le() [9/10]

v_uint64 cv::v_le ( const v_uint64 a,
const v_uint64 b 
)
inline

◆ v_le() [10/10]

v_uint8 cv::v_le ( const v_uint8 a,
const v_uint8 b 
)
inline

◆ v_load() [1/21]

v_float64 cv::v_load ( const double *  ptr)
inline

◆ v_load() [2/21]

v_float32 cv::v_load ( const float *  ptr)
inline

◆ v_load() [3/21]

v_int32 cv::v_load ( const int *  ptr)
inline

◆ v_load() [4/21]

v_int64 cv::v_load ( const int64 ptr)
inline

◆ v_load() [5/21]

v_int8 cv::v_load ( const schar ptr)
inline

◆ v_load() [6/21]

v_int16 cv::v_load ( const short *  ptr)
inline

◆ v_load() [7/21]

v_uint8 cv::v_load ( const uchar ptr)
inline

◆ v_load() [8/21]

v_uint64 cv::v_load ( const uint64 ptr)
inline

◆ v_load() [9/21]

v_uint32x4 cv::v_load ( const unsigned *  ptr)
inline

◆ v_load() [10/21]

v_uint32 cv::v_load ( const unsigned int *  ptr)
inline

◆ v_load() [11/21]

v_uint16 cv::v_load ( const ushort ptr)
inline

◆ v_load() [12/21]

v_float64 cv::v_load ( std::initializer_list< double >  nScalars)
inline

◆ v_load() [13/21]

v_float32 cv::v_load ( std::initializer_list< float >  nScalars)
inline

◆ v_load() [14/21]

v_int32 cv::v_load ( std::initializer_list< int >  nScalars)
inline

◆ v_load() [15/21]

v_int64 cv::v_load ( std::initializer_list< int64 nScalars)
inline

◆ v_load() [16/21]

v_int8 cv::v_load ( std::initializer_list< schar nScalars)
inline

◆ v_load() [17/21]

v_int16 cv::v_load ( std::initializer_list< short >  nScalars)
inline

◆ v_load() [18/21]

v_uint8 cv::v_load ( std::initializer_list< uchar nScalars)
inline

◆ v_load() [19/21]

v_uint64 cv::v_load ( std::initializer_list< uint64 nScalars)
inline

◆ v_load() [20/21]

v_uint32 cv::v_load ( std::initializer_list< unsigned int >  nScalars)
inline

◆ v_load() [21/21]

v_uint16 cv::v_load ( std::initializer_list< ushort nScalars)
inline

◆ v_load_aligned() [1/11]

v_float64 cv::v_load_aligned ( const double *  ptr)
inline

◆ v_load_aligned() [2/11]

v_float32 cv::v_load_aligned ( const float *  ptr)
inline

◆ v_load_aligned() [3/11]

v_int32 cv::v_load_aligned ( const int *  ptr)
inline

◆ v_load_aligned() [4/11]

v_int64 cv::v_load_aligned ( const int64 ptr)
inline

◆ v_load_aligned() [5/11]

v_int8 cv::v_load_aligned ( const schar ptr)
inline

◆ v_load_aligned() [6/11]

v_int16 cv::v_load_aligned ( const short *  ptr)
inline

◆ v_load_aligned() [7/11]

v_uint8 cv::v_load_aligned ( const uchar ptr)
inline

◆ v_load_aligned() [8/11]

v_uint64 cv::v_load_aligned ( const uint64 ptr)
inline

◆ v_load_aligned() [9/11]

v_uint32x4 cv::v_load_aligned ( const unsigned *  ptr)
inline

◆ v_load_aligned() [10/11]

v_uint32 cv::v_load_aligned ( const unsigned int *  ptr)
inline

◆ v_load_aligned() [11/11]

v_uint16 cv::v_load_aligned ( const ushort ptr)
inline

◆ v_load_deinterleave() [1/60]

void cv::v_load_deinterleave ( const double *  ptr,
v_float64 a,
v_float64 b 
)
inline

◆ v_load_deinterleave() [2/60]

void cv::v_load_deinterleave ( const double *  ptr,
v_float64 a,
v_float64 b,
v_float64 c 
)
inline

◆ v_load_deinterleave() [3/60]

void cv::v_load_deinterleave ( const double *  ptr,
v_float64 a,
v_float64 b,
v_float64 c,
v_float64 d 
)
inline

◆ v_load_deinterleave() [4/60]

void cv::v_load_deinterleave ( const double *  ptr,
v_float64x2 a,
v_float64x2 b 
)
inline

◆ v_load_deinterleave() [5/60]

void cv::v_load_deinterleave ( const double *  ptr,
v_float64x2 a,
v_float64x2 b,
v_float64x2 c 
)
inline

◆ v_load_deinterleave() [6/60]

void cv::v_load_deinterleave ( const double *  ptr,
v_float64x2 a,
v_float64x2 b,
v_float64x2 c,
v_float64x2 d 
)
inline

◆ v_load_deinterleave() [7/60]

void cv::v_load_deinterleave ( const float *  ptr,
v_float32 a,
v_float32 b 
)
inline

◆ v_load_deinterleave() [8/60]

void cv::v_load_deinterleave ( const float *  ptr,
v_float32 a,
v_float32 b,
v_float32 c 
)
inline

◆ v_load_deinterleave() [9/60]

void cv::v_load_deinterleave ( const float *  ptr,
v_float32 a,
v_float32 b,
v_float32 c,
v_float32 d 
)
inline

◆ v_load_deinterleave() [10/60]

void cv::v_load_deinterleave ( const float *  ptr,
v_float32x4 a,
v_float32x4 b 
)
inline

◆ v_load_deinterleave() [11/60]

void cv::v_load_deinterleave ( const float *  ptr,
v_float32x4 a,
v_float32x4 b,
v_float32x4 c 
)
inline

◆ v_load_deinterleave() [12/60]

void cv::v_load_deinterleave ( const float *  ptr,
v_float32x4 a,
v_float32x4 b,
v_float32x4 c,
v_float32x4 d 
)
inline

◆ v_load_deinterleave() [13/60]

void cv::v_load_deinterleave ( const int *  ptr,
v_int32 a,
v_int32 b 
)
inline

◆ v_load_deinterleave() [14/60]

void cv::v_load_deinterleave ( const int *  ptr,
v_int32 a,
v_int32 b,
v_int32 c 
)
inline

◆ v_load_deinterleave() [15/60]

void cv::v_load_deinterleave ( const int *  ptr,
v_int32 a,
v_int32 b,
v_int32 c,
v_int32 d 
)
inline

◆ v_load_deinterleave() [16/60]

void cv::v_load_deinterleave ( const int *  ptr,
v_int32x4 a,
v_int32x4 b 
)
inline

◆ v_load_deinterleave() [17/60]

void cv::v_load_deinterleave ( const int *  ptr,
v_int32x4 a,
v_int32x4 b,
v_int32x4 c 
)
inline

◆ v_load_deinterleave() [18/60]

void cv::v_load_deinterleave ( const int *  ptr,
v_int32x4 a,
v_int32x4 b,
v_int32x4 c,
v_int32x4 d 
)
inline

◆ v_load_deinterleave() [19/60]

void cv::v_load_deinterleave ( const int64 ptr,
v_int64 a,
v_int64 b 
)
inline

◆ v_load_deinterleave() [20/60]

void cv::v_load_deinterleave ( const int64 ptr,
v_int64 a,
v_int64 b,
v_int64 c 
)
inline

◆ v_load_deinterleave() [21/60]

void cv::v_load_deinterleave ( const int64 ptr,
v_int64 a,
v_int64 b,
v_int64 c,
v_int64 d 
)
inline

◆ v_load_deinterleave() [22/60]

void cv::v_load_deinterleave ( const int64 ptr,
v_int64x2 a,
v_int64x2 b 
)
inline

◆ v_load_deinterleave() [23/60]

void cv::v_load_deinterleave ( const int64 ptr,
v_int64x2 a,
v_int64x2 b,
v_int64x2 c 
)
inline

◆ v_load_deinterleave() [24/60]

void cv::v_load_deinterleave ( const int64 ptr,
v_int64x2 a,
v_int64x2 b,
v_int64x2 c,
v_int64x2 d 
)
inline

◆ v_load_deinterleave() [25/60]

void cv::v_load_deinterleave ( const schar ptr,
v_int8 a,
v_int8 b 
)
inline

◆ v_load_deinterleave() [26/60]

void cv::v_load_deinterleave ( const schar ptr,
v_int8 a,
v_int8 b,
v_int8 c 
)
inline

◆ v_load_deinterleave() [27/60]

void cv::v_load_deinterleave ( const schar ptr,
v_int8 a,
v_int8 b,
v_int8 c,
v_int8 d 
)
inline

◆ v_load_deinterleave() [28/60]

void cv::v_load_deinterleave ( const schar ptr,
v_int8x16 a,
v_int8x16 b 
)
inline

◆ v_load_deinterleave() [29/60]

void cv::v_load_deinterleave ( const schar ptr,
v_int8x16 a,
v_int8x16 b,
v_int8x16 c 
)
inline

◆ v_load_deinterleave() [30/60]

void cv::v_load_deinterleave ( const schar ptr,
v_int8x16 a,
v_int8x16 b,
v_int8x16 c,
v_int8x16 d 
)
inline

◆ v_load_deinterleave() [31/60]

void cv::v_load_deinterleave ( const short *  ptr,
v_int16 a,
v_int16 b 
)
inline

◆ v_load_deinterleave() [32/60]

void cv::v_load_deinterleave ( const short *  ptr,
v_int16 a,
v_int16 b,
v_int16 c 
)
inline

◆ v_load_deinterleave() [33/60]

void cv::v_load_deinterleave ( const short *  ptr,
v_int16 a,
v_int16 b,
v_int16 c,
v_int16 d 
)
inline

◆ v_load_deinterleave() [34/60]

void cv::v_load_deinterleave ( const short *  ptr,
v_int16x8 a,
v_int16x8 b 
)
inline

◆ v_load_deinterleave() [35/60]

void cv::v_load_deinterleave ( const short *  ptr,
v_int16x8 a,
v_int16x8 b,
v_int16x8 c 
)
inline

◆ v_load_deinterleave() [36/60]

void cv::v_load_deinterleave ( const short *  ptr,
v_int16x8 a,
v_int16x8 b,
v_int16x8 c,
v_int16x8 d 
)
inline

◆ v_load_deinterleave() [37/60]

void cv::v_load_deinterleave ( const uchar ptr,
v_uint8 a,
v_uint8 b 
)
inline

◆ v_load_deinterleave() [38/60]

void cv::v_load_deinterleave ( const uchar ptr,
v_uint8 a,
v_uint8 b,
v_uint8 c 
)
inline

◆ v_load_deinterleave() [39/60]

void cv::v_load_deinterleave ( const uchar ptr,
v_uint8 a,
v_uint8 b,
v_uint8 c,
v_uint8 d 
)
inline

◆ v_load_deinterleave() [40/60]

void cv::v_load_deinterleave ( const uchar ptr,
v_uint8x16 a,
v_uint8x16 b 
)
inline

◆ v_load_deinterleave() [41/60]

void cv::v_load_deinterleave ( const uchar ptr,
v_uint8x16 a,
v_uint8x16 b,
v_uint8x16 c 
)
inline

◆ v_load_deinterleave() [42/60]

void cv::v_load_deinterleave ( const uchar ptr,
v_uint8x16 a,
v_uint8x16 b,
v_uint8x16 c,
v_uint8x16 d 
)
inline

◆ v_load_deinterleave() [43/60]

void cv::v_load_deinterleave ( const uint64 ptr,
v_uint64 a,
v_uint64 b 
)
inline

◆ v_load_deinterleave() [44/60]

void cv::v_load_deinterleave ( const uint64 ptr,
v_uint64 a,
v_uint64 b,
v_uint64 c 
)
inline

◆ v_load_deinterleave() [45/60]

void cv::v_load_deinterleave ( const uint64 ptr,
v_uint64 a,
v_uint64 b,
v_uint64 c,
v_uint64 d 
)
inline

◆ v_load_deinterleave() [46/60]

void cv::v_load_deinterleave ( const uint64 ptr,
v_uint64x2 a,
v_uint64x2 b 
)
inline

◆ v_load_deinterleave() [47/60]

void cv::v_load_deinterleave ( const uint64 ptr,
v_uint64x2 a,
v_uint64x2 b,
v_uint64x2 c 
)
inline

◆ v_load_deinterleave() [48/60]

void cv::v_load_deinterleave ( const uint64 ptr,
v_uint64x2 a,
v_uint64x2 b,
v_uint64x2 c,
v_uint64x2 d 
)
inline

◆ v_load_deinterleave() [49/60]

void cv::v_load_deinterleave ( const unsigned *  ptr,
v_uint32 a,
v_uint32 b 
)
inline

◆ v_load_deinterleave() [50/60]

void cv::v_load_deinterleave ( const unsigned *  ptr,
v_uint32 a,
v_uint32 b,
v_uint32 c 
)
inline

◆ v_load_deinterleave() [51/60]

void cv::v_load_deinterleave ( const unsigned *  ptr,
v_uint32 a,
v_uint32 b,
v_uint32 c,
v_uint32 d 
)
inline

◆ v_load_deinterleave() [52/60]

void cv::v_load_deinterleave ( const unsigned *  ptr,
v_uint32x4 a,
v_uint32x4 b 
)
inline

◆ v_load_deinterleave() [53/60]

void cv::v_load_deinterleave ( const unsigned *  ptr,
v_uint32x4 a,
v_uint32x4 b,
v_uint32x4 c 
)
inline

◆ v_load_deinterleave() [54/60]

void cv::v_load_deinterleave ( const unsigned *  ptr,
v_uint32x4 a,
v_uint32x4 b,
v_uint32x4 c,
v_uint32x4 d 
)
inline

◆ v_load_deinterleave() [55/60]

void cv::v_load_deinterleave ( const ushort ptr,
v_uint16 a,
v_uint16 b 
)
inline

◆ v_load_deinterleave() [56/60]

void cv::v_load_deinterleave ( const ushort ptr,
v_uint16 a,
v_uint16 b,
v_uint16 c 
)
inline

◆ v_load_deinterleave() [57/60]

void cv::v_load_deinterleave ( const ushort ptr,
v_uint16 a,
v_uint16 b,
v_uint16 c,
v_uint16 d 
)
inline

◆ v_load_deinterleave() [58/60]

void cv::v_load_deinterleave ( const ushort ptr,
v_uint16x8 a,
v_uint16x8 b 
)
inline

◆ v_load_deinterleave() [59/60]

void cv::v_load_deinterleave ( const ushort ptr,
v_uint16x8 a,
v_uint16x8 b,
v_uint16x8 c 
)
inline

◆ v_load_deinterleave() [60/60]

void cv::v_load_deinterleave ( const ushort ptr,
v_uint16x8 a,
v_uint16x8 b,
v_uint16x8 c,
v_uint16x8 d 
)
inline

◆ v_load_expand() [1/6]

v_int64 cv::v_load_expand ( const int *  ptr)
inline

◆ v_load_expand() [2/6]

v_int16 cv::v_load_expand ( const schar ptr)
inline

◆ v_load_expand() [3/6]

v_int32 cv::v_load_expand ( const short *  ptr)
inline

◆ v_load_expand() [4/6]

v_uint16 cv::v_load_expand ( const uchar ptr)
inline

◆ v_load_expand() [5/6]

v_uint64 cv::v_load_expand ( const uint ptr)
inline

◆ v_load_expand() [6/6]

v_uint32 cv::v_load_expand ( const ushort ptr)
inline

◆ v_load_expand_q() [1/2]

v_int32 cv::v_load_expand_q ( const schar ptr)
inline

◆ v_load_expand_q() [2/2]

v_uint32 cv::v_load_expand_q ( const uchar ptr)
inline

◆ v_load_f32()

template<typename... Targs>
v_float32 cv::v_load_f32 ( Targs...  nScalars)

◆ v_load_f64()

template<typename... Targs>
v_float64 cv::v_load_f64 ( Targs...  nScalars)

◆ v_load_halves() [1/11]

v_float64 cv::v_load_halves ( const double *  ptr0,
const double *  ptr1 
)
inline

◆ v_load_halves() [2/11]

v_float32 cv::v_load_halves ( const float *  ptr0,
const float *  ptr1 
)
inline

◆ v_load_halves() [3/11]

v_int32 cv::v_load_halves ( const int *  ptr0,
const int *  ptr1 
)
inline

◆ v_load_halves() [4/11]

v_int64 cv::v_load_halves ( const int64 ptr0,
const int64 ptr1 
)
inline

◆ v_load_halves() [5/11]

v_int8 cv::v_load_halves ( const schar ptr0,
const schar ptr1 
)
inline

◆ v_load_halves() [6/11]

v_int16 cv::v_load_halves ( const short *  ptr0,
const short *  ptr1 
)
inline

◆ v_load_halves() [7/11]

v_uint8 cv::v_load_halves ( const uchar ptr0,
const uchar ptr1 
)
inline

◆ v_load_halves() [8/11]

v_uint64 cv::v_load_halves ( const uint64 ptr0,
const uint64 ptr1 
)
inline

◆ v_load_halves() [9/11]

v_uint32x4 cv::v_load_halves ( const unsigned *  ptr0,
const unsigned *  ptr1 
)
inline

◆ v_load_halves() [10/11]

v_uint32 cv::v_load_halves ( const unsigned int *  ptr0,
const unsigned int *  ptr1 
)
inline

◆ v_load_halves() [11/11]

v_uint16 cv::v_load_halves ( const ushort ptr0,
const ushort ptr1 
)
inline

◆ v_load_i16()

template<typename... Targs>
v_int16 cv::v_load_i16 ( Targs...  nScalars)

◆ v_load_i32()

template<typename... Targs>
v_int32 cv::v_load_i32 ( Targs...  nScalars)

◆ v_load_i64()

template<typename... Targs>
v_int64 cv::v_load_i64 ( Targs...  nScalars)

◆ v_load_i8()

template<typename... Targs>
v_int8 cv::v_load_i8 ( Targs...  nScalars)

◆ v_load_low() [1/11]

v_float64 cv::v_load_low ( const double *  ptr)
inline

◆ v_load_low() [2/11]

v_float32 cv::v_load_low ( const float *  ptr)
inline

◆ v_load_low() [3/11]

v_int32 cv::v_load_low ( const int *  ptr)
inline

◆ v_load_low() [4/11]

v_int64 cv::v_load_low ( const int64 ptr)
inline

◆ v_load_low() [5/11]

v_int8 cv::v_load_low ( const schar ptr)
inline

◆ v_load_low() [6/11]

v_int16 cv::v_load_low ( const short *  ptr)
inline

◆ v_load_low() [7/11]

v_uint8 cv::v_load_low ( const uchar ptr)
inline

◆ v_load_low() [8/11]

v_uint64 cv::v_load_low ( const uint64 ptr)
inline

◆ v_load_low() [9/11]

v_uint32x4 cv::v_load_low ( const unsigned *  ptr)
inline

◆ v_load_low() [10/11]

v_uint32 cv::v_load_low ( const unsigned int *  ptr)
inline

◆ v_load_low() [11/11]

v_uint16 cv::v_load_low ( const ushort ptr)
inline

◆ v_load_u16()

template<typename... Targs>
v_uint16 cv::v_load_u16 ( Targs...  nScalars)

◆ v_load_u32()

template<typename... Targs>
v_uint32 cv::v_load_u32 ( Targs...  nScalars)

◆ v_load_u64()

template<typename... Targs>
v_uint64 cv::v_load_u64 ( Targs...  nScalars)

◆ v_load_u8()

template<typename... Targs>
v_uint8 cv::v_load_u8 ( Targs...  nScalars)

◆ v_lt() [1/10]

v_float32 cv::v_lt ( const v_float32 a,
const v_float32 b 
)
inline

◆ v_lt() [2/10]

v_float64 cv::v_lt ( const v_float64 a,
const v_float64 b 
)
inline

◆ v_lt() [3/10]

v_int16 cv::v_lt ( const v_int16 a,
const v_int16 b 
)
inline

◆ v_lt() [4/10]

v_int32 cv::v_lt ( const v_int32 a,
const v_int32 b 
)
inline

◆ v_lt() [5/10]

v_int64 cv::v_lt ( const v_int64 a,
const v_int64 b 
)
inline

◆ v_lt() [6/10]

v_int8 cv::v_lt ( const v_int8 a,
const v_int8 b 
)
inline

◆ v_lt() [7/10]

v_uint16 cv::v_lt ( const v_uint16 a,
const v_uint16 b 
)
inline

◆ v_lt() [8/10]

v_uint32 cv::v_lt ( const v_uint32 a,
const v_uint32 b 
)
inline

◆ v_lt() [9/10]

v_uint64 cv::v_lt ( const v_uint64 a,
const v_uint64 b 
)
inline

◆ v_lt() [10/10]

v_uint8 cv::v_lt ( const v_uint8 a,
const v_uint8 b 
)
inline

◆ v_lut() [1/18]

v_float64 cv::v_lut ( const double *  tab,
const int *  idx 
)
inline

◆ v_lut() [2/18]

v_float64 cv::v_lut ( const double *  tab,
const v_int32 vidx 
)
inline

◆ v_lut() [3/18]

v_float64x2 cv::v_lut ( const double *  tab,
const v_int32x4 idxvec 
)
inline

◆ v_lut() [4/18]

v_float32 cv::v_lut ( const float *  tab,
const int *  idx 
)
inline

◆ v_lut() [5/18]

v_float32 cv::v_lut ( const float *  tab,
const v_int32 vidx 
)
inline

◆ v_lut() [6/18]

v_float32x4 cv::v_lut ( const float *  tab,
const v_int32x4 idxvec 
)
inline

◆ v_lut() [7/18]

v_int32 cv::v_lut ( const int *  tab,
const int *  idx 
)
inline

◆ v_lut() [8/18]

v_int32 cv::v_lut ( const int *  tab,
const v_int32 vidx 
)
inline

◆ v_lut() [9/18]

v_int32x4 cv::v_lut ( const int *  tab,
const v_int32x4 idxvec 
)
inline

◆ v_lut() [10/18]

v_int64 cv::v_lut ( const int64_t tab,
const int *  idx 
)
inline

◆ v_lut() [11/18]

v_int8 cv::v_lut ( const schar tab,
const int *  idx 
)
inline

◆ v_lut() [12/18]

v_int16 cv::v_lut ( const short *  tab,
const int *  idx 
)
inline

◆ v_lut() [13/18]

v_uint8 cv::v_lut ( const uchar tab,
const int *  idx 
)
inline

◆ v_lut() [14/18]

v_uint64 cv::v_lut ( const uint64 tab,
const int *  idx 
)
inline

◆ v_lut() [15/18]

v_uint32 cv::v_lut ( const unsigned *  tab,
const int *  idx 
)
inline

◆ v_lut() [16/18]

v_uint32 cv::v_lut ( const unsigned *  tab,
const v_int32 vidx 
)
inline

◆ v_lut() [17/18]

v_uint32x4 cv::v_lut ( const unsigned *  tab,
const v_int32x4 idxvec 
)
inline

◆ v_lut() [18/18]

v_uint16 cv::v_lut ( const ushort tab,
const int *  idx 
)
inline

◆ v_lut_deinterleave() [1/2]

void cv::v_lut_deinterleave ( const double *  tab,
const v_int32x4 idxvec,
v_float64x2 x,
v_float64x2 y 
)
inline

◆ v_lut_deinterleave() [2/2]

void cv::v_lut_deinterleave ( const float *  tab,
const v_int32x4 idxvec,
v_float32x4 x,
v_float32x4 y 
)
inline

◆ v_lut_pairs() [1/11]

v_float64 cv::v_lut_pairs ( const double *  tab,
const int *  idx 
)
inline

◆ v_lut_pairs() [2/11]

v_float32 cv::v_lut_pairs ( const float *  tab,
const int *  idx 
)
inline

◆ v_lut_pairs() [3/11]

v_int32 cv::v_lut_pairs ( const int *  tab,
const int *  idx 
)
inline

◆ v_lut_pairs() [4/11]

v_int64x2 cv::v_lut_pairs ( const int64 tab,
const int *  idx 
)
inline

◆ v_lut_pairs() [5/11]

v_int64 cv::v_lut_pairs ( const int64_t tab,
const int *  idx 
)
inline

◆ v_lut_pairs() [6/11]

v_int8 cv::v_lut_pairs ( const schar tab,
const int *  idx 
)
inline

◆ v_lut_pairs() [7/11]

v_int16 cv::v_lut_pairs ( const short *  tab,
const int *  idx 
)
inline

◆ v_lut_pairs() [8/11]

v_uint8 cv::v_lut_pairs ( const uchar tab,
const int *  idx 
)
inline

◆ v_lut_pairs() [9/11]

v_uint64 cv::v_lut_pairs ( const uint64 tab,
const int *  idx 
)
inline

◆ v_lut_pairs() [10/11]

v_uint32 cv::v_lut_pairs ( const unsigned *  tab,
const int *  idx 
)
inline

◆ v_lut_pairs() [11/11]

v_uint16 cv::v_lut_pairs ( const ushort tab,
const int *  idx 
)
inline

◆ v_lut_quads() [1/10]

v_float64 cv::v_lut_quads ( const double *  tab,
const int *  idx 
)
inline

◆ v_lut_quads() [2/10]

v_float32 cv::v_lut_quads ( const float *  tab,
const int *  idx 
)
inline

◆ v_lut_quads() [3/10]

v_int32 cv::v_lut_quads ( const int *  tab,
const int *  idx 
)
inline

◆ v_lut_quads() [4/10]

v_int64 cv::v_lut_quads ( const int64_t tab,
const int *  idx 
)
inline

◆ v_lut_quads() [5/10]

v_int8 cv::v_lut_quads ( const schar tab,
const int *  idx 
)
inline

◆ v_lut_quads() [6/10]

v_int16 cv::v_lut_quads ( const short *  tab,
const int *  idx 
)
inline

◆ v_lut_quads() [7/10]

v_uint8 cv::v_lut_quads ( const uchar tab,
const int *  idx 
)
inline

◆ v_lut_quads() [8/10]

v_uint64 cv::v_lut_quads ( const uint64 tab,
const int *  idx 
)
inline

◆ v_lut_quads() [9/10]

v_uint32 cv::v_lut_quads ( const unsigned *  tab,
const int *  idx 
)
inline

◆ v_lut_quads() [10/10]

v_uint16 cv::v_lut_quads ( const ushort tab,
const int *  idx 
)
inline

◆ v_magnitude() [1/4]

v_float32 cv::v_magnitude ( const v_float32 a,
const v_float32 b 
)
inline

◆ v_magnitude() [2/4]

v_float32x4 cv::v_magnitude ( const v_float32x4 a,
const v_float32x4 b 
)
inline

◆ v_magnitude() [3/4]

v_float64 cv::v_magnitude ( const v_float64 a,
const v_float64 b 
)
inline

◆ v_magnitude() [4/4]

v_float64x2 cv::v_magnitude ( const v_float64x2 a,
const v_float64x2 b 
)
inline

◆ v_matmul() [1/2]

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

◆ v_matmul() [2/2]

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

◆ v_matmuladd() [1/2]

v_float32 cv::v_matmuladd ( const v_float32 v,
const v_float32 m0,
const v_float32 m1,
const v_float32 m2,
const v_float32 a 
)
inline

◆ v_matmuladd() [2/2]

v_float32x4 cv::v_matmuladd ( const v_float32x4 v,
const v_float32x4 m0,
const v_float32x4 m1,
const v_float32x4 m2,
const v_float32x4 a 
)
inline

◆ v_max() [1/18]

v_float32 cv::v_max ( const v_float32 a,
const v_float32 b 
)
inline

◆ v_max() [2/18]

v_float32x4 cv::v_max ( const v_float32x4 a,
const v_float32x4 b 
)
inline

◆ v_max() [3/18]

v_float64 cv::v_max ( const v_float64 a,
const v_float64 b 
)
inline

◆ v_max() [4/18]

v_float64x2 cv::v_max ( const v_float64x2 a,
const v_float64x2 b 
)
inline

◆ v_max() [5/18]

v_int16 cv::v_max ( const v_int16 a,
const v_int16 b 
)
inline

◆ v_max() [6/18]

v_int16x8 cv::v_max ( const v_int16x8 a,
const v_int16x8 b 
)
inline

◆ v_max() [7/18]

v_int32 cv::v_max ( const v_int32 a,
const v_int32 b 
)
inline

◆ v_max() [8/18]

v_int32x4 cv::v_max ( const v_int32x4 a,
const v_int32x4 b 
)
inline

◆ v_max() [9/18]

v_int64x2 cv::v_max ( const v_int64x2 a,
const v_int64x2 b 
)
inline

◆ v_max() [10/18]

v_int8 cv::v_max ( const v_int8 a,
const v_int8 b 
)
inline

◆ v_max() [11/18]

v_int8x16 cv::v_max ( const v_int8x16 a,
const v_int8x16 b 
)
inline

◆ v_max() [12/18]

v_uint16 cv::v_max ( const v_uint16 a,
const v_uint16 b 
)
inline

◆ v_max() [13/18]

v_uint16x8 cv::v_max ( const v_uint16x8 a,
const v_uint16x8 b 
)
inline

◆ v_max() [14/18]

v_uint32 cv::v_max ( const v_uint32 a,
const v_uint32 b 
)
inline

◆ v_max() [15/18]

v_uint32x4 cv::v_max ( const v_uint32x4 a,
const v_uint32x4 b 
)
inline

◆ v_max() [16/18]

v_uint64x2 cv::v_max ( const v_uint64x2 a,
const v_uint64x2 b 
)
inline

◆ v_max() [17/18]

v_uint8 cv::v_max ( const v_uint8 a,
const v_uint8 b 
)
inline

◆ v_max() [18/18]

v_uint8x16 cv::v_max ( const v_uint8x16 a,
const v_uint8x16 b 
)
inline

◆ v_min() [1/18]

v_float32 cv::v_min ( const v_float32 a,
const v_float32 b 
)
inline

◆ v_min() [2/18]

v_float32x4 cv::v_min ( const v_float32x4 a,
const v_float32x4 b 
)
inline

◆ v_min() [3/18]

v_float64 cv::v_min ( const v_float64 a,
const v_float64 b 
)
inline

◆ v_min() [4/18]

v_float64x2 cv::v_min ( const v_float64x2 a,
const v_float64x2 b 
)
inline

◆ v_min() [5/18]

v_int16 cv::v_min ( const v_int16 a,
const v_int16 b 
)
inline

◆ v_min() [6/18]

v_int16x8 cv::v_min ( const v_int16x8 a,
const v_int16x8 b 
)
inline

◆ v_min() [7/18]

v_int32 cv::v_min ( const v_int32 a,
const v_int32 b 
)
inline

◆ v_min() [8/18]

v_int32x4 cv::v_min ( const v_int32x4 a,
const v_int32x4 b 
)
inline

◆ v_min() [9/18]

v_int64x2 cv::v_min ( const v_int64x2 a,
const v_int64x2 b 
)
inline

◆ v_min() [10/18]

v_int8 cv::v_min ( const v_int8 a,
const v_int8 b 
)
inline

◆ v_min() [11/18]

v_int8x16 cv::v_min ( const v_int8x16 a,
const v_int8x16 b 
)
inline

◆ v_min() [12/18]

v_uint16 cv::v_min ( const v_uint16 a,
const v_uint16 b 
)
inline

◆ v_min() [13/18]

v_uint16x8 cv::v_min ( const v_uint16x8 a,
const v_uint16x8 b 
)
inline

◆ v_min() [14/18]

v_uint32 cv::v_min ( const v_uint32 a,
const v_uint32 b 
)
inline

◆ v_min() [15/18]

v_uint32x4 cv::v_min ( const v_uint32x4 a,
const v_uint32x4 b 
)
inline

◆ v_min() [16/18]

v_uint64x2 cv::v_min ( const v_uint64x2 a,
const v_uint64x2 b 
)
inline

◆ v_min() [17/18]

v_uint8 cv::v_min ( const v_uint8 a,
const v_uint8 b 
)
inline

◆ v_min() [18/18]

v_uint8x16 cv::v_min ( const v_uint8x16 a,
const v_uint8x16 b 
)
inline

◆ v_mul() [1/16]

v_float32 cv::v_mul ( const v_float32 a,
const v_float32 b 
)
inline

◆ v_mul() [2/16]

template<typename... Args>
v_float32 cv::v_mul ( const v_float32 f1,
const v_float32 f2,
const Args &...  vf 
)
inline

◆ v_mul() [3/16]

v_float64 cv::v_mul ( const v_float64 a,
const v_float64 b 
)
inline

◆ v_mul() [4/16]

template<typename... Args>
v_float64 cv::v_mul ( const v_float64 f1,
const v_float64 f2,
const Args &...  vf 
)
inline

◆ v_mul() [5/16]

v_int16 cv::v_mul ( const v_int16 a,
const v_int16 b 
)
inline

◆ v_mul() [6/16]

template<typename... Args>
v_int16 cv::v_mul ( const v_int16 a1,
const v_int16 a2,
const Args &...  va 
)
inline

◆ v_mul() [7/16]

v_int32 cv::v_mul ( const v_int32 a,
const v_int32 b 
)
inline

◆ v_mul() [8/16]

template<typename... Args>
v_int32 cv::v_mul ( const v_int32 f1,
const v_int32 f2,
const Args &...  vf 
)
inline

◆ v_mul() [9/16]

v_int8 cv::v_mul ( const v_int8 a,
const v_int8 b 
)
inline

◆ v_mul() [10/16]

template<typename... Args>
v_int8 cv::v_mul ( const v_int8 a1,
const v_int8 a2,
const Args &...  va 
)
inline

◆ v_mul() [11/16]

v_uint16 cv::v_mul ( const v_uint16 a,
const v_uint16 b 
)
inline

◆ v_mul() [12/16]

template<typename... Args>
v_uint16 cv::v_mul ( const v_uint16 a1,
const v_uint16 a2,
const Args &...  va 
)
inline

◆ v_mul() [13/16]

v_uint32 cv::v_mul ( const v_uint32 a,
const v_uint32 b 
)
inline

◆ v_mul() [14/16]

template<typename... Args>
v_uint32 cv::v_mul ( const v_uint32 f1,
const v_uint32 f2,
const Args &...  vf 
)
inline

◆ v_mul() [15/16]

v_uint8 cv::v_mul ( const v_uint8 a,
const v_uint8 b 
)
inline

◆ v_mul() [16/16]

template<typename... Args>
v_uint8 cv::v_mul ( const v_uint8 a1,
const v_uint8 a2,
const Args &...  va 
)
inline

◆ v_mul_expand() [1/10]

void cv::v_mul_expand ( const v_int16 a,
const v_int16 b,
v_int32 c,
v_int32 d 
)
inline

◆ v_mul_expand() [2/10]

void cv::v_mul_expand ( const v_int16x8 a,
const v_int16x8 b,
v_int32x4 c,
v_int32x4 d 
)
inline

◆ v_mul_expand() [3/10]

void cv::v_mul_expand ( const v_int8 a,
const v_int8 b,
v_int16 c,
v_int16 d 
)
inline

◆ v_mul_expand() [4/10]

void cv::v_mul_expand ( const v_int8x16 a,
const v_int8x16 b,
v_int16x8 c,
v_int16x8 d 
)
inline

◆ v_mul_expand() [5/10]

void cv::v_mul_expand ( const v_uint16 a,
const v_uint16 b,
v_uint32 c,
v_uint32 d 
)
inline

◆ v_mul_expand() [6/10]

void cv::v_mul_expand ( const v_uint16x8 a,
const v_uint16x8 b,
v_uint32x4 c,
v_uint32x4 d 
)
inline

◆ v_mul_expand() [7/10]

void cv::v_mul_expand ( const v_uint32 a,
const v_uint32 b,
v_uint64 c,
v_uint64 d 
)
inline

◆ v_mul_expand() [8/10]

void cv::v_mul_expand ( const v_uint32x4 a,
const v_uint32x4 b,
v_uint64x2 c,
v_uint64x2 d 
)
inline

◆ v_mul_expand() [9/10]

void cv::v_mul_expand ( const v_uint8 a,
const v_uint8 b,
v_uint16 c,
v_uint16 d 
)
inline

◆ v_mul_expand() [10/10]

void cv::v_mul_expand ( const v_uint8x16 a,
const v_uint8x16 b,
v_uint16x8 c,
v_uint16x8 d 
)
inline

◆ v_mul_hi() [1/4]

v_int16 cv::v_mul_hi ( const v_int16 a,
const v_int16 b 
)
inline

◆ v_mul_hi() [2/4]

v_int16x8 cv::v_mul_hi ( const v_int16x8 a,
const v_int16x8 b 
)
inline

◆ v_mul_hi() [3/4]

v_uint16 cv::v_mul_hi ( const v_uint16 a,
const v_uint16 b 
)
inline

◆ v_mul_hi() [4/4]

v_uint16x8 cv::v_mul_hi ( const v_uint16x8 a,
const v_uint16x8 b 
)
inline

◆ v_mul_wrap() [1/8]

v_int16 cv::v_mul_wrap ( const v_int16 a,
const v_int16 b 
)
inline

◆ v_mul_wrap() [2/8]

v_int16x8 cv::v_mul_wrap ( const v_int16x8 a,
const v_int16x8 b 
)
inline

◆ v_mul_wrap() [3/8]

v_int8 cv::v_mul_wrap ( const v_int8 a,
const v_int8 b 
)
inline

◆ v_mul_wrap() [4/8]

v_int8x16 cv::v_mul_wrap ( const v_int8x16 a,
const v_int8x16 b 
)
inline

◆ v_mul_wrap() [5/8]

v_uint16 cv::v_mul_wrap ( const v_uint16 a,
const v_uint16 b 
)
inline

◆ v_mul_wrap() [6/8]

v_uint16x8 cv::v_mul_wrap ( const v_uint16x8 a,
const v_uint16x8 b 
)
inline

◆ v_mul_wrap() [7/8]

v_uint8 cv::v_mul_wrap ( const v_uint8 a,
const v_uint8 b 
)
inline

◆ v_mul_wrap() [8/8]

v_uint8x16 cv::v_mul_wrap ( const v_uint8x16 a,
const v_uint8x16 b 
)
inline

◆ v_muladd() [1/6]

v_float32 cv::v_muladd ( const v_float32 a,
const v_float32 b,
const v_float32 c 
)
inline

◆ v_muladd() [2/6]

v_float32x4 cv::v_muladd ( const v_float32x4 a,
const v_float32x4 b,
const v_float32x4 c 
)
inline

◆ v_muladd() [3/6]

v_float64 cv::v_muladd ( const v_float64 a,
const v_float64 b,
const v_float64 c 
)
inline

◆ v_muladd() [4/6]

v_float64x2 cv::v_muladd ( const v_float64x2 a,
const v_float64x2 b,
const v_float64x2 c 
)
inline

◆ v_muladd() [5/6]

v_int32 cv::v_muladd ( const v_int32 a,
const v_int32 b,
const v_int32 c 
)
inline

◆ v_muladd() [6/6]

v_int32x4 cv::v_muladd ( const v_int32x4 a,
const v_int32x4 b,
const v_int32x4 c 
)
inline

◆ v_ne() [1/10]

v_float32 cv::v_ne ( const v_float32 a,
const v_float32 b 
)
inline

◆ v_ne() [2/10]

v_float64 cv::v_ne ( const v_float64 a,
const v_float64 b 
)
inline

◆ v_ne() [3/10]

v_int16 cv::v_ne ( const v_int16 a,
const v_int16 b 
)
inline

◆ v_ne() [4/10]

v_int32 cv::v_ne ( const v_int32 a,
const v_int32 b 
)
inline

◆ v_ne() [5/10]

v_int64 cv::v_ne ( const v_int64 a,
const v_int64 b 
)
inline

◆ v_ne() [6/10]

v_int8 cv::v_ne ( const v_int8 a,
const v_int8 b 
)
inline

◆ v_ne() [7/10]

v_uint16 cv::v_ne ( const v_uint16 a,
const v_uint16 b 
)
inline

◆ v_ne() [8/10]

v_uint32 cv::v_ne ( const v_uint32 a,
const v_uint32 b 
)
inline

◆ v_ne() [9/10]

v_uint64 cv::v_ne ( const v_uint64 a,
const v_uint64 b 
)
inline

◆ v_ne() [10/10]

v_uint8 cv::v_ne ( const v_uint8 a,
const v_uint8 b 
)
inline

◆ v_not() [1/10]

v_float32 cv::v_not ( const v_float32 a)
inline

◆ v_not() [2/10]

v_float64 cv::v_not ( const v_float64 a)
inline

◆ v_not() [3/10]

v_int16 cv::v_not ( const v_int16 a)
inline

◆ v_not() [4/10]

v_int32 cv::v_not ( const v_int32 a)
inline

◆ v_not() [5/10]

v_int64 cv::v_not ( const v_int64 a)
inline

◆ v_not() [6/10]

v_int8 cv::v_not ( const v_int8 a)
inline

◆ v_not() [7/10]

v_uint16 cv::v_not ( const v_uint16 a)
inline

◆ v_not() [8/10]

v_uint32 cv::v_not ( const v_uint32 a)
inline

◆ v_not() [9/10]

v_uint64 cv::v_not ( const v_uint64 a)
inline

◆ v_not() [10/10]

v_uint8 cv::v_not ( const v_uint8 a)
inline

◆ v_not_nan() [1/4]

v_float32 cv::v_not_nan ( const v_float32 a)
inline

◆ v_not_nan() [2/4]

v_float32x4 cv::v_not_nan ( const v_float32x4 a)
inline

◆ v_not_nan() [3/4]

v_float64 cv::v_not_nan ( const v_float64 a)
inline

◆ v_not_nan() [4/4]

v_float64x2 cv::v_not_nan ( const v_float64x2 a)
inline

◆ v_or() [1/10]

v_float32 cv::v_or ( const v_float32 a,
const v_float32 b 
)
inline

◆ v_or() [2/10]

v_float64 cv::v_or ( const v_float64 a,
const v_float64 b 
)
inline

◆ v_or() [3/10]

v_int16 cv::v_or ( const v_int16 a,
const v_int16 b 
)
inline

◆ v_or() [4/10]

v_int32 cv::v_or ( const v_int32 a,
const v_int32 b 
)
inline

◆ v_or() [5/10]

v_int64 cv::v_or ( const v_int64 a,
const v_int64 b 
)
inline

◆ v_or() [6/10]

v_int8 cv::v_or ( const v_int8 a,
const v_int8 b 
)
inline

◆ v_or() [7/10]

v_uint16 cv::v_or ( const v_uint16 a,
const v_uint16 b 
)
inline

◆ v_or() [8/10]

v_uint32 cv::v_or ( const v_uint32 a,
const v_uint32 b 
)
inline

◆ v_or() [9/10]

v_uint64 cv::v_or ( const v_uint64 a,
const v_uint64 b 
)
inline

◆ v_or() [10/10]

v_uint8 cv::v_or ( const v_uint8 a,
const v_uint8 b 
)
inline

◆ v_pack() [1/12]

v_int8 cv::v_pack ( const v_int16 a,
const v_int16 b 
)
inline

◆ v_pack() [2/12]

v_int8x16 cv::v_pack ( const v_int16x8 a,
const v_int16x8 b 
)
inline

◆ v_pack() [3/12]

v_int16 cv::v_pack ( const v_int32 a,
const v_int32 b 
)
inline

◆ v_pack() [4/12]

v_int16x8 cv::v_pack ( const v_int32x4 a,
const v_int32x4 b 
)
inline

◆ v_pack() [5/12]

v_int32 cv::v_pack ( const v_int64 a,
const v_int64 b 
)
inline

◆ v_pack() [6/12]

v_int32x4 cv::v_pack ( const v_int64x2 a,
const v_int64x2 b 
)
inline

◆ v_pack() [7/12]

v_uint8 cv::v_pack ( const v_uint16 a,
const v_uint16 b 
)
inline

◆ v_pack() [8/12]

v_uint8x16 cv::v_pack ( const v_uint16x8 a,
const v_uint16x8 b 
)
inline

◆ v_pack() [9/12]

v_uint16 cv::v_pack ( const v_uint32 a,
const v_uint32 b 
)
inline

◆ v_pack() [10/12]

v_uint16x8 cv::v_pack ( const v_uint32x4 a,
const v_uint32x4 b 
)
inline

◆ v_pack() [11/12]

v_uint32 cv::v_pack ( const v_uint64 a,
const v_uint64 b 
)
inline

◆ v_pack() [12/12]

v_uint32x4 cv::v_pack ( const v_uint64x2 a,
const v_uint64x2 b 
)
inline

◆ v_pack_b() [1/6]

v_uint8 cv::v_pack_b ( const v_uint16 a,
const v_uint16 b 
)
inline

◆ v_pack_b() [2/6]

v_uint8x16 cv::v_pack_b ( const v_uint16x8 a,
const v_uint16x8 b 
)
inline

◆ v_pack_b() [3/6]

v_uint8 cv::v_pack_b ( const v_uint32 a,
const v_uint32 b,
const v_uint32 c,
const v_uint32 d 
)
inline

◆ v_pack_b() [4/6]

v_uint8x16 cv::v_pack_b ( const v_uint32x4 a,
const v_uint32x4 b,
const v_uint32x4 c,
const v_uint32x4 d 
)
inline

◆ v_pack_b() [5/6]

v_uint8 cv::v_pack_b ( const v_uint64 a,
const v_uint64 b,
const v_uint64 c,
const v_uint64 d,
const v_uint64 e,
const v_uint64 f,
const v_uint64 g,
const v_uint64 h 
)
inline

◆ v_pack_b() [6/6]

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

◆ v_pack_store() [1/14]

void cv::v_pack_store ( float16_t ptr,
const v_float32 v 
)
inline

◆ v_pack_store() [2/14]

void cv::v_pack_store ( float16_t ptr,
const v_float32x4 v 
)
inline

◆ v_pack_store() [3/14]

void cv::v_pack_store ( int *  ptr,
const v_int64 a 
)
inline

◆ v_pack_store() [4/14]

void cv::v_pack_store ( int *  ptr,
const v_int64x2 a 
)
inline

◆ v_pack_store() [5/14]

void cv::v_pack_store ( schar ptr,
const v_int16 a 
)
inline

◆ v_pack_store() [6/14]

void cv::v_pack_store ( schar ptr,
const v_int16x8 a 
)
inline

◆ v_pack_store() [7/14]

void cv::v_pack_store ( short *  ptr,
const v_int32 a 
)
inline

◆ v_pack_store() [8/14]

void cv::v_pack_store ( short *  ptr,
const v_int32x4 a 
)
inline

◆ v_pack_store() [9/14]

void cv::v_pack_store ( uchar ptr,
const v_uint16 a 
)
inline

◆ v_pack_store() [10/14]

void cv::v_pack_store ( uchar ptr,
const v_uint16x8 a 
)
inline

◆ v_pack_store() [11/14]

void cv::v_pack_store ( unsigned *  ptr,
const v_uint64 a 
)
inline

◆ v_pack_store() [12/14]

void cv::v_pack_store ( unsigned *  ptr,
const v_uint64x2 a 
)
inline

◆ v_pack_store() [13/14]

void cv::v_pack_store ( ushort ptr,
const v_uint32 a 
)
inline

◆ v_pack_store() [14/14]

void cv::v_pack_store ( ushort ptr,
const v_uint32x4 a 
)
inline

◆ v_pack_triplets() [1/17]

v_float32 cv::v_pack_triplets ( const v_float32 vec)
inline

◆ v_pack_triplets() [2/17]

v_float32x4 cv::v_pack_triplets ( const v_float32x4 vec)
inline

◆ v_pack_triplets() [3/17]

v_float64 cv::v_pack_triplets ( const v_float64 vec)
inline

◆ v_pack_triplets() [4/17]

v_int16 cv::v_pack_triplets ( const v_int16 vec)
inline

◆ v_pack_triplets() [5/17]

v_int16x8 cv::v_pack_triplets ( const v_int16x8 vec)
inline

◆ v_pack_triplets() [6/17]

v_int32 cv::v_pack_triplets ( const v_int32 vec)
inline

◆ v_pack_triplets() [7/17]

v_int32x4 cv::v_pack_triplets ( const v_int32x4 vec)
inline

◆ v_pack_triplets() [8/17]

v_int64 cv::v_pack_triplets ( const v_int64 vec)
inline

◆ v_pack_triplets() [9/17]

v_int8 cv::v_pack_triplets ( const v_int8 vec)
inline

◆ v_pack_triplets() [10/17]

v_int8x16 cv::v_pack_triplets ( const v_int8x16 vec)
inline

◆ v_pack_triplets() [11/17]

v_uint16 cv::v_pack_triplets ( const v_uint16 vec)
inline

◆ v_pack_triplets() [12/17]

v_uint16x8 cv::v_pack_triplets ( const v_uint16x8 vec)
inline

◆ v_pack_triplets() [13/17]

v_uint32 cv::v_pack_triplets ( const v_uint32 vec)
inline

◆ v_pack_triplets() [14/17]

v_uint32x4 cv::v_pack_triplets ( const v_uint32x4 vec)
inline

◆ v_pack_triplets() [15/17]

v_uint64 cv::v_pack_triplets ( const v_uint64 vec)
inline

◆ v_pack_triplets() [16/17]

v_uint8 cv::v_pack_triplets ( const v_uint8 vec)
inline

◆ v_pack_triplets() [17/17]

v_uint8x16 cv::v_pack_triplets ( const v_uint8x16 vec)
inline

◆ v_pack_u() [1/4]

v_uint8 cv::v_pack_u ( const v_int16 a,
const v_int16 b 
)
inline

◆ v_pack_u() [2/4]

v_uint8x16 cv::v_pack_u ( const v_int16x8 a,
const v_int16x8 b 
)
inline

◆ v_pack_u() [3/4]

v_uint16 cv::v_pack_u ( const v_int32 a,
const v_int32 b 
)
inline

◆ v_pack_u() [4/4]

v_uint16x8 cv::v_pack_u ( const v_int32x4 a,
const v_int32x4 b 
)
inline

◆ v_pack_u_store() [1/4]

void cv::v_pack_u_store ( uchar ptr,
const v_int16 a 
)
inline

◆ v_pack_u_store() [2/4]

void cv::v_pack_u_store ( uchar ptr,
const v_int16x8 a 
)
inline

◆ v_pack_u_store() [3/4]

void cv::v_pack_u_store ( ushort ptr,
const v_int32 a 
)
inline

◆ v_pack_u_store() [4/4]

void cv::v_pack_u_store ( ushort ptr,
const v_int32x4 a 
)
inline

◆ v_popcount() [1/16]

v_uint16 cv::v_popcount ( const v_int16 a)
inline

◆ v_popcount() [2/16]

v_uint16x8 cv::v_popcount ( const v_int16x8 a)
inline

◆ v_popcount() [3/16]

v_uint32 cv::v_popcount ( const v_int32 a)
inline

◆ v_popcount() [4/16]

v_uint32x4 cv::v_popcount ( const v_int32x4 a)
inline

◆ v_popcount() [5/16]

v_uint64 cv::v_popcount ( const v_int64 a)
inline

◆ v_popcount() [6/16]

v_uint64x2 cv::v_popcount ( const v_int64x2 a)
inline

◆ v_popcount() [7/16]

v_uint8 cv::v_popcount ( const v_int8 a)
inline

◆ v_popcount() [8/16]

v_uint8x16 cv::v_popcount ( const v_int8x16 a)
inline

◆ v_popcount() [9/16]

v_uint16 cv::v_popcount ( const v_uint16 a)
inline

◆ v_popcount() [10/16]

v_uint16x8 cv::v_popcount ( const v_uint16x8 a)
inline

◆ v_popcount() [11/16]

v_uint32 cv::v_popcount ( const v_uint32 a)
inline

◆ v_popcount() [12/16]

v_uint32x4 cv::v_popcount ( const v_uint32x4 a)
inline

◆ v_popcount() [13/16]

v_uint64 cv::v_popcount ( const v_uint64 a)
inline

◆ v_popcount() [14/16]

v_uint64x2 cv::v_popcount ( const v_uint64x2 a)
inline

◆ v_popcount() [15/16]

v_uint8 cv::v_popcount ( const v_uint8 a)
inline

◆ v_popcount() [16/16]

v_uint8x16 cv::v_popcount ( const v_uint8x16 a)
inline

◆ v_recombine() [1/16]

void cv::v_recombine ( const v_float32 a,
const v_float32 b,
v_float32 c,
v_float32 d 
)
inline

◆ v_recombine() [2/16]

void cv::v_recombine ( const v_float32x4 a,
const v_float32x4 b,
v_float32x4 c,
v_float32x4 d 
)
inline

◆ v_recombine() [3/16]

void cv::v_recombine ( const v_float64 a,
const v_float64 b,
v_float64 c,
v_float64 d 
)
inline

◆ v_recombine() [4/16]

void cv::v_recombine ( const v_float64x2 a,
const v_float64x2 b,
v_float64x2 c,
v_float64x2 d 
)
inline

◆ v_recombine() [5/16]

void cv::v_recombine ( const v_int16 a,
const v_int16 b,
v_int16 c,
v_int16 d 
)
inline

◆ v_recombine() [6/16]

void cv::v_recombine ( const v_int16x8 a,
const v_int16x8 b,
v_int16x8 c,
v_int16x8 d 
)
inline

◆ v_recombine() [7/16]

void cv::v_recombine ( const v_int32 a,
const v_int32 b,
v_int32 c,
v_int32 d 
)
inline

◆ v_recombine() [8/16]

void cv::v_recombine ( const v_int32x4 a,
const v_int32x4 b,
v_int32x4 c,
v_int32x4 d 
)
inline

◆ v_recombine() [9/16]

void cv::v_recombine ( const v_int8 a,
const v_int8 b,
v_int8 c,
v_int8 d 
)
inline

◆ v_recombine() [10/16]

void cv::v_recombine ( const v_int8x16 a,
const v_int8x16 b,
v_int8x16 c,
v_int8x16 d 
)
inline

◆ v_recombine() [11/16]

void cv::v_recombine ( const v_uint16 a,
const v_uint16 b,
v_uint16 c,
v_uint16 d 
)
inline

◆ v_recombine() [12/16]

void cv::v_recombine ( const v_uint16x8 a,
const v_uint16x8 b,
v_uint16x8 c,
v_uint16x8 d 
)
inline

◆ v_recombine() [13/16]

void cv::v_recombine ( const v_uint32 a,
const v_uint32 b,
v_uint32 c,
v_uint32 d 
)
inline

◆ v_recombine() [14/16]

void cv::v_recombine ( const v_uint32x4 a,
const v_uint32x4 b,
v_uint32x4 c,
v_uint32x4 d 
)
inline

◆ v_recombine() [15/16]

void cv::v_recombine ( const v_uint8 a,
const v_uint8 b,
v_uint8 c,
v_uint8 d 
)
inline

◆ v_recombine() [16/16]

void cv::v_recombine ( const v_uint8x16 a,
const v_uint8x16 b,
v_uint8x16 c,
v_uint8x16 d 
)
inline

◆ v_reduce_max() [1/14]

float cv::v_reduce_max ( const v_float32 a)
inline

◆ v_reduce_max() [2/14]

float cv::v_reduce_max ( const v_float32x4 a)
inline

◆ v_reduce_max() [3/14]

short cv::v_reduce_max ( const v_int16 a)
inline

◆ v_reduce_max() [4/14]

short cv::v_reduce_max ( const v_int16x8 a)
inline

◆ v_reduce_max() [5/14]

int cv::v_reduce_max ( const v_int32 a)
inline

◆ v_reduce_max() [6/14]

int cv::v_reduce_max ( const v_int32x4 a)
inline

◆ v_reduce_max() [7/14]

schar cv::v_reduce_max ( const v_int8 a)
inline

◆ v_reduce_max() [8/14]

schar cv::v_reduce_max ( const v_int8x16 a)
inline

◆ v_reduce_max() [9/14]

ushort cv::v_reduce_max ( const v_uint16 a)
inline

◆ v_reduce_max() [10/14]

ushort cv::v_reduce_max ( const v_uint16x8 a)
inline

◆ v_reduce_max() [11/14]

unsigned cv::v_reduce_max ( const v_uint32 a)
inline

◆ v_reduce_max() [12/14]

unsigned cv::v_reduce_max ( const v_uint32x4 a)
inline

◆ v_reduce_max() [13/14]

uchar cv::v_reduce_max ( const v_uint8 a)
inline

◆ v_reduce_max() [14/14]

uchar cv::v_reduce_max ( const v_uint8x16 a)
inline

◆ v_reduce_min() [1/14]

float cv::v_reduce_min ( const v_float32 a)
inline

◆ v_reduce_min() [2/14]

float cv::v_reduce_min ( const v_float32x4 a)
inline

◆ v_reduce_min() [3/14]

short cv::v_reduce_min ( const v_int16 a)
inline

◆ v_reduce_min() [4/14]

short cv::v_reduce_min ( const v_int16x8 a)
inline

◆ v_reduce_min() [5/14]

int cv::v_reduce_min ( const v_int32 a)
inline

◆ v_reduce_min() [6/14]

int cv::v_reduce_min ( const v_int32x4 a)
inline

◆ v_reduce_min() [7/14]

schar cv::v_reduce_min ( const v_int8 a)
inline

◆ v_reduce_min() [8/14]

schar cv::v_reduce_min ( const v_int8x16 a)
inline

◆ v_reduce_min() [9/14]

ushort cv::v_reduce_min ( const v_uint16 a)
inline

◆ v_reduce_min() [10/14]

ushort cv::v_reduce_min ( const v_uint16x8 a)
inline

◆ v_reduce_min() [11/14]

unsigned cv::v_reduce_min ( const v_uint32 a)
inline

◆ v_reduce_min() [12/14]

unsigned cv::v_reduce_min ( const v_uint32x4 a)
inline

◆ v_reduce_min() [13/14]

uchar cv::v_reduce_min ( const v_uint8 a)
inline

◆ v_reduce_min() [14/14]

uchar cv::v_reduce_min ( const v_uint8x16 a)
inline

◆ v_reduce_sad() [1/14]

float cv::v_reduce_sad ( const v_float32 a,
const v_float32 b 
)
inline

◆ v_reduce_sad() [2/14]

float cv::v_reduce_sad ( const v_float32x4 a,
const v_float32x4 b 
)
inline

◆ v_reduce_sad() [3/14]

unsigned cv::v_reduce_sad ( const v_int16 a,
const v_int16 b 
)
inline

◆ v_reduce_sad() [4/14]

unsigned cv::v_reduce_sad ( const v_int16x8 a,
const v_int16x8 b 
)
inline

◆ v_reduce_sad() [5/14]

unsigned cv::v_reduce_sad ( const v_int32 a,
const v_int32 b 
)
inline

◆ v_reduce_sad() [6/14]

unsigned cv::v_reduce_sad ( const v_int32x4 a,
const v_int32x4 b 
)
inline

◆ v_reduce_sad() [7/14]

unsigned cv::v_reduce_sad ( const v_int8 a,
const v_int8 b 
)
inline

◆ v_reduce_sad() [8/14]

unsigned cv::v_reduce_sad ( const v_int8x16 a,
const v_int8x16 b 
)
inline

◆ v_reduce_sad() [9/14]

unsigned cv::v_reduce_sad ( const v_uint16 a,
const v_uint16 b 
)
inline

◆ v_reduce_sad() [10/14]

unsigned cv::v_reduce_sad ( const v_uint16x8 a,
const v_uint16x8 b 
)
inline

◆ v_reduce_sad() [11/14]

unsigned cv::v_reduce_sad ( const v_uint32 a,
const v_uint32 b 
)
inline

◆ v_reduce_sad() [12/14]

unsigned cv::v_reduce_sad ( const v_uint32x4 a,
const v_uint32x4 b 
)
inline

◆ v_reduce_sad() [13/14]

unsigned cv::v_reduce_sad ( const v_uint8 a,
const v_uint8 b 
)
inline

◆ v_reduce_sad() [14/14]

unsigned cv::v_reduce_sad ( const v_uint8x16 a,
const v_uint8x16 b 
)
inline

◆ v_reduce_sum() [1/20]

float cv::v_reduce_sum ( const v_float32 a)
inline

◆ v_reduce_sum() [2/20]

float cv::v_reduce_sum ( const v_float32x4 a)
inline

◆ v_reduce_sum() [3/20]

float cv::v_reduce_sum ( const v_float64 a)
inline

◆ v_reduce_sum() [4/20]

double cv::v_reduce_sum ( const v_float64x2 a)
inline

◆ v_reduce_sum() [5/20]

int cv::v_reduce_sum ( const v_int16 a)
inline

◆ v_reduce_sum() [6/20]

int cv::v_reduce_sum ( const v_int16x8 a)
inline

◆ v_reduce_sum() [7/20]

int cv::v_reduce_sum ( const v_int32 a)
inline

◆ v_reduce_sum() [8/20]

int cv::v_reduce_sum ( const v_int32x4 a)
inline

◆ v_reduce_sum() [9/20]

int64 cv::v_reduce_sum ( const v_int64 a)
inline

◆ v_reduce_sum() [10/20]

int64 cv::v_reduce_sum ( const v_int64x2 a)
inline

◆ v_reduce_sum() [11/20]

int cv::v_reduce_sum ( const v_int8 a)
inline

◆ v_reduce_sum() [12/20]

int cv::v_reduce_sum ( const v_int8x16 a)
inline

◆ v_reduce_sum() [13/20]

unsigned cv::v_reduce_sum ( const v_uint16 a)
inline

◆ v_reduce_sum() [14/20]

unsigned cv::v_reduce_sum ( const v_uint16x8 a)
inline

◆ v_reduce_sum() [15/20]

unsigned cv::v_reduce_sum ( const v_uint32 a)
inline

◆ v_reduce_sum() [16/20]

unsigned cv::v_reduce_sum ( const v_uint32x4 a)
inline

◆ v_reduce_sum() [17/20]

uint64 cv::v_reduce_sum ( const v_uint64 a)
inline

◆ v_reduce_sum() [18/20]

uint64 cv::v_reduce_sum ( const v_uint64x2 a)
inline

◆ v_reduce_sum() [19/20]

unsigned cv::v_reduce_sum ( const v_uint8 a)
inline

◆ v_reduce_sum() [20/20]

unsigned cv::v_reduce_sum ( const v_uint8x16 a)
inline

◆ v_reduce_sum4() [1/2]

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

◆ v_reduce_sum4() [2/2]

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

◆ v_reinterpret_as_f32() [1/20]

v_float32 cv::v_reinterpret_as_f32 ( const v_float32 v)
inline

◆ v_reinterpret_as_f32() [2/20]

v_float32x4 cv::v_reinterpret_as_f32 ( const v_float32x4 v)
inline

◆ v_reinterpret_as_f32() [3/20]

v_float32 cv::v_reinterpret_as_f32 ( const v_float64 v)
inline

◆ v_reinterpret_as_f32() [4/20]

v_float32x4 cv::v_reinterpret_as_f32 ( const v_float64x2 v)
inline

◆ v_reinterpret_as_f32() [5/20]

v_float32 cv::v_reinterpret_as_f32 ( const v_int16 v)
inline

◆ v_reinterpret_as_f32() [6/20]

v_float32x4 cv::v_reinterpret_as_f32 ( const v_int16x8 v)
inline

◆ v_reinterpret_as_f32() [7/20]

v_float32 cv::v_reinterpret_as_f32 ( const v_int32 v)
inline

◆ v_reinterpret_as_f32() [8/20]

v_float32x4 cv::v_reinterpret_as_f32 ( const v_int32x4 v)
inline

◆ v_reinterpret_as_f32() [9/20]

v_float32 cv::v_reinterpret_as_f32 ( const v_int64 v)
inline

◆ v_reinterpret_as_f32() [10/20]

v_float32x4 cv::v_reinterpret_as_f32 ( const v_int64x2 v)
inline

◆ v_reinterpret_as_f32() [11/20]

v_float32 cv::v_reinterpret_as_f32 ( const v_int8 v)
inline

◆ v_reinterpret_as_f32() [12/20]

v_float32x4 cv::v_reinterpret_as_f32 ( const v_int8x16 v)
inline

◆ v_reinterpret_as_f32() [13/20]

v_float32 cv::v_reinterpret_as_f32 ( const v_uint16 v)
inline

◆ v_reinterpret_as_f32() [14/20]

v_float32x4 cv::v_reinterpret_as_f32 ( const v_uint16x8 v)
inline

◆ v_reinterpret_as_f32() [15/20]

v_float32 cv::v_reinterpret_as_f32 ( const v_uint32 v)
inline

◆ v_reinterpret_as_f32() [16/20]

v_float32x4 cv::v_reinterpret_as_f32 ( const v_uint32x4 v)
inline

◆ v_reinterpret_as_f32() [17/20]

v_float32 cv::v_reinterpret_as_f32 ( const v_uint64 v)
inline

◆ v_reinterpret_as_f32() [18/20]

v_float32x4 cv::v_reinterpret_as_f32 ( const v_uint64x2 v)
inline

◆ v_reinterpret_as_f32() [19/20]

v_float32 cv::v_reinterpret_as_f32 ( const v_uint8 v)
inline

◆ v_reinterpret_as_f32() [20/20]

v_float32x4 cv::v_reinterpret_as_f32 ( const v_uint8x16 v)
inline

◆ v_reinterpret_as_f64() [1/20]

v_float64 cv::v_reinterpret_as_f64 ( const v_float32 v)
inline

◆ v_reinterpret_as_f64() [2/20]

v_float64x2 cv::v_reinterpret_as_f64 ( const v_float32x4 v)
inline

◆ v_reinterpret_as_f64() [3/20]

v_float64 cv::v_reinterpret_as_f64 ( const v_float64 v)
inline

◆ v_reinterpret_as_f64() [4/20]

v_float64x2 cv::v_reinterpret_as_f64 ( const v_float64x2 v)
inline

◆ v_reinterpret_as_f64() [5/20]

v_float64 cv::v_reinterpret_as_f64 ( const v_int16 v)
inline

◆ v_reinterpret_as_f64() [6/20]

v_float64x2 cv::v_reinterpret_as_f64 ( const v_int16x8 v)
inline

◆ v_reinterpret_as_f64() [7/20]

v_float64 cv::v_reinterpret_as_f64 ( const v_int32 v)
inline

◆ v_reinterpret_as_f64() [8/20]

v_float64x2 cv::v_reinterpret_as_f64 ( const v_int32x4 v)
inline

◆ v_reinterpret_as_f64() [9/20]

v_float64 cv::v_reinterpret_as_f64 ( const v_int64 v)
inline

◆ v_reinterpret_as_f64() [10/20]

v_float64x2 cv::v_reinterpret_as_f64 ( const v_int64x2 v)
inline

◆ v_reinterpret_as_f64() [11/20]

v_float64 cv::v_reinterpret_as_f64 ( const v_int8 v)
inline

◆ v_reinterpret_as_f64() [12/20]

v_float64x2 cv::v_reinterpret_as_f64 ( const v_int8x16 v)
inline

◆ v_reinterpret_as_f64() [13/20]

v_float64 cv::v_reinterpret_as_f64 ( const v_uint16 v)
inline

◆ v_reinterpret_as_f64() [14/20]

v_float64x2 cv::v_reinterpret_as_f64 ( const v_uint16x8 v)
inline

◆ v_reinterpret_as_f64() [15/20]

v_float64 cv::v_reinterpret_as_f64 ( const v_uint32 v)
inline

◆ v_reinterpret_as_f64() [16/20]

v_float64x2 cv::v_reinterpret_as_f64 ( const v_uint32x4 v)
inline

◆ v_reinterpret_as_f64() [17/20]

v_float64 cv::v_reinterpret_as_f64 ( const v_uint64 v)
inline

◆ v_reinterpret_as_f64() [18/20]

v_float64x2 cv::v_reinterpret_as_f64 ( const v_uint64x2 v)
inline

◆ v_reinterpret_as_f64() [19/20]

v_float64 cv::v_reinterpret_as_f64 ( const v_uint8 v)
inline

◆ v_reinterpret_as_f64() [20/20]

v_float64x2 cv::v_reinterpret_as_f64 ( const v_uint8x16 v)
inline

◆ v_reinterpret_as_s16() [1/20]

v_int16 cv::v_reinterpret_as_s16 ( const v_float32 v)
inline

◆ v_reinterpret_as_s16() [2/20]

v_int16x8 cv::v_reinterpret_as_s16 ( const v_float32x4 v)
inline

◆ v_reinterpret_as_s16() [3/20]

v_int16 cv::v_reinterpret_as_s16 ( const v_float64 v)
inline

◆ v_reinterpret_as_s16() [4/20]

v_int16x8 cv::v_reinterpret_as_s16 ( const v_float64x2 v)
inline

◆ v_reinterpret_as_s16() [5/20]

v_int16 cv::v_reinterpret_as_s16 ( const v_int16 v)
inline

◆ v_reinterpret_as_s16() [6/20]

v_int16x8 cv::v_reinterpret_as_s16 ( const v_int16x8 v)
inline

◆ v_reinterpret_as_s16() [7/20]

v_int16 cv::v_reinterpret_as_s16 ( const v_int32 v)
inline

◆ v_reinterpret_as_s16() [8/20]

v_int16x8 cv::v_reinterpret_as_s16 ( const v_int32x4 v)
inline

◆ v_reinterpret_as_s16() [9/20]

v_int16 cv::v_reinterpret_as_s16 ( const v_int64 v)
inline

◆ v_reinterpret_as_s16() [10/20]

v_int16x8 cv::v_reinterpret_as_s16 ( const v_int64x2 v)
inline

◆ v_reinterpret_as_s16() [11/20]

v_int16 cv::v_reinterpret_as_s16 ( const v_int8 v)
inline

◆ v_reinterpret_as_s16() [12/20]

v_int16x8 cv::v_reinterpret_as_s16 ( const v_int8x16 v)
inline

◆ v_reinterpret_as_s16() [13/20]

v_int16 cv::v_reinterpret_as_s16 ( const v_uint16 v)
inline

◆ v_reinterpret_as_s16() [14/20]

v_int16x8 cv::v_reinterpret_as_s16 ( const v_uint16x8 v)
inline

◆ v_reinterpret_as_s16() [15/20]

v_int16 cv::v_reinterpret_as_s16 ( const v_uint32 v)
inline

◆ v_reinterpret_as_s16() [16/20]

v_int16x8 cv::v_reinterpret_as_s16 ( const v_uint32x4 v)
inline

◆ v_reinterpret_as_s16() [17/20]

v_int16 cv::v_reinterpret_as_s16 ( const v_uint64 v)
inline

◆ v_reinterpret_as_s16() [18/20]

v_int16x8 cv::v_reinterpret_as_s16 ( const v_uint64x2 v)
inline

◆ v_reinterpret_as_s16() [19/20]

v_int16 cv::v_reinterpret_as_s16 ( const v_uint8 v)
inline

◆ v_reinterpret_as_s16() [20/20]

v_int16x8 cv::v_reinterpret_as_s16 ( const v_uint8x16 v)
inline

◆ v_reinterpret_as_s32() [1/20]

v_int32 cv::v_reinterpret_as_s32 ( const v_float32 v)
inline

◆ v_reinterpret_as_s32() [2/20]

v_int32x4 cv::v_reinterpret_as_s32 ( const v_float32x4 v)
inline

◆ v_reinterpret_as_s32() [3/20]

v_int32 cv::v_reinterpret_as_s32 ( const v_float64 v)
inline

◆ v_reinterpret_as_s32() [4/20]

v_int32x4 cv::v_reinterpret_as_s32 ( const v_float64x2 v)
inline

◆ v_reinterpret_as_s32() [5/20]

v_int32 cv::v_reinterpret_as_s32 ( const v_int16 v)
inline

◆ v_reinterpret_as_s32() [6/20]

v_int32x4 cv::v_reinterpret_as_s32 ( const v_int16x8 v)
inline

◆ v_reinterpret_as_s32() [7/20]

v_int32 cv::v_reinterpret_as_s32 ( const v_int32 v)
inline

◆ v_reinterpret_as_s32() [8/20]

v_int32x4 cv::v_reinterpret_as_s32 ( const v_int32x4 v)
inline

◆ v_reinterpret_as_s32() [9/20]

v_int32 cv::v_reinterpret_as_s32 ( const v_int64 v)
inline

◆ v_reinterpret_as_s32() [10/20]

v_int32x4 cv::v_reinterpret_as_s32 ( const v_int64x2 v)
inline

◆ v_reinterpret_as_s32() [11/20]

v_int32 cv::v_reinterpret_as_s32 ( const v_int8 v)
inline

◆ v_reinterpret_as_s32() [12/20]

v_int32x4 cv::v_reinterpret_as_s32 ( const v_int8x16 v)
inline

◆ v_reinterpret_as_s32() [13/20]

v_int32 cv::v_reinterpret_as_s32 ( const v_uint16 v)
inline

◆ v_reinterpret_as_s32() [14/20]

v_int32x4 cv::v_reinterpret_as_s32 ( const v_uint16x8 v)
inline

◆ v_reinterpret_as_s32() [15/20]

v_int32 cv::v_reinterpret_as_s32 ( const v_uint32 v)
inline

◆ v_reinterpret_as_s32() [16/20]

v_int32x4 cv::v_reinterpret_as_s32 ( const v_uint32x4 v)
inline

◆ v_reinterpret_as_s32() [17/20]

v_int32 cv::v_reinterpret_as_s32 ( const v_uint64 v)
inline

◆ v_reinterpret_as_s32() [18/20]

v_int32x4 cv::v_reinterpret_as_s32 ( const v_uint64x2 v)
inline

◆ v_reinterpret_as_s32() [19/20]

v_int32 cv::v_reinterpret_as_s32 ( const v_uint8 v)
inline

◆ v_reinterpret_as_s32() [20/20]

v_int32x4 cv::v_reinterpret_as_s32 ( const v_uint8x16 v)
inline

◆ v_reinterpret_as_s64() [1/20]

v_int64 cv::v_reinterpret_as_s64 ( const v_float32 v)
inline

◆ v_reinterpret_as_s64() [2/20]

v_int64x2 cv::v_reinterpret_as_s64 ( const v_float32x4 v)
inline

◆ v_reinterpret_as_s64() [3/20]

v_int64 cv::v_reinterpret_as_s64 ( const v_float64 v)
inline

◆ v_reinterpret_as_s64() [4/20]

v_int64x2 cv::v_reinterpret_as_s64 ( const v_float64x2 v)
inline

◆ v_reinterpret_as_s64() [5/20]

v_int64 cv::v_reinterpret_as_s64 ( const v_int16 v)
inline

◆ v_reinterpret_as_s64() [6/20]

v_int64x2 cv::v_reinterpret_as_s64 ( const v_int16x8 v)
inline

◆ v_reinterpret_as_s64() [7/20]

v_int64 cv::v_reinterpret_as_s64 ( const v_int32 v)
inline

◆ v_reinterpret_as_s64() [8/20]

v_int64x2 cv::v_reinterpret_as_s64 ( const v_int32x4 v)
inline

◆ v_reinterpret_as_s64() [9/20]

v_int64 cv::v_reinterpret_as_s64 ( const v_int64 v)
inline

◆ v_reinterpret_as_s64() [10/20]

v_int64x2 cv::v_reinterpret_as_s64 ( const v_int64x2 v)
inline

◆ v_reinterpret_as_s64() [11/20]

v_int64 cv::v_reinterpret_as_s64 ( const v_int8 v)
inline

◆ v_reinterpret_as_s64() [12/20]

v_int64x2 cv::v_reinterpret_as_s64 ( const v_int8x16 v)
inline

◆ v_reinterpret_as_s64() [13/20]

v_int64 cv::v_reinterpret_as_s64 ( const v_uint16 v)
inline

◆ v_reinterpret_as_s64() [14/20]

v_int64x2 cv::v_reinterpret_as_s64 ( const v_uint16x8 v)
inline

◆ v_reinterpret_as_s64() [15/20]

v_int64 cv::v_reinterpret_as_s64 ( const v_uint32 v)
inline

◆ v_reinterpret_as_s64() [16/20]

v_int64x2 cv::v_reinterpret_as_s64 ( const v_uint32x4 v)
inline

◆ v_reinterpret_as_s64() [17/20]

v_int64 cv::v_reinterpret_as_s64 ( const v_uint64 v)
inline

◆ v_reinterpret_as_s64() [18/20]

v_int64x2 cv::v_reinterpret_as_s64 ( const v_uint64x2 v)
inline

◆ v_reinterpret_as_s64() [19/20]

v_int64 cv::v_reinterpret_as_s64 ( const v_uint8 v)
inline

◆ v_reinterpret_as_s64() [20/20]

v_int64x2 cv::v_reinterpret_as_s64 ( const v_uint8x16 v)
inline

◆ v_reinterpret_as_s8() [1/20]

v_int8 cv::v_reinterpret_as_s8 ( const v_float32 v)
inline

◆ v_reinterpret_as_s8() [2/20]

v_int8x16 cv::v_reinterpret_as_s8 ( const v_float32x4 v)
inline

◆ v_reinterpret_as_s8() [3/20]

v_int8 cv::v_reinterpret_as_s8 ( const v_float64 v)
inline

◆ v_reinterpret_as_s8() [4/20]

v_int8x16 cv::v_reinterpret_as_s8 ( const v_float64x2 v)
inline

◆ v_reinterpret_as_s8() [5/20]

v_int8 cv::v_reinterpret_as_s8 ( const v_int16 v)
inline

◆ v_reinterpret_as_s8() [6/20]

v_int8x16 cv::v_reinterpret_as_s8 ( const v_int16x8 v)
inline

◆ v_reinterpret_as_s8() [7/20]

v_int8 cv::v_reinterpret_as_s8 ( const v_int32 v)
inline

◆ v_reinterpret_as_s8() [8/20]

v_int8x16 cv::v_reinterpret_as_s8 ( const v_int32x4 v)
inline

◆ v_reinterpret_as_s8() [9/20]

v_int8 cv::v_reinterpret_as_s8 ( const v_int64 v)
inline

◆ v_reinterpret_as_s8() [10/20]

v_int8x16 cv::v_reinterpret_as_s8 ( const v_int64x2 v)
inline

◆ v_reinterpret_as_s8() [11/20]

v_int8 cv::v_reinterpret_as_s8 ( const v_int8 v)
inline

◆ v_reinterpret_as_s8() [12/20]

v_int8x16 cv::v_reinterpret_as_s8 ( const v_int8x16 v)
inline

◆ v_reinterpret_as_s8() [13/20]

v_int8 cv::v_reinterpret_as_s8 ( const v_uint16 v)
inline

◆ v_reinterpret_as_s8() [14/20]

v_int8x16 cv::v_reinterpret_as_s8 ( const v_uint16x8 v)
inline

◆ v_reinterpret_as_s8() [15/20]

v_int8 cv::v_reinterpret_as_s8 ( const v_uint32 v)
inline

◆ v_reinterpret_as_s8() [16/20]

v_int8x16 cv::v_reinterpret_as_s8 ( const v_uint32x4 v)
inline

◆ v_reinterpret_as_s8() [17/20]

v_int8 cv::v_reinterpret_as_s8 ( const v_uint64 v)
inline

◆ v_reinterpret_as_s8() [18/20]

v_int8x16 cv::v_reinterpret_as_s8 ( const v_uint64x2 v)
inline

◆ v_reinterpret_as_s8() [19/20]

v_int8 cv::v_reinterpret_as_s8 ( const v_uint8 v)
inline

◆ v_reinterpret_as_s8() [20/20]

v_int8x16 cv::v_reinterpret_as_s8 ( const v_uint8x16 v)
inline

◆ v_reinterpret_as_u16() [1/20]

v_uint16 cv::v_reinterpret_as_u16 ( const v_float32 v)
inline

◆ v_reinterpret_as_u16() [2/20]

v_uint16x8 cv::v_reinterpret_as_u16 ( const v_float32x4 v)
inline

◆ v_reinterpret_as_u16() [3/20]

v_uint16 cv::v_reinterpret_as_u16 ( const v_float64 v)
inline

◆ v_reinterpret_as_u16() [4/20]

v_uint16x8 cv::v_reinterpret_as_u16 ( const v_float64x2 v)
inline

◆ v_reinterpret_as_u16() [5/20]

v_uint16 cv::v_reinterpret_as_u16 ( const v_int16 v)
inline

◆ v_reinterpret_as_u16() [6/20]

v_uint16x8 cv::v_reinterpret_as_u16 ( const v_int16x8 v)
inline

◆ v_reinterpret_as_u16() [7/20]

v_uint16 cv::v_reinterpret_as_u16 ( const v_int32 v)
inline

◆ v_reinterpret_as_u16() [8/20]

v_uint16x8 cv::v_reinterpret_as_u16 ( const v_int32x4 v)
inline

◆ v_reinterpret_as_u16() [9/20]

v_uint16 cv::v_reinterpret_as_u16 ( const v_int64 v)
inline

◆ v_reinterpret_as_u16() [10/20]

v_uint16x8 cv::v_reinterpret_as_u16 ( const v_int64x2 v)
inline

◆ v_reinterpret_as_u16() [11/20]

v_uint16 cv::v_reinterpret_as_u16 ( const v_int8 v)
inline

◆ v_reinterpret_as_u16() [12/20]

v_uint16x8 cv::v_reinterpret_as_u16 ( const v_int8x16 v)
inline

◆ v_reinterpret_as_u16() [13/20]

v_uint16 cv::v_reinterpret_as_u16 ( const v_uint16 v)
inline

◆ v_reinterpret_as_u16() [14/20]

v_uint16x8 cv::v_reinterpret_as_u16 ( const v_uint16x8 v)
inline

◆ v_reinterpret_as_u16() [15/20]

v_uint16 cv::v_reinterpret_as_u16 ( const v_uint32 v)
inline

◆ v_reinterpret_as_u16() [16/20]

v_uint16x8 cv::v_reinterpret_as_u16 ( const v_uint32x4 v)
inline

◆ v_reinterpret_as_u16() [17/20]

v_uint16 cv::v_reinterpret_as_u16 ( const v_uint64 v)
inline

◆ v_reinterpret_as_u16() [18/20]

v_uint16x8 cv::v_reinterpret_as_u16 ( const v_uint64x2 v)
inline

◆ v_reinterpret_as_u16() [19/20]

v_uint16 cv::v_reinterpret_as_u16 ( const v_uint8 v)
inline

◆ v_reinterpret_as_u16() [20/20]

v_uint16x8 cv::v_reinterpret_as_u16 ( const v_uint8x16 v)
inline

◆ v_reinterpret_as_u32() [1/20]

v_uint32 cv::v_reinterpret_as_u32 ( const v_float32 v)
inline

◆ v_reinterpret_as_u32() [2/20]

v_uint32x4 cv::v_reinterpret_as_u32 ( const v_float32x4 v)
inline

◆ v_reinterpret_as_u32() [3/20]

v_uint32 cv::v_reinterpret_as_u32 ( const v_float64 v)
inline

◆ v_reinterpret_as_u32() [4/20]

v_uint32x4 cv::v_reinterpret_as_u32 ( const v_float64x2 v)
inline

◆ v_reinterpret_as_u32() [5/20]

v_uint32 cv::v_reinterpret_as_u32 ( const v_int16 v)
inline

◆ v_reinterpret_as_u32() [6/20]

v_uint32x4 cv::v_reinterpret_as_u32 ( const v_int16x8 v)
inline

◆ v_reinterpret_as_u32() [7/20]

v_uint32 cv::v_reinterpret_as_u32 ( const v_int32 v)
inline

◆ v_reinterpret_as_u32() [8/20]

v_uint32x4 cv::v_reinterpret_as_u32 ( const v_int32x4 v)
inline

◆ v_reinterpret_as_u32() [9/20]

v_uint32 cv::v_reinterpret_as_u32 ( const v_int64 v)
inline

◆ v_reinterpret_as_u32() [10/20]

v_uint32x4 cv::v_reinterpret_as_u32 ( const v_int64x2 v)
inline

◆ v_reinterpret_as_u32() [11/20]

v_uint32 cv::v_reinterpret_as_u32 ( const v_int8 v)
inline

◆ v_reinterpret_as_u32() [12/20]

v_uint32x4 cv::v_reinterpret_as_u32 ( const v_int8x16 v)
inline

◆ v_reinterpret_as_u32() [13/20]

v_uint32 cv::v_reinterpret_as_u32 ( const v_uint16 v)
inline

◆ v_reinterpret_as_u32() [14/20]

v_uint32x4 cv::v_reinterpret_as_u32 ( const v_uint16x8 v)
inline

◆ v_reinterpret_as_u32() [15/20]

v_uint32 cv::v_reinterpret_as_u32 ( const v_uint32 v)
inline

◆ v_reinterpret_as_u32() [16/20]

v_uint32x4 cv::v_reinterpret_as_u32 ( const v_uint32x4 v)
inline

◆ v_reinterpret_as_u32() [17/20]

v_uint32 cv::v_reinterpret_as_u32 ( const v_uint64 v)
inline

◆ v_reinterpret_as_u32() [18/20]

v_uint32x4 cv::v_reinterpret_as_u32 ( const v_uint64x2 v)
inline

◆ v_reinterpret_as_u32() [19/20]

v_uint32 cv::v_reinterpret_as_u32 ( const v_uint8 v)
inline

◆ v_reinterpret_as_u32() [20/20]

v_uint32x4 cv::v_reinterpret_as_u32 ( const v_uint8x16 v)
inline

◆ v_reinterpret_as_u64() [1/20]

v_uint64 cv::v_reinterpret_as_u64 ( const v_float32 v)
inline

◆ v_reinterpret_as_u64() [2/20]

v_uint64x2 cv::v_reinterpret_as_u64 ( const v_float32x4 v)
inline

◆ v_reinterpret_as_u64() [3/20]

v_uint64 cv::v_reinterpret_as_u64 ( const v_float64 v)
inline

◆ v_reinterpret_as_u64() [4/20]

v_uint64x2 cv::v_reinterpret_as_u64 ( const v_float64x2 v)
inline

◆ v_reinterpret_as_u64() [5/20]

v_uint64 cv::v_reinterpret_as_u64 ( const v_int16 v)
inline

◆ v_reinterpret_as_u64() [6/20]

v_uint64x2 cv::v_reinterpret_as_u64 ( const v_int16x8 v)
inline

◆ v_reinterpret_as_u64() [7/20]

v_uint64 cv::v_reinterpret_as_u64 ( const v_int32 v)
inline

◆ v_reinterpret_as_u64() [8/20]

v_uint64x2 cv::v_reinterpret_as_u64 ( const v_int32x4 v)
inline

◆ v_reinterpret_as_u64() [9/20]

v_uint64 cv::v_reinterpret_as_u64 ( const v_int64 v)
inline

◆ v_reinterpret_as_u64() [10/20]

v_uint64x2 cv::v_reinterpret_as_u64 ( const v_int64x2 v)
inline

◆ v_reinterpret_as_u64() [11/20]

v_uint64 cv::v_reinterpret_as_u64 ( const v_int8 v)
inline

◆ v_reinterpret_as_u64() [12/20]

v_uint64x2 cv::v_reinterpret_as_u64 ( const v_int8x16 v)
inline

◆ v_reinterpret_as_u64() [13/20]

v_uint64 cv::v_reinterpret_as_u64 ( const v_uint16 v)
inline

◆ v_reinterpret_as_u64() [14/20]

v_uint64x2 cv::v_reinterpret_as_u64 ( const v_uint16x8 v)
inline

◆ v_reinterpret_as_u64() [15/20]

v_uint64 cv::v_reinterpret_as_u64 ( const v_uint32 v)
inline

◆ v_reinterpret_as_u64() [16/20]

v_uint64x2 cv::v_reinterpret_as_u64 ( const v_uint32x4 v)
inline

◆ v_reinterpret_as_u64() [17/20]

v_uint64 cv::v_reinterpret_as_u64 ( const v_uint64 v)
inline

◆ v_reinterpret_as_u64() [18/20]

v_uint64x2 cv::v_reinterpret_as_u64 ( const v_uint64x2 v)
inline

◆ v_reinterpret_as_u64() [19/20]

v_uint64 cv::v_reinterpret_as_u64 ( const v_uint8 v)
inline

◆ v_reinterpret_as_u64() [20/20]

v_uint64x2 cv::v_reinterpret_as_u64 ( const v_uint8x16 v)
inline

◆ v_reinterpret_as_u8() [1/20]

v_uint8 cv::v_reinterpret_as_u8 ( const v_float32 v)
inline

◆ v_reinterpret_as_u8() [2/20]

v_uint8x16 cv::v_reinterpret_as_u8 ( const v_float32x4 v)
inline

◆ v_reinterpret_as_u8() [3/20]

v_uint8 cv::v_reinterpret_as_u8 ( const v_float64 v)
inline

◆ v_reinterpret_as_u8() [4/20]

v_uint8x16 cv::v_reinterpret_as_u8 ( const v_float64x2 v)
inline

◆ v_reinterpret_as_u8() [5/20]

v_uint8 cv::v_reinterpret_as_u8 ( const v_int16 v)
inline

◆ v_reinterpret_as_u8() [6/20]

v_uint8x16 cv::v_reinterpret_as_u8 ( const v_int16x8 v)
inline

◆ v_reinterpret_as_u8() [7/20]

v_uint8 cv::v_reinterpret_as_u8 ( const v_int32 v)
inline

◆ v_reinterpret_as_u8() [8/20]

v_uint8x16 cv::v_reinterpret_as_u8 ( const v_int32x4 v)
inline

◆ v_reinterpret_as_u8() [9/20]

v_uint8 cv::v_reinterpret_as_u8 ( const v_int64 v)
inline

◆ v_reinterpret_as_u8() [10/20]

v_uint8x16 cv::v_reinterpret_as_u8 ( const v_int64x2 v)
inline

◆ v_reinterpret_as_u8() [11/20]

v_uint8 cv::v_reinterpret_as_u8 ( const v_int8 v)
inline

◆ v_reinterpret_as_u8() [12/20]

v_uint8x16 cv::v_reinterpret_as_u8 ( const v_int8x16 v)
inline

◆ v_reinterpret_as_u8() [13/20]

v_uint8 cv::v_reinterpret_as_u8 ( const v_uint16 v)
inline

◆ v_reinterpret_as_u8() [14/20]

v_uint8x16 cv::v_reinterpret_as_u8 ( const v_uint16x8 v)
inline

◆ v_reinterpret_as_u8() [15/20]

v_uint8 cv::v_reinterpret_as_u8 ( const v_uint32 v)
inline

◆ v_reinterpret_as_u8() [16/20]

v_uint8x16 cv::v_reinterpret_as_u8 ( const v_uint32x4 v)
inline

◆ v_reinterpret_as_u8() [17/20]

v_uint8 cv::v_reinterpret_as_u8 ( const v_uint64 v)
inline

◆ v_reinterpret_as_u8() [18/20]

v_uint8x16 cv::v_reinterpret_as_u8 ( const v_uint64x2 v)
inline

◆ v_reinterpret_as_u8() [19/20]

v_uint8 cv::v_reinterpret_as_u8 ( const v_uint8 v)
inline

◆ v_reinterpret_as_u8() [20/20]

v_uint8x16 cv::v_reinterpret_as_u8 ( const v_uint8x16 v)
inline

◆ v_reverse() [1/20]

v_float32 cv::v_reverse ( const v_float32 a)
inline

◆ v_reverse() [2/20]

v_float32x4 cv::v_reverse ( const v_float32x4 a)
inline

◆ v_reverse() [3/20]

v_float64 cv::v_reverse ( const v_float64 a)
inline

◆ v_reverse() [4/20]

v_float64x2 cv::v_reverse ( const v_float64x2 a)
inline

◆ v_reverse() [5/20]

v_int16 cv::v_reverse ( const v_int16 a)
inline

◆ v_reverse() [6/20]

v_int16x8 cv::v_reverse ( const v_int16x8 a)
inline

◆ v_reverse() [7/20]

v_int32 cv::v_reverse ( const v_int32 a)
inline

◆ v_reverse() [8/20]

v_int32x4 cv::v_reverse ( const v_int32x4 a)
inline

◆ v_reverse() [9/20]

v_int64 cv::v_reverse ( const v_int64 a)
inline

◆ v_reverse() [10/20]

v_int64x2 cv::v_reverse ( const v_int64x2 a)
inline

◆ v_reverse() [11/20]

v_int8 cv::v_reverse ( const v_int8 a)
inline

◆ v_reverse() [12/20]

v_int8x16 cv::v_reverse ( const v_int8x16 a)
inline

◆ v_reverse() [13/20]

v_uint16 cv::v_reverse ( const v_uint16 a)
inline

◆ v_reverse() [14/20]

v_uint16x8 cv::v_reverse ( const v_uint16x8 a)
inline

◆ v_reverse() [15/20]

v_uint32 cv::v_reverse ( const v_uint32 a)
inline

◆ v_reverse() [16/20]

v_uint32x4 cv::v_reverse ( const v_uint32x4 a)
inline

◆ v_reverse() [17/20]

v_uint64 cv::v_reverse ( const v_uint64 a)
inline

◆ v_reverse() [18/20]

v_uint64x2 cv::v_reverse ( const v_uint64x2 a)
inline

◆ v_reverse() [19/20]

v_uint8 cv::v_reverse ( const v_uint8 a)
inline

◆ v_reverse() [20/20]

v_uint8x16 cv::v_reverse ( const v_uint8x16 a)
inline

◆ v_rotate_left() [1/40]

template<int n>
v_float32 cv::v_rotate_left ( const v_float32 a)
inline

◆ v_rotate_left() [2/40]

template<int n>
v_float32 cv::v_rotate_left ( const v_float32 a,
const v_float32 b 
)
inline

◆ v_rotate_left() [3/40]

template<int n>
v_float32x4 cv::v_rotate_left ( const v_float32x4 a)
inline

◆ v_rotate_left() [4/40]

template<int n>
v_float32x4 cv::v_rotate_left ( const v_float32x4 a,
const v_float32x4 b 
)
inline

◆ v_rotate_left() [5/40]

template<int n>
v_float64 cv::v_rotate_left ( const v_float64 a)
inline

◆ v_rotate_left() [6/40]

template<int n>
v_float64 cv::v_rotate_left ( const v_float64 a,
const v_float64 b 
)
inline

◆ v_rotate_left() [7/40]

template<int n>
v_float64x2 cv::v_rotate_left ( const v_float64x2 a)
inline

◆ v_rotate_left() [8/40]

template<int n>
v_float64x2 cv::v_rotate_left ( const v_float64x2 a,
const v_float64x2 b 
)
inline

◆ v_rotate_left() [9/40]

template<int n>
v_int16 cv::v_rotate_left ( const v_int16 a)
inline

◆ v_rotate_left() [10/40]

template<int n>
v_int16 cv::v_rotate_left ( const v_int16 a,
const v_int16 b 
)
inline

◆ v_rotate_left() [11/40]

template<int n>
v_int16x8 cv::v_rotate_left ( const v_int16x8 a)
inline

◆ v_rotate_left() [12/40]

template<int n>
v_int16x8 cv::v_rotate_left ( const v_int16x8 a,
const v_int16x8 b 
)
inline

◆ v_rotate_left() [13/40]

template<int n>
v_int32 cv::v_rotate_left ( const v_int32 a)
inline

◆ v_rotate_left() [14/40]

template<int n>
v_int32 cv::v_rotate_left ( const v_int32 a,
const v_int32 b 
)
inline

◆ v_rotate_left() [15/40]

template<int n>
v_int32x4 cv::v_rotate_left ( const v_int32x4 a)
inline

◆ v_rotate_left() [16/40]

template<int n>
v_int32x4 cv::v_rotate_left ( const v_int32x4 a,
const v_int32x4 b 
)
inline

◆ v_rotate_left() [17/40]

template<int n>
v_int64 cv::v_rotate_left ( const v_int64 a)
inline

◆ v_rotate_left() [18/40]

template<int n>
v_int64 cv::v_rotate_left ( const v_int64 a,
const v_int64 b 
)
inline

◆ v_rotate_left() [19/40]

template<int n>
v_int64x2 cv::v_rotate_left ( const v_int64x2 a)
inline

◆ v_rotate_left() [20/40]

template<int n>
v_int64x2 cv::v_rotate_left ( const v_int64x2 a,
const v_int64x2 b 
)
inline

◆ v_rotate_left() [21/40]

template<int n>
v_int8 cv::v_rotate_left ( const v_int8 a)
inline

◆ v_rotate_left() [22/40]

template<int n>
v_int8 cv::v_rotate_left ( const v_int8 a,
const v_int8 b 
)
inline

◆ v_rotate_left() [23/40]

template<int n>
v_int8x16 cv::v_rotate_left ( const v_int8x16 a)
inline

◆ v_rotate_left() [24/40]

template<int n>
v_int8x16 cv::v_rotate_left ( const v_int8x16 a,
const v_int8x16 b 
)
inline

◆ v_rotate_left() [25/40]

template<int n>
v_uint16 cv::v_rotate_left ( const v_uint16 a)
inline

◆ v_rotate_left() [26/40]

template<int n>
v_uint16 cv::v_rotate_left ( const v_uint16 a,
const v_uint16 b 
)
inline

◆ v_rotate_left() [27/40]

template<int n>
v_uint16x8 cv::v_rotate_left ( const v_uint16x8 a)
inline

◆ v_rotate_left() [28/40]

template<int n>
v_uint16x8 cv::v_rotate_left ( const v_uint16x8 a,
const v_uint16x8 b 
)
inline

◆ v_rotate_left() [29/40]

template<int n>
v_uint32 cv::v_rotate_left ( const v_uint32 a)
inline

◆ v_rotate_left() [30/40]

template<int n>
v_uint32 cv::v_rotate_left ( const v_uint32 a,
const v_uint32 b 
)
inline

◆ v_rotate_left() [31/40]

template<int n>
v_uint32x4 cv::v_rotate_left ( const v_uint32x4 a)
inline

◆ v_rotate_left() [32/40]

template<int n>
v_uint32x4 cv::v_rotate_left ( const v_uint32x4 a,
const v_uint32x4 b 
)
inline

◆ v_rotate_left() [33/40]

template<int n>
v_uint64 cv::v_rotate_left ( const v_uint64 a)
inline

◆ v_rotate_left() [34/40]

template<int n>
v_uint64 cv::v_rotate_left ( const v_uint64 a,
const v_uint64 b 
)
inline

◆ v_rotate_left() [35/40]

template<int n>
v_uint64x2 cv::v_rotate_left ( const v_uint64x2 a)
inline

◆ v_rotate_left() [36/40]

template<int n>
v_uint64x2 cv::v_rotate_left ( const v_uint64x2 a,
const v_uint64x2 b 
)
inline

◆ v_rotate_left() [37/40]

template<int n>
v_uint8 cv::v_rotate_left ( const v_uint8 a)
inline

◆ v_rotate_left() [38/40]

template<int n>
v_uint8 cv::v_rotate_left ( const v_uint8 a,
const v_uint8 b 
)
inline

◆ v_rotate_left() [39/40]

template<int n>
v_uint8x16 cv::v_rotate_left ( const v_uint8x16 a)
inline

◆ v_rotate_left() [40/40]

template<int n>
v_uint8x16 cv::v_rotate_left ( const v_uint8x16 a,
const v_uint8x16 b 
)
inline

◆ v_rotate_left< 0 >() [1/40]

template<>
v_float32 cv::v_rotate_left< 0 > ( const v_float32 a)
inline

◆ v_rotate_left< 0 >() [2/40]

template<>
v_float32 cv::v_rotate_left< 0 > ( const v_float32 a,
const v_float32 b 
)
inline

◆ v_rotate_left< 0 >() [3/40]

template<>
v_float32x4 cv::v_rotate_left< 0 > ( const v_float32x4 a)
inline

◆ v_rotate_left< 0 >() [4/40]

template<>
v_float32x4 cv::v_rotate_left< 0 > ( const v_float32x4 a,
const v_float32x4 b 
)
inline

◆ v_rotate_left< 0 >() [5/40]

template<>
v_float64 cv::v_rotate_left< 0 > ( const v_float64 a)
inline

◆ v_rotate_left< 0 >() [6/40]

template<>
v_float64 cv::v_rotate_left< 0 > ( const v_float64 a,
const v_float64 b 
)
inline

◆ v_rotate_left< 0 >() [7/40]

template<>
v_float64x2 cv::v_rotate_left< 0 > ( const v_float64x2 a)
inline

◆ v_rotate_left< 0 >() [8/40]

template<>
v_float64x2 cv::v_rotate_left< 0 > ( const v_float64x2 a,
const v_float64x2 b 
)
inline

◆ v_rotate_left< 0 >() [9/40]

template<>
v_int16 cv::v_rotate_left< 0 > ( const v_int16 a)
inline

◆ v_rotate_left< 0 >() [10/40]

template<>
v_int16 cv::v_rotate_left< 0 > ( const v_int16 a,
const v_int16 b 
)
inline

◆ v_rotate_left< 0 >() [11/40]

template<>
v_int16x8 cv::v_rotate_left< 0 > ( const v_int16x8 a)
inline

◆ v_rotate_left< 0 >() [12/40]

template<>
v_int16x8 cv::v_rotate_left< 0 > ( const v_int16x8 a,
const v_int16x8 b 
)
inline

◆ v_rotate_left< 0 >() [13/40]

template<>
v_int32 cv::v_rotate_left< 0 > ( const v_int32 a)
inline

◆ v_rotate_left< 0 >() [14/40]

template<>
v_int32 cv::v_rotate_left< 0 > ( const v_int32 a,
const v_int32 b 
)
inline

◆ v_rotate_left< 0 >() [15/40]

template<>
v_int32x4 cv::v_rotate_left< 0 > ( const v_int32x4 a)
inline

◆ v_rotate_left< 0 >() [16/40]

template<>
v_int32x4 cv::v_rotate_left< 0 > ( const v_int32x4 a,
const v_int32x4 b 
)
inline

◆ v_rotate_left< 0 >() [17/40]

template<>
v_int64 cv::v_rotate_left< 0 > ( const v_int64 a)
inline

◆ v_rotate_left< 0 >() [18/40]

template<>
v_int64 cv::v_rotate_left< 0 > ( const v_int64 a,
const v_int64 b 
)
inline

◆ v_rotate_left< 0 >() [19/40]

template<>
v_int64x2 cv::v_rotate_left< 0 > ( const v_int64x2 a)
inline

◆ v_rotate_left< 0 >() [20/40]

template<>
v_int64x2 cv::v_rotate_left< 0 > ( const v_int64x2 a,
const v_int64x2 b 
)
inline

◆ v_rotate_left< 0 >() [21/40]

template<>
v_int8 cv::v_rotate_left< 0 > ( const v_int8 a)
inline

◆ v_rotate_left< 0 >() [22/40]

template<>
v_int8 cv::v_rotate_left< 0 > ( const v_int8 a,
const v_int8 b 
)
inline

◆ v_rotate_left< 0 >() [23/40]

template<>
v_int8x16 cv::v_rotate_left< 0 > ( const v_int8x16 a)
inline

◆ v_rotate_left< 0 >() [24/40]

template<>
v_int8x16 cv::v_rotate_left< 0 > ( const v_int8x16 a,
const v_int8x16 b 
)
inline

◆ v_rotate_left< 0 >() [25/40]

template<>
v_uint16 cv::v_rotate_left< 0 > ( const v_uint16 a)
inline

◆ v_rotate_left< 0 >() [26/40]

template<>
v_uint16 cv::v_rotate_left< 0 > ( const v_uint16 a,
const v_uint16 b 
)
inline

◆ v_rotate_left< 0 >() [27/40]

template<>
v_uint16x8 cv::v_rotate_left< 0 > ( const v_uint16x8 a)
inline

◆ v_rotate_left< 0 >() [28/40]

template<>
v_uint16x8 cv::v_rotate_left< 0 > ( const v_uint16x8 a,
const v_uint16x8 b 
)
inline

◆ v_rotate_left< 0 >() [29/40]

template<>
v_uint32 cv::v_rotate_left< 0 > ( const v_uint32 a)
inline

◆ v_rotate_left< 0 >() [30/40]

template<>
v_uint32 cv::v_rotate_left< 0 > ( const v_uint32 a,
const v_uint32 b 
)
inline

◆ v_rotate_left< 0 >() [31/40]

template<>
v_uint32x4 cv::v_rotate_left< 0 > ( const v_uint32x4 a)
inline

◆ v_rotate_left< 0 >() [32/40]

template<>
v_uint32x4 cv::v_rotate_left< 0 > ( const v_uint32x4 a,
const v_uint32x4 b 
)
inline

◆ v_rotate_left< 0 >() [33/40]

template<>
v_uint64 cv::v_rotate_left< 0 > ( const v_uint64 a)
inline

◆ v_rotate_left< 0 >() [34/40]

template<>
v_uint64 cv::v_rotate_left< 0 > ( const v_uint64 a,
const v_uint64 b 
)
inline

◆ v_rotate_left< 0 >() [35/40]

template<>
v_uint64x2 cv::v_rotate_left< 0 > ( const v_uint64x2 a)
inline

◆ v_rotate_left< 0 >() [36/40]

template<>
v_uint64x2 cv::v_rotate_left< 0 > ( const v_uint64x2 a,
const v_uint64x2 b 
)
inline

◆ v_rotate_left< 0 >() [37/40]

template<>
v_uint8 cv::v_rotate_left< 0 > ( const v_uint8 a)
inline

◆ v_rotate_left< 0 >() [38/40]

template<>
v_uint8 cv::v_rotate_left< 0 > ( const v_uint8 a,
const v_uint8 b 
)
inline

◆ v_rotate_left< 0 >() [39/40]

template<>
v_uint8x16 cv::v_rotate_left< 0 > ( const v_uint8x16 a)
inline

◆ v_rotate_left< 0 >() [40/40]

template<>
v_uint8x16 cv::v_rotate_left< 0 > ( const v_uint8x16 a,
const v_uint8x16 b 
)
inline

◆ v_rotate_right() [1/40]

template<int n>
v_float32 cv::v_rotate_right ( const v_float32 a)
inline

◆ v_rotate_right() [2/40]

template<int n>
v_float32 cv::v_rotate_right ( const v_float32 a,
const v_float32 b 
)
inline

◆ v_rotate_right() [3/40]

template<int n>
v_float32x4 cv::v_rotate_right ( const v_float32x4 a)
inline

◆ v_rotate_right() [4/40]

template<int n>
v_float32x4 cv::v_rotate_right ( const v_float32x4 a,
const v_float32x4 b 
)
inline

◆ v_rotate_right() [5/40]

template<int n>
v_float64 cv::v_rotate_right ( const v_float64 a)
inline

◆ v_rotate_right() [6/40]

template<int n>
v_float64 cv::v_rotate_right ( const v_float64 a,
const v_float64 b 
)
inline

◆ v_rotate_right() [7/40]

template<int n>
v_float64x2 cv::v_rotate_right ( const v_float64x2 a)
inline

◆ v_rotate_right() [8/40]

template<int n>
v_float64x2 cv::v_rotate_right ( const v_float64x2 a,
const v_float64x2 b 
)
inline

◆ v_rotate_right() [9/40]

template<int n>
v_int16 cv::v_rotate_right ( const v_int16 a)
inline

◆ v_rotate_right() [10/40]

template<int n>
v_int16 cv::v_rotate_right ( const v_int16 a,
const v_int16 b 
)
inline

◆ v_rotate_right() [11/40]

template<int n>
v_int16x8 cv::v_rotate_right ( const v_int16x8 a)
inline

◆ v_rotate_right() [12/40]

template<int n>
v_int16x8 cv::v_rotate_right ( const v_int16x8 a,
const v_int16x8 b 
)
inline

◆ v_rotate_right() [13/40]

template<int n>
v_int32 cv::v_rotate_right ( const v_int32 a)
inline

◆ v_rotate_right() [14/40]

template<int n>
v_int32 cv::v_rotate_right ( const v_int32 a,
const v_int32 b 
)
inline

◆ v_rotate_right() [15/40]

template<int n>
v_int32x4 cv::v_rotate_right ( const v_int32x4 a)
inline

◆ v_rotate_right() [16/40]

template<int n>
v_int32x4 cv::v_rotate_right ( const v_int32x4 a,
const v_int32x4 b 
)
inline

◆ v_rotate_right() [17/40]

template<int n>
v_int64 cv::v_rotate_right ( const v_int64 a)
inline

◆ v_rotate_right() [18/40]

template<int n>
v_int64 cv::v_rotate_right ( const v_int64 a,
const v_int64 b 
)
inline

◆ v_rotate_right() [19/40]

template<int n>
v_int64x2 cv::v_rotate_right ( const v_int64x2 a)
inline

◆ v_rotate_right() [20/40]

template<int n>
v_int64x2 cv::v_rotate_right ( const v_int64x2 a,
const v_int64x2 b 
)
inline

◆ v_rotate_right() [21/40]

template<int n>
v_int8 cv::v_rotate_right ( const v_int8 a)
inline

◆ v_rotate_right() [22/40]

template<int n>
v_int8 cv::v_rotate_right ( const v_int8 a,
const v_int8 b 
)
inline

◆ v_rotate_right() [23/40]

template<int n>
v_int8x16 cv::v_rotate_right ( const v_int8x16 a)
inline

◆ v_rotate_right() [24/40]

template<int n>
v_int8x16 cv::v_rotate_right ( const v_int8x16 a,
const v_int8x16 b 
)
inline

◆ v_rotate_right() [25/40]

template<int n>
v_uint16 cv::v_rotate_right ( const v_uint16 a)
inline

◆ v_rotate_right() [26/40]

template<int n>
v_uint16 cv::v_rotate_right ( const v_uint16 a,
const v_uint16 b 
)
inline

◆ v_rotate_right() [27/40]

template<int n>
v_uint16x8 cv::v_rotate_right ( const v_uint16x8 a)
inline

◆ v_rotate_right() [28/40]

template<int n>
v_uint16x8 cv::v_rotate_right ( const v_uint16x8 a,
const v_uint16x8 b 
)
inline

◆ v_rotate_right() [29/40]

template<int n>
v_uint32 cv::v_rotate_right ( const v_uint32 a)
inline

◆ v_rotate_right() [30/40]

template<int n>
v_uint32 cv::v_rotate_right ( const v_uint32 a,
const v_uint32 b 
)
inline

◆ v_rotate_right() [31/40]

template<int n>
v_uint32x4 cv::v_rotate_right ( const v_uint32x4 a)
inline

◆ v_rotate_right() [32/40]

template<int n>
v_uint32x4 cv::v_rotate_right ( const v_uint32x4 a,
const v_uint32x4 b 
)
inline

◆ v_rotate_right() [33/40]

template<int n>
v_uint64 cv::v_rotate_right ( const v_uint64 a)
inline

◆ v_rotate_right() [34/40]

template<int n>
v_uint64 cv::v_rotate_right ( const v_uint64 a,
const v_uint64 b 
)
inline

◆ v_rotate_right() [35/40]

template<int n>
v_uint64x2 cv::v_rotate_right ( const v_uint64x2 a)
inline

◆ v_rotate_right() [36/40]

template<int n>
v_uint64x2 cv::v_rotate_right ( const v_uint64x2 a,
const v_uint64x2 b 
)
inline

◆ v_rotate_right() [37/40]

template<int n>
v_uint8 cv::v_rotate_right ( const v_uint8 a)
inline

◆ v_rotate_right() [38/40]

template<int n>
v_uint8 cv::v_rotate_right ( const v_uint8 a,
const v_uint8 b 
)
inline

◆ v_rotate_right() [39/40]

template<int n>
v_uint8x16 cv::v_rotate_right ( const v_uint8x16 a)
inline

◆ v_rotate_right() [40/40]

template<int n>
v_uint8x16 cv::v_rotate_right ( const v_uint8x16 a,
const v_uint8x16 b 
)
inline

◆ v_round() [1/6]

v_int32 cv::v_round ( const v_float32 a)
inline

◆ v_round() [2/6]

v_int32x4 cv::v_round ( const v_float32x4 a)
inline

◆ v_round() [3/6]

v_int32 cv::v_round ( const v_float64 a)
inline

◆ v_round() [4/6]

v_int32 cv::v_round ( const v_float64 a,
const v_float64 b 
)
inline

◆ v_round() [5/6]

v_int32x4 cv::v_round ( const v_float64x2 a)
inline

◆ v_round() [6/6]

v_int32x4 cv::v_round ( const v_float64x2 a,
const v_float64x2 b 
)
inline

◆ v_rshr_pack() [1/12]

template<int n = 0>
v_int8 cv::v_rshr_pack ( const v_int16 a,
const v_int16 b,
int  N = n 
)
inline

◆ v_rshr_pack() [2/12]

template<int n>
v_int8x16 cv::v_rshr_pack ( const v_int16x8 a,
const v_int16x8 b 
)
inline

◆ v_rshr_pack() [3/12]

template<int n = 0>
v_int16 cv::v_rshr_pack ( const v_int32 a,
const v_int32 b,
int  N = n 
)
inline

◆ v_rshr_pack() [4/12]

template<int n>
v_int16x8 cv::v_rshr_pack ( const v_int32x4 a,
const v_int32x4 b 
)
inline

◆ v_rshr_pack() [5/12]

template<int n = 0>
v_int32 cv::v_rshr_pack ( const v_int64 a,
const v_int64 b,
int  N = n 
)
inline

◆ v_rshr_pack() [6/12]

template<int n>
v_int32x4 cv::v_rshr_pack ( const v_int64x2 a,
const v_int64x2 b 
)
inline

◆ v_rshr_pack() [7/12]

template<int n = 0>
v_uint8 cv::v_rshr_pack ( const v_uint16 a,
const v_uint16 b,
int  N = n 
)
inline

◆ v_rshr_pack() [8/12]

template<int n>
v_uint8x16 cv::v_rshr_pack ( const v_uint16x8 a,
const v_uint16x8 b 
)
inline

◆ v_rshr_pack() [9/12]

template<int n = 0>
v_uint16 cv::v_rshr_pack ( const v_uint32 a,
const v_uint32 b,
int  N = n 
)
inline

◆ v_rshr_pack() [10/12]

template<int n>
v_uint16x8 cv::v_rshr_pack ( const v_uint32x4 a,
const v_uint32x4 b 
)
inline

◆ v_rshr_pack() [11/12]

template<int n = 0>
v_uint32 cv::v_rshr_pack ( const v_uint64 a,
const v_uint64 b,
int  N = n 
)
inline

◆ v_rshr_pack() [12/12]

template<int n>
v_uint32x4 cv::v_rshr_pack ( const v_uint64x2 a,
const v_uint64x2 b 
)
inline

◆ v_rshr_pack_store() [1/12]

template<int n = 0>
void cv::v_rshr_pack_store ( int *  ptr,
const v_int64 a,
int  N = n 
)
inline

◆ v_rshr_pack_store() [2/12]

template<int n>
void cv::v_rshr_pack_store ( int *  ptr,
const v_int64x2 a 
)
inline

◆ v_rshr_pack_store() [3/12]

template<int n = 0>
void cv::v_rshr_pack_store ( schar ptr,
const v_int16 a,
int  N = n 
)
inline

◆ v_rshr_pack_store() [4/12]

template<int n>
void cv::v_rshr_pack_store ( schar ptr,
const v_int16x8 a 
)
inline

◆ v_rshr_pack_store() [5/12]

template<int n = 0>
void cv::v_rshr_pack_store ( short *  ptr,
const v_int32 a,
int  N = n 
)
inline

◆ v_rshr_pack_store() [6/12]

template<int n>
void cv::v_rshr_pack_store ( short *  ptr,
const v_int32x4 a 
)
inline

◆ v_rshr_pack_store() [7/12]

template<int n = 0>
void cv::v_rshr_pack_store ( uchar ptr,
const v_uint16 a,
int  N = n 
)
inline

◆ v_rshr_pack_store() [8/12]

template<int n>
void cv::v_rshr_pack_store ( uchar ptr,
const v_uint16x8 a 
)
inline

◆ v_rshr_pack_store() [9/12]

template<int n = 0>
void cv::v_rshr_pack_store ( unsigned *  ptr,
const v_uint64 a,
int  N = n 
)
inline

◆ v_rshr_pack_store() [10/12]

template<int n>
void cv::v_rshr_pack_store ( unsigned *  ptr,
const v_uint64x2 a 
)
inline

◆ v_rshr_pack_store() [11/12]

template<int n = 0>
void cv::v_rshr_pack_store ( ushort ptr,
const v_uint32 a,
int  N = n 
)
inline

◆ v_rshr_pack_store() [12/12]

template<int n>
void cv::v_rshr_pack_store ( ushort ptr,
const v_uint32x4 a 
)
inline

◆ v_rshr_pack_u() [1/4]

template<int N = 0>
v_uint8 cv::v_rshr_pack_u ( const v_int16 a,
const v_int16 b,
int  n = N 
)
inline

◆ v_rshr_pack_u() [2/4]

template<int n>
v_uint8x16 cv::v_rshr_pack_u ( const v_int16x8 a,
const v_int16x8 b 
)
inline

◆ v_rshr_pack_u() [3/4]

template<int N = 0>
v_uint16 cv::v_rshr_pack_u ( const v_int32 a,
const v_int32 b,
int  n = N 
)
inline

◆ v_rshr_pack_u() [4/4]

template<int n>
v_uint16x8 cv::v_rshr_pack_u ( const v_int32x4 a,
const v_int32x4 b 
)
inline

◆ v_rshr_pack_u_store() [1/4]

template<int N = 0>
void cv::v_rshr_pack_u_store ( uchar ptr,
const v_int16 a,
int  n = N 
)
inline

◆ v_rshr_pack_u_store() [2/4]

template<int n>
void cv::v_rshr_pack_u_store ( uchar ptr,
const v_int16x8 a 
)
inline

◆ v_rshr_pack_u_store() [3/4]

template<int N = 0>
void cv::v_rshr_pack_u_store ( ushort ptr,
const v_int32 a,
int  n = N 
)
inline

◆ v_rshr_pack_u_store() [4/4]

template<int n>
void cv::v_rshr_pack_u_store ( ushort ptr,
const v_int32x4 a 
)
inline

◆ v_scan_forward() [1/20]

int cv::v_scan_forward ( const v_float32 a)
inline

◆ v_scan_forward() [2/20]

int cv::v_scan_forward ( const v_float32x4 a)
inline

◆ v_scan_forward() [3/20]

int cv::v_scan_forward ( const v_float64 a)
inline

◆ v_scan_forward() [4/20]

int cv::v_scan_forward ( const v_float64x2 a)
inline

◆ v_scan_forward() [5/20]

int cv::v_scan_forward ( const v_int16 a)
inline

◆ v_scan_forward() [6/20]

int cv::v_scan_forward ( const v_int16x8 a)
inline

◆ v_scan_forward() [7/20]

int cv::v_scan_forward ( const v_int32 a)
inline

◆ v_scan_forward() [8/20]

int cv::v_scan_forward ( const v_int32x4 a)
inline

◆ v_scan_forward() [9/20]

int cv::v_scan_forward ( const v_int64 a)
inline

◆ v_scan_forward() [10/20]

int cv::v_scan_forward ( const v_int64x2 a)
inline

◆ v_scan_forward() [11/20]

int cv::v_scan_forward ( const v_int8 a)
inline

◆ v_scan_forward() [12/20]

int cv::v_scan_forward ( const v_int8x16 a)
inline

◆ v_scan_forward() [13/20]

int cv::v_scan_forward ( const v_uint16 a)
inline

◆ v_scan_forward() [14/20]

int cv::v_scan_forward ( const v_uint16x8 a)
inline

◆ v_scan_forward() [15/20]

int cv::v_scan_forward ( const v_uint32 a)
inline

◆ v_scan_forward() [16/20]

int cv::v_scan_forward ( const v_uint32x4 a)
inline

◆ v_scan_forward() [17/20]

int cv::v_scan_forward ( const v_uint64 a)
inline

◆ v_scan_forward() [18/20]

int cv::v_scan_forward ( const v_uint64x2 a)
inline

◆ v_scan_forward() [19/20]

int cv::v_scan_forward ( const v_uint8 a)
inline

◆ v_scan_forward() [20/20]

int cv::v_scan_forward ( const v_uint8x16 a)
inline

◆ v_select() [1/16]

v_float32 cv::v_select ( const v_float32 mask,
const v_float32 a,
const v_float32 b 
)
inline

◆ v_select() [2/16]

v_float32x4 cv::v_select ( const v_float32x4 mask,
const v_float32x4 a,
const v_float32x4 b 
)
inline

◆ v_select() [3/16]

v_float64 cv::v_select ( const v_float64 mask,
const v_float64 a,
const v_float64 b 
)
inline

◆ v_select() [4/16]

v_float64x2 cv::v_select ( const v_float64x2 mask,
const v_float64x2 a,
const v_float64x2 b 
)
inline

◆ v_select() [5/16]

v_int16 cv::v_select ( const v_int16 mask,
const v_int16 a,
const v_int16 b 
)
inline

◆ v_select() [6/16]

v_int16x8 cv::v_select ( const v_int16x8 mask,
const v_int16x8 a,
const v_int16x8 b 
)
inline

◆ v_select() [7/16]

v_int32 cv::v_select ( const v_int32 mask,
const v_int32 a,
const v_int32 b 
)
inline

◆ v_select() [8/16]

v_int32x4 cv::v_select ( const v_int32x4 mask,
const v_int32x4 a,
const v_int32x4 b 
)
inline

◆ v_select() [9/16]

v_int8 cv::v_select ( const v_int8 mask,
const v_int8 a,
const v_int8 b 
)
inline

◆ v_select() [10/16]

v_int8x16 cv::v_select ( const v_int8x16 mask,
const v_int8x16 a,
const v_int8x16 b 
)
inline

◆ v_select() [11/16]

v_uint16 cv::v_select ( const v_uint16 mask,
const v_uint16 a,
const v_uint16 b 
)
inline

◆ v_select() [12/16]

v_uint16x8 cv::v_select ( const v_uint16x8 mask,
const v_uint16x8 a,
const v_uint16x8 b 
)
inline

◆ v_select() [13/16]

v_uint32 cv::v_select ( const v_uint32 mask,
const v_uint32 a,
const v_uint32 b 
)
inline

◆ v_select() [14/16]

v_uint32x4 cv::v_select ( const v_uint32x4 mask,
const v_uint32x4 a,
const v_uint32x4 b 
)
inline

◆ v_select() [15/16]

v_uint8 cv::v_select ( const v_uint8 mask,
const v_uint8 a,
const v_uint8 b 
)
inline

◆ v_select() [16/16]

v_uint8x16 cv::v_select ( const v_uint8x16 mask,
const v_uint8x16 a,
const v_uint8x16 b 
)
inline

◆ v_setall_u32()

v_uint32 cv::v_setall_u32 ( uint  v)
inline

◆ v_shl() [1/14]

template<int s = 0>
v_int16 cv::v_shl ( const v_int16 a,
int  n = s 
)
inline

◆ v_shl() [2/14]

template<int n>
v_int16x8 cv::v_shl ( const v_int16x8 a)
inline

◆ v_shl() [3/14]

template<int s = 0>
v_int32 cv::v_shl ( const v_int32 a,
int  n = s 
)
inline

◆ v_shl() [4/14]

template<int n>
v_int32x4 cv::v_shl ( const v_int32x4 a)
inline

◆ v_shl() [5/14]

template<int s = 0>
v_int64 cv::v_shl ( const v_int64 a,
int  n = s 
)
inline

◆ v_shl() [6/14]

template<int n>
v_int64x2 cv::v_shl ( const v_int64x2 a)
inline

◆ v_shl() [7/14]

template<int n>
v_int8x16 cv::v_shl ( const v_int8x16 a)
inline

◆ v_shl() [8/14]

template<int s = 0>
v_uint16 cv::v_shl ( const v_uint16 a,
int  n = s 
)
inline

◆ v_shl() [9/14]

template<int n>
v_uint16x8 cv::v_shl ( const v_uint16x8 a)
inline

◆ v_shl() [10/14]

template<int s = 0>
v_uint32 cv::v_shl ( const v_uint32 a,
int  n = s 
)
inline

◆ v_shl() [11/14]

template<int n>
v_uint32x4 cv::v_shl ( const v_uint32x4 a)
inline

◆ v_shl() [12/14]

template<int s = 0>
v_uint64 cv::v_shl ( const v_uint64 a,
int  n = s 
)
inline

◆ v_shl() [13/14]

template<int n>
v_uint64x2 cv::v_shl ( const v_uint64x2 a)
inline

◆ v_shl() [14/14]

template<int n>
v_uint8x16 cv::v_shl ( const v_uint8x16 a)
inline

◆ v_shr() [1/14]

template<int s = 0>
v_int16 cv::v_shr ( const v_int16 a,
int  n = s 
)
inline

◆ v_shr() [2/14]

template<int n>
v_int16x8 cv::v_shr ( const v_int16x8 a)
inline

◆ v_shr() [3/14]

template<int s = 0>
v_int32 cv::v_shr ( const v_int32 a,
int  n = s 
)
inline

◆ v_shr() [4/14]

template<int n>
v_int32x4 cv::v_shr ( const v_int32x4 a)
inline

◆ v_shr() [5/14]

template<int s = 0>
v_int64 cv::v_shr ( const v_int64 a,
int  n = s 
)
inline

◆ v_shr() [6/14]

template<int n>
v_int64x2 cv::v_shr ( const v_int64x2 a)
inline

◆ v_shr() [7/14]

template<int n>
v_int8x16 cv::v_shr ( const v_int8x16 a)
inline

◆ v_shr() [8/14]

template<int s = 0>
v_uint16 cv::v_shr ( const v_uint16 a,
int  n = s 
)
inline

◆ v_shr() [9/14]

template<int n>
v_uint16x8 cv::v_shr ( const v_uint16x8 a)
inline

◆ v_shr() [10/14]

template<int s = 0>
v_uint32 cv::v_shr ( const v_uint32 a,
int  n = s 
)
inline

◆ v_shr() [11/14]

template<int n>
v_uint32x4 cv::v_shr ( const v_uint32x4 a)
inline

◆ v_shr() [12/14]

template<int s = 0>
v_uint64 cv::v_shr ( const v_uint64 a,
int  n = s 
)
inline

◆ v_shr() [13/14]

template<int n>
v_uint64x2 cv::v_shr ( const v_uint64x2 a)
inline

◆ v_shr() [14/14]

template<int n>
v_uint8x16 cv::v_shr ( const v_uint8x16 a)
inline

◆ v_signmask() [1/20]

int cv::v_signmask ( const v_float32 a)
inline

◆ v_signmask() [2/20]

int cv::v_signmask ( const v_float32x4 a)
inline

◆ v_signmask() [3/20]

int cv::v_signmask ( const v_float64 a)
inline

◆ v_signmask() [4/20]

int cv::v_signmask ( const v_float64x2 a)
inline

◆ v_signmask() [5/20]

int cv::v_signmask ( const v_int16 a)
inline

◆ v_signmask() [6/20]

int cv::v_signmask ( const v_int16x8 a)
inline

◆ v_signmask() [7/20]

int cv::v_signmask ( const v_int32 a)
inline

◆ v_signmask() [8/20]

int cv::v_signmask ( const v_int32x4 a)
inline

◆ v_signmask() [9/20]

int cv::v_signmask ( const v_int64 a)
inline

◆ v_signmask() [10/20]

int cv::v_signmask ( const v_int64x2 a)
inline

◆ v_signmask() [11/20]

int cv::v_signmask ( const v_int8 a)
inline

◆ v_signmask() [12/20]

int cv::v_signmask ( const v_int8x16 a)
inline

◆ v_signmask() [13/20]

int64 cv::v_signmask ( const v_uint16 a)
inline

◆ v_signmask() [14/20]

int cv::v_signmask ( const v_uint16x8 a)
inline

◆ v_signmask() [15/20]

int cv::v_signmask ( const v_uint32 a)
inline

◆ v_signmask() [16/20]

int cv::v_signmask ( const v_uint32x4 a)
inline

◆ v_signmask() [17/20]

int cv::v_signmask ( const v_uint64 a)
inline

◆ v_signmask() [18/20]

int cv::v_signmask ( const v_uint64x2 a)
inline

◆ v_signmask() [19/20]

int64 cv::v_signmask ( const v_uint8 a)
inline

◆ v_signmask() [20/20]

int cv::v_signmask ( const v_uint8x16 a)
inline

◆ v_sqr_magnitude() [1/4]

v_float32 cv::v_sqr_magnitude ( const v_float32 a,
const v_float32 b 
)
inline

◆ v_sqr_magnitude() [2/4]

v_float32x4 cv::v_sqr_magnitude ( const v_float32x4 a,
const v_float32x4 b 
)
inline

◆ v_sqr_magnitude() [3/4]

v_float64 cv::v_sqr_magnitude ( const v_float64 a,
const v_float64 b 
)
inline

◆ v_sqr_magnitude() [4/4]

v_float64x2 cv::v_sqr_magnitude ( const v_float64x2 a,
const v_float64x2 b 
)
inline

◆ v_sqrt() [1/4]

v_float32 cv::v_sqrt ( const v_float32 x)
inline

◆ v_sqrt() [2/4]

v_float32x4 cv::v_sqrt ( const v_float32x4 x)
inline

◆ v_sqrt() [3/4]

v_float64 cv::v_sqrt ( const v_float64 x)
inline

◆ v_sqrt() [4/4]

v_float64x2 cv::v_sqrt ( const v_float64x2 x)
inline

◆ v_store() [1/40]

void cv::v_store ( double *  ptr,
const v_float64 a 
)
inline

◆ v_store() [2/40]

void cv::v_store ( double *  ptr,
const v_float64 a,
hal::StoreMode   
)
inline

◆ v_store() [3/40]

void cv::v_store ( double *  ptr,
const v_float64x2 a 
)
inline

◆ v_store() [4/40]

void cv::v_store ( double *  ptr,
const v_float64x2 a,
hal::StoreMode   
)
inline

◆ v_store() [5/40]

void cv::v_store ( float *  ptr,
const v_float32 a 
)
inline

◆ v_store() [6/40]

void cv::v_store ( float *  ptr,
const v_float32 a,
hal::StoreMode   
)
inline

◆ v_store() [7/40]

void cv::v_store ( float *  ptr,
const v_float32x4 a 
)
inline

◆ v_store() [8/40]

void cv::v_store ( float *  ptr,
const v_float32x4 a,
hal::StoreMode   
)
inline

◆ v_store() [9/40]

void cv::v_store ( int *  ptr,
const v_int32 a 
)
inline

◆ v_store() [10/40]

void cv::v_store ( int *  ptr,
const v_int32 a,
hal::StoreMode   
)
inline

◆ v_store() [11/40]

void cv::v_store ( int *  ptr,
const v_int32x4 a 
)
inline

◆ v_store() [12/40]

void cv::v_store ( int *  ptr,
const v_int32x4 a,
hal::StoreMode   
)
inline

◆ v_store() [13/40]

void cv::v_store ( int64 ptr,
const v_int64 a 
)
inline

◆ v_store() [14/40]

void cv::v_store ( int64 ptr,
const v_int64 a,
hal::StoreMode   
)
inline

◆ v_store() [15/40]

void cv::v_store ( int64 ptr,
const v_int64x2 a 
)
inline

◆ v_store() [16/40]

void cv::v_store ( int64 ptr,
const v_int64x2 a,
hal::StoreMode   
)
inline

◆ v_store() [17/40]

void cv::v_store ( schar ptr,
const v_int8 a 
)
inline

◆ v_store() [18/40]

void cv::v_store ( schar ptr,
const v_int8 a,
hal::StoreMode   
)
inline

◆ v_store() [19/40]

void cv::v_store ( schar ptr,
const v_int8x16 a 
)
inline

◆ v_store() [20/40]

void cv::v_store ( schar ptr,
const v_int8x16 a,
hal::StoreMode   
)
inline

◆ v_store() [21/40]

void cv::v_store ( short *  ptr,
const v_int16 a 
)
inline

◆ v_store() [22/40]

void cv::v_store ( short *  ptr,
const v_int16 a,
hal::StoreMode   
)
inline

◆ v_store() [23/40]

void cv::v_store ( short *  ptr,
const v_int16x8 a 
)
inline

◆ v_store() [24/40]

void cv::v_store ( short *  ptr,
const v_int16x8 a,
hal::StoreMode   
)
inline

◆ v_store() [25/40]

void cv::v_store ( uchar ptr,
const v_uint8 a 
)
inline

◆ v_store() [26/40]

void cv::v_store ( uchar ptr,
const v_uint8 a,
hal::StoreMode   
)
inline

◆ v_store() [27/40]

void cv::v_store ( uchar ptr,
const v_uint8x16 a 
)
inline

◆ v_store() [28/40]

void cv::v_store ( uchar ptr,
const v_uint8x16 a,
hal::StoreMode   
)
inline

◆ v_store() [29/40]

void cv::v_store ( uint64 ptr,
const v_uint64 a 
)
inline

◆ v_store() [30/40]

void cv::v_store ( uint64 ptr,
const v_uint64 a,
hal::StoreMode   
)
inline

◆ v_store() [31/40]

void cv::v_store ( uint64 ptr,
const v_uint64x2 a 
)
inline

◆ v_store() [32/40]

void cv::v_store ( uint64 ptr,
const v_uint64x2 a,
hal::StoreMode   
)
inline

◆ v_store() [33/40]

void cv::v_store ( unsigned *  ptr,
const v_uint32x4 a 
)
inline

◆ v_store() [34/40]

void cv::v_store ( unsigned *  ptr,
const v_uint32x4 a,
hal::StoreMode   
)
inline

◆ v_store() [35/40]

void cv::v_store ( unsigned int *  ptr,
const v_uint32 a 
)
inline

◆ v_store() [36/40]

void cv::v_store ( unsigned int *  ptr,
const v_uint32 a,
hal::StoreMode   
)
inline

◆ v_store() [37/40]

void cv::v_store ( ushort ptr,
const v_uint16 a 
)
inline

◆ v_store() [38/40]

void cv::v_store ( ushort ptr,
const v_uint16 a,
hal::StoreMode   
)
inline

◆ v_store() [39/40]

void cv::v_store ( ushort ptr,
const v_uint16x8 a 
)
inline

◆ v_store() [40/40]

void cv::v_store ( ushort ptr,
const v_uint16x8 a,
hal::StoreMode   
)
inline

◆ v_store_aligned() [1/20]

void cv::v_store_aligned ( double *  ptr,
const v_float64 a 
)
inline

◆ v_store_aligned() [2/20]

void cv::v_store_aligned ( double *  ptr,
const v_float64x2 a 
)
inline

◆ v_store_aligned() [3/20]

void cv::v_store_aligned ( float *  ptr,
const v_float32 a 
)
inline

◆ v_store_aligned() [4/20]

void cv::v_store_aligned ( float *  ptr,
const v_float32x4 a 
)
inline

◆ v_store_aligned() [5/20]

void cv::v_store_aligned ( int *  ptr,
const v_int32 a 
)
inline

◆ v_store_aligned() [6/20]

void cv::v_store_aligned ( int *  ptr,
const v_int32x4 a 
)
inline

◆ v_store_aligned() [7/20]

void cv::v_store_aligned ( int64 ptr,
const v_int64 a 
)
inline

◆ v_store_aligned() [8/20]

void cv::v_store_aligned ( int64 ptr,
const v_int64x2 a 
)
inline

◆ v_store_aligned() [9/20]

void cv::v_store_aligned ( schar ptr,
const v_int8 a 
)
inline

◆ v_store_aligned() [10/20]

void cv::v_store_aligned ( schar ptr,
const v_int8x16 a 
)
inline

◆ v_store_aligned() [11/20]

void cv::v_store_aligned ( short *  ptr,
const v_int16 a 
)
inline

◆ v_store_aligned() [12/20]

void cv::v_store_aligned ( short *  ptr,
const v_int16x8 a 
)
inline

◆ v_store_aligned() [13/20]

void cv::v_store_aligned ( uchar ptr,
const v_uint8 a 
)
inline

◆ v_store_aligned() [14/20]

void cv::v_store_aligned ( uchar ptr,
const v_uint8x16 a 
)
inline

◆ v_store_aligned() [15/20]

void cv::v_store_aligned ( uint64 ptr,
const v_uint64 a 
)
inline

◆ v_store_aligned() [16/20]

void cv::v_store_aligned ( uint64 ptr,
const v_uint64x2 a 
)
inline

◆ v_store_aligned() [17/20]

void cv::v_store_aligned ( unsigned *  ptr,
const v_uint32x4 a 
)
inline

◆ v_store_aligned() [18/20]

void cv::v_store_aligned ( unsigned int *  ptr,
const v_uint32 a 
)
inline

◆ v_store_aligned() [19/20]

void cv::v_store_aligned ( ushort ptr,
const v_uint16 a 
)
inline

◆ v_store_aligned() [20/20]

void cv::v_store_aligned ( ushort ptr,
const v_uint16x8 a 
)
inline

◆ v_store_aligned_nocache() [1/20]

void cv::v_store_aligned_nocache ( double *  ptr,
const v_float64 a 
)
inline

◆ v_store_aligned_nocache() [2/20]

void cv::v_store_aligned_nocache ( double *  ptr,
const v_float64x2 a 
)
inline

◆ v_store_aligned_nocache() [3/20]

void cv::v_store_aligned_nocache ( float *  ptr,
const v_float32 a 
)
inline

◆ v_store_aligned_nocache() [4/20]

void cv::v_store_aligned_nocache ( float *  ptr,
const v_float32x4 a 
)
inline

◆ v_store_aligned_nocache() [5/20]

void cv::v_store_aligned_nocache ( int *  ptr,
const v_int32 a 
)
inline

◆ v_store_aligned_nocache() [6/20]

void cv::v_store_aligned_nocache ( int *  ptr,
const v_int32x4 a 
)
inline

◆ v_store_aligned_nocache() [7/20]

void cv::v_store_aligned_nocache ( int64 ptr,
const v_int64 a 
)
inline

◆ v_store_aligned_nocache() [8/20]

void cv::v_store_aligned_nocache ( int64 ptr,
const v_int64x2 a 
)
inline

◆ v_store_aligned_nocache() [9/20]

void cv::v_store_aligned_nocache ( schar ptr,
const v_int8 a 
)
inline

◆ v_store_aligned_nocache() [10/20]

void cv::v_store_aligned_nocache ( schar ptr,
const v_int8x16 a 
)
inline

◆ v_store_aligned_nocache() [11/20]

void cv::v_store_aligned_nocache ( short *  ptr,
const v_int16 a 
)
inline

◆ v_store_aligned_nocache() [12/20]

void cv::v_store_aligned_nocache ( short *  ptr,
const v_int16x8 a 
)
inline

◆ v_store_aligned_nocache() [13/20]

void cv::v_store_aligned_nocache ( uchar ptr,
const v_uint8 a 
)
inline

◆ v_store_aligned_nocache() [14/20]

void cv::v_store_aligned_nocache ( uchar ptr,
const v_uint8x16 a 
)
inline

◆ v_store_aligned_nocache() [15/20]

void cv::v_store_aligned_nocache ( uint64 ptr,
const v_uint64 a 
)
inline

◆ v_store_aligned_nocache() [16/20]

void cv::v_store_aligned_nocache ( uint64 ptr,
const v_uint64x2 a 
)
inline

◆ v_store_aligned_nocache() [17/20]

void cv::v_store_aligned_nocache ( unsigned *  ptr,
const v_uint32x4 a 
)
inline

◆ v_store_aligned_nocache() [18/20]

void cv::v_store_aligned_nocache ( unsigned int *  ptr,
const v_uint32 a 
)
inline

◆ v_store_aligned_nocache() [19/20]

void cv::v_store_aligned_nocache ( ushort ptr,
const v_uint16 a 
)
inline

◆ v_store_aligned_nocache() [20/20]

void cv::v_store_aligned_nocache ( ushort ptr,
const v_uint16x8 a 
)
inline

◆ v_store_high() [1/20]

void cv::v_store_high ( double *  ptr,
const v_float64 a 
)
inline

◆ v_store_high() [2/20]

void cv::v_store_high ( double *  ptr,
const v_float64x2 a 
)
inline

◆ v_store_high() [3/20]

void cv::v_store_high ( float *  ptr,
const v_float32 a 
)
inline

◆ v_store_high() [4/20]

void cv::v_store_high ( float *  ptr,
const v_float32x4 a 
)
inline

◆ v_store_high() [5/20]

void cv::v_store_high ( int *  ptr,
const v_int32 a 
)
inline

◆ v_store_high() [6/20]

void cv::v_store_high ( int *  ptr,
const v_int32x4 a 
)
inline

◆ v_store_high() [7/20]

void cv::v_store_high ( int64 ptr,
const v_int64 a 
)
inline

◆ v_store_high() [8/20]

void cv::v_store_high ( int64 ptr,
const v_int64x2 a 
)
inline

◆ v_store_high() [9/20]

void cv::v_store_high ( schar ptr,
const v_int8 a 
)
inline

◆ v_store_high() [10/20]

void cv::v_store_high ( schar ptr,
const v_int8x16 a 
)
inline

◆ v_store_high() [11/20]

void cv::v_store_high ( short *  ptr,
const v_int16 a 
)
inline

◆ v_store_high() [12/20]

void cv::v_store_high ( short *  ptr,
const v_int16x8 a 
)
inline

◆ v_store_high() [13/20]

void cv::v_store_high ( uchar ptr,
const v_uint8 a 
)
inline

◆ v_store_high() [14/20]

void cv::v_store_high ( uchar ptr,
const v_uint8x16 a 
)
inline

◆ v_store_high() [15/20]

void cv::v_store_high ( uint64 ptr,
const v_uint64 a 
)
inline

◆ v_store_high() [16/20]

void cv::v_store_high ( uint64 ptr,
const v_uint64x2 a 
)
inline

◆ v_store_high() [17/20]

void cv::v_store_high ( unsigned *  ptr,
const v_uint32x4 a 
)
inline

◆ v_store_high() [18/20]

void cv::v_store_high ( unsigned int *  ptr,
const v_uint32 a 
)
inline

◆ v_store_high() [19/20]

void cv::v_store_high ( ushort ptr,
const v_uint16 a 
)
inline

◆ v_store_high() [20/20]

void cv::v_store_high ( ushort ptr,
const v_uint16x8 a 
)
inline

◆ v_store_interleave() [1/60]

void cv::v_store_interleave ( double *  ptr,
const v_float64 a,
const v_float64 b,
const v_float64 c,
const v_float64 d,
hal::StoreMode  = hal::STORE_UNALIGNED 
)
inline

◆ v_store_interleave() [2/60]

void cv::v_store_interleave ( double *  ptr,
const v_float64 a,
const v_float64 b,
const v_float64 c,
hal::StoreMode  = hal::STORE_UNALIGNED 
)
inline

◆ v_store_interleave() [3/60]

void cv::v_store_interleave ( double *  ptr,
const v_float64 a,
const v_float64 b,
hal::StoreMode  = hal::STORE_UNALIGNED 
)
inline

◆ v_store_interleave() [4/60]

void cv::v_store_interleave ( double *  ptr,
const v_float64x2 a,
const v_float64x2 b,
const v_float64x2 c,
const v_float64x2 d,
hal::StoreMode  = hal::STORE_UNALIGNED 
)
inline

◆ v_store_interleave() [5/60]

void cv::v_store_interleave ( double *  ptr,
const v_float64x2 a,
const v_float64x2 b,
const v_float64x2 c,
hal::StoreMode  = hal::STORE_UNALIGNED 
)
inline

◆ v_store_interleave() [6/60]

void cv::v_store_interleave ( double *  ptr,
const v_float64x2 a,
const v_float64x2 b,
hal::StoreMode  = hal::STORE_UNALIGNED 
)
inline

◆ v_store_interleave() [7/60]

void cv::v_store_interleave ( float *  ptr,
const v_float32 a,
const v_float32 b,
const v_float32 c,
const v_float32 d,
hal::StoreMode  = hal::STORE_UNALIGNED 
)
inline

◆ v_store_interleave() [8/60]

void cv::v_store_interleave ( float *  ptr,
const v_float32 a,
const v_float32 b,
const v_float32 c,
hal::StoreMode  = hal::STORE_UNALIGNED 
)
inline

◆ v_store_interleave() [9/60]

void cv::v_store_interleave ( float *  ptr,
const v_float32 a,
const v_float32 b,
hal::StoreMode  = hal::STORE_UNALIGNED 
)
inline

◆ v_store_interleave() [10/60]

void cv::v_store_interleave ( float *  ptr,
const v_float32x4 a,
const v_float32x4 b,
const v_float32x4 c,
const v_float32x4 d,
hal::StoreMode  = hal::STORE_UNALIGNED 
)
inline

◆ v_store_interleave() [11/60]

void cv::v_store_interleave ( float *  ptr,
const v_float32x4 a,
const v_float32x4 b,
const v_float32x4 c,
hal::StoreMode  = hal::STORE_UNALIGNED 
)
inline

◆ v_store_interleave() [12/60]

void cv::v_store_interleave ( float *  ptr,
const v_float32x4 a,
const v_float32x4 b,
hal::StoreMode  = hal::STORE_UNALIGNED 
)
inline

◆ v_store_interleave() [13/60]

void cv::v_store_interleave ( int *  ptr,
const v_int32 a,
const v_int32 b,
const v_int32 c,
const v_int32 d,
hal::StoreMode  = hal::STORE_UNALIGNED 
)
inline

◆ v_store_interleave() [14/60]

void cv::v_store_interleave ( int *  ptr,
const v_int32 a,
const v_int32 b,
const v_int32 c,
hal::StoreMode  = hal::STORE_UNALIGNED 
)
inline

◆ v_store_interleave() [15/60]

void cv::v_store_interleave ( int *  ptr,
const v_int32 a,
const v_int32 b,
hal::StoreMode  = hal::STORE_UNALIGNED 
)
inline

◆ v_store_interleave() [16/60]

void cv::v_store_interleave ( int *  ptr,
const v_int32x4 a,
const v_int32x4 b,
const v_int32x4 c,
const v_int32x4 d,
hal::StoreMode  = hal::STORE_UNALIGNED 
)
inline

◆ v_store_interleave() [17/60]

void cv::v_store_interleave ( int *  ptr,
const v_int32x4 a,
const v_int32x4 b,
const v_int32x4 c,
hal::StoreMode  = hal::STORE_UNALIGNED 
)
inline

◆ v_store_interleave() [18/60]

void cv::v_store_interleave ( int *  ptr,
const v_int32x4 a,
const v_int32x4 b,
hal::StoreMode  = hal::STORE_UNALIGNED 
)
inline

◆ v_store_interleave() [19/60]

void cv::v_store_interleave ( int64 ptr,
const v_int64 a,
const v_int64 b,
const v_int64 c,
const v_int64 d,
hal::StoreMode  = hal::STORE_UNALIGNED 
)
inline

◆ v_store_interleave() [20/60]

void cv::v_store_interleave ( int64 ptr,
const v_int64 a,
const v_int64 b,
const v_int64 c,
hal::StoreMode  = hal::STORE_UNALIGNED 
)
inline

◆ v_store_interleave() [21/60]

void cv::v_store_interleave ( int64 ptr,
const v_int64 a,
const v_int64 b,
hal::StoreMode  = hal::STORE_UNALIGNED 
)
inline

◆ v_store_interleave() [22/60]

void cv::v_store_interleave ( int64 ptr,
const v_int64x2 a,
const v_int64x2 b,
const v_int64x2 c,
const v_int64x2 d,
hal::StoreMode  = hal::STORE_UNALIGNED 
)
inline

◆ v_store_interleave() [23/60]

void cv::v_store_interleave ( int64 ptr,
const v_int64x2 a,
const v_int64x2 b,
const v_int64x2 c,
hal::StoreMode  = hal::STORE_UNALIGNED 
)
inline

◆ v_store_interleave() [24/60]

void cv::v_store_interleave ( int64 ptr,
const v_int64x2 a,
const v_int64x2 b,
hal::StoreMode  = hal::STORE_UNALIGNED 
)
inline

◆ v_store_interleave() [25/60]

void cv::v_store_interleave ( schar ptr,
const v_int8 a,
const v_int8 b,
const v_int8 c,
const v_int8 d,
hal::StoreMode  = hal::STORE_UNALIGNED 
)
inline

◆ v_store_interleave() [26/60]

void cv::v_store_interleave ( schar ptr,
const v_int8 a,
const v_int8 b,
const v_int8 c,
hal::StoreMode  = hal::STORE_UNALIGNED 
)
inline

◆ v_store_interleave() [27/60]

void cv::v_store_interleave ( schar ptr,
const v_int8 a,
const v_int8 b,
hal::StoreMode  = hal::STORE_UNALIGNED 
)
inline

◆ v_store_interleave() [28/60]

void cv::v_store_interleave ( schar ptr,
const v_int8x16 a,
const v_int8x16 b,
const v_int8x16 c,
const v_int8x16 d,
hal::StoreMode  = hal::STORE_UNALIGNED 
)
inline

◆ v_store_interleave() [29/60]

void cv::v_store_interleave ( schar ptr,
const v_int8x16 a,
const v_int8x16 b,
const v_int8x16 c,
hal::StoreMode  = hal::STORE_UNALIGNED 
)
inline

◆ v_store_interleave() [30/60]

void cv::v_store_interleave ( schar ptr,
const v_int8x16 a,
const v_int8x16 b,
hal::StoreMode  = hal::STORE_UNALIGNED 
)
inline

◆ v_store_interleave() [31/60]

void cv::v_store_interleave ( short *  ptr,
const v_int16 a,
const v_int16 b,
const v_int16 c,
const v_int16 d,
hal::StoreMode  = hal::STORE_UNALIGNED 
)
inline

◆ v_store_interleave() [32/60]

void cv::v_store_interleave ( short *  ptr,
const v_int16 a,
const v_int16 b,
const v_int16 c,
hal::StoreMode  = hal::STORE_UNALIGNED 
)
inline

◆ v_store_interleave() [33/60]

void cv::v_store_interleave ( short *  ptr,
const v_int16 a,
const v_int16 b,
hal::StoreMode  = hal::STORE_UNALIGNED 
)
inline

◆ v_store_interleave() [34/60]

void cv::v_store_interleave ( short *  ptr,
const v_int16x8 a,
const v_int16x8 b,
const v_int16x8 c,
const v_int16x8 d,
hal::StoreMode  = hal::STORE_UNALIGNED 
)
inline

◆ v_store_interleave() [35/60]

void cv::v_store_interleave ( short *  ptr,
const v_int16x8 a,
const v_int16x8 b,
const v_int16x8 c,
hal::StoreMode  = hal::STORE_UNALIGNED 
)
inline

◆ v_store_interleave() [36/60]

void cv::v_store_interleave ( short *  ptr,
const v_int16x8 a,
const v_int16x8 b,
hal::StoreMode  = hal::STORE_UNALIGNED 
)
inline

◆ v_store_interleave() [37/60]

void cv::v_store_interleave ( uchar ptr,
const v_uint8 a,
const v_uint8 b,
const v_uint8 c,
const v_uint8 d,
hal::StoreMode  = hal::STORE_UNALIGNED 
)
inline

◆ v_store_interleave() [38/60]

void cv::v_store_interleave ( uchar ptr,
const v_uint8 a,
const v_uint8 b,
const v_uint8 c,
hal::StoreMode  = hal::STORE_UNALIGNED 
)
inline

◆ v_store_interleave() [39/60]

void cv::v_store_interleave ( uchar ptr,
const v_uint8 a,
const v_uint8 b,
hal::StoreMode  = hal::STORE_UNALIGNED 
)
inline

◆ v_store_interleave() [40/60]

void cv::v_store_interleave ( uchar ptr,
const v_uint8x16 a,
const v_uint8x16 b,
const v_uint8x16 c,
const v_uint8x16 d,
hal::StoreMode  = hal::STORE_UNALIGNED 
)
inline

◆ v_store_interleave() [41/60]

void cv::v_store_interleave ( uchar ptr,
const v_uint8x16 a,
const v_uint8x16 b,
const v_uint8x16 c,
hal::StoreMode  = hal::STORE_UNALIGNED 
)
inline

◆ v_store_interleave() [42/60]

void cv::v_store_interleave ( uchar ptr,
const v_uint8x16 a,
const v_uint8x16 b,
hal::StoreMode  = hal::STORE_UNALIGNED 
)
inline

◆ v_store_interleave() [43/60]

void cv::v_store_interleave ( uint64 ptr,
const v_uint64 a,
const v_uint64 b,
const v_uint64 c,
const v_uint64 d,
hal::StoreMode  = hal::STORE_UNALIGNED 
)
inline

◆ v_store_interleave() [44/60]

void cv::v_store_interleave ( uint64 ptr,
const v_uint64 a,
const v_uint64 b,
const v_uint64 c,
hal::StoreMode  = hal::STORE_UNALIGNED 
)
inline

◆ v_store_interleave() [45/60]

void cv::v_store_interleave ( uint64 ptr,
const v_uint64 a,
const v_uint64 b,
hal::StoreMode  = hal::STORE_UNALIGNED 
)
inline

◆ v_store_interleave() [46/60]

void cv::v_store_interleave ( uint64 ptr,
const v_uint64x2 a,
const v_uint64x2 b,
const v_uint64x2 c,
const v_uint64x2 d,
hal::StoreMode  = hal::STORE_UNALIGNED 
)
inline

◆ v_store_interleave() [47/60]

void cv::v_store_interleave ( uint64 ptr,
const v_uint64x2 a,
const v_uint64x2 b,
const v_uint64x2 c,
hal::StoreMode  = hal::STORE_UNALIGNED 
)
inline

◆ v_store_interleave() [48/60]

void cv::v_store_interleave ( uint64 ptr,
const v_uint64x2 a,
const v_uint64x2 b,
hal::StoreMode  = hal::STORE_UNALIGNED 
)
inline

◆ v_store_interleave() [49/60]

void cv::v_store_interleave ( unsigned *  ptr,
const v_uint32 a,
const v_uint32 b,
const v_uint32 c,
const v_uint32 d,
hal::StoreMode  = hal::STORE_UNALIGNED 
)
inline

◆ v_store_interleave() [50/60]

void cv::v_store_interleave ( unsigned *  ptr,
const v_uint32 a,
const v_uint32 b,
const v_uint32 c,
hal::StoreMode  = hal::STORE_UNALIGNED 
)
inline

◆ v_store_interleave() [51/60]

void cv::v_store_interleave ( unsigned *  ptr,
const v_uint32 a,
const v_uint32 b,
hal::StoreMode  = hal::STORE_UNALIGNED 
)
inline

◆ v_store_interleave() [52/60]

void cv::v_store_interleave ( unsigned *  ptr,
const v_uint32x4 a,
const v_uint32x4 b,
const v_uint32x4 c,
const v_uint32x4 d,
hal::StoreMode  = hal::STORE_UNALIGNED 
)
inline

◆ v_store_interleave() [53/60]

void cv::v_store_interleave ( unsigned *  ptr,
const v_uint32x4 a,
const v_uint32x4 b,
const v_uint32x4 c,
hal::StoreMode  = hal::STORE_UNALIGNED 
)
inline

◆ v_store_interleave() [54/60]

void cv::v_store_interleave ( unsigned *  ptr,
const v_uint32x4 a,
const v_uint32x4 b,
hal::StoreMode  = hal::STORE_UNALIGNED 
)
inline

◆ v_store_interleave() [55/60]

void cv::v_store_interleave ( ushort ptr,
const v_uint16 a,
const v_uint16 b,
const v_uint16 c,
const v_uint16 d,
hal::StoreMode  = hal::STORE_UNALIGNED 
)
inline

◆ v_store_interleave() [56/60]

void cv::v_store_interleave ( ushort ptr,
const v_uint16 a,
const v_uint16 b,
const v_uint16 c,
hal::StoreMode  = hal::STORE_UNALIGNED 
)
inline

◆ v_store_interleave() [57/60]

void cv::v_store_interleave ( ushort ptr,
const v_uint16 a,
const v_uint16 b,
hal::StoreMode  = hal::STORE_UNALIGNED 
)
inline

◆ v_store_interleave() [58/60]

void cv::v_store_interleave ( ushort ptr,
const v_uint16x8 a,
const v_uint16x8 b,
const v_uint16x8 c,
const v_uint16x8 d,
hal::StoreMode  = hal::STORE_UNALIGNED 
)
inline

◆ v_store_interleave() [59/60]

void cv::v_store_interleave ( ushort ptr,
const v_uint16x8 a,
const v_uint16x8 b,
const v_uint16x8 c,
hal::StoreMode  = hal::STORE_UNALIGNED 
)
inline

◆ v_store_interleave() [60/60]

void cv::v_store_interleave ( ushort ptr,
const v_uint16x8 a,
const v_uint16x8 b,
hal::StoreMode  = hal::STORE_UNALIGNED 
)
inline

◆ v_store_low() [1/20]

void cv::v_store_low ( double *  ptr,
const v_float64 a 
)
inline

◆ v_store_low() [2/20]

void cv::v_store_low ( double *  ptr,
const v_float64x2 a 
)
inline

◆ v_store_low() [3/20]

void cv::v_store_low ( float *  ptr,
const v_float32 a 
)
inline

◆ v_store_low() [4/20]

void cv::v_store_low ( float *  ptr,
const v_float32x4 a 
)
inline

◆ v_store_low() [5/20]

void cv::v_store_low ( int *  ptr,
const v_int32 a 
)
inline

◆ v_store_low() [6/20]

void cv::v_store_low ( int *  ptr,
const v_int32x4 a 
)
inline

◆ v_store_low() [7/20]

void cv::v_store_low ( int64 ptr,
const v_int64 a 
)
inline

◆ v_store_low() [8/20]

void cv::v_store_low ( int64 ptr,
const v_int64x2 a 
)
inline

◆ v_store_low() [9/20]

void cv::v_store_low ( schar ptr,
const v_int8 a 
)
inline

◆ v_store_low() [10/20]

void cv::v_store_low ( schar ptr,
const v_int8x16 a 
)
inline

◆ v_store_low() [11/20]

void cv::v_store_low ( short *  ptr,
const v_int16 a 
)
inline

◆ v_store_low() [12/20]

void cv::v_store_low ( short *  ptr,
const v_int16x8 a 
)
inline

◆ v_store_low() [13/20]

void cv::v_store_low ( uchar ptr,
const v_uint8 a 
)
inline

◆ v_store_low() [14/20]

void cv::v_store_low ( uchar ptr,
const v_uint8x16 a 
)
inline

◆ v_store_low() [15/20]

void cv::v_store_low ( uint64 ptr,
const v_uint64 a 
)
inline

◆ v_store_low() [16/20]

void cv::v_store_low ( uint64 ptr,
const v_uint64x2 a 
)
inline

◆ v_store_low() [17/20]

void cv::v_store_low ( unsigned *  ptr,
const v_uint32x4 a 
)
inline

◆ v_store_low() [18/20]

void cv::v_store_low ( unsigned int *  ptr,
const v_uint32 a 
)
inline

◆ v_store_low() [19/20]

void cv::v_store_low ( ushort ptr,
const v_uint16 a 
)
inline

◆ v_store_low() [20/20]

void cv::v_store_low ( ushort ptr,
const v_uint16x8 a 
)
inline

◆ v_sub() [1/10]

v_float32 cv::v_sub ( const v_float32 a,
const v_float32 b 
)
inline

◆ v_sub() [2/10]

v_float64 cv::v_sub ( const v_float64 a,
const v_float64 b 
)
inline

◆ v_sub() [3/10]

v_int16 cv::v_sub ( const v_int16 a,
const v_int16 b 
)
inline

◆ v_sub() [4/10]

v_int32 cv::v_sub ( const v_int32 a,
const v_int32 b 
)
inline

◆ v_sub() [5/10]

v_int64 cv::v_sub ( const v_int64 a,
const v_int64 b 
)
inline

◆ v_sub() [6/10]

v_int8 cv::v_sub ( const v_int8 a,
const v_int8 b 
)
inline

◆ v_sub() [7/10]

v_uint16 cv::v_sub ( const v_uint16 a,
const v_uint16 b 
)
inline

◆ v_sub() [8/10]

v_uint32 cv::v_sub ( const v_uint32 a,
const v_uint32 b 
)
inline

◆ v_sub() [9/10]

v_uint64 cv::v_sub ( const v_uint64 a,
const v_uint64 b 
)
inline

◆ v_sub() [10/10]

v_uint8 cv::v_sub ( const v_uint8 a,
const v_uint8 b 
)
inline

◆ v_sub_wrap() [1/8]

v_int16 cv::v_sub_wrap ( const v_int16 a,
const v_int16 b 
)
inline

◆ v_sub_wrap() [2/8]

v_int16x8 cv::v_sub_wrap ( const v_int16x8 a,
const v_int16x8 b 
)
inline

◆ v_sub_wrap() [3/8]

v_int8 cv::v_sub_wrap ( const v_int8 a,
const v_int8 b 
)
inline

◆ v_sub_wrap() [4/8]

v_int8x16 cv::v_sub_wrap ( const v_int8x16 a,
const v_int8x16 b 
)
inline

◆ v_sub_wrap() [5/8]

v_uint16 cv::v_sub_wrap ( const v_uint16 a,
const v_uint16 b 
)
inline

◆ v_sub_wrap() [6/8]

v_uint16x8 cv::v_sub_wrap ( const v_uint16x8 a,
const v_uint16x8 b 
)
inline

◆ v_sub_wrap() [7/8]

v_uint8 cv::v_sub_wrap ( const v_uint8 a,
const v_uint8 b 
)
inline

◆ v_sub_wrap() [8/8]

v_uint8x16 cv::v_sub_wrap ( const v_uint8x16 a,
const v_uint8x16 b 
)
inline

◆ v_transpose4x4() [1/6]

void cv::v_transpose4x4 ( const v_float32 a0,
const v_float32 a1,
const v_float32 a2,
const v_float32 a3,
v_float32 b0,
v_float32 b1,
v_float32 b2,
v_float32 b3 
)
inline

◆ v_transpose4x4() [2/6]

void cv::v_transpose4x4 ( const v_float32x4 a0,
const v_float32x4 a1,
const v_float32x4 a2,
const v_float32x4 a3,
v_float32x4 b0,
v_float32x4 b1,
v_float32x4 b2,
v_float32x4 b3 
)
inline

◆ v_transpose4x4() [3/6]

void cv::v_transpose4x4 ( const v_int32 a0,
const v_int32 a1,
const v_int32 a2,
const v_int32 a3,
v_int32 b0,
v_int32 b1,
v_int32 b2,
v_int32 b3 
)
inline

◆ v_transpose4x4() [4/6]

void cv::v_transpose4x4 ( const v_int32x4 a0,
const v_int32x4 a1,
const v_int32x4 a2,
const v_int32x4 a3,
v_int32x4 b0,
v_int32x4 b1,
v_int32x4 b2,
v_int32x4 b3 
)
inline

◆ v_transpose4x4() [5/6]

void cv::v_transpose4x4 ( const v_uint32 a0,
const v_uint32 a1,
const v_uint32 a2,
const v_uint32 a3,
v_uint32 b0,
v_uint32 b1,
v_uint32 b2,
v_uint32 b3 
)
inline

◆ v_transpose4x4() [6/6]

void cv::v_transpose4x4 ( const v_uint32x4 a0,
const v_uint32x4 a1,
const v_uint32x4 a2,
const v_uint32x4 a3,
v_uint32x4 b0,
v_uint32x4 b1,
v_uint32x4 b2,
v_uint32x4 b3 
)
inline

◆ v_trunc() [1/4]

v_int32 cv::v_trunc ( const v_float32 a)
inline

◆ v_trunc() [2/4]

v_int32x4 cv::v_trunc ( const v_float32x4 a)
inline

◆ v_trunc() [3/4]

v_int32 cv::v_trunc ( const v_float64 a)
inline

◆ v_trunc() [4/4]

v_int32x4 cv::v_trunc ( const v_float64x2 a)
inline

◆ v_xor() [1/10]

v_float32 cv::v_xor ( const v_float32 a,
const v_float32 b 
)
inline

◆ v_xor() [2/10]

v_float64 cv::v_xor ( const v_float64 a,
const v_float64 b 
)
inline

◆ v_xor() [3/10]

v_int16 cv::v_xor ( const v_int16 a,
const v_int16 b 
)
inline

◆ v_xor() [4/10]

v_int32 cv::v_xor ( const v_int32 a,
const v_int32 b 
)
inline

◆ v_xor() [5/10]

v_int64 cv::v_xor ( const v_int64 a,
const v_int64 b 
)
inline

◆ v_xor() [6/10]

v_int8 cv::v_xor ( const v_int8 a,
const v_int8 b 
)
inline

◆ v_xor() [7/10]

v_uint16 cv::v_xor ( const v_uint16 a,
const v_uint16 b 
)
inline

◆ v_xor() [8/10]

v_uint32 cv::v_xor ( const v_uint32 a,
const v_uint32 b 
)
inline

◆ v_xor() [9/10]

v_uint64 cv::v_xor ( const v_uint64 a,
const v_uint64 b 
)
inline

◆ v_xor() [10/10]

v_uint8 cv::v_xor ( const v_uint8 a,
const v_uint8 b 
)
inline

◆ v_zip() [1/15]

void cv::v_zip ( const v_float32 a0,
const v_float32 a1,
v_float32 b0,
v_float32 b1 
)
inline

◆ v_zip() [2/15]

void cv::v_zip ( const v_float32x4 a0,
const v_float32x4 a1,
v_float32x4 b0,
v_float32x4 b1 
)
inline

◆ v_zip() [3/15]

void cv::v_zip ( const v_float64x2 a0,
const v_float64x2 a1,
v_float64x2 b0,
v_float64x2 b1 
)
inline

◆ v_zip() [4/15]

void cv::v_zip ( const v_int16 a0,
const v_int16 a1,
v_int16 b0,
v_int16 b1 
)
inline

◆ v_zip() [5/15]

void cv::v_zip ( const v_int16x8 a0,
const v_int16x8 a1,
v_int16x8 b0,
v_int16x8 b1 
)
inline

◆ v_zip() [6/15]

void cv::v_zip ( const v_int32 a0,
const v_int32 a1,
v_int32 b0,
v_int32 b1 
)
inline

◆ v_zip() [7/15]

void cv::v_zip ( const v_int32x4 a0,
const v_int32x4 a1,
v_int32x4 b0,
v_int32x4 b1 
)
inline

◆ v_zip() [8/15]

void cv::v_zip ( const v_int8 a0,
const v_int8 a1,
v_int8 b0,
v_int8 b1 
)
inline

◆ v_zip() [9/15]

void cv::v_zip ( const v_int8x16 a0,
const v_int8x16 a1,
v_int8x16 b0,
v_int8x16 b1 
)
inline

◆ v_zip() [10/15]

void cv::v_zip ( const v_uint16 a0,
const v_uint16 a1,
v_uint16 b0,
v_uint16 b1 
)
inline

◆ v_zip() [11/15]

void cv::v_zip ( const v_uint16x8 a0,
const v_uint16x8 a1,
v_uint16x8 b0,
v_uint16x8 b1 
)
inline

◆ v_zip() [12/15]

void cv::v_zip ( const v_uint32 a0,
const v_uint32 a1,
v_uint32 b0,
v_uint32 b1 
)
inline

◆ v_zip() [13/15]

void cv::v_zip ( const v_uint32x4 a0,
const v_uint32x4 a1,
v_uint32x4 b0,
v_uint32x4 b1 
)
inline

◆ v_zip() [14/15]

void cv::v_zip ( const v_uint8 a0,
const v_uint8 a1,
v_uint8 b0,
v_uint8 b1 
)
inline

◆ v_zip() [15/15]

void cv::v_zip ( const v_uint8x16 a0,
const v_uint8x16 a1,
v_uint8x16 b0,
v_uint8x16 b1 
)
inline

◆ v_zip4() [1/3]

void cv::v_zip4 ( const v_float32 a0,
const v_float32 a1,
v_float32 b0,
v_float32 b1 
)
inline

◆ v_zip4() [2/3]

void cv::v_zip4 ( const v_int32 a0,
const v_int32 a1,
v_int32 b0,
v_int32 b1 
)
inline

◆ v_zip4() [3/3]

void cv::v_zip4 ( const v_uint32 a0,
const v_uint32 a1,
v_uint32 b0,
v_uint32 b1 
)
inline

◆ validate_input_arg()

void cv::validate_input_arg ( const GRunArg arg)

◆ validate_input_args()

void cv::validate_input_args ( const GRunArgs args)

◆ value_of()

GRunArg cv::value_of ( const GOrigin &  origin)

◆ vle16_v_i16mf2()

vint16mf2_t cv::vle16_v_i16mf2 ( const int16_t ptr,
size_t  vl 
)
inline

◆ vle16_v_u16mf2()

vuint16mf2_t cv::vle16_v_u16mf2 ( const uint16_t ptr,
size_t  vl 
)
inline

◆ vle32_v_f32mf2()

vfloat32mf2_t cv::vle32_v_f32mf2 ( const float32_t *  ptr,
size_t  vl 
)
inline

◆ vle32_v_i32mf2()

vint32mf2_t cv::vle32_v_i32mf2 ( const int32_t ptr,
size_t  vl 
)
inline

◆ vle32_v_u32mf2()

vuint32mf2_t cv::vle32_v_u32mf2 ( const uint32_t ptr,
size_t  vl 
)
inline

◆ vle64_v_f64mf2()

vfloat64mf2_t cv::vle64_v_f64mf2 ( const float64_t *  ptr,
size_t  vl 
)
inline

◆ vle64_v_i64mf2()

vint64mf2_t cv::vle64_v_i64mf2 ( const int64_t ptr,
size_t  vl 
)
inline

◆ vle64_v_u64mf2()

vuint64mf2_t cv::vle64_v_u64mf2 ( const uint64_t ptr,
size_t  vl 
)
inline

◆ vle8_v_i8mf2()

vint8mf2_t cv::vle8_v_i8mf2 ( const int8_t ptr,
size_t  vl 
)
inline

◆ vle8_v_i8mf4()

vint8mf4_t cv::vle8_v_i8mf4 ( const int8_t base,
size_t  vl 
)
inline

◆ vle8_v_u8mf2()

vuint8mf2_t cv::vle8_v_u8mf2 ( const uint8_t ptr,
size_t  vl 
)
inline

◆ vle8_v_u8mf4()

vuint8mf4_t cv::vle8_v_u8mf4 ( const uint8_t base,
size_t  vl 
)
inline

◆ vse16_v_i16mf2()

void cv::vse16_v_i16mf2 ( int16_t ptr,
vint16mf2_t  v,
size_t  vl 
)
inline

◆ vse16_v_u16mf2()

void cv::vse16_v_u16mf2 ( uint16_t ptr,
vuint16mf2_t  v,
size_t  vl 
)
inline

◆ vse32_v_f32mf2()

void cv::vse32_v_f32mf2 ( float32_t *  ptr,
vfloat32mf2_t  v,
size_t  vl 
)
inline

◆ vse32_v_i32mf2()

void cv::vse32_v_i32mf2 ( int32_t ptr,
vint32mf2_t  v,
size_t  vl 
)
inline

◆ vse32_v_u32mf2()

void cv::vse32_v_u32mf2 ( uint32_t ptr,
vuint32mf2_t  v,
size_t  vl 
)
inline

◆ vse64_v_f64mf2()

void cv::vse64_v_f64mf2 ( float64_t *  ptr,
vfloat64mf2_t  v,
size_t  vl 
)
inline

◆ vse64_v_i64mf2()

void cv::vse64_v_i64mf2 ( int64_t ptr,
vint64mf2_t  v,
size_t  vl 
)
inline

◆ vse64_v_u64mf2()

void cv::vse64_v_u64mf2 ( uint64_t ptr,
vuint64mf2_t  v,
size_t  vl 
)
inline

◆ vse8_v_i8mf2()

void cv::vse8_v_i8mf2 ( int8_t ptr,
vint8mf2_t  v,
size_t  vl 
)
inline

◆ vse8_v_u8mf2()

void cv::vse8_v_u8mf2 ( uint8_t ptr,
vuint8mf2_t  v,
size_t  vl 
)
inline

◆ vwcvt_x_x_v_i16m1()

vint16m1_t cv::vwcvt_x_x_v_i16m1 ( vint8mf2_t  v,
size_t  vl 
)
inline

◆ vwcvt_x_x_v_i16mf2()

vint16mf2_t cv::vwcvt_x_x_v_i16mf2 ( vint8mf4_t  src,
size_t  vl 
)
inline

◆ vwcvt_x_x_v_i32m1()

vint32m1_t cv::vwcvt_x_x_v_i32m1 ( vint16mf2_t  v,
size_t  vl 
)
inline

◆ vwcvt_x_x_v_i64m1()

vint64m1_t cv::vwcvt_x_x_v_i64m1 ( vint32mf2_t  v,
size_t  vl 
)
inline

◆ vwcvtu_x_x_v_u16m1()

vuint16m1_t cv::vwcvtu_x_x_v_u16m1 ( vuint8mf2_t  v,
size_t  vl 
)
inline

◆ vwcvtu_x_x_v_u16mf2()

vuint16mf2_t cv::vwcvtu_x_x_v_u16mf2 ( vuint8mf4_t  src,
size_t  vl 
)
inline

◆ vwcvtu_x_x_v_u32m1()

vuint32m1_t cv::vwcvtu_x_x_v_u32m1 ( vuint16mf2_t  v,
size_t  vl 
)
inline

◆ vwcvtu_x_x_v_u64m1()

vuint64m1_t cv::vwcvtu_x_x_v_u64m1 ( vuint32mf2_t  v,
size_t  vl 
)
inline

◆ write()

void cv::write ( FileStorage fs,
const String name,
const optflow::GPCTree::Node node 
)

Variable Documentation

◆ __cv_rvv_e16m1_nlanes

const int cv::__cv_rvv_e16m1_nlanes = vsetvlmax_e16m1()
static

◆ __cv_rvv_e16m2_nlanes

const int cv::__cv_rvv_e16m2_nlanes = vsetvlmax_e16m2()
static

◆ __cv_rvv_e16m4_nlanes

const int cv::__cv_rvv_e16m4_nlanes = vsetvlmax_e16m4()
static

◆ __cv_rvv_e16m8_nlanes

const int cv::__cv_rvv_e16m8_nlanes = vsetvlmax_e16m8()
static

◆ __cv_rvv_e32m1_nlanes

const int cv::__cv_rvv_e32m1_nlanes = vsetvlmax_e32m1()
static

◆ __cv_rvv_e32m2_nlanes

const int cv::__cv_rvv_e32m2_nlanes = vsetvlmax_e32m2()
static

◆ __cv_rvv_e32m4_nlanes

const int cv::__cv_rvv_e32m4_nlanes = vsetvlmax_e32m4()
static

◆ __cv_rvv_e32m8_nlanes

const int cv::__cv_rvv_e32m8_nlanes = vsetvlmax_e32m8()
static

◆ __cv_rvv_e64m1_nlanes

const int cv::__cv_rvv_e64m1_nlanes = vsetvlmax_e64m1()
static

◆ __cv_rvv_e64m2_nlanes

const int cv::__cv_rvv_e64m2_nlanes = vsetvlmax_e64m2()
static

◆ __cv_rvv_e64m4_nlanes

const int cv::__cv_rvv_e64m4_nlanes = vsetvlmax_e64m4()
static

◆ __cv_rvv_e64m8_nlanes

const int cv::__cv_rvv_e64m8_nlanes = vsetvlmax_e64m8()
static

◆ __cv_rvv_e8m1_nlanes

const int cv::__cv_rvv_e8m1_nlanes = vsetvlmax_e8m1()
static

◆ __cv_rvv_e8m2_nlanes

const int cv::__cv_rvv_e8m2_nlanes = vsetvlmax_e8m2()
static

◆ __cv_rvv_e8m4_nlanes

const int cv::__cv_rvv_e8m4_nlanes = vsetvlmax_e8m4()
static

◆ __cv_rvv_e8m8_nlanes

const int cv::__cv_rvv_e8m8_nlanes = vsetvlmax_e8m8()
static

◆ GKernelPackage

◆ idx_interleave_pairs

uint64_t cv::idx_interleave_pairs[]
static
Initial value:
= {
0x0705060403010200, 0x0f0d0e0c0b090a08, 0x1715161413111210, 0x1f1d1e1c1b191a18,
0x2725262423212220, 0x2f2d2e2c2b292a28, 0x3735363433313230, 0x3f3d3e3c3b393a38,
0x4745464443414240, 0x4f4d4e4c4b494a48, 0x5755565453515250, 0x5f5d5e5c5b595a58,
0x6765666463616260, 0x6f6d6e6c6b696a68, 0x7775767473717270, 0x7f7d7e7c7b797a78}

◆ idx_interleave_quads

uint64_t cv::idx_interleave_quads[]
static
Initial value:
= {
0x0703060205010400, 0x0f0b0e0a0d090c08, 0x1713161215111410, 0x1f1b1e1a1d191c18,
0x2723262225212420, 0x2f2b2e2a2d292c28, 0x3733363235313430, 0x3f3b3e3a3d393c38,
0x4743464245414440, 0x4f4b4e4a4d494c48, 0x5753565255515450, 0x5f5b5e5a5d595c58,
0x6763666265616460, 0x6f6b6e6a6d696c68, 0x7773767275717470, 0x7f7b7e7a7d797c78}

◆ popCountTable [1/2]

const unsigned char cv::popCountTable[256]
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,
}

◆ popCountTable [2/2]

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