|
CV_EXPORTS_W void | cv::absdiff (const Mat &src1, const Mat &src2, CV_OUT Mat &dst) |
| computes element-wise absolute difference of two arrays (dst = abs(src1 - src2))
|
|
CV_EXPORTS_W void | cv::absdiff (const Mat &src1, const Scalar &src2, CV_OUT Mat &dst) |
| computes element-wise absolute difference of array and scalar (dst = abs(src1 - src2))
|
|
CV_EXPORTS_W void | cv::add (const Mat &src1, const Mat &src2, CV_OUT Mat &dst, const Mat &mask CV_WRAP_DEFAULT(Mat())) |
| adds one matrix to another (dst = src1 + src2)
|
|
void | cv::add (const Mat &src1, const Mat &src2, CV_OUT Mat &dst) |
| adds one matrix to another (dst = src1 + src2)
|
|
CV_EXPORTS_W void | cv::add (const Mat &src1, const Scalar &src2, CV_OUT Mat &dst, const Mat &mask=Mat()) |
| adds scalar to a matrix (dst = src1 + src2)
|
|
CV_EXPORTS_W void | cv::addWeighted (const Mat &src1, double alpha, const Mat &src2, double beta, double gamma, CV_OUT Mat &dst) |
| computes weighted sum of two arrays (dst = alpha*src1 + beta*src2 + gamma)
|
|
CV_EXPORTS_W void | cv::bitwise_and (const Mat &src1, const Mat &src2, CV_OUT Mat &dst, const Mat &mask=Mat()) |
| computes bitwise conjunction of the two arrays (dst = src1 & src2)
|
|
CV_EXPORTS_W void | cv::bitwise_and (const Mat &src1, const Scalar &src2, CV_OUT Mat &dst, const Mat &mask=Mat()) |
| computes bitwise conjunction of an array and scalar (dst = src1 & src2)
|
|
CV_EXPORTS_W void | cv::bitwise_not (const Mat &src, CV_OUT Mat &dst) |
| inverts each bit of array (dst = ~src)
|
|
CV_EXPORTS_W void | cv::bitwise_or (const Mat &src1, const Mat &src2, CV_OUT Mat &dst, const Mat &mask=Mat()) |
| computes bitwise disjunction of the two arrays (dst = src1 | src2)
|
|
CV_EXPORTS_W void | cv::bitwise_or (const Mat &src1, const Scalar &src2, CV_OUT Mat &dst, const Mat &mask=Mat()) |
| computes bitwise disjunction of an array and scalar (dst = src1 | src2)
|
|
CV_EXPORTS_W void | cv::bitwise_xor (const Mat &src1, const Mat &src2, CV_OUT Mat &dst, const Mat &mask=Mat()) |
| computes bitwise exclusive-or of the two arrays (dst = src1 ^ src2)
|
|
CV_EXPORTS_W void | cv::bitwise_xor (const Mat &src1, const Scalar &src2, CV_OUT Mat &dst, const Mat &mask=Mat()) |
| computes bitwise exclusive-or of an array and scalar (dst = src1 ^ src2)
|
|
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 (const Mat &samples, CV_OUT Mat &covar, CV_OUT Mat &mean, int flags, int ctype=CV_64F) |
| computes covariation matrix of a set of samples
|
|
CV_EXPORTS_W void | cv::cartToPolar (const Mat &x, const Mat &y, CV_OUT Mat &magnitude, CV_OUT Mat &angle, bool angleInDegrees=false) |
| converts Cartesian coordinates to polar
|
|
CV_EXPORTS_W bool | cv::checkHardwareSupport (int feature) |
|
CV_EXPORTS_W bool | cv::checkRange (const Mat &a, bool quiet=true, CV_OUT Point *pt=0, double minVal=-DBL_MAX, double maxVal=DBL_MAX) |
| checks that each matrix element is within the specified range.
|
|
CV_EXPORTS_W void | cv::circle (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
|
|
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_IN_OUT Point &pt1, CV_IN_OUT Point &pt2) |
| clips the line segment by the rectangle imgRect
|
|
CV_EXPORTS_W void | cv::compare (const Mat &src1, const Mat &src2, CV_OUT Mat &dst, int cmpop) |
| compares elements of two arrays (dst = src1 <cmpop> src2)
|
|
CV_EXPORTS_W void | cv::compare (const Mat &src1, double s, CV_OUT Mat &dst, int cmpop) |
| compares elements of array with scalar (dst = src1 <cmpop> src2)
|
|
CV_EXPORTS_W void | cv::completeSymm (Mat &mtx, bool lowerToUpper=false) |
| extends the symmetrical matrix from the lower half or from the upper half
|
|
CV_EXPORTS_W void | cv::convertScaleAbs (const Mat &src, CV_OUT Mat &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 int | cv::countNonZero (const Mat &src) |
| computes the number of nonzero array elements
|
|
CV_EXPORTS_W float | cv::cubeRoot (float val) |
| computes cube root of the argument
|
|
Mat | cv::cvarrToMat (const CvArr *arr, bool copyData=false, bool allowND=true, int coiMode=0) |
| converts array (CvMat or IplImage) to cv::Mat
|
|
CV_EXPORTS_W void | cv::dct (const Mat &src, CV_OUT Mat &dst, int flags=0) |
| performs forward or inverse 1D or 2D Discrete Cosine Transformation
|
|
CV_EXPORTS_W double | cv::determinant (const Mat &mtx) |
| computes determinant of a square matrix
|
|
CV_EXPORTS_W void | cv::dft (const Mat &src, CV_OUT Mat &dst, int flags=0, int nonzeroRows=0) |
| performs forward or inverse 1D or 2D Discrete Fourier Transformation
|
|
CV_EXPORTS_W void | cv::divide (const Mat &src1, const Mat &src2, CV_OUT Mat &dst, double scale=1) |
| computes element-wise weighted quotient of the two arrays (dst = scale*src1/src2)
|
|
CV_EXPORTS_W void | cv::divide (double scale, const Mat &src2, CV_OUT Mat &dst) |
| computes element-wise weighted reciprocal of an array (dst = scale/src2)
|
|
bool | cv::eigen (const Mat &src, CV_OUT Mat &eigenvalues, int lowindex=-1, int highindex=-1) |
| finds eigenvalues of a symmetric matrix
|
|
bool | cv::eigen (const Mat &src, CV_OUT Mat &eigenvalues, CV_OUT Mat &eigenvectors, int lowindex=-1, int highindex=-1) |
| finds eigenvalues and eigenvectors of a symmetric matrix
|
|
CV_EXPORTS_W void | cv::ellipse (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 (Mat &img, const RotatedRect &box, const Scalar &color, int thickness=1, int lineType=8) |
| draws a rotated ellipse in the image
|
|
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
|
|
void | cv::error (const Exception &exc) |
| Signals an error and raises the exception.
|
|
CV_EXPORTS_W void | cv::exp (const Mat &src, CV_OUT Mat &dst) |
| computes exponent of each matrix element (dst = e**src)
|
|
void | cv::extractImageCOI (const CvArr *arr, CV_OUT Mat &coiimg, int coi=-1) |
| extracts Channel of Interest from CvMat or IplImage and makes cv::Mat out of it.
|
|
CV_EXPORTS_W float | cv::fastAtan2 (float y, float x) |
| computes the angle in degrees (0..360) of the vector (x,y)
|
|
void | cv::fastFree (void *ptr) |
|
void * | cv::fastMalloc (size_t bufSize) |
|
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
|
|
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::flip (const Mat &src, CV_OUT Mat &dst, int flipCode) |
| reverses the order of the rows, columns or both in a matrix
|
|
string | cv::format (const char *fmt,...) |
|
string | cv::fromUtf16 (const WString &str) |
|
CV_EXPORTS_W void | cv::gemm (const Mat &src1, const Mat &src2, double alpha, const Mat &src3, double gamma, CV_OUT Mat &dst, int flags=0) |
| implements generalized matrix product algorithm GEMM from BLAS
|
|
ConvertData | cv::getConvertElem (int fromType, int toType) |
| returns the function for converting pixels from one data type to another
|
|
ConvertScaleData | cv::getConvertScaleElem (int fromType, int toType) |
| returns the function for converting pixels from one data type to another with the optional scaling
|
|
int64 | cv::getCPUTickCount () |
|
int | cv::getNumThreads () |
|
CV_EXPORTS_W int | cv::getOptimalDFTSize (int vecsize) |
| computes the minimal vector size vecsize1 >= vecsize so that the dft() of the vector of length vecsize1 can be computed efficiently
|
|
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
|
|
int | cv::getThreadNum () |
|
int64 | cv::getTickCount () |
| Returns the number of ticks.
|
|
CV_EXPORTS_W double | cv::getTickFrequency () |
|
void | cv::hconcat (const Mat *src, size_t nsrc, Mat &dst) |
|
void | cv::hconcat (const Mat &src1, const Mat &src2, Mat &dst) |
|
CV_EXPORTS_W void | cv::hconcat (const vector< Mat > &src, CV_OUT Mat &dst) |
|
CV_EXPORTS_W void | cv::idct (const Mat &src, CV_OUT Mat &dst, int flags=0) |
| performs inverse 1D or 2D Discrete Cosine Transformation
|
|
CV_EXPORTS_W void | cv::idft (const Mat &src, CV_OUT Mat &dst, int flags=0, int nonzeroRows=0) |
| performs inverse 1D or 2D Discrete Fourier Transformation
|
|
CV_EXPORTS_W void | cv::inRange (const Mat &src, const Mat &lowerb, const Mat &upperb, CV_OUT Mat &dst) |
| set mask elements for those array elements which are within the element-specific bounding box (dst = lowerb <= src && src < upperb)
|
|
CV_EXPORTS_W void | cv::inRange (const Mat &src, const Scalar &lowerb, const Scalar &upperb, CV_OUT Mat &dst) |
| set mask elements for those array elements which are within the fixed bounding box (dst = lowerb <= src && src < upperb)
|
|
void | cv::insertImageCOI (const Mat &coiimg, CvArr *arr, int coi=-1) |
| inserts single-channel cv::Mat into a multi-channel CvMat or IplImage
|
|
CV_EXPORTS_W double | cv::invert (const Mat &src, CV_OUT Mat &dst, int flags=DECOMP_LU) |
| computes inverse or pseudo-inverse matrix
|
|
CV_EXPORTS_W double | cv::kmeans (const Mat &data, int K, CV_OUT Mat &bestLabels, TermCriteria criteria, int attempts, int flags, CV_OUT Mat *centers=0) |
| clusters the input data using k-Means algorithm
|
|
CV_EXPORTS_W void | cv::line (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::log (const Mat &src, CV_OUT Mat &dst) |
| computes natural logarithm of absolute value of each matrix element: dst = log(abs(src))
|
|
CV_EXPORTS_W void | cv::LUT (const Mat &src, const Mat &lut, CV_OUT Mat &dst) |
| transforms 8-bit unsigned integers using lookup table: dst(i)=lut(src(i))
|
|
CV_EXPORTS_W void | cv::magnitude (const Mat &x, const Mat &y, CV_OUT Mat &magnitude) |
| computes magnitude (magnitude(i)) of each (x(i), y(i)) vector
|
|
CV_EXPORTS_W double | cv::Mahalanobis (const Mat &v1, const Mat &v2, const Mat &icovar) |
| computes Mahalanobis distance between two vectors: sqrt((v1-v2)'icovar(v1-v2)), where icovar is the inverse covariation matrix
|
|
double | cv::Mahalonobis (const Mat &v1, const Mat &v2, const Mat &icovar) |
| a synonym for Mahalanobis
|
|
CV_EXPORTS_W void | cv::max (const Mat &src1, const Mat &src2, CV_OUT Mat &dst) |
| computes per-element maximum of two arrays (dst = max(src1, src2))
|
|
CV_EXPORTS_W void | cv::max (const Mat &src1, double src2, CV_OUT Mat &dst) |
| computes per-element maximum of array and scalar (dst = max(src1, src2))
|
|
Scalar | cv::mean (const Mat &src) |
| computes mean value of array elements
|
|
CV_EXPORTS_W Scalar | cv::mean (const Mat &src, const Mat &mask CV_WRAP_DEFAULT(Mat())) |
| computes mean value of selected array elements
|
|
CV_EXPORTS_W void | cv::meanStdDev (const Mat &src, CV_OUT Scalar &mean, CV_OUT Scalar &stddev, const Mat &mask=Mat()) |
| computes mean value and standard deviation of all or selected array elements
|
|
void | cv::merge (const Mat *mv, size_t count, CV_OUT Mat &dst) |
| makes multi-channel array out of several single-channel arrays
|
|
CV_EXPORTS_W void | cv::merge (const vector< Mat > &mv, Mat &dst) |
| makes multi-channel array out of several single-channel arrays
|
|
CV_EXPORTS_W void | cv::min (const Mat &src1, const Mat &src2, CV_OUT Mat &dst) |
| computes per-element minimum of two arrays (dst = min(src1, src2))
|
|
CV_EXPORTS_W void | cv::min (const Mat &src1, double src2, CV_OUT Mat &dst) |
| computes per-element minimum of array and scalar (dst = min(src1, src2))
|
|
void | cv::minMaxIdx (const Mat &src, double *minVal, double *maxVal, int *minIdx=0, int *maxIdx=0, const Mat &mask=Mat()) |
|
CV_EXPORTS_W void | cv::minMaxLoc (const Mat &src, CV_OUT double *minVal, CV_OUT double *maxVal=0, CV_OUT Point *minLoc=0, CV_OUT Point *maxLoc=0, const Mat &mask=Mat()) |
| finds global minimum and maximum array elements and returns their values and their locations
|
|
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
|
|
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
|
|
void | cv::mixChannels (const vector< Mat > &src, vector< Mat > &dst, const int *fromTo, int npairs) |
|
CV_EXPORTS_W void | cv::mulSpectrums (const Mat &a, const Mat &b, CV_OUT Mat &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
|
|
CV_EXPORTS_W void | cv::multiply (const Mat &src1, const Mat &src2, CV_OUT Mat &dst, double scale=1) |
| computes element-wise weighted product of the two arrays (dst = scale*src1*src2)
|
|
CV_EXPORTS_W void | cv::mulTransposed (const Mat &src, CV_OUT Mat &dst, bool aTa, const Mat &delta=Mat(), double scale=1, int rtype=-1) |
| multiplies matrix by its transposition from the left or from the right
|
|
double | cv::norm (const Mat &src1, int normType=NORM_L2) |
| computes norm of array
|
|
double | cv::norm (const Mat &src1, const Mat &src2, int normType=NORM_L2) |
| computes norm of the difference between two arrays
|
|
CV_EXPORTS_W double | cv::norm (const Mat &src1, int normType, const Mat &mask CV_WRAP_DEFAULT(Mat())) |
| computes norm of the selected array part
|
|
CV_EXPORTS_W double | cv::norm (const Mat &src1, const Mat &src2, int normType, const Mat &mask CV_WRAP_DEFAULT(Mat())) |
| computes norm of selected part of the difference between two arrays
|
|
double | cv::norm (const SparseMat &src, int normType) |
| computes norm of a sparse matrix
|
|
CV_EXPORTS_W void | cv::normalize (const Mat &src, CV_OUT Mat &dst, double alpha=1, double beta=0, int norm_type=NORM_L2, int rtype=-1, const Mat &mask=Mat()) |
| 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
|
|
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_W void | cv::perspectiveTransform (const Mat &src, CV_OUT Mat &dst, const Mat &m) |
| performs perspective transformation of each element of multi-channel input matrix
|
|
CV_EXPORTS_W void | cv::phase (const Mat &x, const Mat &y, CV_OUT Mat &angle, bool angleInDegrees=false) |
| computes angle (angle(i)) of each (x(i), y(i)) vector
|
|
CV_EXPORTS_W void | cv::polarToCart (const Mat &magnitude, const Mat &angle, CV_OUT Mat &x, CV_OUT Mat &y, bool angleInDegrees=false) |
| converts polar coordinates to Cartesian
|
|
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::pow (const Mat &src, double power, CV_OUT Mat &dst) |
| raises the input matrix elements to the specified power (b = a**power)
|
|
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 void | cv::randn (CV_OUT Mat &dst, const Scalar &mean, const Scalar &stddev) |
| fills array with normally-distributed random numbers with the specified mean and the standard deviation
|
|
void | cv::randShuffle (Mat &dst, double iterFactor=1., RNG *rng=0) |
| shuffles the input array elements
|
|
CV_EXPORTS_W void | cv::randu (CV_OUT Mat &dst, const Scalar &low, const Scalar &high) |
| fills array with uniformly-distributed random numbers from the range [low, high)
|
|
CV_EXPORTS_W void | cv::rectangle (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
|
|
void | cv::rectangle (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
|
|
ErrorCallback | cv::redirectError (ErrorCallback errCallback, void *userdata=0, void **prevUserdata=0) |
| Sets the new error handler and the optional user data.
|
|
CV_EXPORTS_W void | cv::reduce (const Mat &src, CV_OUT Mat &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_W void | cv::repeat (const Mat &src, int ny, int nx, CV_OUT Mat &dst) |
| replicates the input matrix the specified number of times in the horizontal and/or vertical direction
|
|
Mat | cv::repeat (const Mat &src, int ny, int nx) |
|
void | cv::scalarToRawData (const Scalar &s, void *buf, int type, int unroll_to=0) |
|
CV_EXPORTS_W void | cv::scaleAdd (const Mat &src1, double alpha, const Mat &src2, CV_OUT Mat &dst) |
| adds scaled array to another one (dst = alpha*src1 + src2)
|
|
bool | cv::setBreakOnError (bool flag) |
| Sets/resets the break-on-error mode.
|
|
CV_EXPORTS_W void | cv::setIdentity (Mat &mtx, const Scalar &s=Scalar(1)) |
| initializes scaled identity matrix
|
|
void | cv::setNumThreads (int nthreads) |
|
CV_EXPORTS_W void | cv::setUseOptimized (bool onoff) |
|
CV_EXPORTS_W bool | cv::solve (const Mat &src1, const Mat &src2, CV_OUT Mat &dst, int flags=DECOMP_LU) |
| solves linear system or a least-square problem
|
|
CV_EXPORTS_W int | cv::solveCubic (const Mat &coeffs, CV_OUT Mat &roots) |
| finds real roots of a cubic polynomial
|
|
CV_EXPORTS_W double | cv::solvePoly (const Mat &coeffs, CV_OUT Mat &roots, int maxIters=300) |
| finds real and complex roots of a polynomial
|
|
CV_EXPORTS_W void | cv::sort (const Mat &src, CV_OUT Mat &dst, int flags) |
| sorts independently each matrix row or each matrix column
|
|
CV_EXPORTS_W void | cv::sortIdx (const Mat &src, CV_OUT Mat &dst, int flags) |
| sorts independently each matrix row or each matrix column
|
|
void | cv::split (const Mat &src, Mat *mvbegin) |
| copies each plane of a multi-channel array to a dedicated array
|
|
CV_EXPORTS_W void | cv::split (const Mat &m, vector< Mat > &mv) |
| copies each plane of a multi-channel array to a dedicated array
|
|
CV_EXPORTS_W void | cv::sqrt (const Mat &src, CV_OUT Mat &dst) |
| computes square root of each matrix element (dst = src**0.5)
|
|
CV_EXPORTS_W void | cv::subtract (const Mat &src1, const Mat &src2, CV_OUT Mat &dst, const Mat &mask CV_WRAP_DEFAULT(Mat())) |
| subtracts one matrix from another (dst = src1 - src2)
|
|
void | cv::subtract (const Mat &src1, const Mat &src2, CV_OUT Mat &dst) |
| subtracts one matrix from another (dst = src1 - src2)
|
|
CV_EXPORTS_W void | cv::subtract (const Mat &src1, const Scalar &src2, CV_OUT Mat &dst, const Mat &mask=Mat()) |
| subtracts scalar from a matrix (dst = src1 - src2)
|
|
CV_EXPORTS_W void | cv::subtract (const Scalar &src1, const Mat &src2, CV_OUT Mat &dst, const Mat &mask=Mat()) |
| subtracts matrix from scalar (dst = src1 - src2)
|
|
CV_EXPORTS_W Scalar | cv::sum (const Mat &src) |
| computes sum of array elements
|
|
void | cv::swap (Mat &a, Mat &b) |
| swaps two matrices
|
|
RNG & | cv::theRNG () |
| returns the thread-local Random number generator
|
|
WString | cv::toUtf16 (const string &str) |
|
CV_EXPORTS_W Scalar | cv::trace (const Mat &mtx) |
| computes trace of a matrix
|
|
CV_EXPORTS_W void | cv::transform (const Mat &src, CV_OUT Mat &dst, const Mat &m) |
| performs affine transformation of each element of multi-channel input matrix
|
|
CV_EXPORTS_W void | cv::transpose (const Mat &src, CV_OUT Mat &dst) |
| transposes the matrix
|
|
CV_EXPORTS_W bool | cv::useOptimized () |
|
void | cv::vconcat (const Mat *src, size_t nsrc, Mat &dst) |
|
void | cv::vconcat (const Mat &src1, const Mat &src2, Mat &dst) |
|
CV_EXPORTS_W void | cv::vconcat (const vector< Mat > &src, CV_OUT Mat &dst) |
|