Namespace where all the C++ OpenCV functionality resides. More...
Namespaces | |
detail | |
flann | |
gpu | |
linemod | |
ocl | |
of2 | |
ogl | |
RenderMode | |
render mode | |
superres | |
videostab | |
Classes | |
class | _InputArray |
Proxy datatype for passing Mat's and vector<>'s as input parameters. More... | |
class | _OutputArray |
Proxy datatype for passing Mat's and vector<>'s as input parameters. More... | |
struct | Accumulator |
struct | Accumulator< char > |
struct | Accumulator< short > |
struct | Accumulator< unsigned char > |
struct | Accumulator< unsigned short > |
class | AdjusterAdapter |
A feature detector parameter adjuster, this is used by the DynamicAdaptedFeatureDetector and is a wrapper for FeatureDetector that allow them to be adjusted after a detection. More... | |
class | Affine3 |
class | Algorithm |
Base class for high-level OpenCV algorithms. More... | |
class | AlgorithmInfo |
class | Allocator |
The STL-compilant memory Allocator based on cv::fastMalloc() and cv::fastFree() More... | |
class | AutoBuffer |
Automatically Allocated Buffer Class. More... | |
class | AutoLock |
class | BackgroundSubtractor |
The Base Class for Background/Foreground Segmentation. More... | |
class | BackgroundSubtractorGMG |
class | BackgroundSubtractorMOG |
Gaussian Mixture-based Backbround/Foreground Segmentation Algorithm. More... | |
class | BackgroundSubtractorMOG2 |
The class implements the following algorithm: "Improved adaptive Gausian mixture model for background subtraction" Z.Zivkovic International Conference Pattern Recognition, UK, August, 2004. More... | |
class | BaseColumnFilter |
The Base Class for Column-wise Filters. More... | |
class | BaseFilter |
The Base Class for Non-Separable 2D Filters. More... | |
struct | BaseKeypoint |
class | BaseRowFilter |
The Base Class for 1D or Row-wise Filters. More... | |
class | BFMatcher |
class | BlockedRange |
class | BOWImgDescriptorExtractor |
class | BOWKMeansTrainer |
class | BOWTrainer |
class | BriefDescriptorExtractor |
class | BRISK |
BRISK implementation. More... | |
class | BruteForceMatcher |
class | CalonderDescriptorExtractor |
class | CascadeClassifier |
class | CLAHE |
class | CommandLineParser |
"\nThe CommandLineParser class is designed for command line arguments parsing\n" "Keys map: \n" "Before you start to work with CommandLineParser you have to create a map for keys.\n" " It will look like this\n" " const char* keys =\n" " {\n" " { s| string| 123asd |string parameter}\n" " { d| digit | 100 |digit parameter }\n" " { c|noCamera|false |without camera }\n" " { 1| |some text|help }\n" " { 2| |333 |another help }\n" " };\n" "Usage syntax: \n" " \"{" - start of parameter string. " " "}" - end of parameter string " " "|" - separator between short name, full name, default value and help " "Supported syntax: " " --key1=arg1 <If a key with '--' must has an argument " " you have to assign it through '=' sign.> " "<If the key with '--' doesn't have any argument, it means that it is a bool key> " " -key2=arg2 <If a key with '-' must has an argument " " you have to assign it through '=' sign.> " "If the key with '-' doesn't have any argument, it means that it is a bool key " " key3 <This key can't has any parameter> " "Usage: " " Imagine that the input parameters are next: " " -s=string_value --digit=250 --noCamera lena.jpg 10000 " " CommandLineParser parser(argc, argv, keys) - create a parser object " " parser.get<string>("s" or "string") will return you first parameter value " " parser.get<string>("s", false or "string", false) will return you first parameter value " " without spaces in end and begin " " parser.get<int>("d" or "digit") will return you second parameter value. " " It also works with 'unsigned int', 'double', and 'float' types> " " parser.get<bool>("c" or "noCamera") will return you true . " " If you enter this key in commandline> " " It return you false otherwise. " " parser.get<string>("1") will return you the first argument without parameter (lena.jpg) " " parser.get<int>("2") will return you the second argument without parameter (10000) " " It also works with 'unsigned int', 'double', and 'float' types " More... | |
class | Complex |
A complex number class. More... | |
class | CompressedRectilinearPortraitWarper |
class | CompressedRectilinearWarper |
class | CvAffinePose |
class | CvFeatureTracker |
struct | CvFeatureTrackerParams |
class | CvHybridTracker |
struct | CvHybridTrackerParams |
class | CvMeanShiftTracker |
struct | CvMeanShiftTrackerParams |
struct | CvMotionModel |
class | CylindricalWarper |
class | CylindricalWarperGpu |
class | DataDepth |
A helper class for cv::DataType. More... | |
class | DataDepth< _Tp * > |
class | DataDepth< bool > |
class | DataDepth< char > |
class | DataDepth< double > |
class | DataDepth< float > |
class | DataDepth< int > |
class | DataDepth< schar > |
class | DataDepth< short > |
class | DataDepth< uchar > |
class | DataDepth< unsigned > |
class | DataDepth< ushort > |
class | DataType |
Informative template class for OpenCV "scalars". More... | |
class | DataType< Affine3< _Tp > > |
class | DataType< bool > |
class | DataType< char > |
class | DataType< Complex< _Tp > > |
class | DataType< double > |
class | DataType< float > |
class | DataType< int > |
class | DataType< Matx< _Tp, m, n > > |
class | DataType< Point3_< _Tp > > |
class | DataType< Point_< _Tp > > |
class | DataType< Range > |
class | DataType< Rect_< _Tp > > |
class | DataType< Scalar_< _Tp > > |
class | DataType< schar > |
class | DataType< short > |
class | DataType< Size_< _Tp > > |
class | DataType< std::complex< _Tp > > |
class | DataType< uchar > |
class | DataType< ushort > |
class | DataType< Vec< _Tp, cn > > |
class | DenseFeatureDetector |
class | DenseOpticalFlow |
class | DescriptorExtractor |
class | DescriptorMatcher |
struct | DetectionROI |
class | Directory |
struct | DMatch |
struct | DrawMatchesFlags |
class | DynamicAdaptedFeatureDetector |
an adaptively adjusting detector that iteratively detects until the desired number of features are detected. Beware that this is not thread safe - as the adjustment of parameters breaks the const of the detection routine... /TODO Make this const correct and thread safe More... | |
class | EM |
class | Exception |
The standard OpenCV exception class. More... | |
class | FaceRecognizer |
class | FastAdjuster |
an adjust for the FAST detector. This will basically decrement or increment the threshold by 1 More... | |
class | FastFeatureDetector |
class | Feature2D |
class | FeatureDetector |
class | FeatureEvaluator |
class | FernClassifier |
class | FernDescriptorMatcher |
class | FileNode |
File Storage Node class. More... | |
class | FileNodeIterator |
File Node Iterator. More... | |
class | FileStorage |
XML/YAML File Storage Class. More... | |
class | FilterEngine |
The Main Class for Image Filtering. More... | |
class | FisheyeWarper |
class | FlannBasedMatcher |
struct | Formatted |
class | Formatter |
class | FREAK |
FREAK implementation. More... | |
class | GeneralizedHough |
class | GenericDescriptorMatcher |
class | GFTTDetector |
class | GlArrays |
OpenGL Arrays. More... | |
class | GlBuffer |
Smart pointer for OpenGL buffer memory with reference counting. More... | |
class | GlCamera |
OpenGL camera. More... | |
class | GlFont |
OpenGL Font. More... | |
class | GlTexture |
Smart pointer for OpenGL 2d texture memory with reference counting. More... | |
class | GreaterEq |
class | GreaterEqIdx |
class | GridAdaptedFeatureDetector |
struct | Hamming |
struct | HammingMultilevel |
struct | HOGDescriptor |
class | KalmanFilter |
Kalman filter. More... | |
class | KDTree |
Fast Nearest Neighbor Search Class. More... | |
class | KeyPoint |
The Keypoint Class. More... | |
class | KeyPointsFilter |
struct | L1 |
struct | L2 |
class | LatentSvmDetector |
class | LDA |
class | LDetector |
class | LessThan |
class | LessThanIdx |
class | LevMarqSparse |
class | LineIterator |
Line iterator class. More... | |
class | LogPolar_Adjacent |
class | LogPolar_Interp |
class | LogPolar_Overlapping |
class | Mat |
The n-dimensional matrix class. More... | |
class | Mat_ |
Template matrix class derived from Mat. More... | |
class | MatAllocator |
Custom array allocator. More... | |
class | MatCommaInitializer_ |
Comma-separated Matrix Initializer. More... | |
class | MatConstIterator |
class | MatConstIterator_ |
Matrix read-only iterator. More... | |
class | MatExpr |
class | MatIterator_ |
Matrix read-write iterator. More... | |
class | MatOp |
class | MatOp_Iter_ |
class | Matx |
struct | Matx_AddOp |
A short numerical vector. More... | |
struct | Matx_DetOp |
struct | Matx_DetOp< _Tp, 1 > |
struct | Matx_DetOp< _Tp, 2 > |
struct | Matx_DetOp< _Tp, 3 > |
struct | Matx_FastInvOp |
struct | Matx_FastInvOp< _Tp, 2 > |
struct | Matx_FastInvOp< _Tp, 3 > |
struct | Matx_FastSolveOp |
struct | Matx_FastSolveOp< _Tp, 2, 1 > |
struct | Matx_FastSolveOp< _Tp, 3, 1 > |
struct | Matx_MatMulOp |
struct | Matx_MulOp |
struct | Matx_ScaleOp |
struct | Matx_SubOp |
struct | Matx_TOp |
class | MatxCommaInitializer |
class | MercatorWarper |
class | Mesh3D |
class | Moments |
raster image moments More... | |
class | MSER |
Maximal Stable Extremal Regions class. More... | |
class | Mutex |
class | NAryMatIterator |
n-Dimensional Dense Matrix Iterator Class. More... | |
class | Octree |
class | OneWayDescriptor |
class | OneWayDescriptorBase |
class | OneWayDescriptorMatcher |
class | OneWayDescriptorObject |
class | OpponentColorDescriptorExtractor |
class | ORB |
ORB implementation. More... | |
class | PaniniPortraitWarper |
class | PaniniWarper |
class | ParallelLoopBody |
struct | Param |
struct | ParamType |
struct | ParamType< Algorithm > |
struct | ParamType< bool > |
struct | ParamType< double > |
struct | ParamType< float > |
struct | ParamType< int > |
struct | ParamType< Mat > |
struct | ParamType< short > |
struct | ParamType< string > |
struct | ParamType< uchar > |
struct | ParamType< uint64 > |
struct | ParamType< unsigned > |
struct | ParamType< vector< Mat > > |
class | PatchGenerator |
The Patch Generator class. More... | |
class | PCA |
Principal Component Analysis. More... | |
class | PlanarObjectDetector |
class | PlaneWarper |
class | PlaneWarperGpu |
class | Point3_ |
template 3D point class. More... | |
class | Point_ |
template 2D point class. More... | |
class | Ptr |
Smart pointer to dynamically allocated objects. More... | |
class | PyramidAdaptedFeatureDetector |
class | RandomizedTree |
class | Range |
The 2D range class. More... | |
class | Rect_ |
The 2D up-right rectangle class. More... | |
class | Retina |
class | RNG |
Random Number Generator. More... | |
class | RNG_MT19937 |
Random Number Generator - MT. More... | |
class | RotatedRect |
The rotated 2D rectangle. More... | |
class | RTreeClassifier |
struct | RTreeNode |
struct | RTTIImpl |
class | Scalar_ |
The template scalar class. More... | |
class | SelfSimDescriptor |
class | Seq |
Template Sequence Class derived from CvSeq. More... | |
class | SeqIterator |
STL-style Sequence Iterator inherited from the CvSeqReader structure. More... | |
class | SIFT |
SIFT implementation. More... | |
class | SimilarRects |
class | SimpleBlobDetector |
class | Size_ |
The 2D size class. More... | |
struct | SL2 |
class | SparseMat |
Sparse matrix class. More... | |
class | SparseMat_ |
The Template Sparse Matrix class derived from cv::SparseMat. More... | |
class | SparseMatConstIterator |
Read-Only Sparse Matrix Iterator. More... | |
class | SparseMatConstIterator_ |
Template Read-Only Sparse Matrix Iterator Class. More... | |
class | SparseMatIterator |
Read-write Sparse Matrix Iterator. More... | |
class | SparseMatIterator_ |
Template Read-Write Sparse Matrix Iterator Class. More... | |
class | SphericalWarper |
class | SphericalWarperGpu |
class | SpinImageModel |
class | Split |
class | StarAdjuster |
class | StarDetector |
The "Star" Detector. More... | |
class | StereoBM |
Block Matching Stereo Correspondence Algorithm. More... | |
class | StereographicWarper |
class | StereoSGBM |
Semi-Global Block Matching Stereo Correspondence Algorithm. More... | |
class | StereoVar |
class | Stitcher |
class | Subdiv2D |
class | SURF |
SURF implementation. More... | |
class | SurfAdjuster |
class | SVD |
Singular Value Decomposition class. More... | |
class | TermCriteria |
Termination criteria in iterative algorithms. More... | |
class | TickMeter |
class | TLSData |
class | TLSDataContainer |
class | TransverseMercatorWarper |
class | Vec |
A short numerical vector. More... | |
class | VecCommaInitializer |
class | VecReaderProxy |
class | VecReaderProxy< _Tp, 1 > |
class | Vector |
class | VectorDescriptorMatcher |
class | VecWriterProxy |
class | VecWriterProxy< _Tp, 1 > |
class | VideoCapture |
class | VideoWriter |
class | WarperCreator |
class | WImage |
class | WImageBuffer |
class | WImageBufferC |
class | WImageC |
class | WImageView |
class | WImageViewC |
class | WriteStructContext |
Functions | |
CV_EXPORTS_W void | Rodrigues (InputArray src, OutputArray dst, OutputArray jacobian=noArray()) |
converts rotation vector to rotation matrix or vice versa using Rodrigues transformation More... | |
CV_EXPORTS_W Mat | findHomography (InputArray srcPoints, InputArray dstPoints, int method=0, double ransacReprojThreshold=3, OutputArray mask=noArray()) |
computes the best-fit perspective transformation mapping srcPoints to dstPoints. More... | |
CV_EXPORTS Mat | findHomography (InputArray srcPoints, InputArray dstPoints, OutputArray mask, int method=0, double ransacReprojThreshold=3) |
variant of findHomography for backward compatibility More... | |
CV_EXPORTS_W Vec3d | RQDecomp3x3 (InputArray src, OutputArray mtxR, OutputArray mtxQ, OutputArray Qx=noArray(), OutputArray Qy=noArray(), OutputArray Qz=noArray()) |
Computes RQ decomposition of 3x3 matrix. More... | |
CV_EXPORTS_W void | decomposeProjectionMatrix (InputArray projMatrix, OutputArray cameraMatrix, OutputArray rotMatrix, OutputArray transVect, OutputArray rotMatrixX=noArray(), OutputArray rotMatrixY=noArray(), OutputArray rotMatrixZ=noArray(), OutputArray eulerAngles=noArray()) |
Decomposes the projection matrix into camera matrix and the rotation martix and the translation vector. More... | |
CV_EXPORTS_W void | matMulDeriv (InputArray A, InputArray B, OutputArray dABdA, OutputArray dABdB) |
computes derivatives of the matrix product w.r.t each of the multiplied matrix coefficients More... | |
CV_EXPORTS_W 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()) |
composes 2 [R|t] transformations together. Also computes the derivatives of the result w.r.t the arguments More... | |
CV_EXPORTS_W void | projectPoints (InputArray objectPoints, InputArray rvec, InputArray tvec, InputArray cameraMatrix, InputArray distCoeffs, OutputArray imagePoints, OutputArray jacobian=noArray(), double aspectRatio=0) |
projects points from the model coordinate space to the image coordinates. Also computes derivatives of the image coordinates w.r.t the intrinsic and extrinsic camera parameters More... | |
CV_EXPORTS_W bool | solvePnP (InputArray objectPoints, InputArray imagePoints, InputArray cameraMatrix, InputArray distCoeffs, OutputArray rvec, OutputArray tvec, bool useExtrinsicGuess=false, int flags=ITERATIVE) |
CV_EXPORTS_W void | solvePnPRansac (InputArray objectPoints, InputArray imagePoints, InputArray cameraMatrix, InputArray distCoeffs, OutputArray rvec, OutputArray tvec, bool useExtrinsicGuess=false, int iterationsCount=100, float reprojectionError=8.0, int minInliersCount=100, OutputArray inliers=noArray(), int flags=ITERATIVE) |
computes the camera pose from a few 3D points and the corresponding projections. The outliers are possible. More... | |
CV_EXPORTS_W Mat | initCameraMatrix2D (InputArrayOfArrays objectPoints, InputArrayOfArrays imagePoints, Size imageSize, double aspectRatio=1.) |
initializes camera matrix from a few 3D points and the corresponding projections. More... | |
CV_EXPORTS_W bool | findChessboardCorners (InputArray image, Size patternSize, OutputArray corners, int flags=CALIB_CB_ADAPTIVE_THRESH+CALIB_CB_NORMALIZE_IMAGE) |
finds checkerboard pattern of the specified size in the image More... | |
CV_EXPORTS bool | find4QuadCornerSubpix (InputArray img, InputOutputArray corners, Size region_size) |
finds subpixel-accurate positions of the chessboard corners More... | |
CV_EXPORTS_W void | drawChessboardCorners (InputOutputArray image, Size patternSize, InputArray corners, bool patternWasFound) |
draws the checkerboard pattern (found or partly found) in the image More... | |
CV_EXPORTS_W bool | findCirclesGrid (InputArray image, Size patternSize, OutputArray centers, int flags=CALIB_CB_SYMMETRIC_GRID, const Ptr< FeatureDetector > &blobDetector=new SimpleBlobDetector()) |
finds circles' grid pattern of the specified size in the image More... | |
CV_EXPORTS_W bool | findCirclesGridDefault (InputArray image, Size patternSize, OutputArray centers, int flags=CALIB_CB_SYMMETRIC_GRID) |
the deprecated function. Use findCirclesGrid() instead of it. More... | |
CV_EXPORTS_W double | calibrateCamera (InputArrayOfArrays objectPoints, InputArrayOfArrays imagePoints, Size imageSize, CV_OUT InputOutputArray cameraMatrix, CV_OUT InputOutputArray distCoeffs, OutputArrayOfArrays rvecs, OutputArrayOfArrays tvecs, int flags=0, TermCriteria criteria=TermCriteria(TermCriteria::COUNT+TermCriteria::EPS, 30, DBL_EPSILON)) |
finds intrinsic and extrinsic camera parameters from several fews of a known calibration pattern. More... | |
CV_EXPORTS_W void | calibrationMatrixValues (InputArray cameraMatrix, Size imageSize, double apertureWidth, double apertureHeight, CV_OUT double &fovx, CV_OUT double &fovy, CV_OUT double &focalLength, CV_OUT Point2d &principalPoint, CV_OUT double &aspectRatio) |
computes several useful camera characteristics from the camera matrix, camera frame resolution and the physical sensor size. More... | |
CV_EXPORTS_W double | stereoCalibrate (InputArrayOfArrays objectPoints, InputArrayOfArrays imagePoints1, InputArrayOfArrays imagePoints2, CV_OUT InputOutputArray cameraMatrix1, CV_OUT InputOutputArray distCoeffs1, CV_OUT InputOutputArray cameraMatrix2, CV_OUT InputOutputArray distCoeffs2, Size imageSize, OutputArray R, OutputArray T, OutputArray E, OutputArray F, TermCriteria criteria=TermCriteria(TermCriteria::COUNT+TermCriteria::EPS, 30, 1e-6), int flags=CALIB_FIX_INTRINSIC) |
finds intrinsic and extrinsic parameters of a stereo camera More... | |
CV_EXPORTS_W 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(), CV_OUT Rect *validPixROI1=0, CV_OUT Rect *validPixROI2=0) |
computes the rectification transformation for a stereo camera from its intrinsic and extrinsic parameters More... | |
CV_EXPORTS_W bool | stereoRectifyUncalibrated (InputArray points1, InputArray points2, InputArray F, Size imgSize, OutputArray H1, OutputArray H2, double threshold=5) |
computes the rectification transformation for an uncalibrated stereo camera (zero distortion is assumed) More... | |
CV_EXPORTS_W 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, CV_OUT Rect *roi1, CV_OUT Rect *roi2, int flags) |
computes the rectification transformations for 3-head camera, where all the heads are on the same line. More... | |
CV_EXPORTS_W Mat | getOptimalNewCameraMatrix (InputArray cameraMatrix, InputArray distCoeffs, Size imageSize, double alpha, Size newImgSize=Size(), CV_OUT Rect *validPixROI=0, bool centerPrincipalPoint=false) |
returns the optimal new camera matrix More... | |
CV_EXPORTS_W void | convertPointsToHomogeneous (InputArray src, OutputArray dst) |
converts point coordinates from normal pixel coordinates to homogeneous coordinates ((x,y)->(x,y,1)) More... | |
CV_EXPORTS_W void | convertPointsFromHomogeneous (InputArray src, OutputArray dst) |
converts point coordinates from homogeneous to normal pixel coordinates ((x,y,z)->(x/z, y/z)) More... | |
CV_EXPORTS void | convertPointsHomogeneous (InputArray src, OutputArray dst) |
for backward compatibility More... | |
CV_EXPORTS_W Mat | findFundamentalMat (InputArray points1, InputArray points2, int method=FM_RANSAC, double param1=3., double param2=0.99, OutputArray mask=noArray()) |
finds fundamental matrix from a set of corresponding 2D points More... | |
CV_EXPORTS Mat | findFundamentalMat (InputArray points1, InputArray points2, OutputArray mask, int method=FM_RANSAC, double param1=3., double param2=0.99) |
variant of findFundamentalMat for backward compatibility More... | |
CV_EXPORTS_W void | computeCorrespondEpilines (InputArray points, int whichImage, InputArray F, OutputArray lines) |
finds coordinates of epipolar lines corresponding the specified points More... | |
CV_EXPORTS_W void | triangulatePoints (InputArray projMatr1, InputArray projMatr2, InputArray projPoints1, InputArray projPoints2, OutputArray points4D) |
CV_EXPORTS_W void | correctMatches (InputArray F, InputArray points1, InputArray points2, OutputArray newPoints1, OutputArray newPoints2) |
CV_EXPORTS_W void | filterSpeckles (InputOutputArray img, double newVal, int maxSpeckleSize, double maxDiff, InputOutputArray buf=noArray()) |
filters off speckles (small regions of incorrectly computed disparity) More... | |
CV_EXPORTS_W Rect | getValidDisparityROI (Rect roi1, Rect roi2, int minDisparity, int numberOfDisparities, int SADWindowSize) |
computes valid disparity ROI from the valid ROIs of the rectified images (that are returned by cv::stereoRectify()) More... | |
CV_EXPORTS_W 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 More... | |
CV_EXPORTS_W void | reprojectImageTo3D (InputArray disparity, OutputArray _3dImage, InputArray Q, bool handleMissingValues=false, int ddepth=-1) |
reprojects disparity image to 3D: (x,y,d)->(X,Y,Z) using the matrix Q returned by cv::stereoRectify More... | |
CV_EXPORTS_W int | estimateAffine3D (InputArray src, InputArray dst, OutputArray out, OutputArray inliers, double ransacThreshold=3, double confidence=0.99) |
CV_EXPORTS std::ostream & | operator<< (std::ostream &out, const TickMeter &tm) |
CV_EXPORTS_W int | chamerMatching (Mat &img, Mat &templ, CV_OUT vector< vector< Point > > &results, CV_OUT vector< float > &cost, double templScale=1, int maxMatches=20, double minMatchDistance=1.0, int padX=3, int padY=3, int scales=5, double minScale=0.6, double maxScale=1.6, double orientationWeight=0.5, double truncate=20) |
CV_EXPORTS void | polyfit (const Mat &srcx, const Mat &srcy, Mat &dst, int order) |
CV_EXPORTS void | generateColors (std::vector< Scalar > &colors, size_t count, size_t factor=100) |
CV_EXPORTS bool | RGBDOdometry (Mat &Rt, const Mat &initRt, const Mat &image0, const Mat &depth0, const Mat &mask0, const Mat &image1, const Mat &depth1, const Mat &mask1, const Mat &cameraMatrix, float minDepth=0.f, float maxDepth=4.f, float maxDepthDiff=0.07f, const std::vector< int > &iterCounts=std::vector< int >(), const std::vector< float > &minGradientMagnitudes=std::vector< float >(), int transformType=RIGID_BODY_MOTION) |
CV_EXPORTS Mat | subspaceProject (InputArray W, InputArray mean, InputArray src) |
CV_EXPORTS Mat | subspaceReconstruct (InputArray W, InputArray mean, InputArray src) |
CV_EXPORTS_W Ptr< FaceRecognizer > | createEigenFaceRecognizer (int num_components=0, double threshold=DBL_MAX) |
CV_EXPORTS_W Ptr< FaceRecognizer > | createFisherFaceRecognizer (int num_components=0, double threshold=DBL_MAX) |
CV_EXPORTS_W Ptr< FaceRecognizer > | createLBPHFaceRecognizer (int radius=1, int neighbors=8, int grid_x=8, int grid_y=8, double threshold=DBL_MAX) |
CV_EXPORTS_W void | applyColorMap (InputArray src, OutputArray dst, int colormap) |
CV_EXPORTS bool | initModule_contrib () |
CV_EXPORTS string | fromUtf16 (const WString &str) |
CV_EXPORTS WString | toUtf16 (const string &str) |
CV_EXPORTS string | format (const char *fmt,...) |
CV_EXPORTS string | tempfile (const char *suffix CV_DEFAULT(0)) |
CV_EXPORTS void | error (const Exception &exc) |
Signals an error and raises the exception. More... | |
CV_EXPORTS bool | setBreakOnError (bool flag) |
Sets/resets the break-on-error mode. More... | |
CV_EXPORTS ErrorCallback | redirectError (ErrorCallback errCallback, void *userdata=0, void **prevUserdata=0) |
Sets the new error handler and the optional user data. More... | |
CV_EXPORTS void | glob (String pattern, std::vector< String > &result, bool recursive=false) |
CV_EXPORTS void | setNumThreads (int nthreads) |
CV_EXPORTS int | getNumThreads () |
CV_EXPORTS int | getThreadNum () |
CV_EXPORTS_W const string & | getBuildInformation () |
CV_EXPORTS_W int64 | getTickCount () |
Returns the number of ticks. More... | |
CV_EXPORTS_W double | getTickFrequency () |
Returns the number of ticks per seconds. More... | |
CV_EXPORTS_W int64 | getCPUTickCount () |
Returns the number of CPU ticks. More... | |
CV_EXPORTS_W bool | checkHardwareSupport (int feature) |
Returns SSE etc. More... | |
CV_EXPORTS_W int | getNumberOfCPUs () |
returns the number of CPUs (including hyper-threading) More... | |
CV_EXPORTS void * | fastMalloc (size_t bufSize) |
Allocates memory buffer. More... | |
CV_EXPORTS void | fastFree (void *ptr) |
Frees the memory allocated with cv::fastMalloc. More... | |
CV_EXPORTS_W void | setUseOptimized (bool onoff) |
Turns on/off available optimization. More... | |
CV_EXPORTS_W bool | useOptimized () |
Returns the current optimization status. More... | |
CV_EXPORTS void | scalarToRawData (const Scalar &s, void *buf, int type, int unroll_to=0) |
CV_EXPORTS OutputArray | noArray () |
CV_EXPORTS BinaryFunc | getConvertFunc (int sdepth, int ddepth) |
CV_EXPORTS BinaryFunc | getConvertScaleFunc (int sdepth, int ddepth) |
CV_EXPORTS BinaryFunc | getCopyMaskFunc (size_t esz) |
CV_EXPORTS void | swap (Mat &a, Mat &b) |
swaps two matrices More... | |
CV_EXPORTS Mat | cvarrToMat (const CvArr *arr, bool copyData=false, bool allowND=true, int coiMode=0) |
converts array (CvMat or IplImage) to cv::Mat More... | |
CV_EXPORTS void | extractImageCOI (const CvArr *arr, OutputArray coiimg, int coi=-1) |
extracts Channel of Interest from CvMat or IplImage and makes cv::Mat out of it. More... | |
CV_EXPORTS void | insertImageCOI (InputArray coiimg, CvArr *arr, int coi=-1) |
inserts single-channel cv::Mat into a multi-channel CvMat or IplImage More... | |
CV_EXPORTS_W void | add (InputArray src1, InputArray src2, OutputArray dst, InputArray mask=noArray(), int dtype=-1) |
adds one matrix to another (dst = src1 + src2) More... | |
CV_EXPORTS_W void | subtract (InputArray src1, InputArray src2, OutputArray dst, InputArray mask=noArray(), int dtype=-1) |
subtracts one matrix from another (dst = src1 - src2) More... | |
CV_EXPORTS_W void | multiply (InputArray src1, InputArray src2, OutputArray dst, double scale=1, int dtype=-1) |
computes element-wise weighted product of the two arrays (dst = scale*src1*src2) More... | |
CV_EXPORTS_W void | divide (InputArray src1, InputArray src2, OutputArray dst, double scale=1, int dtype=-1) |
computes element-wise weighted quotient of the two arrays (dst = scale*src1/src2) More... | |
CV_EXPORTS_W void | divide (double scale, InputArray src2, OutputArray dst, int dtype=-1) |
computes element-wise weighted reciprocal of an array (dst = scale/src2) More... | |
CV_EXPORTS_W void | scaleAdd (InputArray src1, double alpha, InputArray src2, OutputArray dst) |
adds scaled array to another one (dst = alpha*src1 + src2) More... | |
CV_EXPORTS_W void | addWeighted (InputArray src1, double alpha, InputArray src2, double beta, double gamma, OutputArray dst, int dtype=-1) |
computes weighted sum of two arrays (dst = alpha*src1 + beta*src2 + gamma) More... | |
CV_EXPORTS_W void | convertScaleAbs (InputArray src, OutputArray dst, double alpha=1, double beta=0) |
scales array elements, computes absolute values and converts the results to 8-bit unsigned integers: dst(i)=saturate_cast<uchar>abs(src(i)*alpha+beta) More... | |
CV_EXPORTS_W void | LUT (InputArray src, InputArray lut, OutputArray dst, int interpolation=0) |
transforms array of numbers using a lookup table: dst(i)=lut(src(i)) More... | |
CV_EXPORTS_AS (sumElems) Scalar sum(InputArray src) | |
computes sum of array elements More... | |
CV_EXPORTS_W int | countNonZero (InputArray src) |
computes the number of nonzero array elements More... | |
CV_EXPORTS_W void | findNonZero (InputArray src, OutputArray idx) |
returns the list of locations of non-zero pixels More... | |
CV_EXPORTS_W Scalar | mean (InputArray src, InputArray mask=noArray()) |
computes mean value of selected array elements More... | |
CV_EXPORTS_W void | meanStdDev (InputArray src, OutputArray mean, OutputArray stddev, InputArray mask=noArray()) |
computes mean value and standard deviation of all or selected array elements More... | |
CV_EXPORTS_W double | norm (InputArray src1, int normType=NORM_L2, InputArray mask=noArray()) |
computes norm of the selected array part More... | |
CV_EXPORTS_W double | norm (InputArray src1, InputArray src2, int normType=NORM_L2, InputArray mask=noArray()) |
computes norm of selected part of the difference between two arrays More... | |
CV_EXPORTS_W 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 More... | |
CV_EXPORTS_W void | normalize (InputArray src, OutputArray dst, double alpha=1, double beta=0, int norm_type=NORM_L2, int dtype=-1, InputArray mask=noArray()) |
scales and shifts array elements so that either the specified norm (alpha) or the minimum (alpha) and maximum (beta) array values get the specified values More... | |
CV_EXPORTS_W void | minMaxLoc (InputArray src, CV_OUT double *minVal, CV_OUT double *maxVal=0, CV_OUT Point *minLoc=0, CV_OUT Point *maxLoc=0, InputArray mask=noArray()) |
finds global minimum and maximum array elements and returns their values and their locations More... | |
CV_EXPORTS void | minMaxIdx (InputArray src, double *minVal, double *maxVal, int *minIdx=0, int *maxIdx=0, InputArray mask=noArray()) |
CV_EXPORTS_W void | reduce (InputArray src, OutputArray dst, int dim, int rtype, int dtype=-1) |
transforms 2D matrix to 1D row or column vector by taking sum, minimum, maximum or mean value over all the rows More... | |
CV_EXPORTS void | merge (const Mat *mv, size_t count, OutputArray dst) |
makes multi-channel array out of several single-channel arrays More... | |
CV_EXPORTS void | merge (const vector< Mat > &mv, OutputArray dst) |
CV_EXPORTS_W void | merge (InputArrayOfArrays mv, OutputArray dst) |
makes multi-channel array out of several single-channel arrays More... | |
CV_EXPORTS void | split (const Mat &src, Mat *mvbegin) |
copies each plane of a multi-channel array to a dedicated array More... | |
CV_EXPORTS void | split (const Mat &m, vector< Mat > &mv) |
CV_EXPORTS_W void | split (InputArray m, OutputArrayOfArrays mv) |
copies each plane of a multi-channel array to a dedicated array More... | |
CV_EXPORTS void | mixChannels (const Mat *src, size_t nsrcs, Mat *dst, size_t ndsts, const int *fromTo, size_t npairs) |
copies selected channels from the input arrays to the selected channels of the output arrays More... | |
CV_EXPORTS void | mixChannels (const vector< Mat > &src, vector< Mat > &dst, const int *fromTo, size_t npairs) |
CV_EXPORTS_W void | mixChannels (InputArrayOfArrays src, InputArrayOfArrays dst, const vector< int > &fromTo) |
CV_EXPORTS_W void | extractChannel (InputArray src, OutputArray dst, int coi) |
extracts a single channel from src (coi is 0-based index) More... | |
CV_EXPORTS_W void | insertChannel (InputArray src, InputOutputArray dst, int coi) |
inserts a single channel to dst (coi is 0-based index) More... | |
CV_EXPORTS_W void | flip (InputArray src, OutputArray dst, int flipCode) |
reverses the order of the rows, columns or both in a matrix More... | |
CV_EXPORTS_W void | repeat (InputArray src, int ny, int nx, OutputArray dst) |
replicates the input matrix the specified number of times in the horizontal and/or vertical direction More... | |
CV_EXPORTS Mat | repeat (const Mat &src, int ny, int nx) |
CV_EXPORTS void | hconcat (const Mat *src, size_t nsrc, OutputArray dst) |
CV_EXPORTS void | hconcat (InputArray src1, InputArray src2, OutputArray dst) |
CV_EXPORTS_W void | hconcat (InputArrayOfArrays src, OutputArray dst) |
CV_EXPORTS void | vconcat (const Mat *src, size_t nsrc, OutputArray dst) |
CV_EXPORTS void | vconcat (InputArray src1, InputArray src2, OutputArray dst) |
CV_EXPORTS_W void | vconcat (InputArrayOfArrays src, OutputArray dst) |
CV_EXPORTS_W void | bitwise_and (InputArray src1, InputArray src2, OutputArray dst, InputArray mask=noArray()) |
computes bitwise conjunction of the two arrays (dst = src1 & src2) More... | |
CV_EXPORTS_W void | bitwise_or (InputArray src1, InputArray src2, OutputArray dst, InputArray mask=noArray()) |
computes bitwise disjunction of the two arrays (dst = src1 | src2) More... | |
CV_EXPORTS_W void | bitwise_xor (InputArray src1, InputArray src2, OutputArray dst, InputArray mask=noArray()) |
computes bitwise exclusive-or of the two arrays (dst = src1 ^ src2) More... | |
CV_EXPORTS_W void | bitwise_not (InputArray src, OutputArray dst, InputArray mask=noArray()) |
inverts each bit of array (dst = ~src) More... | |
CV_EXPORTS_W void | absdiff (InputArray src1, InputArray src2, OutputArray dst) |
computes element-wise absolute difference of two arrays (dst = abs(src1 - src2)) More... | |
CV_EXPORTS_W void | inRange (InputArray src, InputArray lowerb, InputArray upperb, OutputArray dst) |
set mask elements for those array elements which are within the element-specific bounding box (dst = lowerb <= src && src < upperb) More... | |
CV_EXPORTS_W void | compare (InputArray src1, InputArray src2, OutputArray dst, int cmpop) |
compares elements of two arrays (dst = src1 <cmpop> src2) More... | |
CV_EXPORTS_W void | min (InputArray src1, InputArray src2, OutputArray dst) |
computes per-element minimum of two arrays (dst = min(src1, src2)) More... | |
CV_EXPORTS_W void | max (InputArray src1, InputArray src2, OutputArray dst) |
computes per-element maximum of two arrays (dst = max(src1, src2)) More... | |
CV_EXPORTS void | min (const Mat &src1, const Mat &src2, Mat &dst) |
computes per-element minimum of two arrays (dst = min(src1, src2)) More... | |
CV_EXPORTS void | min (const Mat &src1, double src2, Mat &dst) |
computes per-element minimum of array and scalar (dst = min(src1, src2)) More... | |
CV_EXPORTS void | max (const Mat &src1, const Mat &src2, Mat &dst) |
computes per-element maximum of two arrays (dst = max(src1, src2)) More... | |
CV_EXPORTS void | max (const Mat &src1, double src2, Mat &dst) |
computes per-element maximum of array and scalar (dst = max(src1, src2)) More... | |
CV_EXPORTS_W void | sqrt (InputArray src, OutputArray dst) |
computes square root of each matrix element (dst = src**0.5) More... | |
CV_EXPORTS_W void | pow (InputArray src, double power, OutputArray dst) |
raises the input matrix elements to the specified power (b = a**power) More... | |
CV_EXPORTS_W void | exp (InputArray src, OutputArray dst) |
computes exponent of each matrix element (dst = e**src) More... | |
CV_EXPORTS_W void | log (InputArray src, OutputArray dst) |
computes natural logarithm of absolute value of each matrix element: dst = log(abs(src)) More... | |
CV_EXPORTS_W float | cubeRoot (float val) |
computes cube root of the argument More... | |
CV_EXPORTS_W float | fastAtan2 (float y, float x) |
computes the angle in degrees (0..360) of the vector (x,y) More... | |
CV_EXPORTS void | exp (const float *src, float *dst, int n) |
CV_EXPORTS void | log (const float *src, float *dst, int n) |
CV_EXPORTS void | fastAtan2 (const float *y, const float *x, float *dst, int n, bool angleInDegrees) |
CV_EXPORTS void | magnitude (const float *x, const float *y, float *dst, int n) |
CV_EXPORTS_W void | polarToCart (InputArray magnitude, InputArray angle, OutputArray x, OutputArray y, bool angleInDegrees=false) |
converts polar coordinates to Cartesian More... | |
CV_EXPORTS_W void | cartToPolar (InputArray x, InputArray y, OutputArray magnitude, OutputArray angle, bool angleInDegrees=false) |
converts Cartesian coordinates to polar More... | |
CV_EXPORTS_W void | phase (InputArray x, InputArray y, OutputArray angle, bool angleInDegrees=false) |
computes angle (angle(i)) of each (x(i), y(i)) vector More... | |
CV_EXPORTS_W void | magnitude (InputArray x, InputArray y, OutputArray magnitude) |
computes magnitude (magnitude(i)) of each (x(i), y(i)) vector More... | |
CV_EXPORTS_W bool | checkRange (InputArray a, bool quiet=true, CV_OUT Point *pos=0, double minVal=-DBL_MAX, double maxVal=DBL_MAX) |
checks that each matrix element is within the specified range. More... | |
CV_EXPORTS_W void | patchNaNs (InputOutputArray a, double val=0) |
converts NaN's to the given number More... | |
CV_EXPORTS_W void | gemm (InputArray src1, InputArray src2, double alpha, InputArray src3, double gamma, OutputArray dst, int flags=0) |
implements generalized matrix product algorithm GEMM from BLAS More... | |
CV_EXPORTS_W void | mulTransposed (InputArray src, OutputArray dst, bool aTa, InputArray delta=noArray(), double scale=1, int dtype=-1) |
multiplies matrix by its transposition from the left or from the right More... | |
CV_EXPORTS_W void | transpose (InputArray src, OutputArray dst) |
transposes the matrix More... | |
CV_EXPORTS_W void | transform (InputArray src, OutputArray dst, InputArray m) |
performs affine transformation of each element of multi-channel input matrix More... | |
CV_EXPORTS_W void | perspectiveTransform (InputArray src, OutputArray dst, InputArray m) |
performs perspective transformation of each element of multi-channel input matrix More... | |
CV_EXPORTS_W void | completeSymm (InputOutputArray mtx, bool lowerToUpper=false) |
extends the symmetrical matrix from the lower half or from the upper half More... | |
CV_EXPORTS_W void | setIdentity (InputOutputArray mtx, const Scalar &s=Scalar(1)) |
initializes scaled identity matrix More... | |
CV_EXPORTS_W double | determinant (InputArray mtx) |
computes determinant of a square matrix More... | |
CV_EXPORTS_W Scalar | trace (InputArray mtx) |
computes trace of a matrix More... | |
CV_EXPORTS_W double | invert (InputArray src, OutputArray dst, int flags=DECOMP_LU) |
computes inverse or pseudo-inverse matrix More... | |
CV_EXPORTS_W bool | solve (InputArray src1, InputArray src2, OutputArray dst, int flags=DECOMP_LU) |
solves linear system or a least-square problem More... | |
CV_EXPORTS_W void | sort (InputArray src, OutputArray dst, int flags) |
sorts independently each matrix row or each matrix column More... | |
CV_EXPORTS_W void | sortIdx (InputArray src, OutputArray dst, int flags) |
sorts independently each matrix row or each matrix column More... | |
CV_EXPORTS_W int | solveCubic (InputArray coeffs, OutputArray roots) |
finds real roots of a cubic polynomial More... | |
CV_EXPORTS_W double | solvePoly (InputArray coeffs, OutputArray roots, int maxIters=300) |
finds real and complex roots of a polynomial More... | |
CV_EXPORTS bool | eigen (InputArray src, OutputArray eigenvalues, int lowindex=-1, int highindex=-1) |
finds eigenvalues of a symmetric matrix More... | |
CV_EXPORTS bool | eigen (InputArray src, OutputArray eigenvalues, OutputArray eigenvectors, int lowindex=-1, int highindex=-1) |
finds eigenvalues and eigenvectors of a symmetric matrix More... | |
CV_EXPORTS_W bool | eigen (InputArray src, bool computeEigenvectors, OutputArray eigenvalues, OutputArray eigenvectors) |
CV_EXPORTS void | calcCovarMatrix (const Mat *samples, int nsamples, Mat &covar, Mat &mean, int flags, int ctype=CV_64F) |
computes covariation matrix of a set of samples More... | |
CV_EXPORTS_W void | calcCovarMatrix (InputArray samples, OutputArray covar, OutputArray mean, int flags, int ctype=CV_64F) |
computes covariation matrix of a set of samples More... | |
CV_EXPORTS_W void | PCACompute (InputArray data, CV_OUT InputOutputArray mean, OutputArray eigenvectors, int maxComponents=0) |
CV_EXPORTS_W void | PCAComputeVar (InputArray data, CV_OUT InputOutputArray mean, OutputArray eigenvectors, double retainedVariance) |
CV_EXPORTS_W void | PCAProject (InputArray data, InputArray mean, InputArray eigenvectors, OutputArray result) |
CV_EXPORTS_W void | PCABackProject (InputArray data, InputArray mean, InputArray eigenvectors, OutputArray result) |
CV_EXPORTS_W void | SVDecomp (InputArray src, CV_OUT OutputArray w, CV_OUT OutputArray u, CV_OUT OutputArray vt, int flags=0) |
computes SVD of src More... | |
CV_EXPORTS_W void | SVBackSubst (InputArray w, InputArray u, InputArray vt, InputArray rhs, CV_OUT OutputArray dst) |
performs back substitution for the previously computed SVD More... | |
CV_EXPORTS_W double | Mahalanobis (InputArray v1, InputArray v2, InputArray icovar) |
computes Mahalanobis distance between two vectors: sqrt((v1-v2)'icovar(v1-v2)), where icovar is the inverse covariation matrix More... | |
CV_EXPORTS double | Mahalonobis (InputArray v1, InputArray v2, InputArray icovar) |
a synonym for Mahalanobis More... | |
CV_EXPORTS_W void | dft (InputArray src, OutputArray dst, int flags=0, int nonzeroRows=0) |
performs forward or inverse 1D or 2D Discrete Fourier Transformation More... | |
CV_EXPORTS_W void | idft (InputArray src, OutputArray dst, int flags=0, int nonzeroRows=0) |
performs inverse 1D or 2D Discrete Fourier Transformation More... | |
CV_EXPORTS_W void | dct (InputArray src, OutputArray dst, int flags=0) |
performs forward or inverse 1D or 2D Discrete Cosine Transformation More... | |
CV_EXPORTS_W void | idct (InputArray src, OutputArray dst, int flags=0) |
performs inverse 1D or 2D Discrete Cosine Transformation More... | |
CV_EXPORTS_W void | mulSpectrums (InputArray a, InputArray b, OutputArray c, int flags, bool conjB=false) |
computes element-wise product of the two Fourier spectrums. The second spectrum can optionally be conjugated before the multiplication More... | |
CV_EXPORTS_W int | getOptimalDFTSize (int vecsize) |
computes the minimal vector size vecsize1 >= vecsize so that the dft() of the vector of length vecsize1 can be computed efficiently More... | |
CV_EXPORTS_W double | kmeans (InputArray data, int K, CV_OUT InputOutputArray bestLabels, TermCriteria criteria, int attempts, int flags, OutputArray centers=noArray()) |
clusters the input data using k-Means algorithm More... | |
CV_EXPORTS RNG & | theRNG () |
returns the thread-local Random number generator More... | |
CV_EXPORTS_W void | randu (InputOutputArray dst, InputArray low, InputArray high) |
fills array with uniformly-distributed random numbers from the range [low, high) More... | |
CV_EXPORTS_W void | randn (InputOutputArray dst, InputArray mean, InputArray stddev) |
fills array with normally-distributed random numbers with the specified mean and the standard deviation More... | |
CV_EXPORTS void | randShuffle (InputOutputArray dst, double iterFactor=1., RNG *rng=0) |
shuffles the input array elements More... | |
CV_EXPORTS_AS (randShuffle) void randShuffle_(InputOutputArray dst | |
CV_EXPORTS_W void | line (CV_IN_OUT Mat &img, Point pt1, Point pt2, const Scalar &color, int thickness=1, int lineType=8, int shift=0) |
draws the line segment (pt1, pt2) in the image More... | |
CV_EXPORTS_W void | rectangle (CV_IN_OUT Mat &img, Point pt1, Point pt2, const Scalar &color, int thickness=1, int lineType=8, int shift=0) |
draws the rectangle outline or a solid rectangle with the opposite corners pt1 and pt2 in the image More... | |
CV_EXPORTS void | rectangle (CV_IN_OUT Mat &img, Rect rec, const Scalar &color, int thickness=1, int lineType=8, int shift=0) |
draws the rectangle outline or a solid rectangle covering rec in the image More... | |
CV_EXPORTS_W void | circle (CV_IN_OUT Mat &img, Point center, int radius, const Scalar &color, int thickness=1, int lineType=8, int shift=0) |
draws the circle outline or a solid circle in the image More... | |
CV_EXPORTS_W void | ellipse (CV_IN_OUT Mat &img, Point center, Size axes, double angle, double startAngle, double endAngle, const Scalar &color, int thickness=1, int lineType=8, int shift=0) |
draws an elliptic arc, ellipse sector or a rotated ellipse in the image More... | |
CV_EXPORTS_W void | ellipse (CV_IN_OUT Mat &img, const RotatedRect &box, const Scalar &color, int thickness=1, int lineType=8) |
draws a rotated ellipse in the image More... | |
CV_EXPORTS void | fillConvexPoly (Mat &img, const Point *pts, int npts, const Scalar &color, int lineType=8, int shift=0) |
draws a filled convex polygon in the image More... | |
CV_EXPORTS_W void | fillConvexPoly (InputOutputArray img, InputArray points, const Scalar &color, int lineType=8, int shift=0) |
CV_EXPORTS void | fillPoly (Mat &img, const Point **pts, const int *npts, int ncontours, const Scalar &color, int lineType=8, int shift=0, Point offset=Point()) |
fills an area bounded by one or more polygons More... | |
CV_EXPORTS_W void | fillPoly (InputOutputArray img, InputArrayOfArrays pts, const Scalar &color, int lineType=8, int shift=0, Point offset=Point()) |
CV_EXPORTS void | polylines (Mat &img, const Point **pts, const int *npts, int ncontours, bool isClosed, const Scalar &color, int thickness=1, int lineType=8, int shift=0) |
draws one or more polygonal curves More... | |
CV_EXPORTS_W void | polylines (InputOutputArray img, InputArrayOfArrays pts, bool isClosed, const Scalar &color, int thickness=1, int lineType=8, int shift=0) |
CV_EXPORTS bool | clipLine (Size imgSize, CV_IN_OUT Point &pt1, CV_IN_OUT Point &pt2) |
clips the line segment by the rectangle Rect(0, 0, imgSize.width, imgSize.height) More... | |
CV_EXPORTS_W bool | clipLine (Rect imgRect, CV_OUT CV_IN_OUT Point &pt1, CV_OUT CV_IN_OUT Point &pt2) |
clips the line segment by the rectangle imgRect More... | |
CV_EXPORTS_W void | ellipse2Poly (Point center, Size axes, int angle, int arcStart, int arcEnd, int delta, CV_OUT vector< Point > &pts) |
converts elliptic arc to a polygonal curve More... | |
CV_EXPORTS_W void | putText (Mat &img, const string &text, Point org, int fontFace, double fontScale, Scalar color, int thickness=1, int lineType=8, bool bottomLeftOrigin=false) |
renders text string in the image More... | |
CV_EXPORTS_W Size | getTextSize (const string &text, int fontFace, double fontScale, int thickness, CV_OUT int *baseLine) |
returns bounding box of the text string More... | |
CV_EXPORTS ConvertData | getConvertElem (int fromType, int toType) |
returns the function for converting pixels from one data type to another More... | |
CV_EXPORTS ConvertScaleData | getConvertScaleElem (int fromType, int toType) |
returns the function for converting pixels from one data type to another with the optional scaling More... | |
CV_EXPORTS void | minMaxLoc (const SparseMat &a, double *minVal, double *maxVal, int *minIdx=0, int *maxIdx=0) |
finds global minimum and maximum sparse array elements and returns their values and their locations More... | |
CV_EXPORTS double | norm (const SparseMat &src, int normType) |
computes norm of a sparse matrix More... | |
CV_EXPORTS void | normalize (const SparseMat &src, SparseMat &dst, double alpha, int normType) |
scales and shifts array elements so that either the specified norm (alpha) or the minimum (alpha) and maximum (beta) array values get the specified values More... | |
template<> | |
CV_EXPORTS std::string | CommandLineParser::analyzeValue< std::string > (const std::string &str, bool space_delete) |
CV_EXPORTS void | parallel_for_ (const Range &range, const ParallelLoopBody &body, double nstripes=-1.) |
template<typename _Tp , int _rows, int _cols, int _options, int _maxRows, int _maxCols> | |
void | eigen2cv (const Eigen::Matrix< _Tp, _rows, _cols, _options, _maxRows, _maxCols > &src, Mat &dst) |
template<typename _Tp , int _rows, int _cols, int _options, int _maxRows, int _maxCols> | |
void | cv2eigen (const Mat &src, Eigen::Matrix< _Tp, _rows, _cols, _options, _maxRows, _maxCols > &dst) |
template<typename _Tp , int _rows, int _cols, int _options, int _maxRows, int _maxCols> | |
void | cv2eigen (const Matx< _Tp, _rows, _cols > &src, Eigen::Matrix< _Tp, _rows, _cols, _options, _maxRows, _maxCols > &dst) |
template<typename _Tp > | |
void | cv2eigen (const Mat &src, Eigen::Matrix< _Tp, Eigen::Dynamic, Eigen::Dynamic > &dst) |
template<typename _Tp , int _rows, int _cols> | |
void | cv2eigen (const Matx< _Tp, _rows, _cols > &src, Eigen::Matrix< _Tp, Eigen::Dynamic, Eigen::Dynamic > &dst) |
template<typename _Tp > | |
void | cv2eigen (const Mat &src, Eigen::Matrix< _Tp, Eigen::Dynamic, 1 > &dst) |
template<typename _Tp , int _rows> | |
void | cv2eigen (const Matx< _Tp, _rows, 1 > &src, Eigen::Matrix< _Tp, Eigen::Dynamic, 1 > &dst) |
template<typename _Tp > | |
void | cv2eigen (const Mat &src, Eigen::Matrix< _Tp, 1, Eigen::Dynamic > &dst) |
template<typename _Tp , int _cols> | |
void | cv2eigen (const Matx< _Tp, 1, _cols > &src, Eigen::Matrix< _Tp, 1, Eigen::Dynamic > &dst) |
CV_EXPORTS const char * | currentParallelFramework () |
template<typename T1 , typename T2 , typename Op > | |
void | process (const Mat_< T1 > &m1, Mat_< T2 > &m2, Op op) |
template<typename T1 , typename T2 , typename T3 , typename Op > | |
void | process (const Mat_< T1 > &m1, const Mat_< T2 > &m2, Mat_< T3 > &m3, Op op) |
CV_EXPORTS MatExpr | operator+ (const Mat &a, const Mat &b) |
CV_EXPORTS MatExpr | operator+ (const Mat &a, const Scalar &s) |
CV_EXPORTS MatExpr | operator+ (const Scalar &s, const Mat &a) |
CV_EXPORTS MatExpr | operator+ (const MatExpr &e, const Mat &m) |
CV_EXPORTS MatExpr | operator+ (const Mat &m, const MatExpr &e) |
CV_EXPORTS MatExpr | operator+ (const MatExpr &e, const Scalar &s) |
CV_EXPORTS MatExpr | operator+ (const Scalar &s, const MatExpr &e) |
CV_EXPORTS MatExpr | operator+ (const MatExpr &e1, const MatExpr &e2) |
CV_EXPORTS MatExpr | operator- (const Mat &a, const Mat &b) |
CV_EXPORTS MatExpr | operator- (const Mat &a, const Scalar &s) |
CV_EXPORTS MatExpr | operator- (const Scalar &s, const Mat &a) |
CV_EXPORTS MatExpr | operator- (const MatExpr &e, const Mat &m) |
CV_EXPORTS MatExpr | operator- (const Mat &m, const MatExpr &e) |
CV_EXPORTS MatExpr | operator- (const MatExpr &e, const Scalar &s) |
CV_EXPORTS MatExpr | operator- (const Scalar &s, const MatExpr &e) |
CV_EXPORTS MatExpr | operator- (const MatExpr &e1, const MatExpr &e2) |
CV_EXPORTS MatExpr | operator- (const Mat &m) |
CV_EXPORTS MatExpr | operator- (const MatExpr &e) |
CV_EXPORTS MatExpr | operator* (const Mat &a, const Mat &b) |
CV_EXPORTS MatExpr | operator* (const Mat &a, double s) |
CV_EXPORTS MatExpr | operator* (double s, const Mat &a) |
CV_EXPORTS MatExpr | operator* (const MatExpr &e, const Mat &m) |
CV_EXPORTS MatExpr | operator* (const Mat &m, const MatExpr &e) |
CV_EXPORTS MatExpr | operator* (const MatExpr &e, double s) |
CV_EXPORTS MatExpr | operator* (double s, const MatExpr &e) |
CV_EXPORTS MatExpr | operator* (const MatExpr &e1, const MatExpr &e2) |
CV_EXPORTS MatExpr | operator/ (const Mat &a, const Mat &b) |
CV_EXPORTS MatExpr | operator/ (const Mat &a, double s) |
CV_EXPORTS MatExpr | operator/ (double s, const Mat &a) |
CV_EXPORTS MatExpr | operator/ (const MatExpr &e, const Mat &m) |
CV_EXPORTS MatExpr | operator/ (const Mat &m, const MatExpr &e) |
CV_EXPORTS MatExpr | operator/ (const MatExpr &e, double s) |
CV_EXPORTS MatExpr | operator/ (double s, const MatExpr &e) |
CV_EXPORTS MatExpr | operator/ (const MatExpr &e1, const MatExpr &e2) |
CV_EXPORTS MatExpr | operator< (const Mat &a, const Mat &b) |
CV_EXPORTS MatExpr | operator< (const Mat &a, double s) |
CV_EXPORTS MatExpr | operator< (double s, const Mat &a) |
CV_EXPORTS MatExpr | operator<= (const Mat &a, const Mat &b) |
CV_EXPORTS MatExpr | operator<= (const Mat &a, double s) |
CV_EXPORTS MatExpr | operator<= (double s, const Mat &a) |
CV_EXPORTS MatExpr | operator== (const Mat &a, const Mat &b) |
CV_EXPORTS MatExpr | operator== (const Mat &a, double s) |
CV_EXPORTS MatExpr | operator== (double s, const Mat &a) |
CV_EXPORTS MatExpr | operator!= (const Mat &a, const Mat &b) |
CV_EXPORTS MatExpr | operator!= (const Mat &a, double s) |
CV_EXPORTS MatExpr | operator!= (double s, const Mat &a) |
CV_EXPORTS MatExpr | operator>= (const Mat &a, const Mat &b) |
CV_EXPORTS MatExpr | operator>= (const Mat &a, double s) |
CV_EXPORTS MatExpr | operator>= (double s, const Mat &a) |
CV_EXPORTS MatExpr | operator> (const Mat &a, const Mat &b) |
CV_EXPORTS MatExpr | operator> (const Mat &a, double s) |
CV_EXPORTS MatExpr | operator> (double s, const Mat &a) |
CV_EXPORTS MatExpr | min (const Mat &a, const Mat &b) |
CV_EXPORTS MatExpr | min (const Mat &a, double s) |
CV_EXPORTS MatExpr | min (double s, const Mat &a) |
CV_EXPORTS MatExpr | max (const Mat &a, const Mat &b) |
CV_EXPORTS MatExpr | max (const Mat &a, double s) |
CV_EXPORTS MatExpr | max (double s, const Mat &a) |
CV_EXPORTS MatExpr | operator& (const Mat &a, const Mat &b) |
CV_EXPORTS MatExpr | operator& (const Mat &a, const Scalar &s) |
CV_EXPORTS MatExpr | operator& (const Scalar &s, const Mat &a) |
CV_EXPORTS MatExpr | operator| (const Mat &a, const Mat &b) |
CV_EXPORTS MatExpr | operator| (const Mat &a, const Scalar &s) |
CV_EXPORTS MatExpr | operator| (const Scalar &s, const Mat &a) |
CV_EXPORTS MatExpr | operator^ (const Mat &a, const Mat &b) |
CV_EXPORTS MatExpr | operator^ (const Mat &a, const Scalar &s) |
CV_EXPORTS MatExpr | operator^ (const Scalar &s, const Mat &a) |
CV_EXPORTS MatExpr | operator~ (const Mat &m) |
CV_EXPORTS MatExpr | abs (const Mat &m) |
CV_EXPORTS MatExpr | abs (const MatExpr &e) |
template<typename _Tp > | |
void | split (const Mat &src, vector< Mat_< _Tp > > &mv) |
CV_EXPORTS ptrdiff_t | operator- (const MatConstIterator &b, const MatConstIterator &a) |
CV_EXPORTS void | render (const GlTexture &tex, Rect_< double > wndRect=Rect_< double >(0.0, 0.0, 1.0, 1.0), Rect_< double > texRect=Rect_< double >(0.0, 0.0, 1.0, 1.0)) |
render functions More... | |
CV_EXPORTS void | render (const GlArrays &arr, int mode=RenderMode::POINTS, Scalar color=Scalar::all(255)) |
render OpenGL arrays More... | |
CV_EXPORTS void | render (const std::string &str, const Ptr< GlFont > &font, Scalar color, Point2d pos) |
CV_EXPORTS int | _interlockedExchangeAdd (int *addr, int delta) |
template<> | |
uchar | saturate_cast< uchar > (schar v) |
template<> | |
uchar | saturate_cast< uchar > (ushort v) |
template<> | |
uchar | saturate_cast< uchar > (int v) |
template<> | |
uchar | saturate_cast< uchar > (short v) |
template<> | |
uchar | saturate_cast< uchar > (unsigned v) |
template<> | |
uchar | saturate_cast< uchar > (float v) |
template<> | |
uchar | saturate_cast< uchar > (double v) |
template<> | |
schar | saturate_cast< schar > (uchar v) |
template<> | |
schar | saturate_cast< schar > (ushort v) |
template<> | |
schar | saturate_cast< schar > (int v) |
template<> | |
schar | saturate_cast< schar > (short v) |
template<> | |
schar | saturate_cast< schar > (unsigned v) |
template<> | |
schar | saturate_cast< schar > (float v) |
template<> | |
schar | saturate_cast< schar > (double v) |
template<> | |
ushort | saturate_cast< ushort > (schar v) |
template<> | |
ushort | saturate_cast< ushort > (short v) |
template<> | |
ushort | saturate_cast< ushort > (int v) |
template<> | |
ushort | saturate_cast< ushort > (unsigned v) |
template<> | |
ushort | saturate_cast< ushort > (float v) |
template<> | |
ushort | saturate_cast< ushort > (double v) |
template<> | |
short | saturate_cast< short > (ushort v) |
template<> | |
short | saturate_cast< short > (int v) |
template<> | |
short | saturate_cast< short > (unsigned v) |
template<> | |
short | saturate_cast< short > (float v) |
template<> | |
short | saturate_cast< short > (double v) |
template<> | |
int | saturate_cast< int > (float v) |
template<> | |
int | saturate_cast< int > (double v) |
template<> | |
unsigned | saturate_cast< unsigned > (float v) |
template<> | |
unsigned | saturate_cast< unsigned > (double v) |
int | fast_abs (uchar v) |
int | fast_abs (schar v) |
int | fast_abs (ushort v) |
int | fast_abs (short v) |
int | fast_abs (int v) |
float | fast_abs (float v) |
double | fast_abs (double v) |
CV_EXPORTS int | LU (float *A, size_t astep, int m, float *b, size_t bstep, int n) |
CV_EXPORTS int | LU (double *A, size_t astep, int m, double *b, size_t bstep, int n) |
CV_EXPORTS bool | Cholesky (float *A, size_t astep, int m, float *b, size_t bstep, int n) |
CV_EXPORTS bool | Cholesky (double *A, size_t astep, int m, double *b, size_t bstep, int n) |
CV_EXPORTS float | normL2Sqr_ (const float *a, const float *b, int n) |
CV_EXPORTS float | normL1_ (const float *a, const float *b, int n) |
CV_EXPORTS int | normL1_ (const uchar *a, const uchar *b, int n) |
CV_EXPORTS int | normHamming (const uchar *a, const uchar *b, int n) |
CV_EXPORTS int | normHamming (const uchar *a, const uchar *b, int n, int cellSize) |
template<> | |
float | normL2Sqr (const float *a, const float *b, int n) |
template<> | |
float | normL1 (const float *a, const float *b, int n) |
template<> | |
int | normL1 (const uchar *a, const uchar *b, int n) |
template<typename _Tp > | |
Vec< _Tp, 2 > | conjugate (const Vec< _Tp, 2 > &v) |
template<typename _Tp > | |
Vec< _Tp, 4 > | conjugate (const Vec< _Tp, 4 > &v) |
template<typename _Tp > | |
Vec< _Tp, 4 > | operator* (const Vec< _Tp, 4 > &v1, const Vec< _Tp, 4 > &v2) |
template<typename _Tp > | |
Vec< _Tp, 4 > & | operator*= (Vec< _Tp, 4 > &v1, const Vec< _Tp, 4 > &v2) |
template<typename _Tp , int cn> | |
Vec< _Tp, cn > | normalize (const Vec< _Tp, cn > &v) |
template<typename _Tp > | |
DataType< _Tp >::work_type | dot (const Vector< _Tp > &v1, const Vector< _Tp > &v2) |
CV_EXPORTS_W void | write (FileStorage &fs, const string &name, int value) |
CV_EXPORTS_W void | write (FileStorage &fs, const string &name, float value) |
CV_EXPORTS_W void | write (FileStorage &fs, const string &name, double value) |
CV_EXPORTS_W void | write (FileStorage &fs, const string &name, const string &value) |
template<typename _Tp > | |
void | write (FileStorage &fs, const _Tp &value) |
CV_EXPORTS void | writeScalar (FileStorage &fs, int value) |
CV_EXPORTS void | writeScalar (FileStorage &fs, float value) |
CV_EXPORTS void | writeScalar (FileStorage &fs, double value) |
CV_EXPORTS void | writeScalar (FileStorage &fs, const string &value) |
template<> | |
void | write (FileStorage &fs, const int &value) |
template<> | |
void | write (FileStorage &fs, const float &value) |
template<> | |
void | write (FileStorage &fs, const double &value) |
template<> | |
void | write (FileStorage &fs, const string &value) |
template<typename _Tp > | |
void | write (FileStorage &fs, const Point_< _Tp > &pt) |
template<typename _Tp > | |
void | write (FileStorage &fs, const Point3_< _Tp > &pt) |
template<typename _Tp > | |
void | write (FileStorage &fs, const Size_< _Tp > &sz) |
template<typename _Tp > | |
void | write (FileStorage &fs, const Complex< _Tp > &c) |
template<typename _Tp > | |
void | write (FileStorage &fs, const Rect_< _Tp > &r) |
template<typename _Tp , int cn> | |
void | write (FileStorage &fs, const Vec< _Tp, cn > &v) |
template<typename _Tp > | |
void | write (FileStorage &fs, const Scalar_< _Tp > &s) |
void | write (FileStorage &fs, const Range &r) |
template<typename _Tp > | |
void | write (FileStorage &fs, const string &name, const Point_< _Tp > &pt) |
template<typename _Tp > | |
void | write (FileStorage &fs, const string &name, const Point3_< _Tp > &pt) |
template<typename _Tp > | |
void | write (FileStorage &fs, const string &name, const Size_< _Tp > &sz) |
template<typename _Tp > | |
void | write (FileStorage &fs, const string &name, const Complex< _Tp > &c) |
template<typename _Tp > | |
void | write (FileStorage &fs, const string &name, const Rect_< _Tp > &r) |
template<typename _Tp , int cn> | |
void | write (FileStorage &fs, const string &name, const Vec< _Tp, cn > &v) |
template<typename _Tp > | |
void | write (FileStorage &fs, const string &name, const Scalar_< _Tp > &s) |
void | write (FileStorage &fs, const string &name, const Range &r) |
CV_EXPORTS_W void | write (FileStorage &fs, const string &name, const Mat &value) |
CV_EXPORTS void | write (FileStorage &fs, const string &name, const SparseMat &value) |
CV_EXPORTS FileStorage & | operator<< (FileStorage &fs, const string &str) |
CV_EXPORTS_W void | read (const FileNode &node, Mat &mat, const Mat &default_mat=Mat()) |
CV_EXPORTS void | read (const FileNode &node, SparseMat &mat, const SparseMat &default_mat=SparseMat()) |
template<typename _Tp , class _LT > | |
void | sort (vector< _Tp > &vec, _LT LT=_LT()) |
template<typename _Tp , class _EqPredicate > | |
int | partition (const vector< _Tp > &_vec, vector< int > &labels, _EqPredicate predicate=_EqPredicate()) |
CV_EXPORTS schar * | seqPush (CvSeq *seq, const void *element=0) |
CV_EXPORTS schar * | seqPushFront (CvSeq *seq, const void *element=0) |
CV_EXPORTS void | seqPop (CvSeq *seq, void *element=0) |
CV_EXPORTS void | seqPopFront (CvSeq *seq, void *element=0) |
CV_EXPORTS void | seqPopMulti (CvSeq *seq, void *elements, int count, int in_front=0) |
CV_EXPORTS void | seqRemove (CvSeq *seq, int index) |
CV_EXPORTS void | clearSeq (CvSeq *seq) |
CV_EXPORTS schar * | getSeqElem (const CvSeq *seq, int index) |
CV_EXPORTS void | seqRemoveSlice (CvSeq *seq, CvSlice slice) |
CV_EXPORTS void | seqInsertSlice (CvSeq *seq, int before_index, const CvArr *from_arr) |
template<typename _Tp > | |
ptrdiff_t | operator- (const SeqIterator< _Tp > &a, const SeqIterator< _Tp > &b) |
template<typename _Tp > | |
bool | operator== (const SeqIterator< _Tp > &a, const SeqIterator< _Tp > &b) |
template<typename _Tp > | |
bool | operator!= (const SeqIterator< _Tp > &a, const SeqIterator< _Tp > &b) |
template<typename _Tp , int m, int n> | |
std::ostream & | operator<< (std::ostream &out, const Matx< _Tp, m, n > &matx) |
template<typename _Tp > | |
std::ostream & | operator<< (std::ostream &out, const Point_< _Tp > &p) |
template<typename _Tp > | |
std::ostream & | operator<< (std::ostream &out, const Point3_< _Tp > &p) |
template<typename _Tp , int n> | |
std::ostream & | operator<< (std::ostream &out, const Vec< _Tp, n > &vec) |
template<typename _Tp > | |
std::ostream & | operator<< (std::ostream &out, const Size_< _Tp > &size) |
template<typename _Tp > | |
std::ostream & | operator<< (std::ostream &out, const Rect_< _Tp > &rect) |
CV_EXPORTS bool | initModule_features2d () |
CV_EXPORTS void | write (FileStorage &fs, const string &name, const vector< KeyPoint > &keypoints) |
writes vector of keypoints to the file storage More... | |
CV_EXPORTS void | read (const FileNode &node, CV_OUT vector< KeyPoint > &keypoints) |
reads vector of keypoints from the specified file storage node More... | |
CV_EXPORTS void | FAST (InputArray image, CV_OUT vector< KeyPoint > &keypoints, int threshold, bool nonmaxSuppression=true) |
detects corners using FAST algorithm by E. Rosten More... | |
CV_EXPORTS void | FASTX (InputArray image, CV_OUT vector< KeyPoint > &keypoints, int threshold, bool nonmaxSuppression, int type) |
CV_EXPORTS Mat | windowedMatchingMask (const vector< KeyPoint > &keypoints1, const vector< KeyPoint > &keypoints2, float maxDeltaX, float maxDeltaY) |
CV_EXPORTS_W void | drawKeypoints (const Mat &image, const vector< KeyPoint > &keypoints, CV_OUT Mat &outImage, const Scalar &color=Scalar::all(-1), int flags=DrawMatchesFlags::DEFAULT) |
CV_EXPORTS void | drawMatches (const Mat &img1, const vector< KeyPoint > &keypoints1, const Mat &img2, const vector< KeyPoint > &keypoints2, const vector< DMatch > &matches1to2, Mat &outImg, const Scalar &matchColor=Scalar::all(-1), const Scalar &singlePointColor=Scalar::all(-1), const vector< char > &matchesMask=vector< char >(), int flags=DrawMatchesFlags::DEFAULT) |
CV_EXPORTS void | drawMatches (const Mat &img1, const vector< KeyPoint > &keypoints1, const Mat &img2, const vector< KeyPoint > &keypoints2, const vector< vector< DMatch > > &matches1to2, Mat &outImg, const Scalar &matchColor=Scalar::all(-1), const Scalar &singlePointColor=Scalar::all(-1), const vector< vector< char > > &matchesMask=vector< vector< char > >(), int flags=DrawMatchesFlags::DEFAULT) |
CV_EXPORTS void | evaluateFeatureDetector (const Mat &img1, const Mat &img2, const Mat &H1to2, vector< KeyPoint > *keypoints1, vector< KeyPoint > *keypoints2, float &repeatability, int &correspCount, const Ptr< FeatureDetector > &fdetector=Ptr< FeatureDetector >()) |
CV_EXPORTS void | computeRecallPrecisionCurve (const vector< vector< DMatch > > &matches1to2, const vector< vector< uchar > > &correctMatches1to2Mask, vector< Point2f > &recallPrecisionCurve) |
CV_EXPORTS float | getRecall (const vector< Point2f > &recallPrecisionCurve, float l_precision) |
CV_EXPORTS int | getNearestPoint (const vector< Point2f > &recallPrecisionCurve, float l_precision) |
CV_EXPORTS void | evaluateGenericDescriptorMatcher (const Mat &img1, const Mat &img2, const Mat &H1to2, vector< KeyPoint > &keypoints1, vector< KeyPoint > &keypoints2, vector< vector< DMatch > > *matches1to2, vector< vector< uchar > > *correctMatches1to2Mask, vector< Point2f > &recallPrecisionCurve, const Ptr< GenericDescriptorMatcher > &dmatch=Ptr< GenericDescriptorMatcher >()) |
CV_EXPORTS_W void | namedWindow (const string &winname, int flags=WINDOW_AUTOSIZE) |
CV_EXPORTS_W void | destroyWindow (const string &winname) |
CV_EXPORTS_W void | destroyAllWindows () |
CV_EXPORTS_W int | startWindowThread () |
CV_EXPORTS_W int | waitKey (int delay=0) |
CV_EXPORTS_W void | imshow (const string &winname, InputArray mat) |
CV_EXPORTS_W void | resizeWindow (const string &winname, int width, int height) |
CV_EXPORTS_W void | moveWindow (const string &winname, int x, int y) |
CV_EXPORTS_W void | setWindowProperty (const string &winname, int prop_id, double prop_value) |
CV_EXPORTS_W double | getWindowProperty (const string &winname, int prop_id) |
CV_EXPORTS void | setMouseCallback (const string &winname, MouseCallback onMouse, void *userdata=0) |
assigns callback for mouse events More... | |
CV_EXPORTS int | createTrackbar (const string &trackbarname, const string &winname, int *value, int count, TrackbarCallback onChange=0, void *userdata=0) |
CV_EXPORTS_W int | getTrackbarPos (const string &trackbarname, const string &winname) |
CV_EXPORTS_W void | setTrackbarPos (const string &trackbarname, const string &winname, int pos) |
CV_EXPORTS void | setOpenGlDrawCallback (const string &winname, OpenGlDrawCallback onOpenGlDraw, void *userdata=0) |
CV_EXPORTS void | setOpenGlContext (const string &winname) |
CV_EXPORTS void | updateWindow (const string &winname) |
CV_EXPORTS void | pointCloudShow (const string &winname, const GlCamera &camera, const GlArrays &arr) |
CV_EXPORTS void | pointCloudShow (const string &winname, const GlCamera &camera, InputArray points, InputArray colors=noArray()) |
CV_EXPORTS CvFont | fontQt (const string &nameFont, int pointSize=-1, Scalar color=Scalar::all(0), int weight=CV_FONT_NORMAL, int style=CV_STYLE_NORMAL, int spacing=0) |
CV_EXPORTS void | addText (const Mat &img, const string &text, Point org, CvFont font) |
CV_EXPORTS void | displayOverlay (const string &winname, const string &text, int delayms CV_DEFAULT(0)) |
CV_EXPORTS void | displayStatusBar (const string &winname, const string &text, int delayms CV_DEFAULT(0)) |
CV_EXPORTS void | saveWindowParameters (const string &windowName) |
CV_EXPORTS void | loadWindowParameters (const string &windowName) |
CV_EXPORTS int | startLoop (int(*pt2Func)(int argc, char *argv[]), int argc, char *argv[]) |
CV_EXPORTS void | stopLoop () |
CV_EXPORTS int | createButton (const string &bar_name, ButtonCallback on_change, void *userdata=NULL, int type=CV_PUSH_BUTTON, bool initial_button_state=0) |
CV_EXPORTS_W Mat | imread (const string &filename, int flags=1) |
CV_EXPORTS_W bool | imwrite (const string &filename, InputArray img, const vector< int > ¶ms=vector< int >()) |
CV_EXPORTS_W Mat | imdecode (InputArray buf, int flags) |
CV_EXPORTS Mat | imdecode (InputArray buf, int flags, Mat *dst) |
CV_EXPORTS_W bool | imencode (const string &ext, InputArray img, CV_OUT vector< uchar > &buf, const vector< int > ¶ms=vector< int >()) |
CV_EXPORTS_W int | borderInterpolate (int p, int len, int borderType) |
1D interpolation function: returns coordinate of the "donor" pixel for the specified location p. More... | |
CV_EXPORTS int | getKernelType (InputArray kernel, Point anchor) |
returns type (one of KERNEL_*) of 1D or 2D kernel specified by its coefficients. More... | |
CV_EXPORTS Ptr< BaseRowFilter > | getLinearRowFilter (int srcType, int bufType, InputArray kernel, int anchor, int symmetryType) |
returns the primitive row filter with the specified kernel More... | |
CV_EXPORTS Ptr< BaseColumnFilter > | getLinearColumnFilter (int bufType, int dstType, InputArray kernel, int anchor, int symmetryType, double delta=0, int bits=0) |
returns the primitive column filter with the specified kernel More... | |
CV_EXPORTS Ptr< BaseFilter > | getLinearFilter (int srcType, int dstType, InputArray kernel, Point anchor=Point(-1,-1), double delta=0, int bits=0) |
returns 2D filter with the specified kernel More... | |
CV_EXPORTS Ptr< FilterEngine > | createSeparableLinearFilter (int srcType, int dstType, InputArray rowKernel, InputArray columnKernel, Point anchor=Point(-1,-1), double delta=0, int rowBorderType=BORDER_DEFAULT, int columnBorderType=-1, const Scalar &borderValue=Scalar()) |
returns the separable linear filter engine More... | |
CV_EXPORTS Ptr< FilterEngine > | createLinearFilter (int srcType, int dstType, InputArray kernel, Point _anchor=Point(-1,-1), double delta=0, int rowBorderType=BORDER_DEFAULT, int columnBorderType=-1, const Scalar &borderValue=Scalar()) |
returns the non-separable linear filter engine More... | |
CV_EXPORTS_W Mat | getGaussianKernel (int ksize, double sigma, int ktype=CV_64F) |
returns the Gaussian kernel with the specified parameters More... | |
CV_EXPORTS Ptr< FilterEngine > | createGaussianFilter (int type, Size ksize, double sigma1, double sigma2=0, int borderType=BORDER_DEFAULT) |
returns the Gaussian filter engine More... | |
CV_EXPORTS_W void | getDerivKernels (OutputArray kx, OutputArray ky, int dx, int dy, int ksize, bool normalize=false, int ktype=CV_32F) |
initializes kernels of the generalized Sobel operator More... | |
CV_EXPORTS Ptr< FilterEngine > | createDerivFilter (int srcType, int dstType, int dx, int dy, int ksize, int borderType=BORDER_DEFAULT) |
returns filter engine for the generalized Sobel operator More... | |
CV_EXPORTS Ptr< BaseRowFilter > | getRowSumFilter (int srcType, int sumType, int ksize, int anchor=-1) |
returns horizontal 1D box filter More... | |
CV_EXPORTS Ptr< BaseColumnFilter > | getColumnSumFilter (int sumType, int dstType, int ksize, int anchor=-1, double scale=1) |
returns vertical 1D box filter More... | |
CV_EXPORTS Ptr< FilterEngine > | createBoxFilter (int srcType, int dstType, Size ksize, Point anchor=Point(-1,-1), bool normalize=true, int borderType=BORDER_DEFAULT) |
returns box filter engine More... | |
CV_EXPORTS_W Mat | getGaborKernel (Size ksize, double sigma, double theta, double lambd, double gamma, double psi=CV_PI *0.5, int ktype=CV_64F) |
returns the Gabor kernel with the specified parameters More... | |
CV_EXPORTS Ptr< BaseRowFilter > | getMorphologyRowFilter (int op, int type, int ksize, int anchor=-1) |
returns horizontal 1D morphological filter More... | |
CV_EXPORTS Ptr< BaseColumnFilter > | getMorphologyColumnFilter (int op, int type, int ksize, int anchor=-1) |
returns vertical 1D morphological filter More... | |
CV_EXPORTS Ptr< BaseFilter > | getMorphologyFilter (int op, int type, InputArray kernel, Point anchor=Point(-1,-1)) |
returns 2D morphological filter More... | |
CV_EXPORTS Ptr< FilterEngine > | createMorphologyFilter (int op, int type, InputArray kernel, Point anchor=Point(-1,-1), int rowBorderType=BORDER_CONSTANT, int columnBorderType=-1, const Scalar &borderValue=morphologyDefaultBorderValue()) |
returns morphological filter engine. Only MORPH_ERODE and MORPH_DILATE are supported. More... | |
CV_EXPORTS_W Mat | getStructuringElement (int shape, Size ksize, Point anchor=Point(-1,-1)) |
returns structuring element of the specified shape and size More... | |
CV_EXPORTS_W void | copyMakeBorder (InputArray src, OutputArray dst, int top, int bottom, int left, int right, int borderType, const Scalar &value=Scalar()) |
copies 2D array to a larger destination array with extrapolation of the outer part of src using the specified border mode More... | |
CV_EXPORTS_W void | medianBlur (InputArray src, OutputArray dst, int ksize) |
smooths the image using median filter. More... | |
CV_EXPORTS_W void | GaussianBlur (InputArray src, OutputArray dst, Size ksize, double sigmaX, double sigmaY=0, int borderType=BORDER_DEFAULT) |
smooths the image using Gaussian filter. More... | |
CV_EXPORTS_W void | bilateralFilter (InputArray src, OutputArray dst, int d, double sigmaColor, double sigmaSpace, int borderType=BORDER_DEFAULT) |
smooths the image using bilateral filter More... | |
CV_EXPORTS_W void | adaptiveBilateralFilter (InputArray src, OutputArray dst, Size ksize, double sigmaSpace, double maxSigmaColor=20.0, Point anchor=Point(-1,-1), int borderType=BORDER_DEFAULT) |
smooths the image using adaptive bilateral filter More... | |
CV_EXPORTS_W void | boxFilter (InputArray src, OutputArray dst, int ddepth, Size ksize, Point anchor=Point(-1,-1), bool normalize=true, int borderType=BORDER_DEFAULT) |
smooths the image using the box filter. Each pixel is processed in O(1) time More... | |
CV_EXPORTS_W void | blur (InputArray src, OutputArray dst, Size ksize, Point anchor=Point(-1,-1), int borderType=BORDER_DEFAULT) |
a synonym for normalized box filter More... | |
CV_EXPORTS_W void | filter2D (InputArray src, OutputArray dst, int ddepth, InputArray kernel, Point anchor=Point(-1,-1), double delta=0, int borderType=BORDER_DEFAULT) |
applies non-separable 2D linear filter to the image More... | |
CV_EXPORTS_W 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 separable 2D linear filter to the image More... | |
CV_EXPORTS_W 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) |
applies generalized Sobel operator to the image More... | |
CV_EXPORTS_W void | Scharr (InputArray src, OutputArray dst, int ddepth, int dx, int dy, double scale=1, double delta=0, int borderType=BORDER_DEFAULT) |
applies the vertical or horizontal Scharr operator to the image More... | |
CV_EXPORTS_W void | Laplacian (InputArray src, OutputArray dst, int ddepth, int ksize=1, double scale=1, double delta=0, int borderType=BORDER_DEFAULT) |
applies Laplacian operator to the image More... | |
CV_EXPORTS_W void | Canny (InputArray image, OutputArray edges, double threshold1, double threshold2, int apertureSize=3, bool L2gradient=false) |
applies Canny edge detector and produces the edge map. More... | |
CV_EXPORTS_W void | cornerMinEigenVal (InputArray src, OutputArray dst, int blockSize, int ksize=3, int borderType=BORDER_DEFAULT) |
computes minimum eigen value of 2x2 derivative covariation matrix at each pixel - the cornerness criteria More... | |
CV_EXPORTS_W void | cornerHarris (InputArray src, OutputArray dst, int blockSize, int ksize, double k, int borderType=BORDER_DEFAULT) |
computes Harris cornerness criteria at each image pixel More... | |
CV_EXPORTS void | eigen2x2 (const float *a, float *e, int n) |
CV_EXPORTS_W void | cornerEigenValsAndVecs (InputArray src, OutputArray dst, int blockSize, int ksize, int borderType=BORDER_DEFAULT) |
computes both eigenvalues and the eigenvectors of 2x2 derivative covariation matrix at each pixel. The output is stored as 6-channel matrix. More... | |
CV_EXPORTS_W void | preCornerDetect (InputArray src, OutputArray dst, int ksize, int borderType=BORDER_DEFAULT) |
computes another complex cornerness criteria at each pixel More... | |
CV_EXPORTS_W void | cornerSubPix (InputArray image, InputOutputArray corners, Size winSize, Size zeroZone, TermCriteria criteria) |
adjusts the corner locations with sub-pixel accuracy to maximize the certain cornerness criteria More... | |
CV_EXPORTS_W 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) |
finds the strong enough corners where the cornerMinEigenVal() or cornerHarris() report the local maxima More... | |
CV_EXPORTS_W void | HoughLines (InputArray image, OutputArray lines, double rho, double theta, int threshold, double srn=0, double stn=0) |
finds lines in the black-n-white image using the standard or pyramid Hough transform More... | |
CV_EXPORTS_W void | HoughLinesP (InputArray image, OutputArray lines, double rho, double theta, int threshold, double minLineLength=0, double maxLineGap=0) |
finds line segments in the black-n-white image using probabilistic Hough transform More... | |
CV_EXPORTS_W 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 the grayscale image using 2+1 gradient Hough transform More... | |
CV_EXPORTS_W 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 the image (applies the local minimum operator) More... | |
CV_EXPORTS_W 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 the image (applies the local maximum operator) More... | |
CV_EXPORTS_W 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()) |
applies an advanced morphological operation to the image More... | |
CV_EXPORTS_W void | resize (InputArray src, OutputArray dst, Size dsize, double fx=0, double fy=0, int interpolation=INTER_LINEAR) |
resizes the image More... | |
CV_EXPORTS_W void | warpAffine (InputArray src, OutputArray dst, InputArray M, Size dsize, int flags=INTER_LINEAR, int borderMode=BORDER_CONSTANT, const Scalar &borderValue=Scalar()) |
warps the image using affine transformation More... | |
CV_EXPORTS_W void | warpPerspective (InputArray src, OutputArray dst, InputArray M, Size dsize, int flags=INTER_LINEAR, int borderMode=BORDER_CONSTANT, const Scalar &borderValue=Scalar()) |
warps the image using perspective transformation More... | |
CV_EXPORTS_W void | remap (InputArray src, OutputArray dst, InputArray map1, InputArray map2, int interpolation, int borderMode=BORDER_CONSTANT, const Scalar &borderValue=Scalar()) |
warps the image using the precomputed maps. The maps are stored in either floating-point or integer fixed-point format More... | |
CV_EXPORTS_W void | convertMaps (InputArray map1, InputArray map2, OutputArray dstmap1, OutputArray dstmap2, int dstmap1type, bool nninterpolation=false) |
converts maps for remap from floating-point to fixed-point format or backwards More... | |
CV_EXPORTS_W Mat | getRotationMatrix2D (Point2f center, double angle, double scale) |
returns 2x3 affine transformation matrix for the planar rotation. More... | |
CV_EXPORTS Mat | getPerspectiveTransform (const Point2f src[], const Point2f dst[]) |
returns 3x3 perspective transformation for the corresponding 4 point pairs. More... | |
CV_EXPORTS Mat | getAffineTransform (const Point2f src[], const Point2f dst[]) |
returns 2x3 affine transformation for the corresponding 3 point pairs. More... | |
CV_EXPORTS_W void | invertAffineTransform (InputArray M, OutputArray iM) |
computes 2x3 affine transformation matrix that is inverse to the specified 2x3 affine transformation. More... | |
CV_EXPORTS_W Mat | getPerspectiveTransform (InputArray src, InputArray dst) |
CV_EXPORTS_W Mat | getAffineTransform (InputArray src, InputArray dst) |
CV_EXPORTS_W void | getRectSubPix (InputArray image, Size patchSize, Point2f center, OutputArray patch, int patchType=-1) |
extracts rectangle from the image at sub-pixel location More... | |
CV_EXPORTS_W void | integral (InputArray src, OutputArray sum, int sdepth=-1) |
computes the integral image More... | |
CV_EXPORTS_AS (integral2) void integral(InputArray src | |
computes the integral image and integral for the squared image More... | |
CV_EXPORTS_AS (integral3) void integral(InputArray src | |
computes the integral image, integral for the squared image and the tilted integral image More... | |
CV_EXPORTS_W void | accumulate (InputArray src, InputOutputArray dst, InputArray mask=noArray()) |
adds image to the accumulator (dst += src). Unlike cv::add, dst and src can have different types. More... | |
CV_EXPORTS_W void | accumulateSquare (InputArray src, InputOutputArray dst, InputArray mask=noArray()) |
adds squared src image to the accumulator (dst += src*src). More... | |
CV_EXPORTS_W void | accumulateProduct (InputArray src1, InputArray src2, InputOutputArray dst, InputArray mask=noArray()) |
adds product of the 2 images to the accumulator (dst += src1*src2). More... | |
CV_EXPORTS_W void | accumulateWeighted (InputArray src, InputOutputArray dst, double alpha, InputArray mask=noArray()) |
updates the running average (dst = dst*(1-alpha) + src*alpha) More... | |
CV_EXPORTS_W double | PSNR (InputArray src1, InputArray src2) |
computes PSNR image/video quality metric More... | |
CV_EXPORTS_W Point2d | phaseCorrelate (InputArray src1, InputArray src2, InputArray window=noArray()) |
CV_EXPORTS_W Point2d | phaseCorrelateRes (InputArray src1, InputArray src2, InputArray window, CV_OUT double *response=0) |
CV_EXPORTS_W void | createHanningWindow (OutputArray dst, Size winSize, int type) |
CV_EXPORTS_W double | threshold (InputArray src, OutputArray dst, double thresh, double maxval, int type) |
applies fixed threshold to the image More... | |
CV_EXPORTS_W void | adaptiveThreshold (InputArray src, OutputArray dst, double maxValue, int adaptiveMethod, int thresholdType, int blockSize, double C) |
applies variable (adaptive) threshold to the image More... | |
CV_EXPORTS_W void | pyrDown (InputArray src, OutputArray dst, const Size &dstsize=Size(), int borderType=BORDER_DEFAULT) |
smooths and downsamples the image More... | |
CV_EXPORTS_W void | pyrUp (InputArray src, OutputArray dst, const Size &dstsize=Size(), int borderType=BORDER_DEFAULT) |
upsamples and smoothes the image More... | |
CV_EXPORTS void | buildPyramid (InputArray src, OutputArrayOfArrays dst, int maxlevel, int borderType=BORDER_DEFAULT) |
builds the gaussian pyramid using pyrDown() as a basic operation More... | |
CV_EXPORTS_W void | undistort (InputArray src, OutputArray dst, InputArray cameraMatrix, InputArray distCoeffs, InputArray newCameraMatrix=noArray()) |
corrects lens distortion for the given camera matrix and distortion coefficients More... | |
CV_EXPORTS_W void | initUndistortRectifyMap (InputArray cameraMatrix, InputArray distCoeffs, InputArray R, InputArray newCameraMatrix, Size size, int m1type, OutputArray map1, OutputArray map2) |
initializes maps for cv::remap() to correct lens distortion and optionally rectify the image More... | |
CV_EXPORTS_W float | initWideAngleProjMap (InputArray cameraMatrix, InputArray distCoeffs, Size imageSize, int destImageWidth, int m1type, OutputArray map1, OutputArray map2, int projType=PROJ_SPHERICAL_EQRECT, double alpha=0) |
initializes maps for cv::remap() for wide-angle More... | |
CV_EXPORTS_W Mat | getDefaultNewCameraMatrix (InputArray cameraMatrix, Size imgsize=Size(), bool centerPrincipalPoint=false) |
returns the default new camera matrix (by default it is the same as cameraMatrix unless centerPricipalPoint=true) More... | |
CV_EXPORTS_W void | undistortPoints (InputArray src, OutputArray dst, InputArray cameraMatrix, InputArray distCoeffs, InputArray R=noArray(), InputArray P=noArray()) |
returns points' coordinates after lens distortion correction More... | |
CV_EXPORTS 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) |
computes the joint dense histogram for a set of images. More... | |
CV_EXPORTS 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) |
computes the joint sparse histogram for a set of images. More... | |
CV_EXPORTS_W void | calcHist (InputArrayOfArrays images, const vector< int > &channels, InputArray mask, OutputArray hist, const vector< int > &histSize, const vector< float > &ranges, bool accumulate=false) |
CV_EXPORTS void | calcBackProject (const Mat *images, int nimages, const int *channels, InputArray hist, OutputArray backProject, const float **ranges, double scale=1, bool uniform=true) |
computes back projection for the set of images More... | |
CV_EXPORTS void | calcBackProject (const Mat *images, int nimages, const int *channels, const SparseMat &hist, OutputArray backProject, const float **ranges, double scale=1, bool uniform=true) |
computes back projection for the set of images More... | |
CV_EXPORTS_W void | calcBackProject (InputArrayOfArrays images, const vector< int > &channels, InputArray hist, OutputArray dst, const vector< float > &ranges, double scale) |
CV_EXPORTS_W double | compareHist (InputArray H1, InputArray H2, int method) |
compares two histograms stored in dense arrays More... | |
CV_EXPORTS double | compareHist (const SparseMat &H1, const SparseMat &H2, int method) |
compares two histograms stored in sparse arrays More... | |
CV_EXPORTS_W void | equalizeHist (InputArray src, OutputArray dst) |
normalizes the grayscale image brightness and contrast by normalizing its histogram More... | |
CV_EXPORTS_W Ptr< CLAHE > | createCLAHE (double clipLimit=40.0, Size tileGridSize=Size(8, 8)) |
CV_EXPORTS float | EMD (InputArray signature1, InputArray signature2, int distType, InputArray cost=noArray(), float *lowerBound=0, OutputArray flow=noArray()) |
CV_EXPORTS_W void | watershed (InputArray image, InputOutputArray markers) |
segments the image using watershed algorithm More... | |
CV_EXPORTS_W void | pyrMeanShiftFiltering (InputArray src, OutputArray dst, double sp, double sr, int maxLevel=1, TermCriteria termcrit=TermCriteria(TermCriteria::MAX_ITER+TermCriteria::EPS, 5, 1)) |
filters image using meanshift algorithm More... | |
CV_EXPORTS_W void | grabCut (InputArray img, InputOutputArray mask, Rect rect, InputOutputArray bgdModel, InputOutputArray fgdModel, int iterCount, int mode=GC_EVAL) |
segments the image using GrabCut algorithm More... | |
CV_EXPORTS_AS (distanceTransformWithLabels) void distanceTransform(InputArray src | |
builds the discrete Voronoi diagram More... | |
CV_EXPORTS_W void | distanceTransform (InputArray src, OutputArray dst, int distanceType, int maskSize) |
computes the distance transform map More... | |
CV_EXPORTS int | floodFill (InputOutputArray image, Point seedPoint, Scalar newVal, CV_OUT Rect *rect=0, Scalar loDiff=Scalar(), Scalar upDiff=Scalar(), int flags=4) |
fills the semi-uniform image region starting from the specified seed point More... | |
CV_EXPORTS_W int | floodFill (InputOutputArray image, InputOutputArray mask, Point seedPoint, Scalar newVal, CV_OUT Rect *rect=0, Scalar loDiff=Scalar(), Scalar upDiff=Scalar(), int flags=4) |
fills the semi-uniform image region and/or the mask starting from the specified seed point More... | |
CV_EXPORTS_W void | cvtColor (InputArray src, OutputArray dst, int code, int dstCn=0) |
converts image from one color space to another More... | |
CV_EXPORTS_W Moments | moments (InputArray array, bool binaryImage=false) |
computes moments of the rasterized shape or a vector of points More... | |
CV_EXPORTS void | HuMoments (const Moments &moments, double hu[7]) |
computes 7 Hu invariants from the moments More... | |
CV_EXPORTS_W void | HuMoments (const Moments &m, CV_OUT OutputArray hu) |
CV_EXPORTS_W void | matchTemplate (InputArray image, InputArray templ, OutputArray result, int method) |
computes the proximity map for the raster template and the image where the template is searched for More... | |
CV_EXPORTS_W void | findContours (InputOutputArray image, OutputArrayOfArrays contours, OutputArray hierarchy, int mode, int method, Point offset=Point()) |
retrieves contours and the hierarchical information from black-n-white image. More... | |
CV_EXPORTS void | findContours (InputOutputArray image, OutputArrayOfArrays contours, int mode, int method, Point offset=Point()) |
retrieves contours from black-n-white image. More... | |
CV_EXPORTS_W void | drawContours (InputOutputArray image, InputArrayOfArrays contours, int contourIdx, const Scalar &color, int thickness=1, int lineType=8, InputArray hierarchy=noArray(), int maxLevel=INT_MAX, Point offset=Point()) |
draws contours in the image More... | |
CV_EXPORTS_W void | approxPolyDP (InputArray curve, OutputArray approxCurve, double epsilon, bool closed) |
approximates contour or a curve using Douglas-Peucker algorithm More... | |
CV_EXPORTS_W double | arcLength (InputArray curve, bool closed) |
computes the contour perimeter (closed=true) or a curve length More... | |
CV_EXPORTS_W Rect | boundingRect (InputArray points) |
computes the bounding rectangle for a contour More... | |
CV_EXPORTS_W double | contourArea (InputArray contour, bool oriented=false) |
computes the contour area More... | |
CV_EXPORTS_W RotatedRect | minAreaRect (InputArray points) |
computes the minimal rotated rectangle for a set of points More... | |
CV_EXPORTS_W void | minEnclosingCircle (InputArray points, CV_OUT Point2f ¢er, CV_OUT float &radius) |
computes the minimal enclosing circle for a set of points More... | |
CV_EXPORTS_W double | matchShapes (InputArray contour1, InputArray contour2, int method, double parameter) |
matches two contours using one of the available algorithms More... | |
CV_EXPORTS_W void | convexHull (InputArray points, OutputArray hull, bool clockwise=false, bool returnPoints=true) |
computes convex hull for a set of 2D points. More... | |
CV_EXPORTS_W void | convexityDefects (InputArray contour, InputArray convexhull, OutputArray convexityDefects) |
computes the contour convexity defects More... | |
CV_EXPORTS_W bool | isContourConvex (InputArray contour) |
returns true if the contour is convex. Does not support contours with self-intersection More... | |
CV_EXPORTS_W float | intersectConvexConvex (InputArray _p1, InputArray _p2, OutputArray _p12, bool handleNested=true) |
finds intersection of two convex polygons More... | |
CV_EXPORTS_W RotatedRect | fitEllipse (InputArray points) |
fits ellipse to the set of 2D points More... | |
CV_EXPORTS_W void | fitLine (InputArray points, OutputArray line, int distType, double param, double reps, double aeps) |
fits line to the set of 2D points using M-estimator algorithm More... | |
CV_EXPORTS_W double | pointPolygonTest (InputArray contour, Point2f pt, bool measureDist) |
checks if the point is inside the contour. Optionally computes the signed distance from the point to the contour boundary More... | |
uchar * | getData (IplImage *image) |
CV_EXPORTS bool | initModule_ml (void) |
CV_EXPORTS_W bool | initModule_nonfree () |
CV_EXPORTS void | groupRectangles (CV_OUT CV_IN_OUT vector< Rect > &rectList, int groupThreshold, double eps=0.2) |
CV_EXPORTS_W void | groupRectangles (CV_OUT CV_IN_OUT vector< Rect > &rectList, CV_OUT vector< int > &weights, int groupThreshold, double eps=0.2) |
CV_EXPORTS void | groupRectangles (vector< Rect > &rectList, int groupThreshold, double eps, vector< int > *weights, vector< double > *levelWeights) |
CV_EXPORTS void | groupRectangles (vector< Rect > &rectList, vector< int > &rejectLevels, vector< double > &levelWeights, int groupThreshold, double eps=0.2) |
CV_EXPORTS void | groupRectangles_meanshift (vector< Rect > &rectList, vector< double > &foundWeights, vector< double > &foundScales, double detectThreshold=0.0, Size winDetSize=Size(64, 128)) |
CV_EXPORTS_W void | findDataMatrix (InputArray image, CV_OUT vector< string > &codes, OutputArray corners=noArray(), OutputArrayOfArrays dmtx=noArray()) |
CV_EXPORTS_W void | drawDataMatrixCodes (InputOutputArray image, const vector< string > &codes, InputArray corners) |
CV_EXPORTS_W void | inpaint (InputArray src, InputArray inpaintMask, OutputArray dst, double inpaintRadius, int flags) |
restores the damaged image areas using one of the available intpainting algorithms More... | |
CV_EXPORTS_W void | fastNlMeansDenoising (InputArray src, OutputArray dst, float h=3, int templateWindowSize=7, int searchWindowSize=21) |
CV_EXPORTS_W void | fastNlMeansDenoisingColored (InputArray src, OutputArray dst, float h=3, float hColor=3, int templateWindowSize=7, int searchWindowSize=21) |
CV_EXPORTS_W void | fastNlMeansDenoisingMulti (InputArrayOfArrays srcImgs, OutputArray dst, int imgToDenoiseIndex, int temporalWindowSize, float h=3, int templateWindowSize=7, int searchWindowSize=21) |
CV_EXPORTS_W void | fastNlMeansDenoisingColoredMulti (InputArrayOfArrays srcImgs, OutputArray dst, int imgToDenoiseIndex, int temporalWindowSize, float h=3, float hColor=3, int templateWindowSize=7, int searchWindowSize=21) |
CV_EXPORTS void | PrintTo (const Size &sz,::std::ostream *os) |
CV_EXPORTS_W void | updateMotionHistory (InputArray silhouette, InputOutputArray mhi, double timestamp, double duration) |
updates motion history image using the current silhouette More... | |
CV_EXPORTS_W void | calcMotionGradient (InputArray mhi, OutputArray mask, OutputArray orientation, double delta1, double delta2, int apertureSize=3) |
computes the motion gradient orientation image from the motion history image More... | |
CV_EXPORTS_W double | calcGlobalOrientation (InputArray orientation, InputArray mask, InputArray mhi, double timestamp, double duration) |
computes the global orientation of the selected motion history image part More... | |
CV_EXPORTS_W void | segmentMotion (InputArray mhi, OutputArray segmask, CV_OUT vector< Rect > &boundingRects, double timestamp, double segThresh) |
CV_EXPORTS_W RotatedRect | CamShift (InputArray probImage, CV_OUT CV_IN_OUT Rect &window, TermCriteria criteria) |
updates the object tracking window using CAMSHIFT algorithm More... | |
CV_EXPORTS_W int | meanShift (InputArray probImage, CV_OUT CV_IN_OUT Rect &window, TermCriteria criteria) |
updates the object tracking window using meanshift algorithm More... | |
CV_EXPORTS_W 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 a pyramid which can be used as input for calcOpticalFlowPyrLK More... | |
CV_EXPORTS_W void | calcOpticalFlowPyrLK (InputArray prevImg, InputArray nextImg, InputArray prevPts, CV_OUT 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) |
computes sparse optical flow using multi-scale Lucas-Kanade algorithm More... | |
CV_EXPORTS_W void | calcOpticalFlowFarneback (InputArray prev, InputArray next, CV_OUT InputOutputArray flow, double pyr_scale, int levels, int winsize, int iterations, int poly_n, double poly_sigma, int flags) |
computes dense optical flow using Farneback algorithm More... | |
CV_EXPORTS_W Mat | estimateRigidTransform (InputArray src, InputArray dst, bool fullAffine) |
estimates the best-fit Euqcidean, similarity, affine or perspective transformation More... | |
CV_EXPORTS_W void | calcOpticalFlowSF (Mat &from, Mat &to, Mat &flow, int layers, int averaging_block_size, int max_flow) |
computes dense optical flow using Simple Flow algorithm More... | |
CV_EXPORTS_W void | calcOpticalFlowSF (Mat &from, Mat &to, Mat &flow, int layers, int averaging_block_size, int max_flow, double sigma_dist, double sigma_color, int postprocess_window, double sigma_dist_fix, double sigma_color_fix, double occ_thr, int upscale_averaging_radius, double upscale_sigma_dist, double upscale_sigma_color, double speed_up_thr) |
CV_EXPORTS Ptr< DenseOpticalFlow > | createOptFlow_DualTVL1 () |
CV_EXPORTS bool | initModule_video (void) |
Variables | |
class CV_EXPORTS | MatExpr |
class CV_EXPORTS | MatOp_Base |
class CV_EXPORTS | MatArg |
class CV_EXPORTS | MatConstIterator |
double | iterFactor =1.) |
class CV_EXPORTS | FileNode |
class CV_EXPORTS | FileNodeIterator |
class CV_EXPORTS | Algorithm |
class CV_EXPORTS | AlgorithmInfo |
struct CV_EXPORTS | AlgorithmInfoData |
OutputArray | sum |
OutputArray OutputArray | sqsum |
OutputArray OutputArray int | sdepth =-1 ) |
OutputArray OutputArray OutputArray | tilted |
OutputArray | dst |
OutputArray OutputArray | labels |
OutputArray OutputArray int | distanceType |
OutputArray OutputArray int int | maskSize |
OutputArray OutputArray int int int | labelType =DIST_LABEL_CCOMP ) |
Namespace where all the C++ OpenCV functionality resides.
typedef CvMotionModel cv::MotionModel |
typedef CvFeatureTracker cv::FeatureTracker |
typedef CvHybridTracker cv::HybridTracker |
typedef Affine3<float> cv::Affine3f |
typedef Affine3<double> cv::Affine3d |
typedef std::string cv::String |
typedef std::basic_string<wchar_t> cv::WString |
typedef int(CV_CDECL * cv::ErrorCallback)(int status, const char *func_name, const char *err_msg, const char *file_name, int line, void *userdata) |
typedef Matx<float, 1, 2> cv::Matx12f |
typedef Matx<double, 1, 2> cv::Matx12d |
typedef Matx<float, 1, 3> cv::Matx13f |
typedef Matx<double, 1, 3> cv::Matx13d |
typedef Matx<float, 1, 4> cv::Matx14f |
typedef Matx<double, 1, 4> cv::Matx14d |
typedef Matx<float, 1, 6> cv::Matx16f |
typedef Matx<double, 1, 6> cv::Matx16d |
typedef Matx<float, 2, 1> cv::Matx21f |
typedef Matx<double, 2, 1> cv::Matx21d |
typedef Matx<float, 3, 1> cv::Matx31f |
typedef Matx<double, 3, 1> cv::Matx31d |
typedef Matx<float, 4, 1> cv::Matx41f |
typedef Matx<double, 4, 1> cv::Matx41d |
typedef Matx<float, 6, 1> cv::Matx61f |
typedef Matx<double, 6, 1> cv::Matx61d |
typedef Matx<float, 2, 2> cv::Matx22f |
typedef Matx<double, 2, 2> cv::Matx22d |
typedef Matx<float, 2, 3> cv::Matx23f |
typedef Matx<double, 2, 3> cv::Matx23d |
typedef Matx<float, 3, 2> cv::Matx32f |
typedef Matx<double, 3, 2> cv::Matx32d |
typedef Matx<float, 3, 3> cv::Matx33f |
typedef Matx<double, 3, 3> cv::Matx33d |
typedef Matx<float, 3, 4> cv::Matx34f |
typedef Matx<double, 3, 4> cv::Matx34d |
typedef Matx<float, 4, 3> cv::Matx43f |
typedef Matx<double, 4, 3> cv::Matx43d |
typedef Matx<float, 4, 4> cv::Matx44f |
typedef Matx<double, 4, 4> cv::Matx44d |
typedef Matx<float, 6, 6> cv::Matx66f |
typedef Matx<double, 6, 6> cv::Matx66d |
typedef Complex<float> cv::Complexf |
typedef Complex<double> cv::Complexd |
typedef Point_<int> cv::Point2i |
typedef Size_<int> cv::Size2i |
typedef Size_<double> cv::Size2d |
typedef Point_<float> cv::Point2f |
typedef Point_<double> cv::Point2d |
typedef Size_<float> cv::Size2f |
typedef Point3_<int> cv::Point3i |
typedef Point3_<float> cv::Point3f |
typedef Point3_<double> cv::Point3d |
typedef Scalar_<double> cv::Scalar |
typedef const _InputArray& cv::InputArray |
typedef InputArray cv::InputArrayOfArrays |
typedef const _OutputArray& cv::OutputArray |
typedef OutputArray cv::OutputArrayOfArrays |
typedef OutputArray cv::InputOutputArray |
typedef void(* cv::BinaryFunc)(const uchar *src1, size_t step1, const uchar *src2, size_t step2, uchar *dst, size_t step, Size sz, void *) |
typedef Ptr<CvMemStorage> cv::MemStorage |
typedef tbb::blocked_range<int> cv::BlockedRange |
typedef tbb::split cv::Split |
typedef std::vector< Rect > cv::ConcurrentRectVector |
typedef std::vector< double > cv::ConcurrentDoubleVector |
typedef WImage<uchar> cv::WImage_b |
typedef WImageView<uchar> cv::WImageView_b |
typedef WImageBuffer<uchar> cv::WImageBuffer_b |
typedef WImageC<uchar, 1> cv::WImage1_b |
typedef WImageViewC<uchar, 1> cv::WImageView1_b |
typedef WImageBufferC<uchar, 1> cv::WImageBuffer1_b |
typedef WImageC<uchar, 3> cv::WImage3_b |
typedef WImageViewC<uchar, 3> cv::WImageView3_b |
typedef WImageBufferC<uchar, 3> cv::WImageBuffer3_b |
typedef WImage<float> cv::WImage_f |
typedef WImageView<float> cv::WImageView_f |
typedef WImageBuffer<float> cv::WImageBuffer_f |
typedef WImageC<float, 1> cv::WImage1_f |
typedef WImageViewC<float, 1> cv::WImageView1_f |
typedef WImageBufferC<float, 1> cv::WImageBuffer1_f |
typedef WImageC<float, 3> cv::WImage3_f |
typedef WImageViewC<float, 3> cv::WImageView3_f |
typedef WImageBufferC<float, 3> cv::WImageBuffer3_f |
typedef WImage<short> cv::WImage_16s |
typedef WImageView<short> cv::WImageView_16s |
typedef WImageBuffer<short> cv::WImageBuffer_16s |
typedef WImageC<short, 1> cv::WImage1_16s |
typedef WImageViewC<short, 1> cv::WImageView1_16s |
typedef WImageBufferC<short, 1> cv::WImageBuffer1_16s |
typedef WImageC<short, 3> cv::WImage3_16s |
typedef WImageViewC<short, 3> cv::WImageView3_16s |
typedef WImageBufferC<short, 3> cv::WImageBuffer3_16s |
typedef WImage<ushort> cv::WImage_16u |
typedef WImageView<ushort> cv::WImageView_16u |
typedef WImageBuffer<ushort> cv::WImageBuffer_16u |
typedef WImageC<ushort, 1> cv::WImage1_16u |
typedef WImageViewC<ushort, 1> cv::WImageView1_16u |
typedef WImageBufferC<ushort, 1> cv::WImageBuffer1_16u |
typedef WImageC<ushort, 3> cv::WImage3_16u |
typedef WImageViewC<ushort, 3> cv::WImageView3_16u |
typedef WImageBufferC<ushort, 3> cv::WImageBuffer3_16u |
typedef ORB cv::OrbFeatureDetector |
typedef ORB cv::OrbDescriptorExtractor |
typedef MSER cv::MserFeatureDetector |
typedef StarDetector cv::StarFeatureDetector |
typedef Hamming cv::HammingLUT |
typedef CvEMParams cv::EMParams |
typedef CvEM cv::ExpectationMaximization |
typedef CvStatModel cv::StatModel |
typedef CvParamGrid cv::ParamGrid |
typedef CvKNearest cv::KNearest |
typedef CvSVMParams cv::SVMParams |
typedef CvSVMKernel cv::SVMKernel |
typedef CvSVMSolver cv::SVMSolver |
typedef CvDTreeParams cv::DTreeParams |
typedef CvMLData cv::TrainData |
typedef CvDTree cv::DecisionTree |
typedef CvForestTree cv::ForestTree |
typedef CvRTParams cv::RandomTreeParams |
typedef CvRTrees cv::RandomTrees |
typedef CvERTreeTrainData cv::ERTreeTRainData |
typedef CvForestERTree cv::ERTree |
typedef CvERTrees cv::ERTrees |
typedef CvBoostParams cv::BoostParams |
typedef CvBoostTree cv::BoostTree |
typedef CvANN_MLP cv::NeuralNet_MLP |
typedef CvGBTrees cv::GradientBoostingTrees |
typedef SIFT cv::SiftFeatureDetector |
typedef SIFT cv::SiftDescriptorExtractor |
typedef SURF cv::SurfFeatureDetector |
typedef SURF cv::SurfDescriptorExtractor |
anonymous enum |
anonymous enum |
anonymous enum |
anonymous enum |
anonymous enum |
anonymous enum |
anonymous enum |
anonymous enum |
anonymous enum |
anonymous enum |
anonymous enum |
anonymous enum |
anonymous enum |
anonymous enum |
anonymous enum |
anonymous enum |
anonymous enum |
anonymous enum |
anonymous enum |
anonymous enum |
anonymous enum |
anonymous enum |
anonymous enum |
anonymous enum |
anonymous enum |
anonymous enum |
anonymous enum |
mode of the contour retrieval algorithm
anonymous enum |
anonymous enum |
anonymous enum |
CV_EXPORTS_W void cv::Rodrigues | ( | InputArray | src, |
OutputArray | dst, | ||
OutputArray | jacobian = noArray() |
||
) |
converts rotation vector to rotation matrix or vice versa using Rodrigues transformation
CV_EXPORTS_W Mat cv::findHomography | ( | InputArray | srcPoints, |
InputArray | dstPoints, | ||
int | method = 0 , |
||
double | ransacReprojThreshold = 3 , |
||
OutputArray | mask = noArray() |
||
) |
computes the best-fit perspective transformation mapping srcPoints to dstPoints.
CV_EXPORTS Mat cv::findHomography | ( | InputArray | srcPoints, |
InputArray | dstPoints, | ||
OutputArray | mask, | ||
int | method = 0 , |
||
double | ransacReprojThreshold = 3 |
||
) |
variant of findHomography for backward compatibility
CV_EXPORTS_W Vec3d cv::RQDecomp3x3 | ( | InputArray | src, |
OutputArray | mtxR, | ||
OutputArray | mtxQ, | ||
OutputArray | Qx = noArray() , |
||
OutputArray | Qy = noArray() , |
||
OutputArray | Qz = noArray() |
||
) |
Computes RQ decomposition of 3x3 matrix.
CV_EXPORTS_W void cv::decomposeProjectionMatrix | ( | InputArray | projMatrix, |
OutputArray | cameraMatrix, | ||
OutputArray | rotMatrix, | ||
OutputArray | transVect, | ||
OutputArray | rotMatrixX = noArray() , |
||
OutputArray | rotMatrixY = noArray() , |
||
OutputArray | rotMatrixZ = noArray() , |
||
OutputArray | eulerAngles = noArray() |
||
) |
Decomposes the projection matrix into camera matrix and the rotation martix and the translation vector.
CV_EXPORTS_W void cv::matMulDeriv | ( | InputArray | A, |
InputArray | B, | ||
OutputArray | dABdA, | ||
OutputArray | dABdB | ||
) |
computes derivatives of the matrix product w.r.t each of the multiplied matrix coefficients
CV_EXPORTS_W void cv::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() |
||
) |
composes 2 [R|t] transformations together. Also computes the derivatives of the result w.r.t the arguments
CV_EXPORTS_W void cv::projectPoints | ( | InputArray | objectPoints, |
InputArray | rvec, | ||
InputArray | tvec, | ||
InputArray | cameraMatrix, | ||
InputArray | distCoeffs, | ||
OutputArray | imagePoints, | ||
OutputArray | jacobian = noArray() , |
||
double | aspectRatio = 0 |
||
) |
projects points from the model coordinate space to the image coordinates. Also computes derivatives of the image coordinates w.r.t the intrinsic and extrinsic camera parameters
CV_EXPORTS_W bool cv::solvePnP | ( | InputArray | objectPoints, |
InputArray | imagePoints, | ||
InputArray | cameraMatrix, | ||
InputArray | distCoeffs, | ||
OutputArray | rvec, | ||
OutputArray | tvec, | ||
bool | useExtrinsicGuess = false , |
||
int | flags = ITERATIVE |
||
) |
CV_EXPORTS_W void cv::solvePnPRansac | ( | InputArray | objectPoints, |
InputArray | imagePoints, | ||
InputArray | cameraMatrix, | ||
InputArray | distCoeffs, | ||
OutputArray | rvec, | ||
OutputArray | tvec, | ||
bool | useExtrinsicGuess = false , |
||
int | iterationsCount = 100 , |
||
float | reprojectionError = 8.0 , |
||
int | minInliersCount = 100 , |
||
OutputArray | inliers = noArray() , |
||
int | flags = ITERATIVE |
||
) |
computes the camera pose from a few 3D points and the corresponding projections. The outliers are possible.
CV_EXPORTS_W Mat cv::initCameraMatrix2D | ( | InputArrayOfArrays | objectPoints, |
InputArrayOfArrays | imagePoints, | ||
Size | imageSize, | ||
double | aspectRatio = 1. |
||
) |
initializes camera matrix from a few 3D points and the corresponding projections.
CV_EXPORTS_W bool cv::findChessboardCorners | ( | InputArray | image, |
Size | patternSize, | ||
OutputArray | corners, | ||
int | flags = CALIB_CB_ADAPTIVE_THRESH+CALIB_CB_NORMALIZE_IMAGE |
||
) |
finds checkerboard pattern of the specified size in the image
CV_EXPORTS bool cv::find4QuadCornerSubpix | ( | InputArray | img, |
InputOutputArray | corners, | ||
Size | region_size | ||
) |
finds subpixel-accurate positions of the chessboard corners
CV_EXPORTS_W void cv::drawChessboardCorners | ( | InputOutputArray | image, |
Size | patternSize, | ||
InputArray | corners, | ||
bool | patternWasFound | ||
) |
draws the checkerboard pattern (found or partly found) in the image
CV_EXPORTS_W bool cv::findCirclesGrid | ( | InputArray | image, |
Size | patternSize, | ||
OutputArray | centers, | ||
int | flags = CALIB_CB_SYMMETRIC_GRID , |
||
const Ptr< FeatureDetector > & | blobDetector = new SimpleBlobDetector() |
||
) |
finds circles' grid pattern of the specified size in the image
CV_EXPORTS_W bool cv::findCirclesGridDefault | ( | InputArray | image, |
Size | patternSize, | ||
OutputArray | centers, | ||
int | flags = CALIB_CB_SYMMETRIC_GRID |
||
) |
the deprecated function. Use findCirclesGrid() instead of it.
CV_EXPORTS_W double cv::calibrateCamera | ( | InputArrayOfArrays | objectPoints, |
InputArrayOfArrays | imagePoints, | ||
Size | imageSize, | ||
CV_OUT InputOutputArray | cameraMatrix, | ||
CV_OUT InputOutputArray | distCoeffs, | ||
OutputArrayOfArrays | rvecs, | ||
OutputArrayOfArrays | tvecs, | ||
int | flags = 0 , |
||
TermCriteria | criteria = TermCriteria(TermCriteria::COUNT+TermCriteria::EPS, 30, DBL_EPSILON) |
||
) |
finds intrinsic and extrinsic camera parameters from several fews of a known calibration pattern.
CV_EXPORTS_W void cv::calibrationMatrixValues | ( | InputArray | cameraMatrix, |
Size | imageSize, | ||
double | apertureWidth, | ||
double | apertureHeight, | ||
CV_OUT double & | fovx, | ||
CV_OUT double & | fovy, | ||
CV_OUT double & | focalLength, | ||
CV_OUT Point2d & | principalPoint, | ||
CV_OUT double & | aspectRatio | ||
) |
computes several useful camera characteristics from the camera matrix, camera frame resolution and the physical sensor size.
CV_EXPORTS_W double cv::stereoCalibrate | ( | InputArrayOfArrays | objectPoints, |
InputArrayOfArrays | imagePoints1, | ||
InputArrayOfArrays | imagePoints2, | ||
CV_OUT InputOutputArray | cameraMatrix1, | ||
CV_OUT InputOutputArray | distCoeffs1, | ||
CV_OUT InputOutputArray | cameraMatrix2, | ||
CV_OUT InputOutputArray | distCoeffs2, | ||
Size | imageSize, | ||
OutputArray | R, | ||
OutputArray | T, | ||
OutputArray | E, | ||
OutputArray | F, | ||
TermCriteria | criteria = TermCriteria(TermCriteria::COUNT+TermCriteria::EPS, 30, 1e-6) , |
||
int | flags = CALIB_FIX_INTRINSIC |
||
) |
finds intrinsic and extrinsic parameters of a stereo camera
CV_EXPORTS_W void cv::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() , |
||
CV_OUT Rect * | validPixROI1 = 0 , |
||
CV_OUT Rect * | validPixROI2 = 0 |
||
) |
computes the rectification transformation for a stereo camera from its intrinsic and extrinsic parameters
CV_EXPORTS_W bool cv::stereoRectifyUncalibrated | ( | InputArray | points1, |
InputArray | points2, | ||
InputArray | F, | ||
Size | imgSize, | ||
OutputArray | H1, | ||
OutputArray | H2, | ||
double | threshold = 5 |
||
) |
computes the rectification transformation for an uncalibrated stereo camera (zero distortion is assumed)
CV_EXPORTS_W float cv::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, | ||
CV_OUT Rect * | roi1, | ||
CV_OUT Rect * | roi2, | ||
int | flags | ||
) |
computes the rectification transformations for 3-head camera, where all the heads are on the same line.
CV_EXPORTS_W Mat cv::getOptimalNewCameraMatrix | ( | InputArray | cameraMatrix, |
InputArray | distCoeffs, | ||
Size | imageSize, | ||
double | alpha, | ||
Size | newImgSize = Size() , |
||
CV_OUT Rect * | validPixROI = 0 , |
||
bool | centerPrincipalPoint = false |
||
) |
returns the optimal new camera matrix
CV_EXPORTS_W void cv::convertPointsToHomogeneous | ( | InputArray | src, |
OutputArray | dst | ||
) |
converts point coordinates from normal pixel coordinates to homogeneous coordinates ((x,y)->(x,y,1))
CV_EXPORTS_W void cv::convertPointsFromHomogeneous | ( | InputArray | src, |
OutputArray | dst | ||
) |
converts point coordinates from homogeneous to normal pixel coordinates ((x,y,z)->(x/z, y/z))
CV_EXPORTS void cv::convertPointsHomogeneous | ( | InputArray | src, |
OutputArray | dst | ||
) |
for backward compatibility
CV_EXPORTS_W Mat cv::findFundamentalMat | ( | InputArray | points1, |
InputArray | points2, | ||
int | method = FM_RANSAC , |
||
double | param1 = 3. , |
||
double | param2 = 0.99 , |
||
OutputArray | mask = noArray() |
||
) |
finds fundamental matrix from a set of corresponding 2D points
CV_EXPORTS Mat cv::findFundamentalMat | ( | InputArray | points1, |
InputArray | points2, | ||
OutputArray | mask, | ||
int | method = FM_RANSAC , |
||
double | param1 = 3. , |
||
double | param2 = 0.99 |
||
) |
variant of findFundamentalMat for backward compatibility
CV_EXPORTS_W void cv::computeCorrespondEpilines | ( | InputArray | points, |
int | whichImage, | ||
InputArray | F, | ||
OutputArray | lines | ||
) |
finds coordinates of epipolar lines corresponding the specified points
CV_EXPORTS_W void cv::triangulatePoints | ( | InputArray | projMatr1, |
InputArray | projMatr2, | ||
InputArray | projPoints1, | ||
InputArray | projPoints2, | ||
OutputArray | points4D | ||
) |
CV_EXPORTS_W void cv::correctMatches | ( | InputArray | F, |
InputArray | points1, | ||
InputArray | points2, | ||
OutputArray | newPoints1, | ||
OutputArray | newPoints2 | ||
) |
CV_EXPORTS_W void cv::filterSpeckles | ( | InputOutputArray | img, |
double | newVal, | ||
int | maxSpeckleSize, | ||
double | maxDiff, | ||
InputOutputArray | buf = noArray() |
||
) |
filters off speckles (small regions of incorrectly computed disparity)
CV_EXPORTS_W Rect cv::getValidDisparityROI | ( | Rect | roi1, |
Rect | roi2, | ||
int | minDisparity, | ||
int | numberOfDisparities, | ||
int | SADWindowSize | ||
) |
computes valid disparity ROI from the valid ROIs of the rectified images (that are returned by cv::stereoRectify())
CV_EXPORTS_W void cv::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
CV_EXPORTS_W void cv::reprojectImageTo3D | ( | InputArray | disparity, |
OutputArray | _3dImage, | ||
InputArray | Q, | ||
bool | handleMissingValues = false , |
||
int | ddepth = -1 |
||
) |
reprojects disparity image to 3D: (x,y,d)->(X,Y,Z) using the matrix Q returned by cv::stereoRectify
CV_EXPORTS_W int cv::estimateAffine3D | ( | InputArray | src, |
InputArray | dst, | ||
OutputArray | out, | ||
OutputArray | inliers, | ||
double | ransacThreshold = 3 , |
||
double | confidence = 0.99 |
||
) |
CV_EXPORTS std::ostream& cv::operator<< | ( | std::ostream & | out, |
const TickMeter & | tm | ||
) |
CV_EXPORTS_W int cv::chamerMatching | ( | Mat & | img, |
Mat & | templ, | ||
CV_OUT vector< vector< Point > > & | results, | ||
CV_OUT vector< float > & | cost, | ||
double | templScale = 1 , |
||
int | maxMatches = 20 , |
||
double | minMatchDistance = 1.0 , |
||
int | padX = 3 , |
||
int | padY = 3 , |
||
int | scales = 5 , |
||
double | minScale = 0.6 , |
||
double | maxScale = 1.6 , |
||
double | orientationWeight = 0.5 , |
||
double | truncate = 20 |
||
) |
CV_EXPORTS void cv::generateColors | ( | std::vector< Scalar > & | colors, |
size_t | count, | ||
size_t | factor = 100 |
||
) |
CV_EXPORTS bool cv::RGBDOdometry | ( | Mat & | Rt, |
const Mat & | initRt, | ||
const Mat & | image0, | ||
const Mat & | depth0, | ||
const Mat & | mask0, | ||
const Mat & | image1, | ||
const Mat & | depth1, | ||
const Mat & | mask1, | ||
const Mat & | cameraMatrix, | ||
float | minDepth = 0.f , |
||
float | maxDepth = 4.f , |
||
float | maxDepthDiff = 0.07f , |
||
const std::vector< int > & | iterCounts = std::vector< int >() , |
||
const std::vector< float > & | minGradientMagnitudes = std::vector< float >() , |
||
int | transformType = RIGID_BODY_MOTION |
||
) |
CV_EXPORTS Mat cv::subspaceProject | ( | InputArray | W, |
InputArray | mean, | ||
InputArray | src | ||
) |
CV_EXPORTS Mat cv::subspaceReconstruct | ( | InputArray | W, |
InputArray | mean, | ||
InputArray | src | ||
) |
CV_EXPORTS_W Ptr<FaceRecognizer> cv::createEigenFaceRecognizer | ( | int | num_components = 0 , |
double | threshold = DBL_MAX |
||
) |
CV_EXPORTS_W Ptr<FaceRecognizer> cv::createFisherFaceRecognizer | ( | int | num_components = 0 , |
double | threshold = DBL_MAX |
||
) |
CV_EXPORTS_W Ptr<FaceRecognizer> cv::createLBPHFaceRecognizer | ( | int | radius = 1 , |
int | neighbors = 8 , |
||
int | grid_x = 8 , |
||
int | grid_y = 8 , |
||
double | threshold = DBL_MAX |
||
) |
CV_EXPORTS bool cv::initModule_contrib | ( | ) |
CV_EXPORTS string cv::fromUtf16 | ( | const WString & | str | ) |
CV_EXPORTS string cv::format | ( | const char * | fmt, |
... | |||
) |
CV_EXPORTS string cv::tempfile | ( | const char *suffix | CV_DEFAULT0 | ) |
CV_EXPORTS void cv::error | ( | const Exception & | exc | ) |
Signals an error and raises the exception.
By default the function prints information about the error to stderr, then it either stops if setBreakOnError() had been called before or raises the exception. It is possible to alternate error processing by using redirectError().
exc | the exception raisen. |
CV_EXPORTS bool cv::setBreakOnError | ( | bool | flag | ) |
Sets/resets the break-on-error mode.
When the break-on-error mode is set, the default error handler issues a hardware exception, which can make debugging more convenient.
CV_EXPORTS ErrorCallback cv::redirectError | ( | ErrorCallback | errCallback, |
void * | userdata = 0 , |
||
void ** | prevUserdata = 0 |
||
) |
Sets the new error handler and the optional user data.
The function sets the new error handler, called from cv::error().
errCallback | the new error handler. If NULL, the default error handler is used. |
userdata | the optional user data pointer, passed to the callback. |
prevUserdata | the optional output parameter where the previous user data pointer is stored |
CV_EXPORTS void cv::glob | ( | String | pattern, |
std::vector< String > & | result, | ||
bool | recursive = false |
||
) |
CV_EXPORTS int cv::getNumThreads | ( | ) |
CV_EXPORTS int cv::getThreadNum | ( | ) |
CV_EXPORTS_W const string& cv::getBuildInformation | ( | ) |
CV_EXPORTS_W int64 cv::getTickCount | ( | ) |
Returns the number of ticks.
The function returns the number of ticks since the certain event (e.g. when the machine was turned on). It can be used to initialize cv::RNG or to measure a function execution time by reading the tick count before and after the function call. The granularity of ticks depends on the hardware and OS used. Use cv::getTickFrequency() to convert ticks to seconds.
CV_EXPORTS_W double cv::getTickFrequency | ( | ) |
Returns the number of ticks per seconds.
The function returns the number of ticks (as returned by cv::getTickCount()) per second. The following code computes the execution time in milliseconds:
CV_EXPORTS_W int64 cv::getCPUTickCount | ( | ) |
Returns the number of CPU ticks.
On platforms where the feature is available, the function returns the number of CPU ticks since the certain event (normally, the system power-on moment). Using this function one can accurately measure the execution time of very small code fragments, for which cv::getTickCount() granularity is not enough.
CV_EXPORTS_W bool cv::checkHardwareSupport | ( | int | feature | ) |
Returns SSE etc.
support status
The function returns true if certain hardware features are available. Currently, the following features are recognized:
CV_EXPORTS_W int cv::getNumberOfCPUs | ( | ) |
returns the number of CPUs (including hyper-threading)
CV_EXPORTS void* cv::fastMalloc | ( | size_t | bufSize | ) |
Allocates memory buffer.
This is specialized OpenCV memory allocation function that returns properly aligned memory buffers. The usage is identical to malloc(). The allocated buffers must be freed with cv::fastFree(). If there is not enough memory, the function calls cv::error(), which raises an exception.
bufSize | buffer size in bytes |
Frees the memory allocated with cv::fastMalloc.
This is the corresponding deallocation function for cv::fastMalloc(). When ptr==NULL, the function has no effect.
CV_EXPORTS_W void cv::setUseOptimized | ( | bool | onoff | ) |
Turns on/off available optimization.
The function turns on or off the optimized code in OpenCV. Some optimization can not be enabled or disabled, but, for example, most of SSE code in OpenCV can be temporarily turned on or off this way.
CV_EXPORTS_W bool cv::useOptimized | ( | ) |
Returns the current optimization status.
The function returns the current optimization status, which is controlled by cv::setUseOptimized().
CV_EXPORTS OutputArray cv::noArray | ( | ) |
CV_EXPORTS BinaryFunc cv::getConvertFunc | ( | int | sdepth, |
int | ddepth | ||
) |
CV_EXPORTS BinaryFunc cv::getConvertScaleFunc | ( | int | sdepth, |
int | ddepth | ||
) |
CV_EXPORTS BinaryFunc cv::getCopyMaskFunc | ( | size_t | esz | ) |
CV_EXPORTS void cv::swap | ( | Mat & | a, |
Mat & | b | ||
) |
swaps two matrices
CV_EXPORTS_W void cv::add | ( | InputArray | src1, |
InputArray | src2, | ||
OutputArray | dst, | ||
InputArray | mask = noArray() , |
||
int | dtype = -1 |
||
) |
adds one matrix to another (dst = src1 + src2)
CV_EXPORTS_W void cv::subtract | ( | InputArray | src1, |
InputArray | src2, | ||
OutputArray | dst, | ||
InputArray | mask = noArray() , |
||
int | dtype = -1 |
||
) |
subtracts one matrix from another (dst = src1 - src2)
CV_EXPORTS_W void cv::multiply | ( | InputArray | src1, |
InputArray | src2, | ||
OutputArray | dst, | ||
double | scale = 1 , |
||
int | dtype = -1 |
||
) |
computes element-wise weighted product of the two arrays (dst = scale*src1*src2)
CV_EXPORTS_W void cv::divide | ( | InputArray | src1, |
InputArray | src2, | ||
OutputArray | dst, | ||
double | scale = 1 , |
||
int | dtype = -1 |
||
) |
computes element-wise weighted quotient of the two arrays (dst = scale*src1/src2)
computes element-wise weighted reciprocal of an array (dst = scale/src2)
CV_EXPORTS_W void cv::scaleAdd | ( | InputArray | src1, |
double | alpha, | ||
InputArray | src2, | ||
OutputArray | dst | ||
) |
adds scaled array to another one (dst = alpha*src1 + src2)
CV_EXPORTS_W void cv::addWeighted | ( | InputArray | src1, |
double | alpha, | ||
InputArray | src2, | ||
double | beta, | ||
double | gamma, | ||
OutputArray | dst, | ||
int | dtype = -1 |
||
) |
computes weighted sum of two arrays (dst = alpha*src1 + beta*src2 + gamma)
CV_EXPORTS_W void cv::convertScaleAbs | ( | InputArray | src, |
OutputArray | dst, | ||
double | alpha = 1 , |
||
double | beta = 0 |
||
) |
scales array elements, computes absolute values and converts the results to 8-bit unsigned integers: dst(i)=saturate_cast<uchar>abs(src(i)*alpha+beta)
CV_EXPORTS_W void cv::LUT | ( | InputArray | src, |
InputArray | lut, | ||
OutputArray | dst, | ||
int | interpolation = 0 |
||
) |
transforms array of numbers using a lookup table: dst(i)=lut(src(i))
cv::CV_EXPORTS_AS | ( | sumElems | ) |
computes sum of array elements
CV_EXPORTS_W int cv::countNonZero | ( | InputArray | src | ) |
computes the number of nonzero array elements
CV_EXPORTS_W void cv::findNonZero | ( | InputArray | src, |
OutputArray | idx | ||
) |
returns the list of locations of non-zero pixels
CV_EXPORTS_W Scalar cv::mean | ( | InputArray | src, |
InputArray | mask = noArray() |
||
) |
computes mean value of selected array elements
CV_EXPORTS_W void cv::meanStdDev | ( | InputArray | src, |
OutputArray | mean, | ||
OutputArray | stddev, | ||
InputArray | mask = noArray() |
||
) |
computes mean value and standard deviation of all or selected array elements
CV_EXPORTS_W double cv::norm | ( | InputArray | src1, |
int | normType = NORM_L2 , |
||
InputArray | mask = noArray() |
||
) |
computes norm of the selected array part
CV_EXPORTS_W double cv::norm | ( | InputArray | src1, |
InputArray | src2, | ||
int | normType = NORM_L2 , |
||
InputArray | mask = noArray() |
||
) |
computes norm of selected part of the difference between two arrays
CV_EXPORTS_W void cv::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
CV_EXPORTS_W void cv::normalize | ( | InputArray | src, |
OutputArray | dst, | ||
double | alpha = 1 , |
||
double | beta = 0 , |
||
int | norm_type = NORM_L2 , |
||
int | dtype = -1 , |
||
InputArray | mask = noArray() |
||
) |
scales and shifts array elements so that either the specified norm (alpha) or the minimum (alpha) and maximum (beta) array values get the specified values
CV_EXPORTS_W void cv::minMaxLoc | ( | InputArray | src, |
CV_OUT double * | minVal, | ||
CV_OUT double * | maxVal = 0 , |
||
CV_OUT Point * | minLoc = 0 , |
||
CV_OUT Point * | maxLoc = 0 , |
||
InputArray | mask = noArray() |
||
) |
finds global minimum and maximum array elements and returns their values and their locations
CV_EXPORTS void cv::minMaxIdx | ( | InputArray | src, |
double * | minVal, | ||
double * | maxVal, | ||
int * | minIdx = 0 , |
||
int * | maxIdx = 0 , |
||
InputArray | mask = noArray() |
||
) |
CV_EXPORTS_W void cv::reduce | ( | InputArray | src, |
OutputArray | dst, | ||
int | dim, | ||
int | rtype, | ||
int | dtype = -1 |
||
) |
transforms 2D matrix to 1D row or column vector by taking sum, minimum, maximum or mean value over all the rows
CV_EXPORTS void cv::merge | ( | const Mat * | mv, |
size_t | count, | ||
OutputArray | dst | ||
) |
makes multi-channel array out of several single-channel arrays
CV_EXPORTS void cv::merge | ( | const vector< Mat > & | mv, |
OutputArray | dst | ||
) |
CV_EXPORTS_W void cv::merge | ( | InputArrayOfArrays | mv, |
OutputArray | dst | ||
) |
makes multi-channel array out of several single-channel arrays
CV_EXPORTS void cv::split | ( | const Mat & | src, |
Mat * | mvbegin | ||
) |
copies each plane of a multi-channel array to a dedicated array
CV_EXPORTS void cv::split | ( | const Mat & | m, |
vector< Mat > & | mv | ||
) |
CV_EXPORTS_W void cv::split | ( | InputArray | m, |
OutputArrayOfArrays | mv | ||
) |
copies each plane of a multi-channel array to a dedicated array
CV_EXPORTS void cv::mixChannels | ( | const Mat * | src, |
size_t | nsrcs, | ||
Mat * | dst, | ||
size_t | ndsts, | ||
const int * | fromTo, | ||
size_t | npairs | ||
) |
copies selected channels from the input arrays to the selected channels of the output arrays
CV_EXPORTS void cv::mixChannels | ( | const vector< Mat > & | src, |
vector< Mat > & | dst, | ||
const int * | fromTo, | ||
size_t | npairs | ||
) |
CV_EXPORTS_W void cv::mixChannels | ( | InputArrayOfArrays | src, |
InputArrayOfArrays | dst, | ||
const vector< int > & | fromTo | ||
) |
extracts a single channel from src (coi is 0-based index)
inserts a single channel to dst (coi is 0-based index)
reverses the order of the rows, columns or both in a matrix
replicates the input matrix the specified number of times in the horizontal and/or vertical direction
CV_EXPORTS void cv::hconcat | ( | const Mat * | src, |
size_t | nsrc, | ||
OutputArray | dst | ||
) |
CV_EXPORTS void cv::hconcat | ( | InputArray | src1, |
InputArray | src2, | ||
OutputArray | dst | ||
) |
CV_EXPORTS_W void cv::hconcat | ( | InputArrayOfArrays | src, |
OutputArray | dst | ||
) |
CV_EXPORTS void cv::vconcat | ( | const Mat * | src, |
size_t | nsrc, | ||
OutputArray | dst | ||
) |
CV_EXPORTS void cv::vconcat | ( | InputArray | src1, |
InputArray | src2, | ||
OutputArray | dst | ||
) |
CV_EXPORTS_W void cv::vconcat | ( | InputArrayOfArrays | src, |
OutputArray | dst | ||
) |
CV_EXPORTS_W void cv::bitwise_and | ( | InputArray | src1, |
InputArray | src2, | ||
OutputArray | dst, | ||
InputArray | mask = noArray() |
||
) |
computes bitwise conjunction of the two arrays (dst = src1 & src2)
CV_EXPORTS_W void cv::bitwise_or | ( | InputArray | src1, |
InputArray | src2, | ||
OutputArray | dst, | ||
InputArray | mask = noArray() |
||
) |
computes bitwise disjunction of the two arrays (dst = src1 | src2)
CV_EXPORTS_W void cv::bitwise_xor | ( | InputArray | src1, |
InputArray | src2, | ||
OutputArray | dst, | ||
InputArray | mask = noArray() |
||
) |
computes bitwise exclusive-or of the two arrays (dst = src1 ^ src2)
CV_EXPORTS_W void cv::bitwise_not | ( | InputArray | src, |
OutputArray | dst, | ||
InputArray | mask = noArray() |
||
) |
inverts each bit of array (dst = ~src)
CV_EXPORTS_W void cv::absdiff | ( | InputArray | src1, |
InputArray | src2, | ||
OutputArray | dst | ||
) |
computes element-wise absolute difference of two arrays (dst = abs(src1 - src2))
CV_EXPORTS_W void cv::inRange | ( | InputArray | src, |
InputArray | lowerb, | ||
InputArray | upperb, | ||
OutputArray | dst | ||
) |
set mask elements for those array elements which are within the element-specific bounding box (dst = lowerb <= src && src < upperb)
compares elements of two arrays (dst = src1 <cmpop> src2)
CV_EXPORTS_W void cv::min | ( | InputArray | src1, |
InputArray | src2, | ||
OutputArray | dst | ||
) |
computes per-element minimum of two arrays (dst = min(src1, src2))
CV_EXPORTS_W void cv::max | ( | InputArray | src1, |
InputArray | src2, | ||
OutputArray | dst | ||
) |
computes per-element maximum of two arrays (dst = max(src1, src2))
CV_EXPORTS void cv::min | ( | const Mat & | src1, |
const Mat & | src2, | ||
Mat & | dst | ||
) |
computes per-element minimum of two arrays (dst = min(src1, src2))
CV_EXPORTS void cv::min | ( | const Mat & | src1, |
double | src2, | ||
Mat & | dst | ||
) |
computes per-element minimum of array and scalar (dst = min(src1, src2))
CV_EXPORTS void cv::max | ( | const Mat & | src1, |
const Mat & | src2, | ||
Mat & | dst | ||
) |
computes per-element maximum of two arrays (dst = max(src1, src2))
CV_EXPORTS void cv::max | ( | const Mat & | src1, |
double | src2, | ||
Mat & | dst | ||
) |
computes per-element maximum of array and scalar (dst = max(src1, src2))
CV_EXPORTS_W void cv::sqrt | ( | InputArray | src, |
OutputArray | dst | ||
) |
computes square root of each matrix element (dst = src**0.5)
CV_EXPORTS_W void cv::pow | ( | InputArray | src, |
double | power, | ||
OutputArray | dst | ||
) |
raises the input matrix elements to the specified power (b = a**power)
CV_EXPORTS_W void cv::exp | ( | InputArray | src, |
OutputArray | dst | ||
) |
computes exponent of each matrix element (dst = e**src)
CV_EXPORTS_W void cv::log | ( | InputArray | src, |
OutputArray | dst | ||
) |
computes natural logarithm of absolute value of each matrix element: dst = log(abs(src))
CV_EXPORTS_W float cv::cubeRoot | ( | float | val | ) |
computes cube root of the argument
CV_EXPORTS_W float cv::fastAtan2 | ( | float | y, |
float | x | ||
) |
computes the angle in degrees (0..360) of the vector (x,y)
CV_EXPORTS void cv::fastAtan2 | ( | const float * | y, |
const float * | x, | ||
float * | dst, | ||
int | n, | ||
bool | angleInDegrees | ||
) |
CV_EXPORTS_W void cv::polarToCart | ( | InputArray | magnitude, |
InputArray | angle, | ||
OutputArray | x, | ||
OutputArray | y, | ||
bool | angleInDegrees = false |
||
) |
converts polar coordinates to Cartesian
CV_EXPORTS_W void cv::cartToPolar | ( | InputArray | x, |
InputArray | y, | ||
OutputArray | magnitude, | ||
OutputArray | angle, | ||
bool | angleInDegrees = false |
||
) |
converts Cartesian coordinates to polar
CV_EXPORTS_W void cv::phase | ( | InputArray | x, |
InputArray | y, | ||
OutputArray | angle, | ||
bool | angleInDegrees = false |
||
) |
computes angle (angle(i)) of each (x(i), y(i)) vector
CV_EXPORTS_W void cv::magnitude | ( | InputArray | x, |
InputArray | y, | ||
OutputArray | magnitude | ||
) |
computes magnitude (magnitude(i)) of each (x(i), y(i)) vector
CV_EXPORTS_W bool cv::checkRange | ( | InputArray | a, |
bool | quiet = true , |
||
CV_OUT Point * | pos = 0 , |
||
double | minVal = -DBL_MAX , |
||
double | maxVal = DBL_MAX |
||
) |
checks that each matrix element is within the specified range.
CV_EXPORTS_W void cv::patchNaNs | ( | InputOutputArray | a, |
double | val = 0 |
||
) |
converts NaN's to the given number
CV_EXPORTS_W void cv::gemm | ( | InputArray | src1, |
InputArray | src2, | ||
double | alpha, | ||
InputArray | src3, | ||
double | gamma, | ||
OutputArray | dst, | ||
int | flags = 0 |
||
) |
implements generalized matrix product algorithm GEMM from BLAS
CV_EXPORTS_W void cv::mulTransposed | ( | InputArray | src, |
OutputArray | dst, | ||
bool | aTa, | ||
InputArray | delta = noArray() , |
||
double | scale = 1 , |
||
int | dtype = -1 |
||
) |
multiplies matrix by its transposition from the left or from the right
CV_EXPORTS_W void cv::transpose | ( | InputArray | src, |
OutputArray | dst | ||
) |
transposes the matrix
CV_EXPORTS_W void cv::transform | ( | InputArray | src, |
OutputArray | dst, | ||
InputArray | m | ||
) |
performs affine transformation of each element of multi-channel input matrix
CV_EXPORTS_W void cv::perspectiveTransform | ( | InputArray | src, |
OutputArray | dst, | ||
InputArray | m | ||
) |
performs perspective transformation of each element of multi-channel input matrix
CV_EXPORTS_W void cv::completeSymm | ( | InputOutputArray | mtx, |
bool | lowerToUpper = false |
||
) |
extends the symmetrical matrix from the lower half or from the upper half
CV_EXPORTS_W void cv::setIdentity | ( | InputOutputArray | mtx, |
const Scalar & | s = Scalar(1) |
||
) |
initializes scaled identity matrix
CV_EXPORTS_W double cv::determinant | ( | InputArray | mtx | ) |
computes determinant of a square matrix
CV_EXPORTS_W Scalar cv::trace | ( | InputArray | mtx | ) |
computes trace of a matrix
CV_EXPORTS_W double cv::invert | ( | InputArray | src, |
OutputArray | dst, | ||
int | flags = DECOMP_LU |
||
) |
computes inverse or pseudo-inverse matrix
CV_EXPORTS_W bool cv::solve | ( | InputArray | src1, |
InputArray | src2, | ||
OutputArray | dst, | ||
int | flags = DECOMP_LU |
||
) |
solves linear system or a least-square problem
sorts independently each matrix row or each matrix column
sorts independently each matrix row or each matrix column
CV_EXPORTS_W int cv::solveCubic | ( | InputArray | coeffs, |
OutputArray | roots | ||
) |
finds real roots of a cubic polynomial
CV_EXPORTS_W double cv::solvePoly | ( | InputArray | coeffs, |
OutputArray | roots, | ||
int | maxIters = 300 |
||
) |
finds real and complex roots of a polynomial
CV_EXPORTS bool cv::eigen | ( | InputArray | src, |
OutputArray | eigenvalues, | ||
int | lowindex = -1 , |
||
int | highindex = -1 |
||
) |
finds eigenvalues of a symmetric matrix
CV_EXPORTS bool cv::eigen | ( | InputArray | src, |
OutputArray | eigenvalues, | ||
OutputArray | eigenvectors, | ||
int | lowindex = -1 , |
||
int | highindex = -1 |
||
) |
finds eigenvalues and eigenvectors of a symmetric matrix
CV_EXPORTS_W bool cv::eigen | ( | InputArray | src, |
bool | computeEigenvectors, | ||
OutputArray | eigenvalues, | ||
OutputArray | eigenvectors | ||
) |
CV_EXPORTS void cv::calcCovarMatrix | ( | const Mat * | samples, |
int | nsamples, | ||
Mat & | covar, | ||
Mat & | mean, | ||
int | flags, | ||
int | ctype = CV_64F |
||
) |
computes covariation matrix of a set of samples
CV_EXPORTS_W void cv::calcCovarMatrix | ( | InputArray | samples, |
OutputArray | covar, | ||
OutputArray | mean, | ||
int | flags, | ||
int | ctype = CV_64F |
||
) |
computes covariation matrix of a set of samples
CV_EXPORTS_W void cv::PCACompute | ( | InputArray | data, |
CV_OUT InputOutputArray | mean, | ||
OutputArray | eigenvectors, | ||
int | maxComponents = 0 |
||
) |
CV_EXPORTS_W void cv::PCAComputeVar | ( | InputArray | data, |
CV_OUT InputOutputArray | mean, | ||
OutputArray | eigenvectors, | ||
double | retainedVariance | ||
) |
CV_EXPORTS_W void cv::PCAProject | ( | InputArray | data, |
InputArray | mean, | ||
InputArray | eigenvectors, | ||
OutputArray | result | ||
) |
CV_EXPORTS_W void cv::PCABackProject | ( | InputArray | data, |
InputArray | mean, | ||
InputArray | eigenvectors, | ||
OutputArray | result | ||
) |
CV_EXPORTS_W void cv::SVDecomp | ( | InputArray | src, |
CV_OUT OutputArray | w, | ||
CV_OUT OutputArray | u, | ||
CV_OUT OutputArray | vt, | ||
int | flags = 0 |
||
) |
computes SVD of src
CV_EXPORTS_W void cv::SVBackSubst | ( | InputArray | w, |
InputArray | u, | ||
InputArray | vt, | ||
InputArray | rhs, | ||
CV_OUT OutputArray | dst | ||
) |
performs back substitution for the previously computed SVD
CV_EXPORTS_W double cv::Mahalanobis | ( | InputArray | v1, |
InputArray | v2, | ||
InputArray | icovar | ||
) |
computes Mahalanobis distance between two vectors: sqrt((v1-v2)'icovar(v1-v2)), where icovar is the inverse covariation matrix
CV_EXPORTS double cv::Mahalonobis | ( | InputArray | v1, |
InputArray | v2, | ||
InputArray | icovar | ||
) |
a synonym for Mahalanobis
performs forward or inverse 1D or 2D Discrete Fourier Transformation
performs inverse 1D or 2D Discrete Fourier Transformation
performs forward or inverse 1D or 2D Discrete Cosine Transformation
performs inverse 1D or 2D Discrete Cosine Transformation
CV_EXPORTS_W void cv::mulSpectrums | ( | InputArray | a, |
InputArray | b, | ||
OutputArray | c, | ||
int | flags, | ||
bool | conjB = false |
||
) |
computes element-wise product of the two Fourier spectrums. The second spectrum can optionally be conjugated before the multiplication
computes the minimal vector size vecsize1 >= vecsize so that the dft() of the vector of length vecsize1 can be computed efficiently
CV_EXPORTS_W double cv::kmeans | ( | InputArray | data, |
int | K, | ||
CV_OUT InputOutputArray | bestLabels, | ||
TermCriteria | criteria, | ||
int | attempts, | ||
int | flags, | ||
OutputArray | centers = noArray() |
||
) |
clusters the input data using k-Means algorithm
CV_EXPORTS RNG& cv::theRNG | ( | ) |
returns the thread-local Random number generator
CV_EXPORTS_W void cv::randu | ( | InputOutputArray | dst, |
InputArray | low, | ||
InputArray | high | ||
) |
fills array with uniformly-distributed random numbers from the range [low, high)
CV_EXPORTS_W void cv::randn | ( | InputOutputArray | dst, |
InputArray | mean, | ||
InputArray | stddev | ||
) |
fills array with normally-distributed random numbers with the specified mean and the standard deviation
CV_EXPORTS void cv::randShuffle | ( | InputOutputArray | dst, |
double | iterFactor = 1. , |
||
RNG * | rng = 0 |
||
) |
shuffles the input array elements
cv::CV_EXPORTS_AS | ( | randShuffle | ) |
CV_EXPORTS_W void cv::line | ( | CV_IN_OUT Mat & | img, |
Point | pt1, | ||
Point | pt2, | ||
const Scalar & | color, | ||
int | thickness = 1 , |
||
int | lineType = 8 , |
||
int | shift = 0 |
||
) |
draws the line segment (pt1, pt2) in the image
CV_EXPORTS_W void cv::rectangle | ( | CV_IN_OUT Mat & | img, |
Point | pt1, | ||
Point | pt2, | ||
const Scalar & | color, | ||
int | thickness = 1 , |
||
int | lineType = 8 , |
||
int | shift = 0 |
||
) |
draws the rectangle outline or a solid rectangle with the opposite corners pt1 and pt2 in the image
CV_EXPORTS void cv::rectangle | ( | CV_IN_OUT Mat & | img, |
Rect | rec, | ||
const Scalar & | color, | ||
int | thickness = 1 , |
||
int | lineType = 8 , |
||
int | shift = 0 |
||
) |
draws the rectangle outline or a solid rectangle covering rec in the image
CV_EXPORTS_W void cv::circle | ( | CV_IN_OUT Mat & | img, |
Point | center, | ||
int | radius, | ||
const Scalar & | color, | ||
int | thickness = 1 , |
||
int | lineType = 8 , |
||
int | shift = 0 |
||
) |
draws the circle outline or a solid circle in the image
CV_EXPORTS_W void cv::ellipse | ( | CV_IN_OUT Mat & | img, |
Point | center, | ||
Size | axes, | ||
double | angle, | ||
double | startAngle, | ||
double | endAngle, | ||
const Scalar & | color, | ||
int | thickness = 1 , |
||
int | lineType = 8 , |
||
int | shift = 0 |
||
) |
draws an elliptic arc, ellipse sector or a rotated ellipse in the image
CV_EXPORTS_W void cv::ellipse | ( | CV_IN_OUT Mat & | img, |
const RotatedRect & | box, | ||
const Scalar & | color, | ||
int | thickness = 1 , |
||
int | lineType = 8 |
||
) |
draws a rotated ellipse in the image
CV_EXPORTS void cv::fillConvexPoly | ( | Mat & | img, |
const Point * | pts, | ||
int | npts, | ||
const Scalar & | color, | ||
int | lineType = 8 , |
||
int | shift = 0 |
||
) |
draws a filled convex polygon in the image
CV_EXPORTS_W void cv::fillConvexPoly | ( | InputOutputArray | img, |
InputArray | points, | ||
const Scalar & | color, | ||
int | lineType = 8 , |
||
int | shift = 0 |
||
) |
CV_EXPORTS void cv::fillPoly | ( | Mat & | img, |
const Point ** | pts, | ||
const int * | npts, | ||
int | ncontours, | ||
const Scalar & | color, | ||
int | lineType = 8 , |
||
int | shift = 0 , |
||
Point | offset = Point() |
||
) |
fills an area bounded by one or more polygons
CV_EXPORTS_W void cv::fillPoly | ( | InputOutputArray | img, |
InputArrayOfArrays | pts, | ||
const Scalar & | color, | ||
int | lineType = 8 , |
||
int | shift = 0 , |
||
Point | offset = Point() |
||
) |
CV_EXPORTS void cv::polylines | ( | Mat & | img, |
const Point ** | pts, | ||
const int * | npts, | ||
int | ncontours, | ||
bool | isClosed, | ||
const Scalar & | color, | ||
int | thickness = 1 , |
||
int | lineType = 8 , |
||
int | shift = 0 |
||
) |
draws one or more polygonal curves
CV_EXPORTS_W void cv::polylines | ( | InputOutputArray | img, |
InputArrayOfArrays | pts, | ||
bool | isClosed, | ||
const Scalar & | color, | ||
int | thickness = 1 , |
||
int | lineType = 8 , |
||
int | shift = 0 |
||
) |
CV_EXPORTS bool cv::clipLine | ( | Size | imgSize, |
CV_IN_OUT Point & | pt1, | ||
CV_IN_OUT Point & | pt2 | ||
) |
clips the line segment by the rectangle Rect(0, 0, imgSize.width, imgSize.height)
CV_EXPORTS_W bool cv::clipLine | ( | Rect | imgRect, |
CV_OUT CV_IN_OUT Point & | pt1, | ||
CV_OUT CV_IN_OUT Point & | pt2 | ||
) |
clips the line segment by the rectangle imgRect
CV_EXPORTS_W void cv::ellipse2Poly | ( | Point | center, |
Size | axes, | ||
int | angle, | ||
int | arcStart, | ||
int | arcEnd, | ||
int | delta, | ||
CV_OUT vector< Point > & | pts | ||
) |
converts elliptic arc to a polygonal curve
CV_EXPORTS_W void cv::putText | ( | Mat & | img, |
const string & | text, | ||
Point | org, | ||
int | fontFace, | ||
double | fontScale, | ||
Scalar | color, | ||
int | thickness = 1 , |
||
int | lineType = 8 , |
||
bool | bottomLeftOrigin = false |
||
) |
renders text string in the image
CV_EXPORTS_W Size cv::getTextSize | ( | const string & | text, |
int | fontFace, | ||
double | fontScale, | ||
int | thickness, | ||
CV_OUT int * | baseLine | ||
) |
returns bounding box of the text string
CV_EXPORTS ConvertData cv::getConvertElem | ( | int | fromType, |
int | toType | ||
) |
returns the function for converting pixels from one data type to another
CV_EXPORTS ConvertScaleData cv::getConvertScaleElem | ( | int | fromType, |
int | toType | ||
) |
returns the function for converting pixels from one data type to another with the optional scaling
CV_EXPORTS void cv::minMaxLoc | ( | const SparseMat & | a, |
double * | minVal, | ||
double * | maxVal, | ||
int * | minIdx = 0 , |
||
int * | maxIdx = 0 |
||
) |
finds global minimum and maximum sparse array elements and returns their values and their locations
CV_EXPORTS double cv::norm | ( | const SparseMat & | src, |
int | normType | ||
) |
computes norm of a sparse matrix
CV_EXPORTS void cv::normalize | ( | const SparseMat & | src, |
SparseMat & | dst, | ||
double | alpha, | ||
int | normType | ||
) |
scales and shifts array elements so that either the specified norm (alpha) or the minimum (alpha) and maximum (beta) array values get the specified values
CV_EXPORTS std::string cv::CommandLineParser::analyzeValue< std::string > | ( | const std::string & | str, |
bool | space_delete | ||
) |
CV_EXPORTS void cv::parallel_for_ | ( | const Range & | range, |
const ParallelLoopBody & | body, | ||
double | nstripes = -1. |
||
) |
void cv::eigen2cv | ( | const Eigen::Matrix< _Tp, _rows, _cols, _options, _maxRows, _maxCols > & | src, |
Mat & | dst | ||
) |
void cv::cv2eigen | ( | const Mat & | src, |
Eigen::Matrix< _Tp, _rows, _cols, _options, _maxRows, _maxCols > & | dst | ||
) |
void cv::cv2eigen | ( | const Matx< _Tp, _rows, _cols > & | src, |
Eigen::Matrix< _Tp, _rows, _cols, _options, _maxRows, _maxCols > & | dst | ||
) |
void cv::cv2eigen | ( | const Mat & | src, |
Eigen::Matrix< _Tp, Eigen::Dynamic, Eigen::Dynamic > & | dst | ||
) |
void cv::cv2eigen | ( | const Matx< _Tp, _rows, _cols > & | src, |
Eigen::Matrix< _Tp, Eigen::Dynamic, Eigen::Dynamic > & | dst | ||
) |
void cv::cv2eigen | ( | const Mat & | src, |
Eigen::Matrix< _Tp, Eigen::Dynamic, 1 > & | dst | ||
) |
void cv::cv2eigen | ( | const Matx< _Tp, _rows, 1 > & | src, |
Eigen::Matrix< _Tp, Eigen::Dynamic, 1 > & | dst | ||
) |
void cv::cv2eigen | ( | const Mat & | src, |
Eigen::Matrix< _Tp, 1, Eigen::Dynamic > & | dst | ||
) |
void cv::cv2eigen | ( | const Matx< _Tp, 1, _cols > & | src, |
Eigen::Matrix< _Tp, 1, Eigen::Dynamic > & | dst | ||
) |
CV_EXPORTS const char* cv::currentParallelFramework | ( | ) |
void cv::process | ( | const Mat_< T1 > & | m1, |
Mat_< T2 > & | m2, | ||
Op | op | ||
) |
void cv::process | ( | const Mat_< T1 > & | m1, |
const Mat_< T2 > & | m2, | ||
Mat_< T3 > & | m3, | ||
Op | op | ||
) |
CV_EXPORTS MatExpr cv::operator+ | ( | const Mat & | a, |
const Mat & | b | ||
) |
CV_EXPORTS MatExpr cv::operator+ | ( | const Mat & | a, |
const Scalar & | s | ||
) |
CV_EXPORTS MatExpr cv::operator+ | ( | const Scalar & | s, |
const Mat & | a | ||
) |
CV_EXPORTS MatExpr cv::operator+ | ( | const MatExpr & | e, |
const Mat & | m | ||
) |
CV_EXPORTS MatExpr cv::operator+ | ( | const Mat & | m, |
const MatExpr & | e | ||
) |
CV_EXPORTS MatExpr cv::operator+ | ( | const MatExpr & | e, |
const Scalar & | s | ||
) |
CV_EXPORTS MatExpr cv::operator+ | ( | const Scalar & | s, |
const MatExpr & | e | ||
) |
CV_EXPORTS MatExpr cv::operator+ | ( | const MatExpr & | e1, |
const MatExpr & | e2 | ||
) |
CV_EXPORTS MatExpr cv::operator- | ( | const Mat & | a, |
const Mat & | b | ||
) |
CV_EXPORTS MatExpr cv::operator- | ( | const Mat & | a, |
const Scalar & | s | ||
) |
CV_EXPORTS MatExpr cv::operator- | ( | const Scalar & | s, |
const Mat & | a | ||
) |
CV_EXPORTS MatExpr cv::operator- | ( | const MatExpr & | e, |
const Mat & | m | ||
) |
CV_EXPORTS MatExpr cv::operator- | ( | const Mat & | m, |
const MatExpr & | e | ||
) |
CV_EXPORTS MatExpr cv::operator- | ( | const MatExpr & | e, |
const Scalar & | s | ||
) |
CV_EXPORTS MatExpr cv::operator- | ( | const Scalar & | s, |
const MatExpr & | e | ||
) |
CV_EXPORTS MatExpr cv::operator- | ( | const MatExpr & | e1, |
const MatExpr & | e2 | ||
) |
CV_EXPORTS MatExpr cv::operator- | ( | const Mat & | m | ) |
CV_EXPORTS MatExpr cv::operator- | ( | const MatExpr & | e | ) |
CV_EXPORTS MatExpr cv::operator* | ( | const Mat & | a, |
const Mat & | b | ||
) |
CV_EXPORTS MatExpr cv::operator* | ( | const Mat & | a, |
double | s | ||
) |
CV_EXPORTS MatExpr cv::operator* | ( | double | s, |
const Mat & | a | ||
) |
CV_EXPORTS MatExpr cv::operator* | ( | const MatExpr & | e, |
const Mat & | m | ||
) |
CV_EXPORTS MatExpr cv::operator* | ( | const Mat & | m, |
const MatExpr & | e | ||
) |
CV_EXPORTS MatExpr cv::operator* | ( | const MatExpr & | e, |
double | s | ||
) |
CV_EXPORTS MatExpr cv::operator* | ( | double | s, |
const MatExpr & | e | ||
) |
CV_EXPORTS MatExpr cv::operator* | ( | const MatExpr & | e1, |
const MatExpr & | e2 | ||
) |
CV_EXPORTS MatExpr cv::operator/ | ( | const Mat & | a, |
const Mat & | b | ||
) |
CV_EXPORTS MatExpr cv::operator/ | ( | const Mat & | a, |
double | s | ||
) |
CV_EXPORTS MatExpr cv::operator/ | ( | double | s, |
const Mat & | a | ||
) |
CV_EXPORTS MatExpr cv::operator/ | ( | const MatExpr & | e, |
const Mat & | m | ||
) |
CV_EXPORTS MatExpr cv::operator/ | ( | const Mat & | m, |
const MatExpr & | e | ||
) |
CV_EXPORTS MatExpr cv::operator/ | ( | const MatExpr & | e, |
double | s | ||
) |
CV_EXPORTS MatExpr cv::operator/ | ( | double | s, |
const MatExpr & | e | ||
) |
CV_EXPORTS MatExpr cv::operator/ | ( | const MatExpr & | e1, |
const MatExpr & | e2 | ||
) |
CV_EXPORTS MatExpr cv::operator< | ( | const Mat & | a, |
const Mat & | b | ||
) |
CV_EXPORTS MatExpr cv::operator< | ( | const Mat & | a, |
double | s | ||
) |
CV_EXPORTS MatExpr cv::operator< | ( | double | s, |
const Mat & | a | ||
) |
CV_EXPORTS MatExpr cv::operator<= | ( | const Mat & | a, |
const Mat & | b | ||
) |
CV_EXPORTS MatExpr cv::operator<= | ( | const Mat & | a, |
double | s | ||
) |
CV_EXPORTS MatExpr cv::operator<= | ( | double | s, |
const Mat & | a | ||
) |
CV_EXPORTS MatExpr cv::operator== | ( | const Mat & | a, |
const Mat & | b | ||
) |
CV_EXPORTS MatExpr cv::operator== | ( | const Mat & | a, |
double | s | ||
) |
CV_EXPORTS MatExpr cv::operator== | ( | double | s, |
const Mat & | a | ||
) |
CV_EXPORTS MatExpr cv::operator!= | ( | const Mat & | a, |
const Mat & | b | ||
) |
CV_EXPORTS MatExpr cv::operator!= | ( | const Mat & | a, |
double | s | ||
) |
CV_EXPORTS MatExpr cv::operator!= | ( | double | s, |
const Mat & | a | ||
) |
CV_EXPORTS MatExpr cv::operator>= | ( | const Mat & | a, |
const Mat & | b | ||
) |
CV_EXPORTS MatExpr cv::operator>= | ( | const Mat & | a, |
double | s | ||
) |
CV_EXPORTS MatExpr cv::operator>= | ( | double | s, |
const Mat & | a | ||
) |
CV_EXPORTS MatExpr cv::operator> | ( | const Mat & | a, |
const Mat & | b | ||
) |
CV_EXPORTS MatExpr cv::operator> | ( | const Mat & | a, |
double | s | ||
) |
CV_EXPORTS MatExpr cv::operator> | ( | double | s, |
const Mat & | a | ||
) |
CV_EXPORTS MatExpr cv::min | ( | const Mat & | a, |
const Mat & | b | ||
) |
CV_EXPORTS MatExpr cv::min | ( | const Mat & | a, |
double | s | ||
) |
CV_EXPORTS MatExpr cv::min | ( | double | s, |
const Mat & | a | ||
) |
CV_EXPORTS MatExpr cv::max | ( | const Mat & | a, |
const Mat & | b | ||
) |
CV_EXPORTS MatExpr cv::max | ( | const Mat & | a, |
double | s | ||
) |
CV_EXPORTS MatExpr cv::max | ( | double | s, |
const Mat & | a | ||
) |
CV_EXPORTS MatExpr cv::operator& | ( | const Mat & | a, |
const Mat & | b | ||
) |
CV_EXPORTS MatExpr cv::operator& | ( | const Mat & | a, |
const Scalar & | s | ||
) |
CV_EXPORTS MatExpr cv::operator& | ( | const Scalar & | s, |
const Mat & | a | ||
) |
CV_EXPORTS MatExpr cv::operator| | ( | const Mat & | a, |
const Mat & | b | ||
) |
CV_EXPORTS MatExpr cv::operator| | ( | const Mat & | a, |
const Scalar & | s | ||
) |
CV_EXPORTS MatExpr cv::operator| | ( | const Scalar & | s, |
const Mat & | a | ||
) |
CV_EXPORTS MatExpr cv::operator^ | ( | const Mat & | a, |
const Mat & | b | ||
) |
CV_EXPORTS MatExpr cv::operator^ | ( | const Mat & | a, |
const Scalar & | s | ||
) |
CV_EXPORTS MatExpr cv::operator^ | ( | const Scalar & | s, |
const Mat & | a | ||
) |
CV_EXPORTS MatExpr cv::operator~ | ( | const Mat & | m | ) |
CV_EXPORTS MatExpr cv::abs | ( | const Mat & | m | ) |
CV_EXPORTS MatExpr cv::abs | ( | const MatExpr & | e | ) |
void cv::split | ( | const Mat & | src, |
vector< Mat_< _Tp > > & | mv | ||
) |
CV_EXPORTS ptrdiff_t cv::operator- | ( | const MatConstIterator & | b, |
const MatConstIterator & | a | ||
) |
CV_EXPORTS void cv::render | ( | const GlTexture & | tex, |
Rect_< double > | wndRect = Rect_< double >(0.0, 0.0, 1.0, 1.0) , |
||
Rect_< double > | texRect = Rect_< double >(0.0, 0.0, 1.0, 1.0) |
||
) |
render functions
render texture rectangle in window
CV_EXPORTS void cv::render | ( | const GlArrays & | arr, |
int | mode = RenderMode::POINTS , |
||
Scalar | color = Scalar::all(255) |
||
) |
render OpenGL arrays
CV_EXPORTS void cv::render | ( | const std::string & | str, |
const Ptr< GlFont > & | font, | ||
Scalar | color, | ||
Point2d | pos | ||
) |
short cv::saturate_cast< short > | ( | ushort | v | ) |
short cv::saturate_cast< short > | ( | int | v | ) |
short cv::saturate_cast< short > | ( | unsigned | v | ) |
short cv::saturate_cast< short > | ( | float | v | ) |
short cv::saturate_cast< short > | ( | double | v | ) |
unsigned cv::saturate_cast< unsigned > | ( | float | v | ) |
unsigned cv::saturate_cast< unsigned > | ( | double | v | ) |
int cv::fast_abs | ( | short | v | ) |
float cv::fast_abs | ( | float | v | ) |
double cv::fast_abs | ( | double | v | ) |
CV_EXPORTS float cv::normL2Sqr_ | ( | const float * | a, |
const float * | b, | ||
int | n | ||
) |
CV_EXPORTS float cv::normL1_ | ( | const float * | a, |
const float * | b, | ||
int | n | ||
) |
float cv::normL2Sqr | ( | const float * | a, |
const float * | b, | ||
int | n | ||
) |
float cv::normL1 | ( | const float * | a, |
const float * | b, | ||
int | n | ||
) |
Vec<_Tp, 2> cv::conjugate | ( | const Vec< _Tp, 2 > & | v | ) |
Vec<_Tp, 4> cv::conjugate | ( | const Vec< _Tp, 4 > & | v | ) |
Vec<_Tp, 4> cv::operator* | ( | const Vec< _Tp, 4 > & | v1, |
const Vec< _Tp, 4 > & | v2 | ||
) |
Vec<_Tp, 4>& cv::operator*= | ( | Vec< _Tp, 4 > & | v1, |
const Vec< _Tp, 4 > & | v2 | ||
) |
Vec<_Tp, cn> cv::normalize | ( | const Vec< _Tp, cn > & | v | ) |
DataType<_Tp>::work_type cv::dot | ( | const Vector< _Tp > & | v1, |
const Vector< _Tp > & | v2 | ||
) |
void cv::write | ( | FileStorage & | fs, |
const _Tp & | value | ||
) |
CV_EXPORTS void cv::writeScalar | ( | FileStorage & | fs, |
float | value | ||
) |
CV_EXPORTS void cv::writeScalar | ( | FileStorage & | fs, |
double | value | ||
) |
void cv::write | ( | FileStorage & | fs, |
const float & | value | ||
) |
void cv::write | ( | FileStorage & | fs, |
const double & | value | ||
) |
void cv::write | ( | FileStorage & | fs, |
const Point_< _Tp > & | pt | ||
) |
void cv::write | ( | FileStorage & | fs, |
const Point3_< _Tp > & | pt | ||
) |
void cv::write | ( | FileStorage & | fs, |
const Size_< _Tp > & | sz | ||
) |
void cv::write | ( | FileStorage & | fs, |
const Complex< _Tp > & | c | ||
) |
void cv::write | ( | FileStorage & | fs, |
const Rect_< _Tp > & | r | ||
) |
void cv::write | ( | FileStorage & | fs, |
const Vec< _Tp, cn > & | v | ||
) |
void cv::write | ( | FileStorage & | fs, |
const Scalar_< _Tp > & | s | ||
) |
void cv::write | ( | FileStorage & | fs, |
const Range & | r | ||
) |
void cv::write | ( | FileStorage & | fs, |
const string & | name, | ||
const Point_< _Tp > & | pt | ||
) |
void cv::write | ( | FileStorage & | fs, |
const string & | name, | ||
const Point3_< _Tp > & | pt | ||
) |
void cv::write | ( | FileStorage & | fs, |
const string & | name, | ||
const Size_< _Tp > & | sz | ||
) |
void cv::write | ( | FileStorage & | fs, |
const string & | name, | ||
const Complex< _Tp > & | c | ||
) |
void cv::write | ( | FileStorage & | fs, |
const string & | name, | ||
const Rect_< _Tp > & | r | ||
) |
void cv::write | ( | FileStorage & | fs, |
const string & | name, | ||
const Vec< _Tp, cn > & | v | ||
) |
void cv::write | ( | FileStorage & | fs, |
const string & | name, | ||
const Scalar_< _Tp > & | s | ||
) |
CV_EXPORTS FileStorage& cv::operator<< | ( | FileStorage & | fs, |
const string & | str | ||
) |
CV_EXPORTS_W void cv::read | ( | const FileNode & | node, |
Mat & | mat, | ||
const Mat & | default_mat = Mat() |
||
) |
CV_EXPORTS void cv::read | ( | const FileNode & | node, |
SparseMat & | mat, | ||
const SparseMat & | default_mat = SparseMat() |
||
) |
void cv::sort | ( | vector< _Tp > & | vec, |
_LT | LT = _LT() |
||
) |
int cv::partition | ( | const vector< _Tp > & | _vec, |
vector< int > & | labels, | ||
_EqPredicate | predicate = _EqPredicate() |
||
) |
ptrdiff_t cv::operator- | ( | const SeqIterator< _Tp > & | a, |
const SeqIterator< _Tp > & | b | ||
) |
bool cv::operator== | ( | const SeqIterator< _Tp > & | a, |
const SeqIterator< _Tp > & | b | ||
) |
bool cv::operator!= | ( | const SeqIterator< _Tp > & | a, |
const SeqIterator< _Tp > & | b | ||
) |
std::ostream& cv::operator<< | ( | std::ostream & | out, |
const Matx< _Tp, m, n > & | matx | ||
) |
Writes a Matx to an output stream.
std::ostream& cv::operator<< | ( | std::ostream & | out, |
const Point_< _Tp > & | p | ||
) |
Writes a point to an output stream in Matlab notation
std::ostream& cv::operator<< | ( | std::ostream & | out, |
const Point3_< _Tp > & | p | ||
) |
Writes a point to an output stream in Matlab notation
std::ostream& cv::operator<< | ( | std::ostream & | out, |
const Vec< _Tp, n > & | vec | ||
) |
Writes a Vec to an output stream. Format example : [10, 20, 30]
std::ostream& cv::operator<< | ( | std::ostream & | out, |
const Size_< _Tp > & | size | ||
) |
Writes a Size_ to an output stream. Format example : [640 x 480]
std::ostream& cv::operator<< | ( | std::ostream & | out, |
const Rect_< _Tp > & | rect | ||
) |
Writes a Rect_ to an output stream. Format example : [640 x 480 from (10, 20)]
CV_EXPORTS bool cv::initModule_features2d | ( | ) |
CV_EXPORTS void cv::write | ( | FileStorage & | fs, |
const string & | name, | ||
const vector< KeyPoint > & | keypoints | ||
) |
writes vector of keypoints to the file storage
CV_EXPORTS void cv::read | ( | const FileNode & | node, |
CV_OUT vector< KeyPoint > & | keypoints | ||
) |
reads vector of keypoints from the specified file storage node
CV_EXPORTS void cv::FAST | ( | InputArray | image, |
CV_OUT vector< KeyPoint > & | keypoints, | ||
int | threshold, | ||
bool | nonmaxSuppression = true |
||
) |
detects corners using FAST algorithm by E. Rosten
CV_EXPORTS void cv::FASTX | ( | InputArray | image, |
CV_OUT vector< KeyPoint > & | keypoints, | ||
int | threshold, | ||
bool | nonmaxSuppression, | ||
int | type | ||
) |
CV_EXPORTS Mat cv::windowedMatchingMask | ( | const vector< KeyPoint > & | keypoints1, |
const vector< KeyPoint > & | keypoints2, | ||
float | maxDeltaX, | ||
float | maxDeltaY | ||
) |
CV_EXPORTS_W void cv::drawKeypoints | ( | const Mat & | image, |
const vector< KeyPoint > & | keypoints, | ||
CV_OUT Mat & | outImage, | ||
const Scalar & | color = Scalar::all(-1) , |
||
int | flags = DrawMatchesFlags::DEFAULT |
||
) |
CV_EXPORTS void cv::drawMatches | ( | const Mat & | img1, |
const vector< KeyPoint > & | keypoints1, | ||
const Mat & | img2, | ||
const vector< KeyPoint > & | keypoints2, | ||
const vector< DMatch > & | matches1to2, | ||
Mat & | outImg, | ||
const Scalar & | matchColor = Scalar::all(-1) , |
||
const Scalar & | singlePointColor = Scalar::all(-1) , |
||
const vector< char > & | matchesMask = vector< char >() , |
||
int | flags = DrawMatchesFlags::DEFAULT |
||
) |
CV_EXPORTS void cv::drawMatches | ( | const Mat & | img1, |
const vector< KeyPoint > & | keypoints1, | ||
const Mat & | img2, | ||
const vector< KeyPoint > & | keypoints2, | ||
const vector< vector< DMatch > > & | matches1to2, | ||
Mat & | outImg, | ||
const Scalar & | matchColor = Scalar::all(-1) , |
||
const Scalar & | singlePointColor = Scalar::all(-1) , |
||
const vector< vector< char > > & | matchesMask = vector< vector< char > >() , |
||
int | flags = DrawMatchesFlags::DEFAULT |
||
) |
CV_EXPORTS void cv::evaluateFeatureDetector | ( | const Mat & | img1, |
const Mat & | img2, | ||
const Mat & | H1to2, | ||
vector< KeyPoint > * | keypoints1, | ||
vector< KeyPoint > * | keypoints2, | ||
float & | repeatability, | ||
int & | correspCount, | ||
const Ptr< FeatureDetector > & | fdetector = Ptr< FeatureDetector >() |
||
) |
CV_EXPORTS void cv::computeRecallPrecisionCurve | ( | const vector< vector< DMatch > > & | matches1to2, |
const vector< vector< uchar > > & | correctMatches1to2Mask, | ||
vector< Point2f > & | recallPrecisionCurve | ||
) |
CV_EXPORTS float cv::getRecall | ( | const vector< Point2f > & | recallPrecisionCurve, |
float | l_precision | ||
) |
CV_EXPORTS int cv::getNearestPoint | ( | const vector< Point2f > & | recallPrecisionCurve, |
float | l_precision | ||
) |
CV_EXPORTS void cv::evaluateGenericDescriptorMatcher | ( | const Mat & | img1, |
const Mat & | img2, | ||
const Mat & | H1to2, | ||
vector< KeyPoint > & | keypoints1, | ||
vector< KeyPoint > & | keypoints2, | ||
vector< vector< DMatch > > * | matches1to2, | ||
vector< vector< uchar > > * | correctMatches1to2Mask, | ||
vector< Point2f > & | recallPrecisionCurve, | ||
const Ptr< GenericDescriptorMatcher > & | dmatch = Ptr< GenericDescriptorMatcher >() |
||
) |
CV_EXPORTS_W void cv::destroyAllWindows | ( | ) |
CV_EXPORTS_W int cv::startWindowThread | ( | ) |
CV_EXPORTS void cv::setMouseCallback | ( | const string & | winname, |
MouseCallback | onMouse, | ||
void * | userdata = 0 |
||
) |
assigns callback for mouse events
CV_EXPORTS int cv::createTrackbar | ( | const string & | trackbarname, |
const string & | winname, | ||
int * | value, | ||
int | count, | ||
TrackbarCallback | onChange = 0 , |
||
void * | userdata = 0 |
||
) |
CV_EXPORTS_W void cv::setTrackbarPos | ( | const string & | trackbarname, |
const string & | winname, | ||
int | pos | ||
) |
CV_EXPORTS void cv::setOpenGlDrawCallback | ( | const string & | winname, |
OpenGlDrawCallback | onOpenGlDraw, | ||
void * | userdata = 0 |
||
) |
CV_EXPORTS void cv::pointCloudShow | ( | const string & | winname, |
const GlCamera & | camera, | ||
const GlArrays & | arr | ||
) |
CV_EXPORTS void cv::pointCloudShow | ( | const string & | winname, |
const GlCamera & | camera, | ||
InputArray | points, | ||
InputArray | colors = noArray() |
||
) |
CV_EXPORTS CvFont cv::fontQt | ( | const string & | nameFont, |
int | pointSize = -1 , |
||
Scalar | color = Scalar::all(0) , |
||
int | weight = CV_FONT_NORMAL , |
||
int | style = CV_STYLE_NORMAL , |
||
int | spacing = 0 |
||
) |
CV_EXPORTS void cv::displayOverlay | ( | const string & | winname, |
const string & | text, | ||
int delayms | CV_DEFAULT0 | ||
) |
CV_EXPORTS void cv::displayStatusBar | ( | const string & | winname, |
const string & | text, | ||
int delayms | CV_DEFAULT0 | ||
) |
CV_EXPORTS void cv::stopLoop | ( | ) |
CV_EXPORTS int cv::createButton | ( | const string & | bar_name, |
ButtonCallback | on_change, | ||
void * | userdata = NULL , |
||
int | type = CV_PUSH_BUTTON , |
||
bool | initial_button_state = 0 |
||
) |
CV_EXPORTS_W bool cv::imwrite | ( | const string & | filename, |
InputArray | img, | ||
const vector< int > & | params = vector< int >() |
||
) |
CV_EXPORTS_W bool cv::imencode | ( | const string & | ext, |
InputArray | img, | ||
CV_OUT vector< uchar > & | buf, | ||
const vector< int > & | params = vector< int >() |
||
) |
1D interpolation function: returns coordinate of the "donor" pixel for the specified location p.
CV_EXPORTS int cv::getKernelType | ( | InputArray | kernel, |
Point | anchor | ||
) |
returns type (one of KERNEL_*) of 1D or 2D kernel specified by its coefficients.
CV_EXPORTS Ptr<BaseRowFilter> cv::getLinearRowFilter | ( | int | srcType, |
int | bufType, | ||
InputArray | kernel, | ||
int | anchor, | ||
int | symmetryType | ||
) |
returns the primitive row filter with the specified kernel
CV_EXPORTS Ptr<BaseColumnFilter> cv::getLinearColumnFilter | ( | int | bufType, |
int | dstType, | ||
InputArray | kernel, | ||
int | anchor, | ||
int | symmetryType, | ||
double | delta = 0 , |
||
int | bits = 0 |
||
) |
returns the primitive column filter with the specified kernel
CV_EXPORTS Ptr<BaseFilter> cv::getLinearFilter | ( | int | srcType, |
int | dstType, | ||
InputArray | kernel, | ||
Point | anchor = Point(-1,-1) , |
||
double | delta = 0 , |
||
int | bits = 0 |
||
) |
returns 2D filter with the specified kernel
CV_EXPORTS Ptr<FilterEngine> cv::createSeparableLinearFilter | ( | int | srcType, |
int | dstType, | ||
InputArray | rowKernel, | ||
InputArray | columnKernel, | ||
Point | anchor = Point(-1,-1) , |
||
double | delta = 0 , |
||
int | rowBorderType = BORDER_DEFAULT , |
||
int | columnBorderType = -1 , |
||
const Scalar & | borderValue = Scalar() |
||
) |
returns the separable linear filter engine
CV_EXPORTS Ptr<FilterEngine> cv::createLinearFilter | ( | int | srcType, |
int | dstType, | ||
InputArray | kernel, | ||
Point | _anchor = Point(-1,-1) , |
||
double | delta = 0 , |
||
int | rowBorderType = BORDER_DEFAULT , |
||
int | columnBorderType = -1 , |
||
const Scalar & | borderValue = Scalar() |
||
) |
returns the non-separable linear filter engine
returns the Gaussian kernel with the specified parameters
CV_EXPORTS Ptr<FilterEngine> cv::createGaussianFilter | ( | int | type, |
Size | ksize, | ||
double | sigma1, | ||
double | sigma2 = 0 , |
||
int | borderType = BORDER_DEFAULT |
||
) |
returns the Gaussian filter engine
CV_EXPORTS_W void cv::getDerivKernels | ( | OutputArray | kx, |
OutputArray | ky, | ||
int | dx, | ||
int | dy, | ||
int | ksize, | ||
bool | normalize = false , |
||
int | ktype = CV_32F |
||
) |
initializes kernels of the generalized Sobel operator
CV_EXPORTS Ptr<FilterEngine> cv::createDerivFilter | ( | int | srcType, |
int | dstType, | ||
int | dx, | ||
int | dy, | ||
int | ksize, | ||
int | borderType = BORDER_DEFAULT |
||
) |
returns filter engine for the generalized Sobel operator
CV_EXPORTS Ptr<BaseRowFilter> cv::getRowSumFilter | ( | int | srcType, |
int | sumType, | ||
int | ksize, | ||
int | anchor = -1 |
||
) |
returns horizontal 1D box filter
CV_EXPORTS Ptr<BaseColumnFilter> cv::getColumnSumFilter | ( | int | sumType, |
int | dstType, | ||
int | ksize, | ||
int | anchor = -1 , |
||
double | scale = 1 |
||
) |
returns vertical 1D box filter
CV_EXPORTS Ptr<FilterEngine> cv::createBoxFilter | ( | int | srcType, |
int | dstType, | ||
Size | ksize, | ||
Point | anchor = Point(-1,-1) , |
||
bool | normalize = true , |
||
int | borderType = BORDER_DEFAULT |
||
) |
returns box filter engine
CV_EXPORTS_W Mat cv::getGaborKernel | ( | Size | ksize, |
double | sigma, | ||
double | theta, | ||
double | lambd, | ||
double | gamma, | ||
double | psi = CV_PI *0.5 , |
||
int | ktype = CV_64F |
||
) |
returns the Gabor kernel with the specified parameters
CV_EXPORTS Ptr<BaseRowFilter> cv::getMorphologyRowFilter | ( | int | op, |
int | type, | ||
int | ksize, | ||
int | anchor = -1 |
||
) |
returns horizontal 1D morphological filter
CV_EXPORTS Ptr<BaseColumnFilter> cv::getMorphologyColumnFilter | ( | int | op, |
int | type, | ||
int | ksize, | ||
int | anchor = -1 |
||
) |
returns vertical 1D morphological filter
CV_EXPORTS Ptr<BaseFilter> cv::getMorphologyFilter | ( | int | op, |
int | type, | ||
InputArray | kernel, | ||
Point | anchor = Point(-1,-1) |
||
) |
returns 2D morphological filter
CV_EXPORTS Ptr<FilterEngine> cv::createMorphologyFilter | ( | int | op, |
int | type, | ||
InputArray | kernel, | ||
Point | anchor = Point(-1,-1) , |
||
int | rowBorderType = BORDER_CONSTANT , |
||
int | columnBorderType = -1 , |
||
const Scalar & | borderValue = morphologyDefaultBorderValue() |
||
) |
returns morphological filter engine. Only MORPH_ERODE and MORPH_DILATE are supported.
returns structuring element of the specified shape and size
CV_EXPORTS_W void cv::copyMakeBorder | ( | InputArray | src, |
OutputArray | dst, | ||
int | top, | ||
int | bottom, | ||
int | left, | ||
int | right, | ||
int | borderType, | ||
const Scalar & | value = Scalar() |
||
) |
copies 2D array to a larger destination array with extrapolation of the outer part of src using the specified border mode
smooths the image using median filter.
CV_EXPORTS_W void cv::GaussianBlur | ( | InputArray | src, |
OutputArray | dst, | ||
Size | ksize, | ||
double | sigmaX, | ||
double | sigmaY = 0 , |
||
int | borderType = BORDER_DEFAULT |
||
) |
smooths the image using Gaussian filter.
CV_EXPORTS_W void cv::bilateralFilter | ( | InputArray | src, |
OutputArray | dst, | ||
int | d, | ||
double | sigmaColor, | ||
double | sigmaSpace, | ||
int | borderType = BORDER_DEFAULT |
||
) |
smooths the image using bilateral filter
CV_EXPORTS_W void cv::adaptiveBilateralFilter | ( | InputArray | src, |
OutputArray | dst, | ||
Size | ksize, | ||
double | sigmaSpace, | ||
double | maxSigmaColor = 20.0 , |
||
Point | anchor = Point(-1,-1) , |
||
int | borderType = BORDER_DEFAULT |
||
) |
smooths the image using adaptive bilateral filter
CV_EXPORTS_W void cv::boxFilter | ( | InputArray | src, |
OutputArray | dst, | ||
int | ddepth, | ||
Size | ksize, | ||
Point | anchor = Point(-1,-1) , |
||
bool | normalize = true , |
||
int | borderType = BORDER_DEFAULT |
||
) |
smooths the image using the box filter. Each pixel is processed in O(1) time
CV_EXPORTS_W void cv::blur | ( | InputArray | src, |
OutputArray | dst, | ||
Size | ksize, | ||
Point | anchor = Point(-1,-1) , |
||
int | borderType = BORDER_DEFAULT |
||
) |
a synonym for normalized box filter
CV_EXPORTS_W void cv::filter2D | ( | InputArray | src, |
OutputArray | dst, | ||
int | ddepth, | ||
InputArray | kernel, | ||
Point | anchor = Point(-1,-1) , |
||
double | delta = 0 , |
||
int | borderType = BORDER_DEFAULT |
||
) |
applies non-separable 2D linear filter to the image
CV_EXPORTS_W void cv::sepFilter2D | ( | InputArray | src, |
OutputArray | dst, | ||
int | ddepth, | ||
InputArray | kernelX, | ||
InputArray | kernelY, | ||
Point | anchor = Point(-1,-1) , |
||
double | delta = 0 , |
||
int | borderType = BORDER_DEFAULT |
||
) |
applies separable 2D linear filter to the image
CV_EXPORTS_W void cv::Sobel | ( | InputArray | src, |
OutputArray | dst, | ||
int | ddepth, | ||
int | dx, | ||
int | dy, | ||
int | ksize = 3 , |
||
double | scale = 1 , |
||
double | delta = 0 , |
||
int | borderType = BORDER_DEFAULT |
||
) |
applies generalized Sobel operator to the image
CV_EXPORTS_W void cv::Scharr | ( | InputArray | src, |
OutputArray | dst, | ||
int | ddepth, | ||
int | dx, | ||
int | dy, | ||
double | scale = 1 , |
||
double | delta = 0 , |
||
int | borderType = BORDER_DEFAULT |
||
) |
applies the vertical or horizontal Scharr operator to the image
CV_EXPORTS_W void cv::Laplacian | ( | InputArray | src, |
OutputArray | dst, | ||
int | ddepth, | ||
int | ksize = 1 , |
||
double | scale = 1 , |
||
double | delta = 0 , |
||
int | borderType = BORDER_DEFAULT |
||
) |
applies Laplacian operator to the image
CV_EXPORTS_W void cv::Canny | ( | InputArray | image, |
OutputArray | edges, | ||
double | threshold1, | ||
double | threshold2, | ||
int | apertureSize = 3 , |
||
bool | L2gradient = false |
||
) |
applies Canny edge detector and produces the edge map.
CV_EXPORTS_W void cv::cornerMinEigenVal | ( | InputArray | src, |
OutputArray | dst, | ||
int | blockSize, | ||
int | ksize = 3 , |
||
int | borderType = BORDER_DEFAULT |
||
) |
computes minimum eigen value of 2x2 derivative covariation matrix at each pixel - the cornerness criteria
CV_EXPORTS_W void cv::cornerHarris | ( | InputArray | src, |
OutputArray | dst, | ||
int | blockSize, | ||
int | ksize, | ||
double | k, | ||
int | borderType = BORDER_DEFAULT |
||
) |
computes Harris cornerness criteria at each image pixel
CV_EXPORTS_W void cv::cornerEigenValsAndVecs | ( | InputArray | src, |
OutputArray | dst, | ||
int | blockSize, | ||
int | ksize, | ||
int | borderType = BORDER_DEFAULT |
||
) |
computes both eigenvalues and the eigenvectors of 2x2 derivative covariation matrix at each pixel. The output is stored as 6-channel matrix.
CV_EXPORTS_W void cv::preCornerDetect | ( | InputArray | src, |
OutputArray | dst, | ||
int | ksize, | ||
int | borderType = BORDER_DEFAULT |
||
) |
computes another complex cornerness criteria at each pixel
CV_EXPORTS_W void cv::cornerSubPix | ( | InputArray | image, |
InputOutputArray | corners, | ||
Size | winSize, | ||
Size | zeroZone, | ||
TermCriteria | criteria | ||
) |
adjusts the corner locations with sub-pixel accuracy to maximize the certain cornerness criteria
CV_EXPORTS_W void cv::goodFeaturesToTrack | ( | InputArray | image, |
OutputArray | corners, | ||
int | maxCorners, | ||
double | qualityLevel, | ||
double | minDistance, | ||
InputArray | mask = noArray() , |
||
int | blockSize = 3 , |
||
bool | useHarrisDetector = false , |
||
double | k = 0.04 |
||
) |
finds the strong enough corners where the cornerMinEigenVal() or cornerHarris() report the local maxima
CV_EXPORTS_W void cv::HoughLines | ( | InputArray | image, |
OutputArray | lines, | ||
double | rho, | ||
double | theta, | ||
int | threshold, | ||
double | srn = 0 , |
||
double | stn = 0 |
||
) |
finds lines in the black-n-white image using the standard or pyramid Hough transform
CV_EXPORTS_W void cv::HoughLinesP | ( | InputArray | image, |
OutputArray | lines, | ||
double | rho, | ||
double | theta, | ||
int | threshold, | ||
double | minLineLength = 0 , |
||
double | maxLineGap = 0 |
||
) |
finds line segments in the black-n-white image using probabilistic Hough transform
CV_EXPORTS_W void cv::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 the grayscale image using 2+1 gradient Hough transform
CV_EXPORTS_W void cv::erode | ( | InputArray | src, |
OutputArray | dst, | ||
InputArray | kernel, | ||
Point | anchor = Point(-1,-1) , |
||
int | iterations = 1 , |
||
int | borderType = BORDER_CONSTANT , |
||
const Scalar & | borderValue = morphologyDefaultBorderValue() |
||
) |
erodes the image (applies the local minimum operator)
CV_EXPORTS_W void cv::dilate | ( | InputArray | src, |
OutputArray | dst, | ||
InputArray | kernel, | ||
Point | anchor = Point(-1,-1) , |
||
int | iterations = 1 , |
||
int | borderType = BORDER_CONSTANT , |
||
const Scalar & | borderValue = morphologyDefaultBorderValue() |
||
) |
dilates the image (applies the local maximum operator)
CV_EXPORTS_W void cv::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() |
||
) |
applies an advanced morphological operation to the image
CV_EXPORTS_W void cv::resize | ( | InputArray | src, |
OutputArray | dst, | ||
Size | dsize, | ||
double | fx = 0 , |
||
double | fy = 0 , |
||
int | interpolation = INTER_LINEAR |
||
) |
resizes the image
CV_EXPORTS_W void cv::warpAffine | ( | InputArray | src, |
OutputArray | dst, | ||
InputArray | M, | ||
Size | dsize, | ||
int | flags = INTER_LINEAR , |
||
int | borderMode = BORDER_CONSTANT , |
||
const Scalar & | borderValue = Scalar() |
||
) |
warps the image using affine transformation
CV_EXPORTS_W void cv::warpPerspective | ( | InputArray | src, |
OutputArray | dst, | ||
InputArray | M, | ||
Size | dsize, | ||
int | flags = INTER_LINEAR , |
||
int | borderMode = BORDER_CONSTANT , |
||
const Scalar & | borderValue = Scalar() |
||
) |
warps the image using perspective transformation
CV_EXPORTS_W void cv::remap | ( | InputArray | src, |
OutputArray | dst, | ||
InputArray | map1, | ||
InputArray | map2, | ||
int | interpolation, | ||
int | borderMode = BORDER_CONSTANT , |
||
const Scalar & | borderValue = Scalar() |
||
) |
warps the image using the precomputed maps. The maps are stored in either floating-point or integer fixed-point format
CV_EXPORTS_W void cv::convertMaps | ( | InputArray | map1, |
InputArray | map2, | ||
OutputArray | dstmap1, | ||
OutputArray | dstmap2, | ||
int | dstmap1type, | ||
bool | nninterpolation = false |
||
) |
converts maps for remap from floating-point to fixed-point format or backwards
CV_EXPORTS_W Mat cv::getRotationMatrix2D | ( | Point2f | center, |
double | angle, | ||
double | scale | ||
) |
returns 2x3 affine transformation matrix for the planar rotation.
CV_EXPORTS Mat cv::getPerspectiveTransform | ( | const Point2f | src[], |
const Point2f | dst[] | ||
) |
returns 3x3 perspective transformation for the corresponding 4 point pairs.
CV_EXPORTS Mat cv::getAffineTransform | ( | const Point2f | src[], |
const Point2f | dst[] | ||
) |
returns 2x3 affine transformation for the corresponding 3 point pairs.
CV_EXPORTS_W void cv::invertAffineTransform | ( | InputArray | M, |
OutputArray | iM | ||
) |
computes 2x3 affine transformation matrix that is inverse to the specified 2x3 affine transformation.
CV_EXPORTS_W Mat cv::getPerspectiveTransform | ( | InputArray | src, |
InputArray | dst | ||
) |
CV_EXPORTS_W Mat cv::getAffineTransform | ( | InputArray | src, |
InputArray | dst | ||
) |
CV_EXPORTS_W void cv::getRectSubPix | ( | InputArray | image, |
Size | patchSize, | ||
Point2f | center, | ||
OutputArray | patch, | ||
int | patchType = -1 |
||
) |
extracts rectangle from the image at sub-pixel location
computes the integral image
cv::CV_EXPORTS_AS | ( | integral2 | ) |
computes the integral image and integral for the squared image
cv::CV_EXPORTS_AS | ( | integral3 | ) |
computes the integral image, integral for the squared image and the tilted integral image
CV_EXPORTS_W void cv::accumulate | ( | InputArray | src, |
InputOutputArray | dst, | ||
InputArray | mask = noArray() |
||
) |
adds image to the accumulator (dst += src). Unlike cv::add, dst and src can have different types.
CV_EXPORTS_W void cv::accumulateSquare | ( | InputArray | src, |
InputOutputArray | dst, | ||
InputArray | mask = noArray() |
||
) |
adds squared src image to the accumulator (dst += src*src).
CV_EXPORTS_W void cv::accumulateProduct | ( | InputArray | src1, |
InputArray | src2, | ||
InputOutputArray | dst, | ||
InputArray | mask = noArray() |
||
) |
adds product of the 2 images to the accumulator (dst += src1*src2).
CV_EXPORTS_W void cv::accumulateWeighted | ( | InputArray | src, |
InputOutputArray | dst, | ||
double | alpha, | ||
InputArray | mask = noArray() |
||
) |
updates the running average (dst = dst*(1-alpha) + src*alpha)
CV_EXPORTS_W double cv::PSNR | ( | InputArray | src1, |
InputArray | src2 | ||
) |
computes PSNR image/video quality metric
CV_EXPORTS_W Point2d cv::phaseCorrelate | ( | InputArray | src1, |
InputArray | src2, | ||
InputArray | window = noArray() |
||
) |
CV_EXPORTS_W Point2d cv::phaseCorrelateRes | ( | InputArray | src1, |
InputArray | src2, | ||
InputArray | window, | ||
CV_OUT double * | response = 0 |
||
) |
CV_EXPORTS_W double cv::threshold | ( | InputArray | src, |
OutputArray | dst, | ||
double | thresh, | ||
double | maxval, | ||
int | type | ||
) |
applies fixed threshold to the image
CV_EXPORTS_W void cv::adaptiveThreshold | ( | InputArray | src, |
OutputArray | dst, | ||
double | maxValue, | ||
int | adaptiveMethod, | ||
int | thresholdType, | ||
int | blockSize, | ||
double | C | ||
) |
applies variable (adaptive) threshold to the image
CV_EXPORTS_W void cv::pyrDown | ( | InputArray | src, |
OutputArray | dst, | ||
const Size & | dstsize = Size() , |
||
int | borderType = BORDER_DEFAULT |
||
) |
smooths and downsamples the image
CV_EXPORTS_W void cv::pyrUp | ( | InputArray | src, |
OutputArray | dst, | ||
const Size & | dstsize = Size() , |
||
int | borderType = BORDER_DEFAULT |
||
) |
upsamples and smoothes the image
CV_EXPORTS void cv::buildPyramid | ( | InputArray | src, |
OutputArrayOfArrays | dst, | ||
int | maxlevel, | ||
int | borderType = BORDER_DEFAULT |
||
) |
builds the gaussian pyramid using pyrDown() as a basic operation
CV_EXPORTS_W void cv::undistort | ( | InputArray | src, |
OutputArray | dst, | ||
InputArray | cameraMatrix, | ||
InputArray | distCoeffs, | ||
InputArray | newCameraMatrix = noArray() |
||
) |
corrects lens distortion for the given camera matrix and distortion coefficients
CV_EXPORTS_W void cv::initUndistortRectifyMap | ( | InputArray | cameraMatrix, |
InputArray | distCoeffs, | ||
InputArray | R, | ||
InputArray | newCameraMatrix, | ||
Size | size, | ||
int | m1type, | ||
OutputArray | map1, | ||
OutputArray | map2 | ||
) |
initializes maps for cv::remap() to correct lens distortion and optionally rectify the image
CV_EXPORTS_W float cv::initWideAngleProjMap | ( | InputArray | cameraMatrix, |
InputArray | distCoeffs, | ||
Size | imageSize, | ||
int | destImageWidth, | ||
int | m1type, | ||
OutputArray | map1, | ||
OutputArray | map2, | ||
int | projType = PROJ_SPHERICAL_EQRECT , |
||
double | alpha = 0 |
||
) |
initializes maps for cv::remap() for wide-angle
CV_EXPORTS_W Mat cv::getDefaultNewCameraMatrix | ( | InputArray | cameraMatrix, |
Size | imgsize = Size() , |
||
bool | centerPrincipalPoint = false |
||
) |
returns the default new camera matrix (by default it is the same as cameraMatrix unless centerPricipalPoint=true)
CV_EXPORTS_W void cv::undistortPoints | ( | InputArray | src, |
OutputArray | dst, | ||
InputArray | cameraMatrix, | ||
InputArray | distCoeffs, | ||
InputArray | R = noArray() , |
||
InputArray | P = noArray() |
||
) |
returns points' coordinates after lens distortion correction
CV_EXPORTS void cv::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 |
||
) |
computes the joint dense histogram for a set of images.
CV_EXPORTS void cv::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 |
||
) |
computes the joint sparse histogram for a set of images.
CV_EXPORTS_W void cv::calcHist | ( | InputArrayOfArrays | images, |
const vector< int > & | channels, | ||
InputArray | mask, | ||
OutputArray | hist, | ||
const vector< int > & | histSize, | ||
const vector< float > & | ranges, | ||
bool | accumulate = false |
||
) |
CV_EXPORTS void cv::calcBackProject | ( | const Mat * | images, |
int | nimages, | ||
const int * | channels, | ||
InputArray | hist, | ||
OutputArray | backProject, | ||
const float ** | ranges, | ||
double | scale = 1 , |
||
bool | uniform = true |
||
) |
computes back projection for the set of images
CV_EXPORTS void cv::calcBackProject | ( | const Mat * | images, |
int | nimages, | ||
const int * | channels, | ||
const SparseMat & | hist, | ||
OutputArray | backProject, | ||
const float ** | ranges, | ||
double | scale = 1 , |
||
bool | uniform = true |
||
) |
computes back projection for the set of images
CV_EXPORTS_W void cv::calcBackProject | ( | InputArrayOfArrays | images, |
const vector< int > & | channels, | ||
InputArray | hist, | ||
OutputArray | dst, | ||
const vector< float > & | ranges, | ||
double | scale | ||
) |
CV_EXPORTS_W double cv::compareHist | ( | InputArray | H1, |
InputArray | H2, | ||
int | method | ||
) |
compares two histograms stored in dense arrays
CV_EXPORTS double cv::compareHist | ( | const SparseMat & | H1, |
const SparseMat & | H2, | ||
int | method | ||
) |
compares two histograms stored in sparse arrays
CV_EXPORTS_W void cv::equalizeHist | ( | InputArray | src, |
OutputArray | dst | ||
) |
normalizes the grayscale image brightness and contrast by normalizing its histogram
CV_EXPORTS float cv::EMD | ( | InputArray | signature1, |
InputArray | signature2, | ||
int | distType, | ||
InputArray | cost = noArray() , |
||
float * | lowerBound = 0 , |
||
OutputArray | flow = noArray() |
||
) |
CV_EXPORTS_W void cv::watershed | ( | InputArray | image, |
InputOutputArray | markers | ||
) |
segments the image using watershed algorithm
CV_EXPORTS_W void cv::pyrMeanShiftFiltering | ( | InputArray | src, |
OutputArray | dst, | ||
double | sp, | ||
double | sr, | ||
int | maxLevel = 1 , |
||
TermCriteria | termcrit = TermCriteria(TermCriteria::MAX_ITER+TermCriteria::EPS, 5, 1) |
||
) |
filters image using meanshift algorithm
CV_EXPORTS_W void cv::grabCut | ( | InputArray | img, |
InputOutputArray | mask, | ||
Rect | rect, | ||
InputOutputArray | bgdModel, | ||
InputOutputArray | fgdModel, | ||
int | iterCount, | ||
int | mode = GC_EVAL |
||
) |
segments the image using GrabCut algorithm
cv::CV_EXPORTS_AS | ( | distanceTransformWithLabels | ) |
builds the discrete Voronoi diagram
CV_EXPORTS_W void cv::distanceTransform | ( | InputArray | src, |
OutputArray | dst, | ||
int | distanceType, | ||
int | maskSize | ||
) |
computes the distance transform map
CV_EXPORTS int cv::floodFill | ( | InputOutputArray | image, |
Point | seedPoint, | ||
Scalar | newVal, | ||
CV_OUT Rect * | rect = 0 , |
||
Scalar | loDiff = Scalar() , |
||
Scalar | upDiff = Scalar() , |
||
int | flags = 4 |
||
) |
fills the semi-uniform image region starting from the specified seed point
CV_EXPORTS_W int cv::floodFill | ( | InputOutputArray | image, |
InputOutputArray | mask, | ||
Point | seedPoint, | ||
Scalar | newVal, | ||
CV_OUT Rect * | rect = 0 , |
||
Scalar | loDiff = Scalar() , |
||
Scalar | upDiff = Scalar() , |
||
int | flags = 4 |
||
) |
fills the semi-uniform image region and/or the mask starting from the specified seed point
converts image from one color space to another
CV_EXPORTS_W Moments cv::moments | ( | InputArray | array, |
bool | binaryImage = false |
||
) |
computes moments of the rasterized shape or a vector of points
CV_EXPORTS void cv::HuMoments | ( | const Moments & | moments, |
double | hu[7] | ||
) |
computes 7 Hu invariants from the moments
CV_EXPORTS_W void cv::HuMoments | ( | const Moments & | m, |
CV_OUT OutputArray | hu | ||
) |
CV_EXPORTS_W void cv::matchTemplate | ( | InputArray | image, |
InputArray | templ, | ||
OutputArray | result, | ||
int | method | ||
) |
computes the proximity map for the raster template and the image where the template is searched for
CV_EXPORTS_W void cv::findContours | ( | InputOutputArray | image, |
OutputArrayOfArrays | contours, | ||
OutputArray | hierarchy, | ||
int | mode, | ||
int | method, | ||
Point | offset = Point() |
||
) |
retrieves contours and the hierarchical information from black-n-white image.
CV_EXPORTS void cv::findContours | ( | InputOutputArray | image, |
OutputArrayOfArrays | contours, | ||
int | mode, | ||
int | method, | ||
Point | offset = Point() |
||
) |
retrieves contours from black-n-white image.
CV_EXPORTS_W void cv::drawContours | ( | InputOutputArray | image, |
InputArrayOfArrays | contours, | ||
int | contourIdx, | ||
const Scalar & | color, | ||
int | thickness = 1 , |
||
int | lineType = 8 , |
||
InputArray | hierarchy = noArray() , |
||
int | maxLevel = INT_MAX , |
||
Point | offset = Point() |
||
) |
draws contours in the image
CV_EXPORTS_W void cv::approxPolyDP | ( | InputArray | curve, |
OutputArray | approxCurve, | ||
double | epsilon, | ||
bool | closed | ||
) |
approximates contour or a curve using Douglas-Peucker algorithm
CV_EXPORTS_W double cv::arcLength | ( | InputArray | curve, |
bool | closed | ||
) |
computes the contour perimeter (closed=true) or a curve length
CV_EXPORTS_W Rect cv::boundingRect | ( | InputArray | points | ) |
computes the bounding rectangle for a contour
CV_EXPORTS_W double cv::contourArea | ( | InputArray | contour, |
bool | oriented = false |
||
) |
computes the contour area
CV_EXPORTS_W RotatedRect cv::minAreaRect | ( | InputArray | points | ) |
computes the minimal rotated rectangle for a set of points
CV_EXPORTS_W void cv::minEnclosingCircle | ( | InputArray | points, |
CV_OUT Point2f & | center, | ||
CV_OUT float & | radius | ||
) |
computes the minimal enclosing circle for a set of points
CV_EXPORTS_W double cv::matchShapes | ( | InputArray | contour1, |
InputArray | contour2, | ||
int | method, | ||
double | parameter | ||
) |
matches two contours using one of the available algorithms
CV_EXPORTS_W void cv::convexHull | ( | InputArray | points, |
OutputArray | hull, | ||
bool | clockwise = false , |
||
bool | returnPoints = true |
||
) |
computes convex hull for a set of 2D points.
CV_EXPORTS_W void cv::convexityDefects | ( | InputArray | contour, |
InputArray | convexhull, | ||
OutputArray | convexityDefects | ||
) |
computes the contour convexity defects
CV_EXPORTS_W bool cv::isContourConvex | ( | InputArray | contour | ) |
returns true if the contour is convex. Does not support contours with self-intersection
CV_EXPORTS_W float cv::intersectConvexConvex | ( | InputArray | _p1, |
InputArray | _p2, | ||
OutputArray | _p12, | ||
bool | handleNested = true |
||
) |
finds intersection of two convex polygons
CV_EXPORTS_W RotatedRect cv::fitEllipse | ( | InputArray | points | ) |
fits ellipse to the set of 2D points
CV_EXPORTS_W void cv::fitLine | ( | InputArray | points, |
OutputArray | line, | ||
int | distType, | ||
double | param, | ||
double | reps, | ||
double | aeps | ||
) |
fits line to the set of 2D points using M-estimator algorithm
CV_EXPORTS_W double cv::pointPolygonTest | ( | InputArray | contour, |
Point2f | pt, | ||
bool | measureDist | ||
) |
checks if the point is inside the contour. Optionally computes the signed distance from the point to the contour boundary
CV_EXPORTS bool cv::initModule_ml | ( | void | ) |
CV_EXPORTS_W bool cv::initModule_nonfree | ( | ) |
CV_EXPORTS void cv::groupRectangles | ( | CV_OUT CV_IN_OUT vector< Rect > & | rectList, |
int | groupThreshold, | ||
double | eps = 0.2 |
||
) |
CV_EXPORTS_W void cv::groupRectangles | ( | CV_OUT CV_IN_OUT vector< Rect > & | rectList, |
CV_OUT vector< int > & | weights, | ||
int | groupThreshold, | ||
double | eps = 0.2 |
||
) |
CV_EXPORTS void cv::groupRectangles | ( | vector< Rect > & | rectList, |
int | groupThreshold, | ||
double | eps, | ||
vector< int > * | weights, | ||
vector< double > * | levelWeights | ||
) |
CV_EXPORTS void cv::groupRectangles | ( | vector< Rect > & | rectList, |
vector< int > & | rejectLevels, | ||
vector< double > & | levelWeights, | ||
int | groupThreshold, | ||
double | eps = 0.2 |
||
) |
CV_EXPORTS void cv::groupRectangles_meanshift | ( | vector< Rect > & | rectList, |
vector< double > & | foundWeights, | ||
vector< double > & | foundScales, | ||
double | detectThreshold = 0.0 , |
||
Size | winDetSize = Size(64, 128) |
||
) |
CV_EXPORTS_W void cv::findDataMatrix | ( | InputArray | image, |
CV_OUT vector< string > & | codes, | ||
OutputArray | corners = noArray() , |
||
OutputArrayOfArrays | dmtx = noArray() |
||
) |
CV_EXPORTS_W void cv::drawDataMatrixCodes | ( | InputOutputArray | image, |
const vector< string > & | codes, | ||
InputArray | corners | ||
) |
CV_EXPORTS_W void cv::inpaint | ( | InputArray | src, |
InputArray | inpaintMask, | ||
OutputArray | dst, | ||
double | inpaintRadius, | ||
int | flags | ||
) |
restores the damaged image areas using one of the available intpainting algorithms
CV_EXPORTS_W void cv::fastNlMeansDenoising | ( | InputArray | src, |
OutputArray | dst, | ||
float | h = 3 , |
||
int | templateWindowSize = 7 , |
||
int | searchWindowSize = 21 |
||
) |
CV_EXPORTS_W void cv::fastNlMeansDenoisingColored | ( | InputArray | src, |
OutputArray | dst, | ||
float | h = 3 , |
||
float | hColor = 3 , |
||
int | templateWindowSize = 7 , |
||
int | searchWindowSize = 21 |
||
) |
CV_EXPORTS_W void cv::fastNlMeansDenoisingMulti | ( | InputArrayOfArrays | srcImgs, |
OutputArray | dst, | ||
int | imgToDenoiseIndex, | ||
int | temporalWindowSize, | ||
float | h = 3 , |
||
int | templateWindowSize = 7 , |
||
int | searchWindowSize = 21 |
||
) |
CV_EXPORTS_W void cv::fastNlMeansDenoisingColoredMulti | ( | InputArrayOfArrays | srcImgs, |
OutputArray | dst, | ||
int | imgToDenoiseIndex, | ||
int | temporalWindowSize, | ||
float | h = 3 , |
||
float | hColor = 3 , |
||
int | templateWindowSize = 7 , |
||
int | searchWindowSize = 21 |
||
) |
CV_EXPORTS void cv::PrintTo | ( | const Size & | sz, |
::std::ostream * | os | ||
) |
CV_EXPORTS_W void cv::updateMotionHistory | ( | InputArray | silhouette, |
InputOutputArray | mhi, | ||
double | timestamp, | ||
double | duration | ||
) |
updates motion history image using the current silhouette
CV_EXPORTS_W void cv::calcMotionGradient | ( | InputArray | mhi, |
OutputArray | mask, | ||
OutputArray | orientation, | ||
double | delta1, | ||
double | delta2, | ||
int | apertureSize = 3 |
||
) |
computes the motion gradient orientation image from the motion history image
CV_EXPORTS_W double cv::calcGlobalOrientation | ( | InputArray | orientation, |
InputArray | mask, | ||
InputArray | mhi, | ||
double | timestamp, | ||
double | duration | ||
) |
computes the global orientation of the selected motion history image part
CV_EXPORTS_W void cv::segmentMotion | ( | InputArray | mhi, |
OutputArray | segmask, | ||
CV_OUT vector< Rect > & | boundingRects, | ||
double | timestamp, | ||
double | segThresh | ||
) |
CV_EXPORTS_W RotatedRect cv::CamShift | ( | InputArray | probImage, |
CV_OUT CV_IN_OUT Rect & | window, | ||
TermCriteria | criteria | ||
) |
updates the object tracking window using CAMSHIFT algorithm
CV_EXPORTS_W int cv::meanShift | ( | InputArray | probImage, |
CV_OUT CV_IN_OUT Rect & | window, | ||
TermCriteria | criteria | ||
) |
updates the object tracking window using meanshift algorithm
CV_EXPORTS_W int cv::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 a pyramid which can be used as input for calcOpticalFlowPyrLK
CV_EXPORTS_W void cv::calcOpticalFlowPyrLK | ( | InputArray | prevImg, |
InputArray | nextImg, | ||
InputArray | prevPts, | ||
CV_OUT 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 |
||
) |
computes sparse optical flow using multi-scale Lucas-Kanade algorithm
CV_EXPORTS_W void cv::calcOpticalFlowFarneback | ( | InputArray | prev, |
InputArray | next, | ||
CV_OUT InputOutputArray | flow, | ||
double | pyr_scale, | ||
int | levels, | ||
int | winsize, | ||
int | iterations, | ||
int | poly_n, | ||
double | poly_sigma, | ||
int | flags | ||
) |
computes dense optical flow using Farneback algorithm
CV_EXPORTS_W Mat cv::estimateRigidTransform | ( | InputArray | src, |
InputArray | dst, | ||
bool | fullAffine | ||
) |
estimates the best-fit Euqcidean, similarity, affine or perspective transformation
CV_EXPORTS_W void cv::calcOpticalFlowSF | ( | Mat & | from, |
Mat & | to, | ||
Mat & | flow, | ||
int | layers, | ||
int | averaging_block_size, | ||
int | max_flow | ||
) |
computes dense optical flow using Simple Flow algorithm
CV_EXPORTS_W void cv::calcOpticalFlowSF | ( | Mat & | from, |
Mat & | to, | ||
Mat & | flow, | ||
int | layers, | ||
int | averaging_block_size, | ||
int | max_flow, | ||
double | sigma_dist, | ||
double | sigma_color, | ||
int | postprocess_window, | ||
double | sigma_dist_fix, | ||
double | sigma_color_fix, | ||
double | occ_thr, | ||
int | upscale_averaging_radius, | ||
double | upscale_sigma_dist, | ||
double | upscale_sigma_color, | ||
double | speed_up_thr | ||
) |
CV_EXPORTS Ptr<DenseOpticalFlow> cv::createOptFlow_DualTVL1 | ( | ) |
CV_EXPORTS bool cv::initModule_video | ( | void | ) |
class CV_EXPORTS cv::MatExpr |
class CV_EXPORTS cv::MatOp_Base |
class CV_EXPORTS cv::MatArg |
class CV_EXPORTS cv::MatConstIterator |
double cv::iterFactor =1.) |
class CV_EXPORTS cv::FileNode |
class CV_EXPORTS cv::FileNodeIterator |
class CV_EXPORTS cv::Algorithm |
class CV_EXPORTS cv::AlgorithmInfo |
struct CV_EXPORTS cv::AlgorithmInfoData |
OutputArray cv::sum |
OutputArray OutputArray cv::sqsum |
OutputArray OutputArray OutputArray int cv::sdepth =-1 ) |
OutputArray OutputArray OutputArray cv::tilted |
OutputArray cv::dst |
OutputArray OutputArray cv::labels |
OutputArray OutputArray int cv::distanceType |
OutputArray OutputArray int int cv::maskSize |
OutputArray OutputArray int int int cv::labelType =DIST_LABEL_CCOMP ) |