public class Core
extends java.lang.Object
| Modifier and Type | Class and Description |
|---|---|
static class |
Core.MinMaxLocResult |
| Constructor and Description |
|---|
Core() |
| Modifier and Type | Method and Description |
|---|---|
static void |
absdiff(Mat src1,
Mat src2,
Mat dst)
Calculates the per-element absolute difference between two arrays or between an array and a scalar.
|
static void |
absdiff(Mat src1,
Scalar src2,
Mat dst) |
static void |
add(Mat src1,
Mat src2,
Mat dst)
Calculates the per-element sum of two arrays or an array and a scalar.
|
static void |
add(Mat src1,
Mat src2,
Mat dst,
Mat mask)
Calculates the per-element sum of two arrays or an array and a scalar.
|
static void |
add(Mat src1,
Mat src2,
Mat dst,
Mat mask,
int dtype)
Calculates the per-element sum of two arrays or an array and a scalar.
|
static void |
add(Mat src1,
Scalar src2,
Mat dst) |
static void |
add(Mat src1,
Scalar src2,
Mat dst,
Mat mask) |
static void |
add(Mat src1,
Scalar src2,
Mat dst,
Mat mask,
int dtype) |
static void |
addSamplesDataSearchPath(java.lang.String path)
Override search data path by adding new search location
Use this only to override default behavior
Passed paths are used in LIFO order.
|
static void |
addSamplesDataSearchSubDirectory(java.lang.String subdir)
Append samples search data sub directory
General usage is to add OpenCV modules name (
<opencv_contrib>/modules/<name>/samples/data -> <name>/samples/data + modules/<name>/samples/data). |
static void |
addWeighted(Mat src1,
double alpha,
Mat src2,
double beta,
double gamma,
Mat dst)
Calculates the weighted sum of two arrays.
|
static void |
addWeighted(Mat src1,
double alpha,
Mat src2,
double beta,
double gamma,
Mat dst,
int dtype)
Calculates the weighted sum of two arrays.
|
static void |
batchDistance(Mat src1,
Mat src2,
Mat dist,
int dtype,
Mat nidx)
naive nearest neighbor finder
see http://en.wikipedia.org/wiki/Nearest_neighbor_search
TODO: document
|
static void |
batchDistance(Mat src1,
Mat src2,
Mat dist,
int dtype,
Mat nidx,
int normType)
naive nearest neighbor finder
see http://en.wikipedia.org/wiki/Nearest_neighbor_search
TODO: document
|
static void |
batchDistance(Mat src1,
Mat src2,
Mat dist,
int dtype,
Mat nidx,
int normType,
int K)
naive nearest neighbor finder
see http://en.wikipedia.org/wiki/Nearest_neighbor_search
TODO: document
|
static void |
batchDistance(Mat src1,
Mat src2,
Mat dist,
int dtype,
Mat nidx,
int normType,
int K,
Mat mask)
naive nearest neighbor finder
see http://en.wikipedia.org/wiki/Nearest_neighbor_search
TODO: document
|
static void |
batchDistance(Mat src1,
Mat src2,
Mat dist,
int dtype,
Mat nidx,
int normType,
int K,
Mat mask,
int update)
naive nearest neighbor finder
see http://en.wikipedia.org/wiki/Nearest_neighbor_search
TODO: document
|
static void |
batchDistance(Mat src1,
Mat src2,
Mat dist,
int dtype,
Mat nidx,
int normType,
int K,
Mat mask,
int update,
boolean crosscheck)
naive nearest neighbor finder
see http://en.wikipedia.org/wiki/Nearest_neighbor_search
TODO: document
|
static void |
bitwise_and(Mat src1,
Mat src2,
Mat dst)
computes bitwise conjunction of the two arrays (dst = src1 & src2)
Calculates the per-element bit-wise conjunction of two arrays or an
array and a scalar.
|
static void |
bitwise_and(Mat src1,
Mat src2,
Mat dst,
Mat mask)
computes bitwise conjunction of the two arrays (dst = src1 & src2)
Calculates the per-element bit-wise conjunction of two arrays or an
array and a scalar.
|
static void |
bitwise_not(Mat src,
Mat dst)
Inverts every bit of an array.
|
static void |
bitwise_not(Mat src,
Mat dst,
Mat mask)
Inverts every bit of an array.
|
static void |
bitwise_or(Mat src1,
Mat src2,
Mat dst)
Calculates the per-element bit-wise disjunction of two arrays or an
array and a scalar.
|
static void |
bitwise_or(Mat src1,
Mat src2,
Mat dst,
Mat mask)
Calculates the per-element bit-wise disjunction of two arrays or an
array and a scalar.
|
static void |
bitwise_xor(Mat src1,
Mat src2,
Mat dst)
Calculates the per-element bit-wise "exclusive or" operation on two
arrays or an array and a scalar.
|
static void |
bitwise_xor(Mat src1,
Mat src2,
Mat dst,
Mat mask)
Calculates the per-element bit-wise "exclusive or" operation on two
arrays or an array and a scalar.
|
static int |
borderInterpolate(int p,
int len,
int borderType)
Computes the source location of an extrapolated pixel.
|
static void |
calcCovarMatrix(Mat samples,
Mat covar,
Mat mean,
int flags)
Note: use #COVAR_ROWS or #COVAR_COLS flag
|
static void |
calcCovarMatrix(Mat samples,
Mat covar,
Mat mean,
int flags,
int ctype)
Note: use #COVAR_ROWS or #COVAR_COLS flag
|
static void |
cartToPolar(Mat x,
Mat y,
Mat magnitude,
Mat angle)
Calculates the magnitude and angle of 2D vectors.
|
static void |
cartToPolar(Mat x,
Mat y,
Mat magnitude,
Mat angle,
boolean angleInDegrees)
Calculates the magnitude and angle of 2D vectors.
|
static boolean |
checkRange(Mat a)
Checks every element of an input array for invalid values.
|
static boolean |
checkRange(Mat a,
boolean quiet)
Checks every element of an input array for invalid values.
|
static boolean |
checkRange(Mat a,
boolean quiet,
double minVal)
Checks every element of an input array for invalid values.
|
static boolean |
checkRange(Mat a,
boolean quiet,
double minVal,
double maxVal)
Checks every element of an input array for invalid values.
|
static void |
compare(Mat src1,
Mat src2,
Mat dst,
int cmpop)
Performs the per-element comparison of two arrays or an array and scalar value.
|
static void |
compare(Mat src1,
Scalar src2,
Mat dst,
int cmpop) |
static void |
completeSymm(Mat m)
Copies the lower or the upper half of a square matrix to its another half.
|
static void |
completeSymm(Mat m,
boolean lowerToUpper)
Copies the lower or the upper half of a square matrix to its another half.
|
static void |
convertFp16(Mat src,
Mat dst)
Converts an array to half precision floating number.
|
static void |
convertScaleAbs(Mat src,
Mat dst)
Scales, calculates absolute values, and converts the result to 8-bit.
|
static void |
convertScaleAbs(Mat src,
Mat dst,
double alpha)
Scales, calculates absolute values, and converts the result to 8-bit.
|
static void |
convertScaleAbs(Mat src,
Mat dst,
double alpha,
double beta)
Scales, calculates absolute values, and converts the result to 8-bit.
|
static void |
copyMakeBorder(Mat src,
Mat dst,
int top,
int bottom,
int left,
int right,
int borderType)
Forms a border around an image.
|
static void |
copyMakeBorder(Mat src,
Mat dst,
int top,
int bottom,
int left,
int right,
int borderType,
Scalar value)
Forms a border around an image.
|
static void |
copyTo(Mat src,
Mat dst,
Mat mask)
This is an overloaded member function, provided for convenience (python)
Copies the matrix to another one.
|
static int |
countNonZero(Mat src)
Counts non-zero array elements.
|
static float |
cubeRoot(float val)
Computes the cube root of an argument.
|
static void |
dct(Mat src,
Mat dst)
Performs a forward or inverse discrete Cosine transform of 1D or 2D array.
|
static void |
dct(Mat src,
Mat dst,
int flags)
Performs a forward or inverse discrete Cosine transform of 1D or 2D array.
|
static double |
determinant(Mat mtx)
Returns the determinant of a square floating-point matrix.
|
static void |
dft(Mat src,
Mat dst)
Performs a forward or inverse Discrete Fourier transform of a 1D or 2D floating-point array.
|
static void |
dft(Mat src,
Mat dst,
int flags)
Performs a forward or inverse Discrete Fourier transform of a 1D or 2D floating-point array.
|
static void |
dft(Mat src,
Mat dst,
int flags,
int nonzeroRows)
Performs a forward or inverse Discrete Fourier transform of a 1D or 2D floating-point array.
|
static void |
divide(double scale,
Mat src2,
Mat dst) |
static void |
divide(double scale,
Mat src2,
Mat dst,
int dtype) |
static void |
divide(Mat src1,
Mat src2,
Mat dst)
Performs per-element division of two arrays or a scalar by an array.
|
static void |
divide(Mat src1,
Mat src2,
Mat dst,
double scale)
Performs per-element division of two arrays or a scalar by an array.
|
static void |
divide(Mat src1,
Mat src2,
Mat dst,
double scale,
int dtype)
Performs per-element division of two arrays or a scalar by an array.
|
static void |
divide(Mat src1,
Scalar src2,
Mat dst) |
static void |
divide(Mat src1,
Scalar src2,
Mat dst,
double scale) |
static void |
divide(Mat src1,
Scalar src2,
Mat dst,
double scale,
int dtype) |
static boolean |
eigen(Mat src,
Mat eigenvalues)
Calculates eigenvalues and eigenvectors of a symmetric matrix.
|
static boolean |
eigen(Mat src,
Mat eigenvalues,
Mat eigenvectors)
Calculates eigenvalues and eigenvectors of a symmetric matrix.
|
static void |
eigenNonSymmetric(Mat src,
Mat eigenvalues,
Mat eigenvectors)
Calculates eigenvalues and eigenvectors of a non-symmetric matrix (real eigenvalues only).
|
static void |
exp(Mat src,
Mat dst)
Calculates the exponent of every array element.
|
static void |
extractChannel(Mat src,
Mat dst,
int coi)
Extracts a single channel from src (coi is 0-based index)
|
static float |
fastAtan2(float y,
float x)
Calculates the angle of a 2D vector in degrees.
|
static java.lang.String |
findFile(java.lang.String relative_path)
Try to find requested data file
Search directories:
1.
|
static java.lang.String |
findFile(java.lang.String relative_path,
boolean required)
Try to find requested data file
Search directories:
1.
|
static java.lang.String |
findFile(java.lang.String relative_path,
boolean required,
boolean silentMode)
Try to find requested data file
Search directories:
1.
|
static java.lang.String |
findFileOrKeep(java.lang.String relative_path) |
static java.lang.String |
findFileOrKeep(java.lang.String relative_path,
boolean silentMode) |
static void |
findNonZero(Mat src,
Mat idx)
Returns the list of locations of non-zero pixels
Given a binary matrix (likely returned from an operation such
as threshold(), compare(), >, ==, etc, return all of
the non-zero indices as a cv::Mat or std::vector<cv::Point> (x,y)
For example:
cv::Mat binaryImage; // input, binary image
cv::Mat locations; // output, locations of non-zero pixels
cv::findNonZero(binaryImage, locations);
// access pixel coordinates
Point pnt = locations.at<Point>(i);
or
cv::Mat binaryImage; // input, binary image
vector<Point> locations; // output, locations of non-zero pixels
cv::findNonZero(binaryImage, locations);
// access pixel coordinates
Point pnt = locations[i];
|
static void |
flip(Mat src,
Mat dst,
int flipCode)
Flips a 2D array around vertical, horizontal, or both axes.
|
static void |
gemm(Mat src1,
Mat src2,
double alpha,
Mat src3,
double beta,
Mat dst)
Performs generalized matrix multiplication.
|
static void |
gemm(Mat src1,
Mat src2,
double alpha,
Mat src3,
double beta,
Mat dst,
int flags)
Performs generalized matrix multiplication.
|
static java.lang.String |
getBuildInformation()
Returns full configuration time cmake output.
|
static long |
getCPUTickCount()
Returns the number of CPU ticks.
|
static java.lang.String |
getHardwareFeatureName(int feature)
Returns feature name by ID
Returns empty string if feature is not defined
|
static java.lang.String |
getIppVersion() |
static int |
getNumberOfCPUs()
Returns the number of logical CPUs available for the process.
|
static int |
getNumThreads()
Returns the number of threads used by OpenCV for parallel regions.
|
static int |
getOptimalDFTSize(int vecsize)
Returns the optimal DFT size for a given vector size.
|
static long |
getTickCount()
Returns the number of ticks.
|
static double |
getTickFrequency()
Returns the number of ticks per second.
|
static int |
getVersionMajor()
Returns major library version
|
static int |
getVersionMinor()
Returns minor library version
|
static int |
getVersionRevision()
Returns revision field of the library version
|
static java.lang.String |
getVersionString()
Returns library version string
For example "3.4.1-dev".
|
static void |
hconcat(java.util.List<Mat> src,
Mat dst)
std::vector<cv::Mat> matrices = { cv::Mat(4, 1, CV_8UC1, cv::Scalar(1)),
cv::Mat(4, 1, CV_8UC1, cv::Scalar(2)),
cv::Mat(4, 1, CV_8UC1, cv::Scalar(3)),};
cv::Mat out;
cv::hconcat( matrices, out );
//out:
//[1, 2, 3;
// 1, 2, 3;
// 1, 2, 3;
// 1, 2, 3]
|
static void |
idct(Mat src,
Mat dst)
Calculates the inverse Discrete Cosine Transform of a 1D or 2D array.
|
static void |
idct(Mat src,
Mat dst,
int flags)
Calculates the inverse Discrete Cosine Transform of a 1D or 2D array.
|
static void |
idft(Mat src,
Mat dst)
Calculates the inverse Discrete Fourier Transform of a 1D or 2D array.
|
static void |
idft(Mat src,
Mat dst,
int flags)
Calculates the inverse Discrete Fourier Transform of a 1D or 2D array.
|
static void |
idft(Mat src,
Mat dst,
int flags,
int nonzeroRows)
Calculates the inverse Discrete Fourier Transform of a 1D or 2D array.
|
static void |
inRange(Mat src,
Scalar lowerb,
Scalar upperb,
Mat dst)
Checks if array elements lie between the elements of two other arrays.
|
static void |
insertChannel(Mat src,
Mat dst,
int coi)
Inserts a single channel to dst (coi is 0-based index)
|
static double |
invert(Mat src,
Mat dst)
Finds the inverse or pseudo-inverse of a matrix.
|
static double |
invert(Mat src,
Mat dst,
int flags)
Finds the inverse or pseudo-inverse of a matrix.
|
static double |
kmeans(Mat data,
int K,
Mat bestLabels,
TermCriteria criteria,
int attempts,
int flags)
Finds centers of clusters and groups input samples around the clusters.
|
static double |
kmeans(Mat data,
int K,
Mat bestLabels,
TermCriteria criteria,
int attempts,
int flags,
Mat centers)
Finds centers of clusters and groups input samples around the clusters.
|
static void |
log(Mat src,
Mat dst)
Calculates the natural logarithm of every array element.
|
static void |
LUT(Mat src,
Mat lut,
Mat dst)
Performs a look-up table transform of an array.
|
static void |
magnitude(Mat x,
Mat y,
Mat magnitude)
Calculates the magnitude of 2D vectors.
|
static double |
Mahalanobis(Mat v1,
Mat v2,
Mat icovar)
Calculates the Mahalanobis distance between two vectors.
|
static void |
max(Mat src1,
Mat src2,
Mat dst)
Calculates per-element maximum of two arrays or an array and a scalar.
|
static void |
max(Mat src1,
Scalar src2,
Mat dst) |
static Scalar |
mean(Mat src)
Calculates an average (mean) of array elements.
|
static Scalar |
mean(Mat src,
Mat mask)
Calculates an average (mean) of array elements.
|
static void |
meanStdDev(Mat src,
MatOfDouble mean,
MatOfDouble stddev)
Calculates a mean and standard deviation of array elements.
|
static void |
meanStdDev(Mat src,
MatOfDouble mean,
MatOfDouble stddev,
Mat mask)
Calculates a mean and standard deviation of array elements.
|
static void |
merge(java.util.List<Mat> mv,
Mat dst) |
static void |
min(Mat src1,
Mat src2,
Mat dst)
Calculates per-element minimum of two arrays or an array and a scalar.
|
static void |
min(Mat src1,
Scalar src2,
Mat dst) |
static Core.MinMaxLocResult |
minMaxLoc(Mat src) |
static Core.MinMaxLocResult |
minMaxLoc(Mat src,
Mat mask) |
static void |
mixChannels(java.util.List<Mat> src,
java.util.List<Mat> dst,
MatOfInt fromTo) |
static void |
mulSpectrums(Mat a,
Mat b,
Mat c,
int flags)
Performs the per-element multiplication of two Fourier spectrums.
|
static void |
mulSpectrums(Mat a,
Mat b,
Mat c,
int flags,
boolean conjB)
Performs the per-element multiplication of two Fourier spectrums.
|
static void |
multiply(Mat src1,
Mat src2,
Mat dst)
Calculates the per-element scaled product of two arrays.
|
static void |
multiply(Mat src1,
Mat src2,
Mat dst,
double scale)
Calculates the per-element scaled product of two arrays.
|
static void |
multiply(Mat src1,
Mat src2,
Mat dst,
double scale,
int dtype)
Calculates the per-element scaled product of two arrays.
|
static void |
multiply(Mat src1,
Scalar src2,
Mat dst) |
static void |
multiply(Mat src1,
Scalar src2,
Mat dst,
double scale) |
static void |
multiply(Mat src1,
Scalar src2,
Mat dst,
double scale,
int dtype) |
static void |
mulTransposed(Mat src,
Mat dst,
boolean aTa)
Calculates the product of a matrix and its transposition.
|
static void |
mulTransposed(Mat src,
Mat dst,
boolean aTa,
Mat delta)
Calculates the product of a matrix and its transposition.
|
static void |
mulTransposed(Mat src,
Mat dst,
boolean aTa,
Mat delta,
double scale)
Calculates the product of a matrix and its transposition.
|
static void |
mulTransposed(Mat src,
Mat dst,
boolean aTa,
Mat delta,
double scale,
int dtype)
Calculates the product of a matrix and its transposition.
|
static double |
norm(Mat src1)
Calculates the absolute norm of an array.
|
static double |
norm(Mat src1,
int normType)
Calculates the absolute norm of an array.
|
static double |
norm(Mat src1,
int normType,
Mat mask)
Calculates the absolute norm of an array.
|
static double |
norm(Mat src1,
Mat src2)
Calculates an absolute difference norm or a relative difference norm.
|
static double |
norm(Mat src1,
Mat src2,
int normType)
Calculates an absolute difference norm or a relative difference norm.
|
static double |
norm(Mat src1,
Mat src2,
int normType,
Mat mask)
Calculates an absolute difference norm or a relative difference norm.
|
static void |
normalize(Mat src,
Mat dst)
Normalizes the norm or value range of an array.
|
static void |
normalize(Mat src,
Mat dst,
double alpha)
Normalizes the norm or value range of an array.
|
static void |
normalize(Mat src,
Mat dst,
double alpha,
double beta)
Normalizes the norm or value range of an array.
|
static void |
normalize(Mat src,
Mat dst,
double alpha,
double beta,
int norm_type)
Normalizes the norm or value range of an array.
|
static void |
normalize(Mat src,
Mat dst,
double alpha,
double beta,
int norm_type,
int dtype)
Normalizes the norm or value range of an array.
|
static void |
normalize(Mat src,
Mat dst,
double alpha,
double beta,
int norm_type,
int dtype,
Mat mask)
Normalizes the norm or value range of an array.
|
static void |
patchNaNs(Mat a)
converts NaN's to the given number
|
static void |
patchNaNs(Mat a,
double val)
converts NaN's to the given number
|
static void |
PCABackProject(Mat data,
Mat mean,
Mat eigenvectors,
Mat result)
wrap PCA::backProject
|
static void |
PCACompute(Mat data,
Mat mean,
Mat eigenvectors)
wrap PCA::operator()
|
static void |
PCACompute(Mat data,
Mat mean,
Mat eigenvectors,
double retainedVariance)
wrap PCA::operator()
|
static void |
PCACompute(Mat data,
Mat mean,
Mat eigenvectors,
int maxComponents)
wrap PCA::operator()
|
static void |
PCACompute2(Mat data,
Mat mean,
Mat eigenvectors,
Mat eigenvalues)
wrap PCA::operator() and add eigenvalues output parameter
|
static void |
PCACompute2(Mat data,
Mat mean,
Mat eigenvectors,
Mat eigenvalues,
double retainedVariance)
wrap PCA::operator() and add eigenvalues output parameter
|
static void |
PCACompute2(Mat data,
Mat mean,
Mat eigenvectors,
Mat eigenvalues,
int maxComponents)
wrap PCA::operator() and add eigenvalues output parameter
|
static void |
PCAProject(Mat data,
Mat mean,
Mat eigenvectors,
Mat result)
wrap PCA::project
|
static void |
perspectiveTransform(Mat src,
Mat dst,
Mat m)
Performs the perspective matrix transformation of vectors.
|
static void |
phase(Mat x,
Mat y,
Mat angle)
Calculates the rotation angle of 2D vectors.
|
static void |
phase(Mat x,
Mat y,
Mat angle,
boolean angleInDegrees)
Calculates the rotation angle of 2D vectors.
|
static void |
polarToCart(Mat magnitude,
Mat angle,
Mat x,
Mat y)
Calculates x and y coordinates of 2D vectors from their magnitude and angle.
|
static void |
polarToCart(Mat magnitude,
Mat angle,
Mat x,
Mat y,
boolean angleInDegrees)
Calculates x and y coordinates of 2D vectors from their magnitude and angle.
|
static void |
pow(Mat src,
double power,
Mat dst)
Raises every array element to a power.
|
static double |
PSNR(Mat src1,
Mat src2)
Computes the Peak Signal-to-Noise Ratio (PSNR) image quality metric.
|
static double |
PSNR(Mat src1,
Mat src2,
double R)
Computes the Peak Signal-to-Noise Ratio (PSNR) image quality metric.
|
static void |
randn(Mat dst,
double mean,
double stddev)
Fills the array with normally distributed random numbers.
|
static void |
randShuffle(Mat dst)
Shuffles the array elements randomly.
|
static void |
randShuffle(Mat dst,
double iterFactor)
Shuffles the array elements randomly.
|
static void |
randu(Mat dst,
double low,
double high)
Generates a single uniformly-distributed random number or an array of random numbers.
|
static void |
reduce(Mat src,
Mat dst,
int dim,
int rtype)
Reduces a matrix to a vector.
|
static void |
reduce(Mat src,
Mat dst,
int dim,
int rtype,
int dtype)
Reduces a matrix to a vector.
|
static void |
repeat(Mat src,
int ny,
int nx,
Mat dst)
Fills the output array with repeated copies of the input array.
|
static void |
rotate(Mat src,
Mat dst,
int rotateCode)
Rotates a 2D array in multiples of 90 degrees.
|
static void |
scaleAdd(Mat src1,
double alpha,
Mat src2,
Mat dst)
Calculates the sum of a scaled array and another array.
|
static void |
setErrorVerbosity(boolean verbose) |
static void |
setIdentity(Mat mtx)
Initializes a scaled identity matrix.
|
static void |
setIdentity(Mat mtx,
Scalar s)
Initializes a scaled identity matrix.
|
static void |
setNumThreads(int nthreads)
OpenCV will try to set the number of threads for the next parallel region.
|
static void |
setRNGSeed(int seed)
Sets state of default random number generator.
|
static void |
setUseIPP_NotExact(boolean flag) |
static void |
setUseIPP(boolean flag) |
static boolean |
solve(Mat src1,
Mat src2,
Mat dst)
Solves one or more linear systems or least-squares problems.
|
static boolean |
solve(Mat src1,
Mat src2,
Mat dst,
int flags)
Solves one or more linear systems or least-squares problems.
|
static int |
solveCubic(Mat coeffs,
Mat roots)
Finds the real roots of a cubic equation.
|
static double |
solvePoly(Mat coeffs,
Mat roots)
Finds the real or complex roots of a polynomial equation.
|
static double |
solvePoly(Mat coeffs,
Mat roots,
int maxIters)
Finds the real or complex roots of a polynomial equation.
|
static void |
sort(Mat src,
Mat dst,
int flags)
Sorts each row or each column of a matrix.
|
static void |
sortIdx(Mat src,
Mat dst,
int flags)
Sorts each row or each column of a matrix.
|
static void |
split(Mat m,
java.util.List<Mat> mv) |
static void |
sqrt(Mat src,
Mat dst)
Calculates a square root of array elements.
|
static void |
subtract(Mat src1,
Mat src2,
Mat dst)
Calculates the per-element difference between two arrays or array and a scalar.
|
static void |
subtract(Mat src1,
Mat src2,
Mat dst,
Mat mask)
Calculates the per-element difference between two arrays or array and a scalar.
|
static void |
subtract(Mat src1,
Mat src2,
Mat dst,
Mat mask,
int dtype)
Calculates the per-element difference between two arrays or array and a scalar.
|
static void |
subtract(Mat src1,
Scalar src2,
Mat dst) |
static void |
subtract(Mat src1,
Scalar src2,
Mat dst,
Mat mask) |
static void |
subtract(Mat src1,
Scalar src2,
Mat dst,
Mat mask,
int dtype) |
static Scalar |
sumElems(Mat src)
Calculates the sum of array elements.
|
static void |
SVBackSubst(Mat w,
Mat u,
Mat vt,
Mat rhs,
Mat dst)
wrap SVD::backSubst
|
static void |
SVDecomp(Mat src,
Mat w,
Mat u,
Mat vt)
wrap SVD::compute
|
static void |
SVDecomp(Mat src,
Mat w,
Mat u,
Mat vt,
int flags)
wrap SVD::compute
|
static Scalar |
trace(Mat mtx)
Returns the trace of a matrix.
|
static void |
transform(Mat src,
Mat dst,
Mat m)
Performs the matrix transformation of every array element.
|
static void |
transpose(Mat src,
Mat dst)
Transposes a matrix.
|
static boolean |
useIPP_NotExact() |
static boolean |
useIPP()
proxy for hal::Cholesky
|
static void |
vconcat(java.util.List<Mat> src,
Mat dst)
std::vector<cv::Mat> matrices = { cv::Mat(1, 4, CV_8UC1, cv::Scalar(1)),
cv::Mat(1, 4, CV_8UC1, cv::Scalar(2)),
cv::Mat(1, 4, CV_8UC1, cv::Scalar(3)),};
cv::Mat out;
cv::vconcat( matrices, out );
//out:
//[1, 1, 1, 1;
// 2, 2, 2, 2;
// 3, 3, 3, 3]
|
public static final int BadAlign
public static final int BadAlphaChannel
public static final int BadCallBack
public static final int BadCOI
public static final int BadDataPtr
public static final int BadDepth
public static final int BadImageSize
public static final int BadModelOrChSeq
public static final int BadNumChannel1U
public static final int BadNumChannels
public static final int BadOffset
public static final int BadOrder
public static final int BadOrigin
public static final int BadROISize
public static final int BadStep
public static final int BadTileSize
public static final int BORDER_CONSTANT
public static final int BORDER_DEFAULT
public static final int BORDER_ISOLATED
public static final int BORDER_REFLECT
public static final int BORDER_REFLECT_101
public static final int BORDER_REFLECT101
public static final int BORDER_REPLICATE
public static final int BORDER_TRANSPARENT
public static final int BORDER_WRAP
public static final int CMP_EQ
public static final int CMP_GE
public static final int CMP_GT
public static final int CMP_LE
public static final int CMP_LT
public static final int CMP_NE
public static final int COVAR_COLS
public static final int COVAR_NORMAL
public static final int COVAR_ROWS
public static final int COVAR_SCALE
public static final int COVAR_SCRAMBLED
public static final int COVAR_USE_AVG
public static final int DCT_INVERSE
public static final int DCT_ROWS
public static final int DECOMP_CHOLESKY
public static final int DECOMP_EIG
public static final int DECOMP_LU
public static final int DECOMP_NORMAL
public static final int DECOMP_QR
public static final int DECOMP_SVD
public static final int DFT_COMPLEX_INPUT
public static final int DFT_COMPLEX_OUTPUT
public static final int DFT_INVERSE
public static final int DFT_REAL_OUTPUT
public static final int DFT_ROWS
public static final int DFT_SCALE
public static final int FILLED
public static final int Formatter_FMT_C
public static final int Formatter_FMT_CSV
public static final int Formatter_FMT_DEFAULT
public static final int Formatter_FMT_MATLAB
public static final int Formatter_FMT_NUMPY
public static final int Formatter_FMT_PYTHON
public static final int GEMM_1_T
public static final int GEMM_2_T
public static final int GEMM_3_T
public static final int GpuApiCallError
public static final int GpuNotSupported
public static final int HeaderIsNull
public static final int KMEANS_PP_CENTERS
public static final int KMEANS_RANDOM_CENTERS
public static final int KMEANS_USE_INITIAL_LABELS
public static final int MaskIsTiled
public static final java.lang.String NATIVE_LIBRARY_NAME
public static final int NORM_HAMMING
public static final int NORM_HAMMING2
public static final int NORM_INF
public static final int NORM_L1
public static final int NORM_L2
public static final int NORM_L2SQR
public static final int NORM_MINMAX
public static final int NORM_RELATIVE
public static final int NORM_TYPE_MASK
public static final int OpenCLApiCallError
public static final int OpenCLDoubleNotSupported
public static final int OpenCLInitError
public static final int OpenCLNoAMDBlasFft
public static final int OpenGlApiCallError
public static final int OpenGlNotSupported
public static final int Param_ALGORITHM
public static final int Param_BOOLEAN
public static final int Param_FLOAT
public static final int Param_INT
public static final int Param_MAT
public static final int Param_MAT_VECTOR
public static final int Param_REAL
public static final int Param_SCALAR
public static final int Param_STRING
public static final int Param_UCHAR
public static final int Param_UINT64
public static final int Param_UNSIGNED_INT
public static final int PCA_DATA_AS_COL
public static final int PCA_DATA_AS_ROW
public static final int PCA_USE_AVG
public static final int REDUCE_AVG
public static final int REDUCE_MAX
public static final int REDUCE_MIN
public static final int REDUCE_SUM
public static final int RNG_NORMAL
public static final int RNG_UNIFORM
public static final int ROTATE_180
public static final int ROTATE_90_CLOCKWISE
public static final int ROTATE_90_COUNTERCLOCKWISE
public static final int SORT_ASCENDING
public static final int SORT_DESCENDING
public static final int SORT_EVERY_COLUMN
public static final int SORT_EVERY_ROW
public static final int StsAssert
public static final int StsAutoTrace
public static final int StsBackTrace
public static final int StsBadArg
public static final int StsBadFlag
public static final int StsBadFunc
public static final int StsBadMask
public static final int StsBadMemBlock
public static final int StsBadPoint
public static final int StsBadSize
public static final int StsDivByZero
public static final int StsError
public static final int StsFilterOffsetErr
public static final int StsFilterStructContentErr
public static final int StsInplaceNotSupported
public static final int StsInternal
public static final int StsKernelStructContentErr
public static final int StsNoConv
public static final int StsNoMem
public static final int StsNotImplemented
public static final int StsNullPtr
public static final int StsObjectNotFound
public static final int StsOk
public static final int StsOutOfRange
public static final int StsParseError
public static final int StsUnmatchedFormats
public static final int StsUnmatchedSizes
public static final int StsUnsupportedFormat
public static final int StsVecLengthErr
public static final int SVD_FULL_UV
public static final int SVD_MODIFY_A
public static final int SVD_NO_UV
public static final java.lang.String VERSION
public static final int VERSION_MAJOR
public static final int VERSION_MINOR
public static final int VERSION_REVISION
public static final java.lang.String VERSION_STATUS
public static void absdiff(Mat src1, Mat src2, Mat dst)
src1:
\(\texttt{dst}(I) = \texttt{saturate} (| \texttt{src1}(I) - \texttt{src2} |)\)
Absolute difference between a scalar and an array when the first
array is constructed from Scalar or has as many elements as the
number of channels in src2:
\(\texttt{dst}(I) = \texttt{saturate} (| \texttt{src1} - \texttt{src2}(I) |)\)
where I is a multi-dimensional index of array elements. In case of
multi-channel arrays, each channel is processed independently.
Note: Saturation is not applied when the arrays have the depth CV_32S.
You may even get a negative value in the case of overflow.src1 - first input array or a scalar.src2 - second input array or a scalar.dst - output array that has the same size and type as input arrays.
SEE: cv::abs(const Mat&)public static void add(Mat src1, Mat src2, Mat dst)
src1.channels():
\(\texttt{dst}(I) = \texttt{saturate} ( \texttt{src1}(I) + \texttt{src2} ) \quad \texttt{if mask}(I) \ne0\)
src2.channels():
\(\texttt{dst}(I) = \texttt{saturate} ( \texttt{src1} + \texttt{src2}(I) ) \quad \texttt{if mask}(I) \ne0\)
where I is a multi-dimensional index of array elements. In case of multi-channel arrays, each
channel is processed independently.
dst = src1 + src2;
dst += src1; // equivalent to add(dst, src1, dst);
The input arrays and the output array can all have the same or different depths. For example, you
can add a 16-bit unsigned array to a 8-bit signed array and store the sum as a 32-bit
floating-point array. Depth of the output array is determined by the dtype parameter. In the second
and third cases above, as well as in the first case, when src1.depth() == src2.depth(), dtype can
be set to the default -1. In this case, the output array will have the same depth as the input
array, be it src1, src2 or both.
Note: Saturation is not applied when the output array has the depth CV_32S. You may even get
result of an incorrect sign in the case of overflow.src1 - first input array or a scalar.src2 - second input array or a scalar.dst - output array that has the same size and number of channels as the input array(s); the
depth is defined by dtype or src1/src2.
output array to be changed.
SEE: subtract, addWeighted, scaleAdd, Mat::convertTopublic static void add(Mat src1, Mat src2, Mat dst, Mat mask)
src1.channels():
\(\texttt{dst}(I) = \texttt{saturate} ( \texttt{src1}(I) + \texttt{src2} ) \quad \texttt{if mask}(I) \ne0\)
src2.channels():
\(\texttt{dst}(I) = \texttt{saturate} ( \texttt{src1} + \texttt{src2}(I) ) \quad \texttt{if mask}(I) \ne0\)
where I is a multi-dimensional index of array elements. In case of multi-channel arrays, each
channel is processed independently.
dst = src1 + src2;
dst += src1; // equivalent to add(dst, src1, dst);
The input arrays and the output array can all have the same or different depths. For example, you
can add a 16-bit unsigned array to a 8-bit signed array and store the sum as a 32-bit
floating-point array. Depth of the output array is determined by the dtype parameter. In the second
and third cases above, as well as in the first case, when src1.depth() == src2.depth(), dtype can
be set to the default -1. In this case, the output array will have the same depth as the input
array, be it src1, src2 or both.
Note: Saturation is not applied when the output array has the depth CV_32S. You may even get
result of an incorrect sign in the case of overflow.src1 - first input array or a scalar.src2 - second input array or a scalar.dst - output array that has the same size and number of channels as the input array(s); the
depth is defined by dtype or src1/src2.mask - optional operation mask - 8-bit single channel array, that specifies elements of the
output array to be changed.
SEE: subtract, addWeighted, scaleAdd, Mat::convertTopublic static void add(Mat src1, Mat src2, Mat dst, Mat mask, int dtype)
src1.channels():
\(\texttt{dst}(I) = \texttt{saturate} ( \texttt{src1}(I) + \texttt{src2} ) \quad \texttt{if mask}(I) \ne0\)
src2.channels():
\(\texttt{dst}(I) = \texttt{saturate} ( \texttt{src1} + \texttt{src2}(I) ) \quad \texttt{if mask}(I) \ne0\)
where I is a multi-dimensional index of array elements. In case of multi-channel arrays, each
channel is processed independently.
dst = src1 + src2;
dst += src1; // equivalent to add(dst, src1, dst);
The input arrays and the output array can all have the same or different depths. For example, you
can add a 16-bit unsigned array to a 8-bit signed array and store the sum as a 32-bit
floating-point array. Depth of the output array is determined by the dtype parameter. In the second
and third cases above, as well as in the first case, when src1.depth() == src2.depth(), dtype can
be set to the default -1. In this case, the output array will have the same depth as the input
array, be it src1, src2 or both.
Note: Saturation is not applied when the output array has the depth CV_32S. You may even get
result of an incorrect sign in the case of overflow.src1 - first input array or a scalar.src2 - second input array or a scalar.dst - output array that has the same size and number of channels as the input array(s); the
depth is defined by dtype or src1/src2.mask - optional operation mask - 8-bit single channel array, that specifies elements of the
output array to be changed.dtype - optional depth of the output array (see the discussion below).
SEE: subtract, addWeighted, scaleAdd, Mat::convertTopublic static void addSamplesDataSearchPath(java.lang.String path)
path - Path to used samples datapublic static void addSamplesDataSearchSubDirectory(java.lang.String subdir)
<opencv_contrib>/modules/<name>/samples/data -> <name>/samples/data + modules/<name>/samples/data).
Passed subdirectories are used in LIFO order.subdir - samples data sub directorypublic static void addWeighted(Mat src1, double alpha, Mat src2, double beta, double gamma, Mat dst)
dst = src1*alpha + src2*beta + gamma;
Note: Saturation is not applied when the output array has the depth CV_32S. You may even get
result of an incorrect sign in the case of overflow.src1 - first input array.alpha - weight of the first array elements.src2 - second input array of the same size and channel number as src1.beta - weight of the second array elements.gamma - scalar added to each sum.dst - output array that has the same size and number of channels as the input arrays.
can be set to -1, which will be equivalent to src1.depth().
SEE: add, subtract, scaleAdd, Mat::convertTopublic static void addWeighted(Mat src1, double alpha, Mat src2, double beta, double gamma, Mat dst, int dtype)
dst = src1*alpha + src2*beta + gamma;
Note: Saturation is not applied when the output array has the depth CV_32S. You may even get
result of an incorrect sign in the case of overflow.src1 - first input array.alpha - weight of the first array elements.src2 - second input array of the same size and channel number as src1.beta - weight of the second array elements.gamma - scalar added to each sum.dst - output array that has the same size and number of channels as the input arrays.dtype - optional depth of the output array; when both input arrays have the same depth, dtype
can be set to -1, which will be equivalent to src1.depth().
SEE: add, subtract, scaleAdd, Mat::convertTopublic static void batchDistance(Mat src1, Mat src2, Mat dist, int dtype, Mat nidx)
src1 - automatically generatedsrc2 - automatically generateddist - automatically generateddtype - automatically generatednidx - automatically generatedpublic static void batchDistance(Mat src1, Mat src2, Mat dist, int dtype, Mat nidx, int normType)
src1 - automatically generatedsrc2 - automatically generateddist - automatically generateddtype - automatically generatednidx - automatically generatednormType - automatically generatedpublic static void batchDistance(Mat src1, Mat src2, Mat dist, int dtype, Mat nidx, int normType, int K)
src1 - automatically generatedsrc2 - automatically generateddist - automatically generateddtype - automatically generatednidx - automatically generatednormType - automatically generatedK - automatically generatedpublic static void batchDistance(Mat src1, Mat src2, Mat dist, int dtype, Mat nidx, int normType, int K, Mat mask)
src1 - automatically generatedsrc2 - automatically generateddist - automatically generateddtype - automatically generatednidx - automatically generatednormType - automatically generatedK - automatically generatedmask - automatically generatedpublic static void batchDistance(Mat src1, Mat src2, Mat dist, int dtype, Mat nidx, int normType, int K, Mat mask, int update)
src1 - automatically generatedsrc2 - automatically generateddist - automatically generateddtype - automatically generatednidx - automatically generatednormType - automatically generatedK - automatically generatedmask - automatically generatedupdate - automatically generatedpublic static void batchDistance(Mat src1, Mat src2, Mat dist, int dtype, Mat nidx, int normType, int K, Mat mask, int update, boolean crosscheck)
src1 - automatically generatedsrc2 - automatically generateddist - automatically generateddtype - automatically generatednidx - automatically generatednormType - automatically generatedK - automatically generatedmask - automatically generatedupdate - automatically generatedcrosscheck - automatically generatedpublic static void bitwise_and(Mat src1, Mat src2, Mat dst)
src1.channels():
\(\texttt{dst} (I) = \texttt{src1} (I) \wedge \texttt{src2} \quad \texttt{if mask} (I) \ne0\)
A scalar and an array when src1 is constructed from Scalar or has
the same number of elements as src2.channels():
\(\texttt{dst} (I) = \texttt{src1} \wedge \texttt{src2} (I) \quad \texttt{if mask} (I) \ne0\)
In case of floating-point arrays, their machine-specific bit
representations (usually IEEE754-compliant) are used for the operation.
In case of multi-channel arrays, each channel is processed
independently. In the second and third cases above, the scalar is first
converted to the array type.src1 - first input array or a scalar.src2 - second input array or a scalar.dst - output array that has the same size and type as the input
arrays.
specifies elements of the output array to be changed.public static void bitwise_and(Mat src1, Mat src2, Mat dst, Mat mask)
src1.channels():
\(\texttt{dst} (I) = \texttt{src1} (I) \wedge \texttt{src2} \quad \texttt{if mask} (I) \ne0\)
A scalar and an array when src1 is constructed from Scalar or has
the same number of elements as src2.channels():
\(\texttt{dst} (I) = \texttt{src1} \wedge \texttt{src2} (I) \quad \texttt{if mask} (I) \ne0\)
In case of floating-point arrays, their machine-specific bit
representations (usually IEEE754-compliant) are used for the operation.
In case of multi-channel arrays, each channel is processed
independently. In the second and third cases above, the scalar is first
converted to the array type.src1 - first input array or a scalar.src2 - second input array or a scalar.dst - output array that has the same size and type as the input
arrays.mask - optional operation mask, 8-bit single channel array, that
specifies elements of the output array to be changed.public static void bitwise_not(Mat src, Mat dst)
src - input array.dst - output array that has the same size and type as the input
array.
specifies elements of the output array to be changed.public static void bitwise_not(Mat src, Mat dst, Mat mask)
src - input array.dst - output array that has the same size and type as the input
array.mask - optional operation mask, 8-bit single channel array, that
specifies elements of the output array to be changed.public static void bitwise_or(Mat src1, Mat src2, Mat dst)
src1.channels():
\(\texttt{dst} (I) = \texttt{src1} (I) \vee \texttt{src2} \quad \texttt{if mask} (I) \ne0\)
A scalar and an array when src1 is constructed from Scalar or has
the same number of elements as src2.channels():
\(\texttt{dst} (I) = \texttt{src1} \vee \texttt{src2} (I) \quad \texttt{if mask} (I) \ne0\)
In case of floating-point arrays, their machine-specific bit
representations (usually IEEE754-compliant) are used for the operation.
In case of multi-channel arrays, each channel is processed
independently. In the second and third cases above, the scalar is first
converted to the array type.src1 - first input array or a scalar.src2 - second input array or a scalar.dst - output array that has the same size and type as the input
arrays.
specifies elements of the output array to be changed.public static void bitwise_or(Mat src1, Mat src2, Mat dst, Mat mask)
src1.channels():
\(\texttt{dst} (I) = \texttt{src1} (I) \vee \texttt{src2} \quad \texttt{if mask} (I) \ne0\)
A scalar and an array when src1 is constructed from Scalar or has
the same number of elements as src2.channels():
\(\texttt{dst} (I) = \texttt{src1} \vee \texttt{src2} (I) \quad \texttt{if mask} (I) \ne0\)
In case of floating-point arrays, their machine-specific bit
representations (usually IEEE754-compliant) are used for the operation.
In case of multi-channel arrays, each channel is processed
independently. In the second and third cases above, the scalar is first
converted to the array type.src1 - first input array or a scalar.src2 - second input array or a scalar.dst - output array that has the same size and type as the input
arrays.mask - optional operation mask, 8-bit single channel array, that
specifies elements of the output array to be changed.public static void bitwise_xor(Mat src1, Mat src2, Mat dst)
src1.channels():
\(\texttt{dst} (I) = \texttt{src1} (I) \oplus \texttt{src2} \quad \texttt{if mask} (I) \ne0\)
A scalar and an array when src1 is constructed from Scalar or has
the same number of elements as src2.channels():
\(\texttt{dst} (I) = \texttt{src1} \oplus \texttt{src2} (I) \quad \texttt{if mask} (I) \ne0\)
In case of floating-point arrays, their machine-specific bit
representations (usually IEEE754-compliant) are used for the operation.
In case of multi-channel arrays, each channel is processed
independently. In the 2nd and 3rd cases above, the scalar is first
converted to the array type.src1 - first input array or a scalar.src2 - second input array or a scalar.dst - output array that has the same size and type as the input
arrays.
specifies elements of the output array to be changed.public static void bitwise_xor(Mat src1, Mat src2, Mat dst, Mat mask)
src1.channels():
\(\texttt{dst} (I) = \texttt{src1} (I) \oplus \texttt{src2} \quad \texttt{if mask} (I) \ne0\)
A scalar and an array when src1 is constructed from Scalar or has
the same number of elements as src2.channels():
\(\texttt{dst} (I) = \texttt{src1} \oplus \texttt{src2} (I) \quad \texttt{if mask} (I) \ne0\)
In case of floating-point arrays, their machine-specific bit
representations (usually IEEE754-compliant) are used for the operation.
In case of multi-channel arrays, each channel is processed
independently. In the 2nd and 3rd cases above, the scalar is first
converted to the array type.src1 - first input array or a scalar.src2 - second input array or a scalar.dst - output array that has the same size and type as the input
arrays.mask - optional operation mask, 8-bit single channel array, that
specifies elements of the output array to be changed.public static int borderInterpolate(int p,
int len,
int borderType)
float val = img.at<float>(borderInterpolate(100, img.rows, cv::BORDER_REFLECT_101),
borderInterpolate(-5, img.cols, cv::BORDER_WRAP));
Normally, the function is not called directly. It is used inside filtering functions and also in
copyMakeBorder.p - 0-based coordinate of the extrapolated pixel along one of the axes, likely <0 or >= lenlen - Length of the array along the corresponding axis.borderType - Border type, one of the #BorderTypes, except for #BORDER_TRANSPARENT and
#BORDER_ISOLATED . When borderType==#BORDER_CONSTANT , the function always returns -1, regardless
of p and len.
SEE: copyMakeBorderpublic static void calcCovarMatrix(Mat samples, Mat covar, Mat mean, int flags)
samples - samples stored as rows/columns of a single matrix.covar - output covariance matrix of the type ctype and square size.mean - input or output (depending on the flags) array as the average value of the input vectors.flags - operation flags as a combination of #CovarFlagspublic static void calcCovarMatrix(Mat samples, Mat covar, Mat mean, int flags, int ctype)
samples - samples stored as rows/columns of a single matrix.covar - output covariance matrix of the type ctype and square size.mean - input or output (depending on the flags) array as the average value of the input vectors.flags - operation flags as a combination of #CovarFlagsctype - type of the matrixl; it equals 'CV_64F' by default.public static void cartToPolar(Mat x, Mat y, Mat magnitude, Mat angle)
x - array of x-coordinates; this must be a single-precision or
double-precision floating-point array.y - array of y-coordinates, that must have the same size and same type as x.magnitude - output array of magnitudes of the same size and type as x.angle - output array of angles that has the same size and type as
x; the angles are measured in radians (from 0 to 2\*Pi) or in degrees (0 to 360 degrees).
in radians (which is by default), or in degrees.
SEE: Sobel, Scharrpublic static void cartToPolar(Mat x, Mat y, Mat magnitude, Mat angle, boolean angleInDegrees)
x - array of x-coordinates; this must be a single-precision or
double-precision floating-point array.y - array of y-coordinates, that must have the same size and same type as x.magnitude - output array of magnitudes of the same size and type as x.angle - output array of angles that has the same size and type as
x; the angles are measured in radians (from 0 to 2\*Pi) or in degrees (0 to 360 degrees).angleInDegrees - a flag, indicating whether the angles are measured
in radians (which is by default), or in degrees.
SEE: Sobel, Scharrpublic static boolean checkRange(Mat a)
a - input array.
are out of range or they throw an exception.
elements.
public static boolean checkRange(Mat a, boolean quiet)
a - input array.quiet - a flag, indicating whether the functions quietly return false when the array elements
are out of range or they throw an exception.
elements.
public static boolean checkRange(Mat a, boolean quiet, double minVal)
a - input array.quiet - a flag, indicating whether the functions quietly return false when the array elements
are out of range or they throw an exception.
elements.minVal - inclusive lower boundary of valid values range.
public static boolean checkRange(Mat a, boolean quiet, double minVal, double maxVal)
a - input array.quiet - a flag, indicating whether the functions quietly return false when the array elements
are out of range or they throw an exception.
elements.minVal - inclusive lower boundary of valid values range.maxVal - exclusive upper boundary of valid values range.
public static void compare(Mat src1, Mat src2, Mat dst, int cmpop)
Mat dst1 = src1 >= src2;
Mat dst2 = src1 < 8;
...
src1 - first input array or a scalar; when it is an array, it must have a single channel.src2 - second input array or a scalar; when it is an array, it must have a single channel.dst - output array of type ref CV_8U that has the same size and the same number of channels as
the input arrays.cmpop - a flag, that specifies correspondence between the arrays (cv::CmpTypes)
SEE: checkRange, min, max, thresholdpublic static void completeSymm(Mat m)
m - input-output floating-point square matrix.
the upper half. Otherwise, the upper half is copied to the lower half.
SEE: flip, transposepublic static void completeSymm(Mat m, boolean lowerToUpper)
m - input-output floating-point square matrix.lowerToUpper - operation flag; if true, the lower half is copied to
the upper half. Otherwise, the upper half is copied to the lower half.
SEE: flip, transposepublic static void convertFp16(Mat src, Mat dst)
src - input array.dst - output array.public static void convertScaleAbs(Mat src, Mat dst)
Mat_<float> A(30,30);
randu(A, Scalar(-100), Scalar(100));
Mat_<float> B = A*5 + 3;
B = abs(B);
// Mat_<float> B = abs(A*5+3) will also do the job,
// but it will allocate a temporary matrix
src - input array.dst - output array.
SEE: Mat::convertTo, cv::abs(const Mat&)public static void convertScaleAbs(Mat src, Mat dst, double alpha)
Mat_<float> A(30,30);
randu(A, Scalar(-100), Scalar(100));
Mat_<float> B = A*5 + 3;
B = abs(B);
// Mat_<float> B = abs(A*5+3) will also do the job,
// but it will allocate a temporary matrix
src - input array.dst - output array.alpha - optional scale factor.
SEE: Mat::convertTo, cv::abs(const Mat&)public static void convertScaleAbs(Mat src, Mat dst, double alpha, double beta)
Mat_<float> A(30,30);
randu(A, Scalar(-100), Scalar(100));
Mat_<float> B = A*5 + 3;
B = abs(B);
// Mat_<float> B = abs(A*5+3) will also do the job,
// but it will allocate a temporary matrix
src - input array.dst - output array.alpha - optional scale factor.beta - optional delta added to the scaled values.
SEE: Mat::convertTo, cv::abs(const Mat&)public static void copyMakeBorder(Mat src, Mat dst, int top, int bottom, int left, int right, int borderType)
// let border be the same in all directions
int border=2;
// constructs a larger image to fit both the image and the border
Mat gray_buf(rgb.rows + border*2, rgb.cols + border*2, rgb.depth());
// select the middle part of it w/o copying data
Mat gray(gray_canvas, Rect(border, border, rgb.cols, rgb.rows));
// convert image from RGB to grayscale
cvtColor(rgb, gray, COLOR_RGB2GRAY);
// form a border in-place
copyMakeBorder(gray, gray_buf, border, border,
border, border, BORDER_REPLICATE);
// now do some custom filtering ...
...
Note: When the source image is a part (ROI) of a bigger image, the function will try to use the
pixels outside of the ROI to form a border. To disable this feature and always do extrapolation, as
if src was not a ROI, use borderType | #BORDER_ISOLATED.src - Source image.dst - Destination image of the same type as src and the size Size(src.cols+left+right,
src.rows+top+bottom) .top - the top pixelsbottom - the bottom pixelsleft - the left pixelsright - Parameter specifying how many pixels in each direction from the source image rectangle
to extrapolate. For example, top=1, bottom=1, left=1, right=1 mean that 1 pixel-wide border needs
to be built.borderType - Border type. See borderInterpolate for details.
SEE: borderInterpolatepublic static void copyMakeBorder(Mat src, Mat dst, int top, int bottom, int left, int right, int borderType, Scalar value)
// let border be the same in all directions
int border=2;
// constructs a larger image to fit both the image and the border
Mat gray_buf(rgb.rows + border*2, rgb.cols + border*2, rgb.depth());
// select the middle part of it w/o copying data
Mat gray(gray_canvas, Rect(border, border, rgb.cols, rgb.rows));
// convert image from RGB to grayscale
cvtColor(rgb, gray, COLOR_RGB2GRAY);
// form a border in-place
copyMakeBorder(gray, gray_buf, border, border,
border, border, BORDER_REPLICATE);
// now do some custom filtering ...
...
Note: When the source image is a part (ROI) of a bigger image, the function will try to use the
pixels outside of the ROI to form a border. To disable this feature and always do extrapolation, as
if src was not a ROI, use borderType | #BORDER_ISOLATED.src - Source image.dst - Destination image of the same type as src and the size Size(src.cols+left+right,
src.rows+top+bottom) .top - the top pixelsbottom - the bottom pixelsleft - the left pixelsright - Parameter specifying how many pixels in each direction from the source image rectangle
to extrapolate. For example, top=1, bottom=1, left=1, right=1 mean that 1 pixel-wide border needs
to be built.borderType - Border type. See borderInterpolate for details.value - Border value if borderType==BORDER_CONSTANT .
SEE: borderInterpolatepublic static void copyTo(Mat src, Mat dst, Mat mask)
src - source matrix.dst - Destination matrix. If it does not have a proper size or type before the operation, it is
reallocated.mask - Operation mask of the same size as \*this. Its non-zero elements indicate which matrix
elements need to be copied. The mask has to be of type CV_8U and can have 1 or multiple channels.public static int countNonZero(Mat src)
src - single-channel array.
SEE: mean, meanStdDev, norm, minMaxLoc, calcCovarMatrixpublic static float cubeRoot(float val)
val - A function argument.public static void dct(Mat src, Mat dst)
size_t getOptimalDCTSize(size_t N) { return 2*getOptimalDFTSize((N+1)/2); }
N1 = getOptimalDCTSize(N);
src - input floating-point array.dst - output array of the same size and type as src .
SEE: dft , getOptimalDFTSize , idctpublic static void dct(Mat src, Mat dst, int flags)
size_t getOptimalDCTSize(size_t N) { return 2*getOptimalDFTSize((N+1)/2); }
N1 = getOptimalDCTSize(N);
src - input floating-point array.dst - output array of the same size and type as src .flags - transformation flags as a combination of cv::DftFlags (DCT_*)
SEE: dft , getOptimalDFTSize , idctpublic static double determinant(Mat mtx)
mtx - input matrix that must have CV_32FC1 or CV_64FC1 type and
square size.
SEE: trace, invert, solve, eigen, REF: MatrixExpressionspublic static void dft(Mat src, Mat dst)
void convolveDFT(InputArray A, InputArray B, OutputArray C)
{
// reallocate the output array if needed
C.create(abs(A.rows - B.rows)+1, abs(A.cols - B.cols)+1, A.type());
Size dftSize;
// calculate the size of DFT transform
dftSize.width = getOptimalDFTSize(A.cols + B.cols - 1);
dftSize.height = getOptimalDFTSize(A.rows + B.rows - 1);
// allocate temporary buffers and initialize them with 0's
Mat tempA(dftSize, A.type(), Scalar::all(0));
Mat tempB(dftSize, B.type(), Scalar::all(0));
// copy A and B to the top-left corners of tempA and tempB, respectively
Mat roiA(tempA, Rect(0,0,A.cols,A.rows));
A.copyTo(roiA);
Mat roiB(tempB, Rect(0,0,B.cols,B.rows));
B.copyTo(roiB);
// now transform the padded A & B in-place;
// use "nonzeroRows" hint for faster processing
dft(tempA, tempA, 0, A.rows);
dft(tempB, tempB, 0, B.rows);
// multiply the spectrums;
// the function handles packed spectrum representations well
mulSpectrums(tempA, tempB, tempA);
// transform the product back from the frequency domain.
// Even though all the result rows will be non-zero,
// you need only the first C.rows of them, and thus you
// pass nonzeroRows == C.rows
dft(tempA, tempA, DFT_INVERSE + DFT_SCALE, C.rows);
// now copy the result back to C.
tempA(Rect(0, 0, C.cols, C.rows)).copyTo(C);
// all the temporary buffers will be deallocated automatically
}
To optimize this sample, consider the following approaches:
src - input array that could be real or complex.dst - output array whose size and type depends on the flags .
nonzeroRows rows of the input array (#DFT_INVERSE is not set) or only the first nonzeroRows of the
output array (#DFT_INVERSE is set) contain non-zeros, thus, the function can handle the rest of the
rows more efficiently and save some time; this technique is very useful for calculating array
cross-correlation or convolution using DFT.
SEE: dct , getOptimalDFTSize , mulSpectrums, filter2D , matchTemplate , flip , cartToPolar ,
magnitude , phase
public static void dft(Mat src, Mat dst, int flags)
void convolveDFT(InputArray A, InputArray B, OutputArray C)
{
// reallocate the output array if needed
C.create(abs(A.rows - B.rows)+1, abs(A.cols - B.cols)+1, A.type());
Size dftSize;
// calculate the size of DFT transform
dftSize.width = getOptimalDFTSize(A.cols + B.cols - 1);
dftSize.height = getOptimalDFTSize(A.rows + B.rows - 1);
// allocate temporary buffers and initialize them with 0's
Mat tempA(dftSize, A.type(), Scalar::all(0));
Mat tempB(dftSize, B.type(), Scalar::all(0));
// copy A and B to the top-left corners of tempA and tempB, respectively
Mat roiA(tempA, Rect(0,0,A.cols,A.rows));
A.copyTo(roiA);
Mat roiB(tempB, Rect(0,0,B.cols,B.rows));
B.copyTo(roiB);
// now transform the padded A & B in-place;
// use "nonzeroRows" hint for faster processing
dft(tempA, tempA, 0, A.rows);
dft(tempB, tempB, 0, B.rows);
// multiply the spectrums;
// the function handles packed spectrum representations well
mulSpectrums(tempA, tempB, tempA);
// transform the product back from the frequency domain.
// Even though all the result rows will be non-zero,
// you need only the first C.rows of them, and thus you
// pass nonzeroRows == C.rows
dft(tempA, tempA, DFT_INVERSE + DFT_SCALE, C.rows);
// now copy the result back to C.
tempA(Rect(0, 0, C.cols, C.rows)).copyTo(C);
// all the temporary buffers will be deallocated automatically
}
To optimize this sample, consider the following approaches:
src - input array that could be real or complex.dst - output array whose size and type depends on the flags .flags - transformation flags, representing a combination of the #DftFlags
nonzeroRows rows of the input array (#DFT_INVERSE is not set) or only the first nonzeroRows of the
output array (#DFT_INVERSE is set) contain non-zeros, thus, the function can handle the rest of the
rows more efficiently and save some time; this technique is very useful for calculating array
cross-correlation or convolution using DFT.
SEE: dct , getOptimalDFTSize , mulSpectrums, filter2D , matchTemplate , flip , cartToPolar ,
magnitude , phase
public static void dft(Mat src, Mat dst, int flags, int nonzeroRows)
void convolveDFT(InputArray A, InputArray B, OutputArray C)
{
// reallocate the output array if needed
C.create(abs(A.rows - B.rows)+1, abs(A.cols - B.cols)+1, A.type());
Size dftSize;
// calculate the size of DFT transform
dftSize.width = getOptimalDFTSize(A.cols + B.cols - 1);
dftSize.height = getOptimalDFTSize(A.rows + B.rows - 1);
// allocate temporary buffers and initialize them with 0's
Mat tempA(dftSize, A.type(), Scalar::all(0));
Mat tempB(dftSize, B.type(), Scalar::all(0));
// copy A and B to the top-left corners of tempA and tempB, respectively
Mat roiA(tempA, Rect(0,0,A.cols,A.rows));
A.copyTo(roiA);
Mat roiB(tempB, Rect(0,0,B.cols,B.rows));
B.copyTo(roiB);
// now transform the padded A & B in-place;
// use "nonzeroRows" hint for faster processing
dft(tempA, tempA, 0, A.rows);
dft(tempB, tempB, 0, B.rows);
// multiply the spectrums;
// the function handles packed spectrum representations well
mulSpectrums(tempA, tempB, tempA);
// transform the product back from the frequency domain.
// Even though all the result rows will be non-zero,
// you need only the first C.rows of them, and thus you
// pass nonzeroRows == C.rows
dft(tempA, tempA, DFT_INVERSE + DFT_SCALE, C.rows);
// now copy the result back to C.
tempA(Rect(0, 0, C.cols, C.rows)).copyTo(C);
// all the temporary buffers will be deallocated automatically
}
To optimize this sample, consider the following approaches:
src - input array that could be real or complex.dst - output array whose size and type depends on the flags .flags - transformation flags, representing a combination of the #DftFlagsnonzeroRows - when the parameter is not zero, the function assumes that only the first
nonzeroRows rows of the input array (#DFT_INVERSE is not set) or only the first nonzeroRows of the
output array (#DFT_INVERSE is set) contain non-zeros, thus, the function can handle the rest of the
rows more efficiently and save some time; this technique is very useful for calculating array
cross-correlation or convolution using DFT.
SEE: dct , getOptimalDFTSize , mulSpectrums, filter2D , matchTemplate , flip , cartToPolar ,
magnitude , phase
public static void divide(Mat src1, Mat src2, Mat dst)
src1 - first input array.src2 - second input array of the same size and type as src1.dst - output array of the same size and type as src2.
case of an array-by-array division, you can only pass -1 when src1.depth()==src2.depth().
SEE: multiply, add, subtractpublic static void divide(Mat src1, Mat src2, Mat dst, double scale)
src1 - first input array.src2 - second input array of the same size and type as src1.scale - scalar factor.dst - output array of the same size and type as src2.
case of an array-by-array division, you can only pass -1 when src1.depth()==src2.depth().
SEE: multiply, add, subtractpublic static void divide(Mat src1, Mat src2, Mat dst, double scale, int dtype)
src1 - first input array.src2 - second input array of the same size and type as src1.scale - scalar factor.dst - output array of the same size and type as src2.dtype - optional depth of the output array; if -1, dst will have depth src2.depth(), but in
case of an array-by-array division, you can only pass -1 when src1.depth()==src2.depth().
SEE: multiply, add, subtractpublic static boolean eigen(Mat src, Mat eigenvalues)
src*eigenvectors.row(i).t() = eigenvalues.at<srcType>(i)*eigenvectors.row(i).t()
Note: Use cv::eigenNonSymmetric for calculation of real eigenvalues and eigenvectors of non-symmetric matrix.src - input matrix that must have CV_32FC1 or CV_64FC1 type, square size and be symmetrical
(src ^T^ == src).eigenvalues - output vector of eigenvalues of the same type as src; the eigenvalues are stored
in the descending order.
eigenvectors are stored as subsequent matrix rows, in the same order as the corresponding
eigenvalues.
SEE: eigenNonSymmetric, completeSymm , PCApublic static boolean eigen(Mat src, Mat eigenvalues, Mat eigenvectors)
src*eigenvectors.row(i).t() = eigenvalues.at<srcType>(i)*eigenvectors.row(i).t()
Note: Use cv::eigenNonSymmetric for calculation of real eigenvalues and eigenvectors of non-symmetric matrix.src - input matrix that must have CV_32FC1 or CV_64FC1 type, square size and be symmetrical
(src ^T^ == src).eigenvalues - output vector of eigenvalues of the same type as src; the eigenvalues are stored
in the descending order.eigenvectors - output matrix of eigenvectors; it has the same size and type as src; the
eigenvectors are stored as subsequent matrix rows, in the same order as the corresponding
eigenvalues.
SEE: eigenNonSymmetric, completeSymm , PCApublic static void eigenNonSymmetric(Mat src, Mat eigenvalues, Mat eigenvectors)
src*eigenvectors.row(i).t() = eigenvalues.at<srcType>(i)*eigenvectors.row(i).t()
src - input matrix (CV_32FC1 or CV_64FC1 type).eigenvalues - output vector of eigenvalues (type is the same type as src).eigenvectors - output matrix of eigenvectors (type is the same type as src). The eigenvectors are stored as subsequent matrix rows, in the same order as the corresponding eigenvalues.
SEE: eigenpublic static void exp(Mat src, Mat dst)
src - input array.dst - output array of the same size and type as src.
SEE: log , cartToPolar , polarToCart , phase , pow , sqrt , magnitudepublic static void extractChannel(Mat src, Mat dst, int coi)
src - input arraydst - output arraycoi - index of channel to extract
SEE: mixChannels, splitpublic static float fastAtan2(float y,
float x)
x - x-coordinate of the vector.y - y-coordinate of the vector.public static java.lang.String findFile(java.lang.String relative_path)
addSamplesDataSearchPath()
2. OPENCV_SAMPLES_DATA_PATH_HINT environment variable
3. OPENCV_SAMPLES_DATA_PATH environment variable
If parameter value is not empty and nothing is found then stop searching.
4. Detects build/install path based on:
a. current working directory (CWD)
b. and/or binary module location (opencv_core/opencv_world, doesn't work with static linkage)
5. Scan <source>/{,data,samples/data} directories if build directory is detected or the current directory is in source tree.
6. Scan <install>/share/OpenCV directory if install directory is detected.
SEE: cv::utils::findDataFilerelative_path - Relative path to data file
If true, function prints information message and raises cv::Exception.
If false, function returns empty resultpublic static java.lang.String findFile(java.lang.String relative_path,
boolean required)
addSamplesDataSearchPath()
2. OPENCV_SAMPLES_DATA_PATH_HINT environment variable
3. OPENCV_SAMPLES_DATA_PATH environment variable
If parameter value is not empty and nothing is found then stop searching.
4. Detects build/install path based on:
a. current working directory (CWD)
b. and/or binary module location (opencv_core/opencv_world, doesn't work with static linkage)
5. Scan <source>/{,data,samples/data} directories if build directory is detected or the current directory is in source tree.
6. Scan <install>/share/OpenCV directory if install directory is detected.
SEE: cv::utils::findDataFilerelative_path - Relative path to data filerequired - Specify "file not found" handling.
If true, function prints information message and raises cv::Exception.
If false, function returns empty resultpublic static java.lang.String findFile(java.lang.String relative_path,
boolean required,
boolean silentMode)
addSamplesDataSearchPath()
2. OPENCV_SAMPLES_DATA_PATH_HINT environment variable
3. OPENCV_SAMPLES_DATA_PATH environment variable
If parameter value is not empty and nothing is found then stop searching.
4. Detects build/install path based on:
a. current working directory (CWD)
b. and/or binary module location (opencv_core/opencv_world, doesn't work with static linkage)
5. Scan <source>/{,data,samples/data} directories if build directory is detected or the current directory is in source tree.
6. Scan <install>/share/OpenCV directory if install directory is detected.
SEE: cv::utils::findDataFilerelative_path - Relative path to data filerequired - Specify "file not found" handling.
If true, function prints information message and raises cv::Exception.
If false, function returns empty resultsilentMode - Disables messagespublic static java.lang.String findFileOrKeep(java.lang.String relative_path)
public static java.lang.String findFileOrKeep(java.lang.String relative_path,
boolean silentMode)
public static void findNonZero(Mat src, Mat idx)
cv::Mat binaryImage; // input, binary image
cv::Mat locations; // output, locations of non-zero pixels
cv::findNonZero(binaryImage, locations);
// access pixel coordinates
Point pnt = locations.at<Point>(i);
or
cv::Mat binaryImage; // input, binary image
vector<Point> locations; // output, locations of non-zero pixels
cv::findNonZero(binaryImage, locations);
// access pixel coordinates
Point pnt = locations[i];
src - single-channel arrayidx - the output array, type of cv::Mat or std::vector<Point>, corresponding to non-zero indices in the inputpublic static void flip(Mat src, Mat dst, int flipCode)
src - input array.dst - output array of the same size and type as src.flipCode - a flag to specify how to flip the array; 0 means
flipping around the x-axis and positive value (for example, 1) means
flipping around y-axis. Negative value (for example, -1) means flipping
around both axes.
SEE: transpose , repeat , completeSymmpublic static void gemm(Mat src1, Mat src2, double alpha, Mat src3, double beta, Mat dst)
gemm(src1, src2, alpha, src3, beta, dst, GEMM_1_T + GEMM_3_T)
corresponds to
\(\texttt{dst} = \texttt{alpha} \cdot \texttt{src1} ^T \cdot \texttt{src2} + \texttt{beta} \cdot \texttt{src3} ^T\)
In case of complex (two-channel) data, performed a complex matrix
multiplication.
The function can be replaced with a matrix expression. For example, the
above call can be replaced with:
dst = alpha*src1.t()*src2 + beta*src3.t();
src1 - first multiplied input matrix that could be real(CV_32FC1,
CV_64FC1) or complex(CV_32FC2, CV_64FC2).src2 - second multiplied input matrix of the same type as src1.alpha - weight of the matrix product.src3 - third optional delta matrix added to the matrix product; it
should have the same type as src1 and src2.beta - weight of src3.dst - output matrix; it has the proper size and the same type as
input matrices.
SEE: mulTransposed , transformpublic static void gemm(Mat src1, Mat src2, double alpha, Mat src3, double beta, Mat dst, int flags)
gemm(src1, src2, alpha, src3, beta, dst, GEMM_1_T + GEMM_3_T)
corresponds to
\(\texttt{dst} = \texttt{alpha} \cdot \texttt{src1} ^T \cdot \texttt{src2} + \texttt{beta} \cdot \texttt{src3} ^T\)
In case of complex (two-channel) data, performed a complex matrix
multiplication.
The function can be replaced with a matrix expression. For example, the
above call can be replaced with:
dst = alpha*src1.t()*src2 + beta*src3.t();
src1 - first multiplied input matrix that could be real(CV_32FC1,
CV_64FC1) or complex(CV_32FC2, CV_64FC2).src2 - second multiplied input matrix of the same type as src1.alpha - weight of the matrix product.src3 - third optional delta matrix added to the matrix product; it
should have the same type as src1 and src2.beta - weight of src3.dst - output matrix; it has the proper size and the same type as
input matrices.flags - operation flags (cv::GemmFlags)
SEE: mulTransposed , transformpublic static java.lang.String getBuildInformation()
public static long getCPUTickCount()
public static java.lang.String getHardwareFeatureName(int feature)
feature - automatically generatedpublic static java.lang.String getIppVersion()
public static int getNumberOfCPUs()
public static int getNumThreads()
TBB - The number of threads, that OpenCV will try to use for parallel regions. If there is
any tbb::thread_scheduler_init in user code conflicting with OpenCV, then function returns
default number of threads used by TBB library.
OpenMP - An upper bound on the number of threads that could be used to form a new team.
Concurrency - The number of threads, that OpenCV will try to use for parallel regions.
GCD - Unsupported; returns the GCD thread pool limit (512) for compatibility.
C= - The number of threads, that OpenCV will try to use for parallel regions, if before
called setNumThreads with threads > 0, otherwise returns the number of logical CPUs,
available for the process.
SEE: setNumThreads, getThreadNum
public static int getOptimalDFTSize(int vecsize)
vecsize - vector size.
SEE: dft , dct , idft , idct , mulSpectrumspublic static long getTickCount()
public static double getTickFrequency()
double t = (double)getTickCount();
// do something ...
t = ((double)getTickCount() - t)/getTickFrequency();
SEE: getTickCount, TickMeterpublic static int getVersionMajor()
public static int getVersionMinor()
public static int getVersionRevision()
public static java.lang.String getVersionString()
public static void hconcat(java.util.List<Mat> src, Mat dst)
std::vector<cv::Mat> matrices = { cv::Mat(4, 1, CV_8UC1, cv::Scalar(1)),
cv::Mat(4, 1, CV_8UC1, cv::Scalar(2)),
cv::Mat(4, 1, CV_8UC1, cv::Scalar(3)),};
cv::Mat out;
cv::hconcat( matrices, out );
//out:
//[1, 2, 3;
// 1, 2, 3;
// 1, 2, 3;
// 1, 2, 3]
src - input array or vector of matrices. all of the matrices must have the same number of rows and the same depth.dst - output array. It has the same number of rows and depth as the src, and the sum of cols of the src.
same depth.public static void idct(Mat src, Mat dst)
src - input floating-point single-channel array.dst - output array of the same size and type as src.
SEE: dct, dft, idft, getOptimalDFTSizepublic static void idct(Mat src, Mat dst, int flags)
src - input floating-point single-channel array.dst - output array of the same size and type as src.flags - operation flags.
SEE: dct, dft, idft, getOptimalDFTSizepublic static void idft(Mat src, Mat dst)
src - input floating-point real or complex array.dst - output array whose size and type depend on the flags.
the convolution sample in dft description.public static void idft(Mat src, Mat dst, int flags)
src - input floating-point real or complex array.dst - output array whose size and type depend on the flags.flags - operation flags (see dft and #DftFlags).
the convolution sample in dft description.public static void idft(Mat src, Mat dst, int flags, int nonzeroRows)
src - input floating-point real or complex array.dst - output array whose size and type depend on the flags.flags - operation flags (see dft and #DftFlags).nonzeroRows - number of dst rows to process; the rest of the rows have undefined content (see
the convolution sample in dft description.public static void inRange(Mat src, Scalar lowerb, Scalar upperb, Mat dst)
src - first input array.lowerb - inclusive lower boundary array or a scalar.upperb - inclusive upper boundary array or a scalar.dst - output array of the same size as src and CV_8U type.public static void insertChannel(Mat src, Mat dst, int coi)
src - input arraydst - output arraycoi - index of channel for insertion
SEE: mixChannels, mergepublic static double invert(Mat src, Mat dst)
src - input floating-point M x N matrix.dst - output matrix of N x M size and the same type as src.
SEE: solve, SVDpublic static double invert(Mat src, Mat dst, int flags)
src - input floating-point M x N matrix.dst - output matrix of N x M size and the same type as src.flags - inversion method (cv::DecompTypes)
SEE: solve, SVDpublic static double kmeans(Mat data, int K, Mat bestLabels, TermCriteria criteria, int attempts, int flags)
data - Data for clustering. An array of N-Dimensional points with float coordinates is needed.
Examples of this array can be:
K - Number of clusters to split the set by.bestLabels - Input/output integer array that stores the cluster indices for every sample.criteria - The algorithm termination criteria, that is, the maximum number of iterations and/or
the desired accuracy. The accuracy is specified as criteria.epsilon. As soon as each of the cluster
centers moves by less than criteria.epsilon on some iteration, the algorithm stops.attempts - Flag to specify the number of times the algorithm is executed using different
initial labellings. The algorithm returns the labels that yield the best compactness (see the last
function parameter).flags - Flag that can take values of cv::KmeansFlagspublic static double kmeans(Mat data, int K, Mat bestLabels, TermCriteria criteria, int attempts, int flags, Mat centers)
data - Data for clustering. An array of N-Dimensional points with float coordinates is needed.
Examples of this array can be:
K - Number of clusters to split the set by.bestLabels - Input/output integer array that stores the cluster indices for every sample.criteria - The algorithm termination criteria, that is, the maximum number of iterations and/or
the desired accuracy. The accuracy is specified as criteria.epsilon. As soon as each of the cluster
centers moves by less than criteria.epsilon on some iteration, the algorithm stops.attempts - Flag to specify the number of times the algorithm is executed using different
initial labellings. The algorithm returns the labels that yield the best compactness (see the last
function parameter).flags - Flag that can take values of cv::KmeansFlagscenters - Output matrix of the cluster centers, one row per each cluster center.public static void log(Mat src, Mat dst)
src - input array.dst - output array of the same size and type as src .
SEE: exp, cartToPolar, polarToCart, phase, pow, sqrt, magnitudepublic static void LUT(Mat src, Mat lut, Mat dst)
src - input array of 8-bit elements.lut - look-up table of 256 elements; in case of multi-channel input array, the table should
either have a single channel (in this case the same table is used for all channels) or the same
number of channels as in the input array.dst - output array of the same size and number of channels as src, and the same depth as lut.
SEE: convertScaleAbs, Mat::convertTopublic static void magnitude(Mat x, Mat y, Mat magnitude)
x - floating-point array of x-coordinates of the vectors.y - floating-point array of y-coordinates of the vectors; it must
have the same size as x.magnitude - output array of the same size and type as x.
SEE: cartToPolar, polarToCart, phase, sqrtpublic static double Mahalanobis(Mat v1, Mat v2, Mat icovar)
v1 - first 1D input vector.v2 - second 1D input vector.icovar - inverse covariance matrix.public static void max(Mat src1, Mat src2, Mat dst)
src1 - first input array.src2 - second input array of the same size and type as src1 .dst - output array of the same size and type as src1.
SEE: min, compare, inRange, minMaxLoc, REF: MatrixExpressionspublic static Scalar mean(Mat src)
src - input array that should have from 1 to 4 channels so that the result can be stored in
Scalar_ .
SEE: countNonZero, meanStdDev, norm, minMaxLocpublic static Scalar mean(Mat src, Mat mask)
src - input array that should have from 1 to 4 channels so that the result can be stored in
Scalar_ .mask - optional operation mask.
SEE: countNonZero, meanStdDev, norm, minMaxLocpublic static void meanStdDev(Mat src, MatOfDouble mean, MatOfDouble stddev)
src - input array that should have from 1 to 4 channels so that the results can be stored in
Scalar_ 's.mean - output parameter: calculated mean value.stddev - output parameter: calculated standard deviation.
SEE: countNonZero, mean, norm, minMaxLoc, calcCovarMatrixpublic static void meanStdDev(Mat src, MatOfDouble mean, MatOfDouble stddev, Mat mask)
src - input array that should have from 1 to 4 channels so that the results can be stored in
Scalar_ 's.mean - output parameter: calculated mean value.stddev - output parameter: calculated standard deviation.mask - optional operation mask.
SEE: countNonZero, mean, norm, minMaxLoc, calcCovarMatrixpublic static void merge(java.util.List<Mat> mv, Mat dst)
mv - input vector of matrices to be merged; all the matrices in mv must have the same
size and the same depth.dst - output array of the same size and the same depth as mv[0]; The number of channels will
be the total number of channels in the matrix array.public static void min(Mat src1, Mat src2, Mat dst)
src1 - first input array.src2 - second input array of the same size and type as src1.dst - output array of the same size and type as src1.
SEE: max, compare, inRange, minMaxLocpublic static Core.MinMaxLocResult minMaxLoc(Mat src)
public static Core.MinMaxLocResult minMaxLoc(Mat src, Mat mask)
public static void mixChannels(java.util.List<Mat> src, java.util.List<Mat> dst, MatOfInt fromTo)
src - input array or vector of matrices; all of the matrices must have the same size and the
same depth.dst - output array or vector of matrices; all the matrices must be allocated; their size and
depth must be the same as in src[0].fromTo - array of index pairs specifying which channels are copied and where; fromTo[k\*2] is
a 0-based index of the input channel in src, fromTo[k\*2+1] is an index of the output channel in
dst; the continuous channel numbering is used: the first input image channels are indexed from 0 to
src[0].channels()-1, the second input image channels are indexed from src[0].channels() to
src[0].channels() + src[1].channels()-1, and so on, the same scheme is used for the output image
channels; as a special case, when fromTo[k\*2] is negative, the corresponding output channel is
filled with zero .public static void mulSpectrums(Mat a, Mat b, Mat c, int flags)
a - first input array.b - second input array of the same size and type as src1 .c - output array of the same size and type as src1 .flags - operation flags; currently, the only supported flag is cv::DFT_ROWS, which indicates that
each row of src1 and src2 is an independent 1D Fourier spectrum. If you do not want to use this flag, then simply add a 0 as value.
or not (false).public static void mulSpectrums(Mat a, Mat b, Mat c, int flags, boolean conjB)
a - first input array.b - second input array of the same size and type as src1 .c - output array of the same size and type as src1 .flags - operation flags; currently, the only supported flag is cv::DFT_ROWS, which indicates that
each row of src1 and src2 is an independent 1D Fourier spectrum. If you do not want to use this flag, then simply add a 0 as value.conjB - optional flag that conjugates the second input array before the multiplication (true)
or not (false).public static void multiply(Mat src1, Mat src2, Mat dst)
src1 - first input array.src2 - second input array of the same size and the same type as src1.dst - output array of the same size and type as src1.
SEE: add, subtract, divide, scaleAdd, addWeighted, accumulate, accumulateProduct, accumulateSquare,
Mat::convertTopublic static void multiply(Mat src1, Mat src2, Mat dst, double scale)
src1 - first input array.src2 - second input array of the same size and the same type as src1.dst - output array of the same size and type as src1.scale - optional scale factor.
SEE: add, subtract, divide, scaleAdd, addWeighted, accumulate, accumulateProduct, accumulateSquare,
Mat::convertTopublic static void multiply(Mat src1, Mat src2, Mat dst, double scale, int dtype)
src1 - first input array.src2 - second input array of the same size and the same type as src1.dst - output array of the same size and type as src1.scale - optional scale factor.dtype - optional depth of the output array
SEE: add, subtract, divide, scaleAdd, addWeighted, accumulate, accumulateProduct, accumulateSquare,
Mat::convertTopublic static void mulTransposed(Mat src, Mat dst, boolean aTa)
src - input single-channel matrix. Note that unlike gemm, the
function can multiply not only floating-point matrices.dst - output square matrix.aTa - Flag specifying the multiplication ordering. See the
description below.
multiplication. When the matrix is empty ( delta=noArray() ), it is
assumed to be zero, that is, nothing is subtracted. If it has the same
size as src , it is simply subtracted. Otherwise, it is "repeated" (see
repeat ) to cover the full src and then subtracted. Type of the delta
matrix, when it is not empty, must be the same as the type of created
output matrix. See the dtype parameter description below.
the output matrix will have the same type as src . Otherwise, it will be
type=CV_MAT_DEPTH(dtype) that should be either CV_32F or CV_64F .
SEE: calcCovarMatrix, gemm, repeat, reducepublic static void mulTransposed(Mat src, Mat dst, boolean aTa, Mat delta)
src - input single-channel matrix. Note that unlike gemm, the
function can multiply not only floating-point matrices.dst - output square matrix.aTa - Flag specifying the multiplication ordering. See the
description below.delta - Optional delta matrix subtracted from src before the
multiplication. When the matrix is empty ( delta=noArray() ), it is
assumed to be zero, that is, nothing is subtracted. If it has the same
size as src , it is simply subtracted. Otherwise, it is "repeated" (see
repeat ) to cover the full src and then subtracted. Type of the delta
matrix, when it is not empty, must be the same as the type of created
output matrix. See the dtype parameter description below.
the output matrix will have the same type as src . Otherwise, it will be
type=CV_MAT_DEPTH(dtype) that should be either CV_32F or CV_64F .
SEE: calcCovarMatrix, gemm, repeat, reducepublic static void mulTransposed(Mat src, Mat dst, boolean aTa, Mat delta, double scale)
src - input single-channel matrix. Note that unlike gemm, the
function can multiply not only floating-point matrices.dst - output square matrix.aTa - Flag specifying the multiplication ordering. See the
description below.delta - Optional delta matrix subtracted from src before the
multiplication. When the matrix is empty ( delta=noArray() ), it is
assumed to be zero, that is, nothing is subtracted. If it has the same
size as src , it is simply subtracted. Otherwise, it is "repeated" (see
repeat ) to cover the full src and then subtracted. Type of the delta
matrix, when it is not empty, must be the same as the type of created
output matrix. See the dtype parameter description below.scale - Optional scale factor for the matrix product.
the output matrix will have the same type as src . Otherwise, it will be
type=CV_MAT_DEPTH(dtype) that should be either CV_32F or CV_64F .
SEE: calcCovarMatrix, gemm, repeat, reducepublic static void mulTransposed(Mat src, Mat dst, boolean aTa, Mat delta, double scale, int dtype)
src - input single-channel matrix. Note that unlike gemm, the
function can multiply not only floating-point matrices.dst - output square matrix.aTa - Flag specifying the multiplication ordering. See the
description below.delta - Optional delta matrix subtracted from src before the
multiplication. When the matrix is empty ( delta=noArray() ), it is
assumed to be zero, that is, nothing is subtracted. If it has the same
size as src , it is simply subtracted. Otherwise, it is "repeated" (see
repeat ) to cover the full src and then subtracted. Type of the delta
matrix, when it is not empty, must be the same as the type of created
output matrix. See the dtype parameter description below.scale - Optional scale factor for the matrix product.dtype - Optional type of the output matrix. When it is negative,
the output matrix will have the same type as src . Otherwise, it will be
type=CV_MAT_DEPTH(dtype) that should be either CV_32F or CV_64F .
SEE: calcCovarMatrix, gemm, repeat, reducepublic static double norm(Mat src1)
src1 - first input array.public static double norm(Mat src1, int normType)
src1 - first input array.normType - type of the norm (see #NormTypes).public static double norm(Mat src1, int normType, Mat mask)
src1 - first input array.normType - type of the norm (see #NormTypes).mask - optional operation mask; it must have the same size as src1 and CV_8UC1 type.public static double norm(Mat src1, Mat src2)
src1 - first input array.src2 - second input array of the same size and the same type as src1.public static double norm(Mat src1, Mat src2, int normType)
src1 - first input array.src2 - second input array of the same size and the same type as src1.normType - type of the norm (see #NormTypes).public static double norm(Mat src1, Mat src2, int normType, Mat mask)
src1 - first input array.src2 - second input array of the same size and the same type as src1.normType - type of the norm (see #NormTypes).mask - optional operation mask; it must have the same size as src1 and CV_8UC1 type.public static void normalize(Mat src, Mat dst)
vector<double> positiveData = { 2.0, 8.0, 10.0 };
vector<double> normalizedData_l1, normalizedData_l2, normalizedData_inf, normalizedData_minmax;
// Norm to probability (total count)
// sum(numbers) = 20.0
// 2.0 0.1 (2.0/20.0)
// 8.0 0.4 (8.0/20.0)
// 10.0 0.5 (10.0/20.0)
normalize(positiveData, normalizedData_l1, 1.0, 0.0, NORM_L1);
// Norm to unit vector: ||positiveData|| = 1.0
// 2.0 0.15
// 8.0 0.62
// 10.0 0.77
normalize(positiveData, normalizedData_l2, 1.0, 0.0, NORM_L2);
// Norm to max element
// 2.0 0.2 (2.0/10.0)
// 8.0 0.8 (8.0/10.0)
// 10.0 1.0 (10.0/10.0)
normalize(positiveData, normalizedData_inf, 1.0, 0.0, NORM_INF);
// Norm to range [0.0;1.0]
// 2.0 0.0 (shift to left border)
// 8.0 0.75 (6.0/8.0)
// 10.0 1.0 (shift to right border)
normalize(positiveData, normalizedData_minmax, 1.0, 0.0, NORM_MINMAX);
src - input array.dst - output array of the same size as src .
normalization.
normalization.
number of channels as src and the depth =CV_MAT_DEPTH(dtype).
SEE: norm, Mat::convertTo, SparseMat::convertTopublic static void normalize(Mat src, Mat dst, double alpha)
vector<double> positiveData = { 2.0, 8.0, 10.0 };
vector<double> normalizedData_l1, normalizedData_l2, normalizedData_inf, normalizedData_minmax;
// Norm to probability (total count)
// sum(numbers) = 20.0
// 2.0 0.1 (2.0/20.0)
// 8.0 0.4 (8.0/20.0)
// 10.0 0.5 (10.0/20.0)
normalize(positiveData, normalizedData_l1, 1.0, 0.0, NORM_L1);
// Norm to unit vector: ||positiveData|| = 1.0
// 2.0 0.15
// 8.0 0.62
// 10.0 0.77
normalize(positiveData, normalizedData_l2, 1.0, 0.0, NORM_L2);
// Norm to max element
// 2.0 0.2 (2.0/10.0)
// 8.0 0.8 (8.0/10.0)
// 10.0 1.0 (10.0/10.0)
normalize(positiveData, normalizedData_inf, 1.0, 0.0, NORM_INF);
// Norm to range [0.0;1.0]
// 2.0 0.0 (shift to left border)
// 8.0 0.75 (6.0/8.0)
// 10.0 1.0 (shift to right border)
normalize(positiveData, normalizedData_minmax, 1.0, 0.0, NORM_MINMAX);
src - input array.dst - output array of the same size as src .alpha - norm value to normalize to or the lower range boundary in case of the range
normalization.
normalization.
number of channels as src and the depth =CV_MAT_DEPTH(dtype).
SEE: norm, Mat::convertTo, SparseMat::convertTopublic static void normalize(Mat src, Mat dst, double alpha, double beta)
vector<double> positiveData = { 2.0, 8.0, 10.0 };
vector<double> normalizedData_l1, normalizedData_l2, normalizedData_inf, normalizedData_minmax;
// Norm to probability (total count)
// sum(numbers) = 20.0
// 2.0 0.1 (2.0/20.0)
// 8.0 0.4 (8.0/20.0)
// 10.0 0.5 (10.0/20.0)
normalize(positiveData, normalizedData_l1, 1.0, 0.0, NORM_L1);
// Norm to unit vector: ||positiveData|| = 1.0
// 2.0 0.15
// 8.0 0.62
// 10.0 0.77
normalize(positiveData, normalizedData_l2, 1.0, 0.0, NORM_L2);
// Norm to max element
// 2.0 0.2 (2.0/10.0)
// 8.0 0.8 (8.0/10.0)
// 10.0 1.0 (10.0/10.0)
normalize(positiveData, normalizedData_inf, 1.0, 0.0, NORM_INF);
// Norm to range [0.0;1.0]
// 2.0 0.0 (shift to left border)
// 8.0 0.75 (6.0/8.0)
// 10.0 1.0 (shift to right border)
normalize(positiveData, normalizedData_minmax, 1.0, 0.0, NORM_MINMAX);
src - input array.dst - output array of the same size as src .alpha - norm value to normalize to or the lower range boundary in case of the range
normalization.beta - upper range boundary in case of the range normalization; it is not used for the norm
normalization.
number of channels as src and the depth =CV_MAT_DEPTH(dtype).
SEE: norm, Mat::convertTo, SparseMat::convertTopublic static void normalize(Mat src, Mat dst, double alpha, double beta, int norm_type)
vector<double> positiveData = { 2.0, 8.0, 10.0 };
vector<double> normalizedData_l1, normalizedData_l2, normalizedData_inf, normalizedData_minmax;
// Norm to probability (total count)
// sum(numbers) = 20.0
// 2.0 0.1 (2.0/20.0)
// 8.0 0.4 (8.0/20.0)
// 10.0 0.5 (10.0/20.0)
normalize(positiveData, normalizedData_l1, 1.0, 0.0, NORM_L1);
// Norm to unit vector: ||positiveData|| = 1.0
// 2.0 0.15
// 8.0 0.62
// 10.0 0.77
normalize(positiveData, normalizedData_l2, 1.0, 0.0, NORM_L2);
// Norm to max element
// 2.0 0.2 (2.0/10.0)
// 8.0 0.8 (8.0/10.0)
// 10.0 1.0 (10.0/10.0)
normalize(positiveData, normalizedData_inf, 1.0, 0.0, NORM_INF);
// Norm to range [0.0;1.0]
// 2.0 0.0 (shift to left border)
// 8.0 0.75 (6.0/8.0)
// 10.0 1.0 (shift to right border)
normalize(positiveData, normalizedData_minmax, 1.0, 0.0, NORM_MINMAX);
src - input array.dst - output array of the same size as src .alpha - norm value to normalize to or the lower range boundary in case of the range
normalization.beta - upper range boundary in case of the range normalization; it is not used for the norm
normalization.norm_type - normalization type (see cv::NormTypes).
number of channels as src and the depth =CV_MAT_DEPTH(dtype).
SEE: norm, Mat::convertTo, SparseMat::convertTopublic static void normalize(Mat src, Mat dst, double alpha, double beta, int norm_type, int dtype)
vector<double> positiveData = { 2.0, 8.0, 10.0 };
vector<double> normalizedData_l1, normalizedData_l2, normalizedData_inf, normalizedData_minmax;
// Norm to probability (total count)
// sum(numbers) = 20.0
// 2.0 0.1 (2.0/20.0)
// 8.0 0.4 (8.0/20.0)
// 10.0 0.5 (10.0/20.0)
normalize(positiveData, normalizedData_l1, 1.0, 0.0, NORM_L1);
// Norm to unit vector: ||positiveData|| = 1.0
// 2.0 0.15
// 8.0 0.62
// 10.0 0.77
normalize(positiveData, normalizedData_l2, 1.0, 0.0, NORM_L2);
// Norm to max element
// 2.0 0.2 (2.0/10.0)
// 8.0 0.8 (8.0/10.0)
// 10.0 1.0 (10.0/10.0)
normalize(positiveData, normalizedData_inf, 1.0, 0.0, NORM_INF);
// Norm to range [0.0;1.0]
// 2.0 0.0 (shift to left border)
// 8.0 0.75 (6.0/8.0)
// 10.0 1.0 (shift to right border)
normalize(positiveData, normalizedData_minmax, 1.0, 0.0, NORM_MINMAX);
src - input array.dst - output array of the same size as src .alpha - norm value to normalize to or the lower range boundary in case of the range
normalization.beta - upper range boundary in case of the range normalization; it is not used for the norm
normalization.norm_type - normalization type (see cv::NormTypes).dtype - when negative, the output array has the same type as src; otherwise, it has the same
number of channels as src and the depth =CV_MAT_DEPTH(dtype).
SEE: norm, Mat::convertTo, SparseMat::convertTopublic static void normalize(Mat src, Mat dst, double alpha, double beta, int norm_type, int dtype, Mat mask)
vector<double> positiveData = { 2.0, 8.0, 10.0 };
vector<double> normalizedData_l1, normalizedData_l2, normalizedData_inf, normalizedData_minmax;
// Norm to probability (total count)
// sum(numbers) = 20.0
// 2.0 0.1 (2.0/20.0)
// 8.0 0.4 (8.0/20.0)
// 10.0 0.5 (10.0/20.0)
normalize(positiveData, normalizedData_l1, 1.0, 0.0, NORM_L1);
// Norm to unit vector: ||positiveData|| = 1.0
// 2.0 0.15
// 8.0 0.62
// 10.0 0.77
normalize(positiveData, normalizedData_l2, 1.0, 0.0, NORM_L2);
// Norm to max element
// 2.0 0.2 (2.0/10.0)
// 8.0 0.8 (8.0/10.0)
// 10.0 1.0 (10.0/10.0)
normalize(positiveData, normalizedData_inf, 1.0, 0.0, NORM_INF);
// Norm to range [0.0;1.0]
// 2.0 0.0 (shift to left border)
// 8.0 0.75 (6.0/8.0)
// 10.0 1.0 (shift to right border)
normalize(positiveData, normalizedData_minmax, 1.0, 0.0, NORM_MINMAX);
src - input array.dst - output array of the same size as src .alpha - norm value to normalize to or the lower range boundary in case of the range
normalization.beta - upper range boundary in case of the range normalization; it is not used for the norm
normalization.norm_type - normalization type (see cv::NormTypes).dtype - when negative, the output array has the same type as src; otherwise, it has the same
number of channels as src and the depth =CV_MAT_DEPTH(dtype).mask - optional operation mask.
SEE: norm, Mat::convertTo, SparseMat::convertTopublic static void patchNaNs(Mat a)
a - automatically generatedpublic static void patchNaNs(Mat a, double val)
a - automatically generatedval - automatically generatedpublic static void PCABackProject(Mat data, Mat mean, Mat eigenvectors, Mat result)
data - automatically generatedmean - automatically generatedeigenvectors - automatically generatedresult - automatically generatedpublic static void PCACompute(Mat data, Mat mean, Mat eigenvectors)
data - automatically generatedmean - automatically generatedeigenvectors - automatically generatedpublic static void PCACompute(Mat data, Mat mean, Mat eigenvectors, double retainedVariance)
data - automatically generatedmean - automatically generatedeigenvectors - automatically generatedretainedVariance - automatically generatedpublic static void PCACompute(Mat data, Mat mean, Mat eigenvectors, int maxComponents)
data - automatically generatedmean - automatically generatedeigenvectors - automatically generatedmaxComponents - automatically generatedpublic static void PCACompute2(Mat data, Mat mean, Mat eigenvectors, Mat eigenvalues)
data - automatically generatedmean - automatically generatedeigenvectors - automatically generatedeigenvalues - automatically generatedpublic static void PCACompute2(Mat data, Mat mean, Mat eigenvectors, Mat eigenvalues, double retainedVariance)
data - automatically generatedmean - automatically generatedeigenvectors - automatically generatedeigenvalues - automatically generatedretainedVariance - automatically generatedpublic static void PCACompute2(Mat data, Mat mean, Mat eigenvectors, Mat eigenvalues, int maxComponents)
data - automatically generatedmean - automatically generatedeigenvectors - automatically generatedeigenvalues - automatically generatedmaxComponents - automatically generatedpublic static void PCAProject(Mat data, Mat mean, Mat eigenvectors, Mat result)
data - automatically generatedmean - automatically generatedeigenvectors - automatically generatedresult - automatically generatedpublic static void perspectiveTransform(Mat src, Mat dst, Mat m)
src - input two-channel or three-channel floating-point array; each
element is a 2D/3D vector to be transformed.dst - output array of the same size and type as src.m - 3x3 or 4x4 floating-point transformation matrix.
SEE: transform, warpPerspective, getPerspectiveTransform, findHomographypublic static void phase(Mat x, Mat y, Mat angle)
x - input floating-point array of x-coordinates of 2D vectors.y - input array of y-coordinates of 2D vectors; it must have the
same size and the same type as x.angle - output array of vector angles; it has the same size and
same type as x .
degrees, otherwise, they are measured in radians.public static void phase(Mat x, Mat y, Mat angle, boolean angleInDegrees)
x - input floating-point array of x-coordinates of 2D vectors.y - input array of y-coordinates of 2D vectors; it must have the
same size and the same type as x.angle - output array of vector angles; it has the same size and
same type as x .angleInDegrees - when true, the function calculates the angle in
degrees, otherwise, they are measured in radians.public static void polarToCart(Mat magnitude, Mat angle, Mat x, Mat y)
magnitude - input floating-point array of magnitudes of 2D vectors;
it can be an empty matrix (=Mat()), in this case, the function assumes
that all the magnitudes are =1; if it is not empty, it must have the
same size and type as angle.angle - input floating-point array of angles of 2D vectors.x - output array of x-coordinates of 2D vectors; it has the same
size and type as angle.y - output array of y-coordinates of 2D vectors; it has the same
size and type as angle.
degrees, otherwise, they are measured in radians.
SEE: cartToPolar, magnitude, phase, exp, log, pow, sqrtpublic static void polarToCart(Mat magnitude, Mat angle, Mat x, Mat y, boolean angleInDegrees)
magnitude - input floating-point array of magnitudes of 2D vectors;
it can be an empty matrix (=Mat()), in this case, the function assumes
that all the magnitudes are =1; if it is not empty, it must have the
same size and type as angle.angle - input floating-point array of angles of 2D vectors.x - output array of x-coordinates of 2D vectors; it has the same
size and type as angle.y - output array of y-coordinates of 2D vectors; it has the same
size and type as angle.angleInDegrees - when true, the input angles are measured in
degrees, otherwise, they are measured in radians.
SEE: cartToPolar, magnitude, phase, exp, log, pow, sqrtpublic static void pow(Mat src, double power, Mat dst)
Mat mask = src < 0;
pow(src, 1./5, dst);
subtract(Scalar::all(0), dst, dst, mask);
For some values of power, such as integer values, 0.5 and -0.5,
specialized faster algorithms are used.
Special values (NaN, Inf) are not handled.src - input array.power - exponent of power.dst - output array of the same size and type as src.
SEE: sqrt, exp, log, cartToPolar, polarToCartpublic static double PSNR(Mat src1, Mat src2)
src1 - first input array.src2 - second input array of the same size as src1.public static double PSNR(Mat src1, Mat src2, double R)
src1 - first input array.src2 - second input array of the same size as src1.R - the maximum pixel value (255 by default)public static void randn(Mat dst, double mean, double stddev)
dst - output array of random numbers; the array must be pre-allocated and have 1 to 4 channels.mean - mean value (expectation) of the generated random numbers.stddev - standard deviation of the generated random numbers; it can be either a vector (in
which case a diagonal standard deviation matrix is assumed) or a square matrix.
SEE: RNG, randupublic static void randShuffle(Mat dst)
dst - input/output numerical 1D array.
below).
instead.
SEE: RNG, sortpublic static void randShuffle(Mat dst, double iterFactor)
dst - input/output numerical 1D array.iterFactor - scale factor that determines the number of random swap operations (see the details
below).
instead.
SEE: RNG, sortpublic static void randu(Mat dst, double low, double high)
dst - output array of random numbers; the array must be pre-allocated.low - inclusive lower boundary of the generated random numbers.high - exclusive upper boundary of the generated random numbers.
SEE: RNG, randn, theRNGpublic static void reduce(Mat src, Mat dst, int dim, int rtype)
src - input 2D matrix.dst - output vector. Its size and type is defined by dim and dtype parameters.dim - dimension index along which the matrix is reduced. 0 means that the matrix is reduced to
a single row. 1 means that the matrix is reduced to a single column.rtype - reduction operation that could be one of #ReduceTypes
otherwise, its type will be CV_MAKE_TYPE(CV_MAT_DEPTH(dtype), src.channels()).
SEE: repeatpublic static void reduce(Mat src, Mat dst, int dim, int rtype, int dtype)
src - input 2D matrix.dst - output vector. Its size and type is defined by dim and dtype parameters.dim - dimension index along which the matrix is reduced. 0 means that the matrix is reduced to
a single row. 1 means that the matrix is reduced to a single column.rtype - reduction operation that could be one of #ReduceTypesdtype - when negative, the output vector will have the same type as the input matrix,
otherwise, its type will be CV_MAKE_TYPE(CV_MAT_DEPTH(dtype), src.channels()).
SEE: repeatpublic static void repeat(Mat src, int ny, int nx, Mat dst)
src - input array to replicate.ny - Flag to specify how many times the src is repeated along the
vertical axis.nx - Flag to specify how many times the src is repeated along the
horizontal axis.dst - output array of the same type as src.
SEE: cv::reducepublic static void rotate(Mat src, Mat dst, int rotateCode)
src - input array.dst - output array of the same type as src. The size is the same with ROTATE_180,
and the rows and cols are switched for ROTATE_90_CLOCKWISE and ROTATE_90_COUNTERCLOCKWISE.rotateCode - an enum to specify how to rotate the array; see the enum #RotateFlags
SEE: transpose , repeat , completeSymm, flip, RotateFlagspublic static void scaleAdd(Mat src1, double alpha, Mat src2, Mat dst)
Mat A(3, 3, CV_64F);
...
A.row(0) = A.row(1)*2 + A.row(2);
src1 - first input array.alpha - scale factor for the first array.src2 - second input array of the same size and type as src1.dst - output array of the same size and type as src1.
SEE: add, addWeighted, subtract, Mat::dot, Mat::convertTopublic static void setErrorVerbosity(boolean verbose)
public static void setIdentity(Mat mtx)
Mat A = Mat::eye(4, 3, CV_32F)*5;
// A will be set to [[5, 0, 0], [0, 5, 0], [0, 0, 5], [0, 0, 0]]
mtx - matrix to initialize (not necessarily square).
SEE: Mat::zeros, Mat::ones, Mat::setTo, Mat::operator=public static void setIdentity(Mat mtx, Scalar s)
Mat A = Mat::eye(4, 3, CV_32F)*5;
// A will be set to [[5, 0, 0], [0, 5, 0], [0, 0, 5], [0, 0, 0]]
mtx - matrix to initialize (not necessarily square).s - value to assign to diagonal elements.
SEE: Mat::zeros, Mat::ones, Mat::setTo, Mat::operator=public static void setNumThreads(int nthreads)
TBB - User-defined parallel constructions will run with the same threads number, if
another is not specified. If later on user creates his own scheduler, OpenCV will use it.
OpenMP - No special defined behaviour.
Concurrency - If threads == 1, OpenCV will disable threading optimizations and run its
functions sequentially.
GCD - Supports only values <= 0.
C= - No special defined behaviour.nthreads - Number of threads used by OpenCV.
SEE: getNumThreads, getThreadNum
public static void setRNGSeed(int seed)
seed - new state for default random number generator
SEE: RNG, randu, randnpublic static void setUseIPP_NotExact(boolean flag)
public static void setUseIPP(boolean flag)
public static boolean solve(Mat src1, Mat src2, Mat dst)
src1 - input matrix on the left-hand side of the system.src2 - input matrix on the right-hand side of the system.dst - output solution.
SEE: invert, SVD, eigenpublic static boolean solve(Mat src1, Mat src2, Mat dst, int flags)
src1 - input matrix on the left-hand side of the system.src2 - input matrix on the right-hand side of the system.dst - output solution.flags - solution (matrix inversion) method (#DecompTypes)
SEE: invert, SVD, eigenpublic static int solveCubic(Mat coeffs, Mat roots)
coeffs - equation coefficients, an array of 3 or 4 elements.roots - output array of real roots that has 1 or 3 elements.public static double solvePoly(Mat coeffs, Mat roots)
coeffs - array of polynomial coefficients.roots - output (complex) array of roots.public static double solvePoly(Mat coeffs, Mat roots, int maxIters)
coeffs - array of polynomial coefficients.roots - output (complex) array of roots.maxIters - maximum number of iterations the algorithm does.public static void sort(Mat src, Mat dst, int flags)
src - input single-channel array.dst - output array of the same size and type as src.flags - operation flags, a combination of #SortFlags
SEE: sortIdx, randShufflepublic static void sortIdx(Mat src, Mat dst, int flags)
Mat A = Mat::eye(3,3,CV_32F), B;
sortIdx(A, B, SORT_EVERY_ROW + SORT_ASCENDING);
// B will probably contain
// (because of equal elements in A some permutations are possible):
// [[1, 2, 0], [0, 2, 1], [0, 1, 2]]
src - input single-channel array.dst - output integer array of the same size as src.flags - operation flags that could be a combination of cv::SortFlags
SEE: sort, randShufflepublic static void split(Mat m, java.util.List<Mat> mv)
m - input multi-channel array.mv - output vector of arrays; the arrays themselves are reallocated, if needed.public static void sqrt(Mat src, Mat dst)
src - input floating-point array.dst - output array of the same size and type as src.public static void subtract(Mat src1, Mat src2, Mat dst)
src1.channels():
\(\texttt{dst}(I) = \texttt{saturate} ( \texttt{src1}(I) - \texttt{src2} ) \quad \texttt{if mask}(I) \ne0\)
src2.channels():
\(\texttt{dst}(I) = \texttt{saturate} ( \texttt{src1} - \texttt{src2}(I) ) \quad \texttt{if mask}(I) \ne0\)
SubRS:
\(\texttt{dst}(I) = \texttt{saturate} ( \texttt{src2} - \texttt{src1}(I) ) \quad \texttt{if mask}(I) \ne0\)
where I is a multi-dimensional index of array elements. In case of multi-channel arrays, each
channel is processed independently.
dst = src1 - src2;
dst -= src1; // equivalent to subtract(dst, src1, dst);
The input arrays and the output array can all have the same or different depths. For example, you
can subtract to 8-bit unsigned arrays and store the difference in a 16-bit signed array. Depth of
the output array is determined by dtype parameter. In the second and third cases above, as well as
in the first case, when src1.depth() == src2.depth(), dtype can be set to the default -1. In this
case the output array will have the same depth as the input array, be it src1, src2 or both.
Note: Saturation is not applied when the output array has the depth CV_32S. You may even get
result of an incorrect sign in the case of overflow.src1 - first input array or a scalar.src2 - second input array or a scalar.dst - output array of the same size and the same number of channels as the input array.
of the output array to be changed.
SEE: add, addWeighted, scaleAdd, Mat::convertTopublic static void subtract(Mat src1, Mat src2, Mat dst, Mat mask)
src1.channels():
\(\texttt{dst}(I) = \texttt{saturate} ( \texttt{src1}(I) - \texttt{src2} ) \quad \texttt{if mask}(I) \ne0\)
src2.channels():
\(\texttt{dst}(I) = \texttt{saturate} ( \texttt{src1} - \texttt{src2}(I) ) \quad \texttt{if mask}(I) \ne0\)
SubRS:
\(\texttt{dst}(I) = \texttt{saturate} ( \texttt{src2} - \texttt{src1}(I) ) \quad \texttt{if mask}(I) \ne0\)
where I is a multi-dimensional index of array elements. In case of multi-channel arrays, each
channel is processed independently.
dst = src1 - src2;
dst -= src1; // equivalent to subtract(dst, src1, dst);
The input arrays and the output array can all have the same or different depths. For example, you
can subtract to 8-bit unsigned arrays and store the difference in a 16-bit signed array. Depth of
the output array is determined by dtype parameter. In the second and third cases above, as well as
in the first case, when src1.depth() == src2.depth(), dtype can be set to the default -1. In this
case the output array will have the same depth as the input array, be it src1, src2 or both.
Note: Saturation is not applied when the output array has the depth CV_32S. You may even get
result of an incorrect sign in the case of overflow.src1 - first input array or a scalar.src2 - second input array or a scalar.dst - output array of the same size and the same number of channels as the input array.mask - optional operation mask; this is an 8-bit single channel array that specifies elements
of the output array to be changed.
SEE: add, addWeighted, scaleAdd, Mat::convertTopublic static void subtract(Mat src1, Mat src2, Mat dst, Mat mask, int dtype)
src1.channels():
\(\texttt{dst}(I) = \texttt{saturate} ( \texttt{src1}(I) - \texttt{src2} ) \quad \texttt{if mask}(I) \ne0\)
src2.channels():
\(\texttt{dst}(I) = \texttt{saturate} ( \texttt{src1} - \texttt{src2}(I) ) \quad \texttt{if mask}(I) \ne0\)
SubRS:
\(\texttt{dst}(I) = \texttt{saturate} ( \texttt{src2} - \texttt{src1}(I) ) \quad \texttt{if mask}(I) \ne0\)
where I is a multi-dimensional index of array elements. In case of multi-channel arrays, each
channel is processed independently.
dst = src1 - src2;
dst -= src1; // equivalent to subtract(dst, src1, dst);
The input arrays and the output array can all have the same or different depths. For example, you
can subtract to 8-bit unsigned arrays and store the difference in a 16-bit signed array. Depth of
the output array is determined by dtype parameter. In the second and third cases above, as well as
in the first case, when src1.depth() == src2.depth(), dtype can be set to the default -1. In this
case the output array will have the same depth as the input array, be it src1, src2 or both.
Note: Saturation is not applied when the output array has the depth CV_32S. You may even get
result of an incorrect sign in the case of overflow.src1 - first input array or a scalar.src2 - second input array or a scalar.dst - output array of the same size and the same number of channels as the input array.mask - optional operation mask; this is an 8-bit single channel array that specifies elements
of the output array to be changed.dtype - optional depth of the output array
SEE: add, addWeighted, scaleAdd, Mat::convertTopublic static Scalar sumElems(Mat src)
src - input array that must have from 1 to 4 channels.
SEE: countNonZero, mean, meanStdDev, norm, minMaxLoc, reducepublic static void SVBackSubst(Mat w, Mat u, Mat vt, Mat rhs, Mat dst)
w - automatically generatedu - automatically generatedvt - automatically generatedrhs - automatically generateddst - automatically generatedpublic static void SVDecomp(Mat src, Mat w, Mat u, Mat vt)
src - automatically generatedw - automatically generatedu - automatically generatedvt - automatically generatedpublic static void SVDecomp(Mat src, Mat w, Mat u, Mat vt, int flags)
src - automatically generatedw - automatically generatedu - automatically generatedvt - automatically generatedflags - automatically generatedpublic static Scalar trace(Mat mtx)
mtx - input matrix.public static void transform(Mat src, Mat dst, Mat m)
src - input array that must have as many channels (1 to 4) as
m.cols or m.cols-1.dst - output array of the same size and depth as src; it has as
many channels as m.rows.m - transformation 2x2 or 2x3 floating-point matrix.
SEE: perspectiveTransform, getAffineTransform, estimateAffine2D, warpAffine, warpPerspectivepublic static void transpose(Mat src, Mat dst)
src - input array.dst - output array of the same type as src.public static boolean useIPP_NotExact()
public static boolean useIPP()
public static void vconcat(java.util.List<Mat> src, Mat dst)
std::vector<cv::Mat> matrices = { cv::Mat(1, 4, CV_8UC1, cv::Scalar(1)),
cv::Mat(1, 4, CV_8UC1, cv::Scalar(2)),
cv::Mat(1, 4, CV_8UC1, cv::Scalar(3)),};
cv::Mat out;
cv::vconcat( matrices, out );
//out:
//[1, 1, 1, 1;
// 2, 2, 2, 2;
// 3, 3, 3, 3]
src - input array or vector of matrices. all of the matrices must have the same number of cols and the same depthdst - output array. It has the same number of cols and depth as the src, and the sum of rows of the src.
same depth.Generated on 2019-12-20 14:24:32 / OpenCV 4.2.0