"black box" representation of the file storage associated with a file on disk.
More...
|
| 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 _Tp * | alignPtr (_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< AffineTransformer > | createAffineTransformer (bool fullAffine) |
| |
| Ptr< AlignMTB > | createAlignMTB (int max_bits=6, int exclude_range=4, bool cut=true) |
| | Creates AlignMTB object.
|
| |
| Ptr< BackgroundSubtractorKNN > | createBackgroundSubtractorKNN (int history=500, double dist2Threshold=400.0, bool detectShadows=true) |
| | Creates KNN Background Subtractor.
|
| |
| Ptr< BackgroundSubtractorMOG2 > | createBackgroundSubtractorMOG2 (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< CalibrateDebevec > | createCalibrateDebevec (int samples=70, float lambda=10.0f, bool random=false) |
| | Creates CalibrateDebevec object.
|
| |
| Ptr< CalibrateRobertson > | createCalibrateRobertson (int max_iter=30, float threshold=0.01f) |
| | Creates CalibrateRobertson object.
|
| |
| Ptr< HistogramCostExtractor > | createChiHistogramCostExtractor (int nDummies=25, float defaultCost=0.2f) |
| |
| Ptr< CLAHE > | createCLAHE (double clipLimit=40.0, Size tileGridSize=Size(8, 8)) |
| | Creates a smart pointer to a cv::CLAHE class and initializes it.
|
| |
| Ptr< HistogramCostExtractor > | createEMDHistogramCostExtractor (int flag=DIST_L2, int nDummies=25, float defaultCost=0.2f) |
| |
| Ptr< HistogramCostExtractor > | createEMDL1HistogramCostExtractor (int nDummies=25, float defaultCost=0.2f) |
| |
| Ptr< BaseCascadeClassifier::MaskGenerator > | createFaceDetectionMaskGenerator () |
| |
| Ptr< GeneralizedHoughBallard > | createGeneralizedHoughBallard () |
| | Creates a smart pointer to a cv::GeneralizedHoughBallard class and initializes it.
|
| |
| Ptr< GeneralizedHoughGuil > | createGeneralizedHoughGuil () |
| | 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< HausdorffDistanceExtractor > | createHausdorffDistanceExtractor (int distanceFlag=cv::NORM_L2, float rankProp=0.6f) |
| |
| Ptr< LineSegmentDetector > | createLineSegmentDetector (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< MergeDebevec > | createMergeDebevec () |
| | Creates MergeDebevec object.
|
| |
| Ptr< MergeMertens > | createMergeMertens (float contrast_weight=1.0f, float saturation_weight=1.0f, float exposure_weight=0.0f) |
| | Creates MergeMertens object.
|
| |
| Ptr< MergeRobertson > | createMergeRobertson () |
| | Creates MergeRobertson object.
|
| |
| Ptr< HistogramCostExtractor > | createNormHistogramCostExtractor (int flag=DIST_L2, int nDummies=25, float defaultCost=0.2f) |
| |
| Ptr< ShapeContextDistanceExtractor > | createShapeContextDistanceExtractor (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< Stitcher > | createStitcher (bool try_use_gpu=false) |
| |
| Ptr< Stitcher > | createStitcherScans (bool try_use_gpu=false) |
| |
| Ptr< ThinPlateSplineShapeTransformer > | createThinPlateSplineShapeTransformer (double regularizationParameter=0) |
| |
| Ptr< Tonemap > | createTonemap (float gamma=1.0f) |
| | Creates simple linear mapper with gamma correction.
|
| |
| Ptr< TonemapDrago > | createTonemapDrago (float gamma=1.0f, float saturation=1.0f, float bias=0.85f) |
| | Creates TonemapDrago object.
|
| |
| Ptr< TonemapMantiuk > | createTonemapMantiuk (float gamma=1.0f, float scale=0.7f, float saturation=1.0f) |
| | Creates TonemapMantiuk object.
|
| |
| Ptr< TonemapReinhard > | createTonemapReinhard (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 ¶ms) |
| |
| 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 ¶meters) |
| | 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 ¶ms) |
| |
| 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 ¶ms) |
| |
| 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 ¶ms) |
| |
| 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 String & | getBuildInformation () |
| | 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 > ¶ms=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 > ¶ms=std::vector< int >()) |
| | Saves an image to a specified file.
|
| |
| static CV_WRAP bool | imwritemulti (const String &filename, InputArrayOfArrays img, const std::vector< int > ¶ms=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< _Tp > | makePtr (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 ¢er, 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_float32x4 & | operator&= (v_float32x4 &a, const v_float32x4 &b) |
| |
| v_float64x2 & | operator&= (v_float64x2 &a, const v_float64x2 &b) |
| |
| v_int16x8 & | operator&= (v_int16x8 &a, const v_int16x8 &b) |
| |
| v_int32x4 & | operator&= (v_int32x4 &a, const v_int32x4 &b) |
| |
| v_int64x2 & | operator&= (v_int64x2 &a, const v_int64x2 &b) |
| |
| v_int8x16 & | operator&= (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_uint16x8 & | operator&= (v_uint16x8 &a, const v_uint16x8 &b) |
| |
| v_uint32x4 & | operator&= (v_uint32x4 &a, const v_uint32x4 &b) |
| |
| v_uint64x2 & | operator&= (v_uint64x2 &a, const v_uint64x2 &b) |
| |
| v_uint8x16 & | operator&= (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_float32x4 & | operator*= (v_float32x4 &a, const v_float32x4 &b) |
| |
| v_float64x2 & | operator*= (v_float64x2 &a, const v_float64x2 &b) |
| |
| v_int16x8 & | operator*= (v_int16x8 &a, const v_int16x8 &b) |
| |
| v_int32x4 & | operator*= (v_int32x4 &a, const v_int32x4 &b) |
| |
| v_int64x2 & | operator*= (v_int64x2 &a, const v_int64x2 &b) |
| |
| v_int8x16 & | operator*= (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_uint16x8 & | operator*= (v_uint16x8 &a, const v_uint16x8 &b) |
| |
| v_uint32x4 & | operator*= (v_uint32x4 &a, const v_uint32x4 &b) |
| |
| v_uint64x2 & | operator*= (v_uint64x2 &a, const v_uint64x2 &b) |
| |
| v_uint8x16 & | operator*= (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::GCompileArgs & | operator+= (cv::GCompileArgs &lhs, const cv::GCompileArgs &rhs) |
| |
| template<typename Tg > |
| cv::GIOProtoArgs< Tg > & | operator+= (cv::GIOProtoArgs< Tg > &lhs, const cv::GIOProtoArgs< Tg > &rhs) |
| |
| GRunArgs & | operator+= (GRunArgs &lhs, const GRunArgs &rhs) |
| | This operator allows to complement the input vector at runtime.
|
| |
| GRunArgsP & | operator+= (GRunArgsP &lhs, const GRunArgsP &rhs) |
| | This operator allows to complement the output vector at runtime.
|
| |
| v_float32x4 & | operator+= (v_float32x4 &a, const v_float32x4 &b) |
| |
| v_float64x2 & | operator+= (v_float64x2 &a, const v_float64x2 &b) |
| |
| v_int16x8 & | operator+= (v_int16x8 &a, const v_int16x8 &b) |
| |
| v_int32x4 & | operator+= (v_int32x4 &a, const v_int32x4 &b) |
| |
| v_int64x2 & | operator+= (v_int64x2 &a, const v_int64x2 &b) |
| |
| v_int8x16 & | operator+= (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_uint16x8 & | operator+= (v_uint16x8 &a, const v_uint16x8 &b) |
| |
| v_uint32x4 & | operator+= (v_uint32x4 &a, const v_uint32x4 &b) |
| |
| v_uint64x2 & | operator+= (v_uint64x2 &a, const v_uint64x2 &b) |
| |
| v_uint8x16 & | operator+= (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_float32x4 & | operator-= (v_float32x4 &a, const v_float32x4 &b) |
| |
| v_float64x2 & | operator-= (v_float64x2 &a, const v_float64x2 &b) |
| |
| v_int16x8 & | operator-= (v_int16x8 &a, const v_int16x8 &b) |
| |
| v_int32x4 & | operator-= (v_int32x4 &a, const v_int32x4 &b) |
| |
| v_int64x2 & | operator-= (v_int64x2 &a, const v_int64x2 &b) |
| |
| v_int8x16 & | operator-= (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_uint16x8 & | operator-= (v_uint16x8 &a, const v_uint16x8 &b) |
| |
| v_uint32x4 & | operator-= (v_uint32x4 &a, const v_uint32x4 &b) |
| |
| v_uint64x2 & | operator-= (v_uint64x2 &a, const v_uint64x2 &b) |
| |
| v_uint8x16 & | operator-= (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_float32x4 & | operator/= (v_float32x4 &a, const v_float32x4 &b) |
| |
| v_float64x2 & | operator/= (v_float64x2 &a, const v_float64x2 &b) |
| |
| v_int16x8 & | operator/= (v_int16x8 &a, const v_int16x8 &b) |
| |
| v_int32x4 & | operator/= (v_int32x4 &a, const v_int32x4 &b) |
| |
| v_int64x2 & | operator/= (v_int64x2 &a, const v_int64x2 &b) |
| |
| v_int8x16 & | operator/= (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_uint16x8 & | operator/= (v_uint16x8 &a, const v_uint16x8 &b) |
| |
| v_uint32x4 & | operator/= (v_uint32x4 &a, const v_uint32x4 &b) |
| |
| v_uint64x2 & | operator/= (v_uint64x2 &a, const v_uint64x2 &b) |
| |
| v_uint8x16 & | operator/= (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 String & | operator<< (String &out, const Mat &mtx) |
| |
| static String & | operator<< (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_float32x4 & | operator^= (v_float32x4 &a, const v_float32x4 &b) |
| |
| v_float64x2 & | operator^= (v_float64x2 &a, const v_float64x2 &b) |
| |
| v_int16x8 & | operator^= (v_int16x8 &a, const v_int16x8 &b) |
| |
| v_int32x4 & | operator^= (v_int32x4 &a, const v_int32x4 &b) |
| |
| v_int64x2 & | operator^= (v_int64x2 &a, const v_int64x2 &b) |
| |
| v_int8x16 & | operator^= (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_uint16x8 & | operator^= (v_uint16x8 &a, const v_uint16x8 &b) |
| |
| v_uint32x4 & | operator^= (v_uint32x4 &a, const v_uint32x4 &b) |
| |
| v_uint64x2 & | operator^= (v_uint64x2 &a, const v_uint64x2 &b) |
| |
| v_uint8x16 & | operator^= (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_float32x4 & | operator|= (v_float32x4 &a, const v_float32x4 &b) |
| |
| v_float64x2 & | operator|= (v_float64x2 &a, const v_float64x2 &b) |
| |
| v_int16x8 & | operator|= (v_int16x8 &a, const v_int16x8 &b) |
| |
| v_int32x4 & | operator|= (v_int32x4 &a, const v_int32x4 &b) |
| |
| v_int64x2 & | operator|= (v_int64x2 &a, const v_int64x2 &b) |
| |
| v_int8x16 & | operator|= (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_uint16x8 & | operator|= (v_uint16x8 &a, const v_uint16x8 &b) |
| |
| v_uint32x4 & | operator|= (v_uint32x4 &a, const v_uint32x4 &b) |
| |
| v_uint64x2 & | operator|= (v_uint64x2 &a, const v_uint64x2 &b) |
| |
| v_uint8x16 & | operator|= (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 ¶ms=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.
|
| |
| RNG & | theRNG () |
| | 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.
|
| |
|
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 () |
| |
|
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) |
| |
|
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) |
| |
|
|
| 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) |
| |
|
|
| 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) |
| |
|
|
| 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 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 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) |
| |
|
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) |
| |
|
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 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) |
| |
