🤖 AIによる機械翻訳（非公式） — これは OpenCV 4.13.0 公式リファレンス（英語）を AI (Claude) で自動翻訳したものです。訳に誤りを含む場合があります。正確な情報は 公式英語版（原文） を参照してください。
Package org.opencv.core

クラス Core

  • public class Core
extends java.lang.Object

    • ネストされたクラスの要約

      ネストされたクラス
      Modifier and Type Class Description
      static class  Core.MinMaxLocResult  

    • コンストラクタの要約

      コンストラクタ
      Constructor Description
      Core()  

    • メソッドの要約

      全メソッド 静的メソッド 具象メソッド 非推奨メソッド
      Modifier and Type Method 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 broadcast​(Mat src, Mat shape, Mat dst)
      Broadcast the given Mat to the given shape.
      static void calcCovarMatrix​(Mat samples, Mat covar, Mat mean, int flags)
      覚え書き: use #COVAR_ROWS or #COVAR_COLS flag
      static void calcCovarMatrix​(Mat samples, Mat covar, Mat mean, int flags, int ctype)
      覚え書き: 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 checkHardwareSupport​(int feature)
      Returns true if the specified feature is supported by the host hardware.
      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)
      Deprecated.
      Use Mat::convertTo with CV_16F instead.
      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]; The function do not work with multi-channel arrays.
      static void flip​(Mat src, Mat dst, int flipCode)
      Flips a 2D array around vertical, horizontal, or both axes.
      static void flipND​(Mat src, Mat dst, int axis)
      Flips a n-dimensional at given axis
      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 java.lang.String getCPUFeaturesLine()
      Returns list of CPU features enabled during compilation.
      static long getCPUTickCount()
      Returns the number of CPU ticks.
      static int getDefaultAlgorithmHint()  
      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 int getThreadNum()
      Deprecated.
      Current implementation doesn't corresponding to this documentation.
      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 boolean hasNonZero​(Mat src)
      Checks for the presence of at least one non-zero array element.
      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)
      Replaces NaNs (Not-a-Number values) in a matrix with the specified value.
      static void patchNaNs​(Mat a, double val)
      Replaces NaNs (Not-a-Number values) in a matrix with the specified value.
      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 reduceArgMax​(Mat src, Mat dst, int axis)
      Finds indices of max elements along provided axis 覚え書き: - If input or output array is not continuous, this function will create an internal copy.
      static void reduceArgMax​(Mat src, Mat dst, int axis, boolean lastIndex)
      Finds indices of max elements along provided axis 覚え書き: - If input or output array is not continuous, this function will create an internal copy.
      static void reduceArgMin​(Mat src, Mat dst, int axis)
      Finds indices of min elements along provided axis 覚え書き: - If input or output array is not continuous, this function will create an internal copy.
      static void reduceArgMin​(Mat src, Mat dst, int axis, boolean lastIndex)
      Finds indices of min elements along provided axis 覚え書き: - If input or output array is not continuous, this function will create an internal copy.
      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 subsequent parallel regions.
      static void setRNGSeed​(int seed)
      Sets state of default random number generator.
      static void setUseIPP​(boolean flag)  
      static void setUseIPP_NotExact​(boolean flag)  
      static void setUseOptimized​(boolean onoff)
      Enables or disables the optimized code.
      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 void transposeND​(Mat src, MatOfInt order, Mat dst)
      Transpose for n-dimensional matrices.
      static boolean useIPP()
      proxy for hal::Cholesky
      static boolean useIPP_NotExact()  
      static boolean useOptimized()
      Returns the status of optimized code usage.
      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]

      • クラス java.lang.Object から継承したメソッド

        clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

    • コンストラクタの詳細

      • Core

        public Core()

    • メソッドの詳細

      • cubeRoot

        public static float cubeRoot​(float val)
        Computes the cube root of an argument. The function cubeRoot computes \(\sqrt[3]{\texttt{val}}\). Negative arguments are handled correctly. NaN and Inf are not handled. The accuracy approaches the maximum possible accuracy for single-precision data.
        引数:
        val - 関数の引数。
        戻り値:
        自動生成

      • fastAtan2

        public static float fastAtan2​(float y,
                              float x)
        Calculates the angle of a 2D vector in degrees. The function fastAtan2 calculates the full-range angle of an input 2D vector. The angle is measured in degrees and varies from 0 to 360 degrees. The accuracy is about 0.3 degrees.
        引数:
        x - ベクトルのx座標。
        y - ベクトルのy座標。
        戻り値:
        自動生成

      • useIPP

        public static boolean useIPP()
        proxy for hal::Cholesky
        戻り値:
        自動生成

      • setUseIPP

        public static void setUseIPP​(boolean flag)

      • getIppVersion

        public static java.lang.String getIppVersion()

      • useIPP_NotExact

        public static boolean useIPP_NotExact()

      • setUseIPP_NotExact

        public static void setUseIPP_NotExact​(boolean flag)

      • borderInterpolate

        public static int borderInterpolate​(int p,
                                    int len,
                                    int borderType)
        Computes the source location of an extrapolated pixel. The function computes and returns the coordinate of a donor pixel corresponding to the specified extrapolated pixel when using the specified extrapolation border mode. For example, if you use cv::BORDER_WRAP mode in the horizontal direction, cv::BORDER_REFLECT_101 in the vertical direction and want to compute value of the "virtual" pixel Point(-5, 100) in a floating-point image img, it looks like: 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始まりの座標。多くの場合 <0 または >= len となる
        len - 対応する軸方向の配列の長さ。
        borderType - 境界の種類。#BORDER_TRANSPARENT と #BORDER_ISOLATED を除く #BorderTypes のいずれか。borderType==#BORDER_CONSTANT の場合、この関数は p と len によらず常に -1 を返す。SEE: copyMakeBorder
        戻り値:
        自動生成

      • copyMakeBorder

        public 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. The function copies the source image into the middle of the destination image. The areas to the left, to the right, above and below the copied source image will be filled with extrapolated pixels. This is not what filtering functions based on it do (they extrapolate pixels on-fly), but what other more complex functions, including your own, may do to simplify image boundary handling. The function supports the mode when src is already in the middle of dst . In this case, the function does not copy src itself but simply constructs the border, for example: // 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 ... ... 覚え書き: 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 - 入力画像。
        dst - src と同じ型で、サイズが Size(src.cols+left+right, src.rows+top+bottom) の出力画像。
        top - 上側のピクセル数
        bottom - 下側のピクセル数
        left - 左側のピクセル数
        right - 入力画像の矩形から各方向に何ピクセル外挿するかを指定する引数。例えば top=1, bottom=1, left=1, right=1 は、幅1ピクセルの境界を作成する必要があることを意味する。
        borderType - 境界の種類。詳細は borderInterpolate を参照。
        value - borderType==BORDER_CONSTANT の場合の境界値。SEE: borderInterpolate

      • copyMakeBorder

        public static void copyMakeBorder​(Mat src,
                                  Mat dst,
                                  int top,
                                  int bottom,
                                  int left,
                                  int right,
                                  int borderType)
        Forms a border around an image. The function copies the source image into the middle of the destination image. The areas to the left, to the right, above and below the copied source image will be filled with extrapolated pixels. This is not what filtering functions based on it do (they extrapolate pixels on-fly), but what other more complex functions, including your own, may do to simplify image boundary handling. The function supports the mode when src is already in the middle of dst . In this case, the function does not copy src itself but simply constructs the border, for example: // 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 ... ... 覚え書き: 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 - 入力画像。
        dst - src と同じ型で、サイズが Size(src.cols+left+right, src.rows+top+bottom) の出力画像。
        top - 上側のピクセル数
        bottom - 下側のピクセル数
        left - 左側のピクセル数
        right - 入力画像の矩形から各方向に何ピクセル外挿するかを指定する引数。例えば top=1, bottom=1, left=1, right=1 は、幅1ピクセルの境界を作成する必要があることを意味する。
        borderType - 境界の種類。詳細は borderInterpolate を参照。SEE: borderInterpolate

      • add

        public 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. The function add calculates:
        • 2つの入力配列が同じサイズかつ同じチャンネル数を持つ場合の、2配列の和: \(\texttt{dst}(I) = \texttt{saturate} ( \texttt{src1}(I) + \texttt{src2}(I)) \quad \texttt{if mask}(I) \ne0\)
        • src2 が Scalar から構築されているか、src1.channels() と同じ要素数を持つ場合の、配列とスカラーの和: \(\texttt{dst}(I) = \texttt{saturate} ( \texttt{src1}(I) + \texttt{src2} ) \quad \texttt{if mask}(I) \ne0\)
        • src1 が Scalar から構築されているか、src2.channels() と同じ要素数を持つ場合の、スカラーと配列の和: \(\texttt{dst}(I) = \texttt{saturate} ( \texttt{src1} + \texttt{src2}(I) ) \quad \texttt{if mask}(I) \ne0\) ここで I は配列要素の多次元インデックスである。マルチチャンネル配列の場合、各チャンネルは独立に処理される。
        The first function in the list above can be replaced with matrix expressions: 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. 覚え書き: 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. 覚え書き: (Python) Be careful to difference behaviour between src1/src2 are single number and they are tuple/array. add(src,X) means add(src,(X,X,X,X)). add(src,(X,)) means add(src,(X,0,0,0)).
        引数:
        src1 - 第1の入力配列またはスカラー。
        src2 - 第2の入力配列またはスカラー。
        dst - 入力配列と同じサイズおよびチャンネル数を持つ出力配列。ビット深度は dtype または src1/src2 によって決まる。
        mask - 省略可能な演算マスク。8ビットシングルチャンネル配列で、変更する出力配列の要素を指定する。
        dtype - 省略可能な出力配列のビット深度（後述の説明を参照）。SEE: subtract, addWeighted, scaleAdd, Mat::convertTo

      • add

        public 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. The function add calculates:
        • 2つの入力配列が同じサイズかつ同じチャンネル数を持つ場合の、2配列の和: \(\texttt{dst}(I) = \texttt{saturate} ( \texttt{src1}(I) + \texttt{src2}(I)) \quad \texttt{if mask}(I) \ne0\)
        • src2 が Scalar から構築されているか、src1.channels() と同じ要素数を持つ場合の、配列とスカラーの和: \(\texttt{dst}(I) = \texttt{saturate} ( \texttt{src1}(I) + \texttt{src2} ) \quad \texttt{if mask}(I) \ne0\)
        • src1 が Scalar から構築されているか、src2.channels() と同じ要素数を持つ場合の、スカラーと配列の和: \(\texttt{dst}(I) = \texttt{saturate} ( \texttt{src1} + \texttt{src2}(I) ) \quad \texttt{if mask}(I) \ne0\) ここで I は配列要素の多次元インデックスである。マルチチャンネル配列の場合、各チャンネルは独立に処理される。
        The first function in the list above can be replaced with matrix expressions: 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. 覚え書き: 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. 覚え書き: (Python) Be careful to difference behaviour between src1/src2 are single number and they are tuple/array. add(src,X) means add(src,(X,X,X,X)). add(src,(X,)) means add(src,(X,0,0,0)).
        引数:
        src1 - 第1の入力配列またはスカラー。
        src2 - 第2の入力配列またはスカラー。
        dst - 入力配列と同じサイズおよびチャンネル数を持つ出力配列。ビット深度は dtype または src1/src2 によって決まる。
        mask - 省略可能な演算マスク。8ビットシングルチャンネル配列で、変更する出力配列の要素を指定する。SEE: subtract, addWeighted, scaleAdd, Mat::convertTo

      • add

        public static void add​(Mat src1,
                       Mat src2,
                       Mat dst)
        Calculates the per-element sum of two arrays or an array and a scalar. The function add calculates:
        • 2つの入力配列が同じサイズかつ同じチャンネル数を持つ場合の、2配列の和: \(\texttt{dst}(I) = \texttt{saturate} ( \texttt{src1}(I) + \texttt{src2}(I)) \quad \texttt{if mask}(I) \ne0\)
        • src2 が Scalar から構築されているか、src1.channels() と同じ要素数を持つ場合の、配列とスカラーの和: \(\texttt{dst}(I) = \texttt{saturate} ( \texttt{src1}(I) + \texttt{src2} ) \quad \texttt{if mask}(I) \ne0\)
        • src1 が Scalar から構築されているか、src2.channels() と同じ要素数を持つ場合の、スカラーと配列の和: \(\texttt{dst}(I) = \texttt{saturate} ( \texttt{src1} + \texttt{src2}(I) ) \quad \texttt{if mask}(I) \ne0\) ここで I は配列要素の多次元インデックスである。マルチチャンネル配列の場合、各チャンネルは独立に処理される。
        The first function in the list above can be replaced with matrix expressions: 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. 覚え書き: 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. 覚え書き: (Python) Be careful to difference behaviour between src1/src2 are single number and they are tuple/array. add(src,X) means add(src,(X,X,X,X)). add(src,(X,)) means add(src,(X,0,0,0)).
        引数:
        src1 - 第1の入力配列またはスカラー。
        src2 - 第2の入力配列またはスカラー。
        dst - 入力配列と同じサイズおよびチャンネル数を持つ出力配列。ビット深度は dtype または src1/src2 によって決まる。変更する出力配列の要素。SEE: subtract, addWeighted, scaleAdd, Mat::convertTo

      • subtract

        public 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. The function subtract calculates:
        • 2つの入力配列が同じサイズかつ同じチャンネル数を持つ場合の、2配列の差: \(\texttt{dst}(I) = \texttt{saturate} ( \texttt{src1}(I) - \texttt{src2}(I)) \quad \texttt{if mask}(I) \ne0\)
        • src2 が Scalar から構築されているか、src1.channels() と同じ要素数を持つ場合の、配列とスカラーの差: \(\texttt{dst}(I) = \texttt{saturate} ( \texttt{src1}(I) - \texttt{src2} ) \quad \texttt{if mask}(I) \ne0\)
        • src1 が Scalar から構築されているか、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\) ここで I は配列要素の多次元インデックスである。マルチチャンネル配列の場合、各チャンネルは独立に処理される。
        The first function in the list above can be replaced with matrix expressions: 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. 覚え書き: 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. 覚え書き: (Python) Be careful to difference behaviour between src1/src2 are single number and they are tuple/array. subtract(src,X) means subtract(src,(X,X,X,X)). subtract(src,(X,)) means subtract(src,(X,0,0,0)).
        引数:
        src1 - 第1の入力配列またはスカラー。
        src2 - 第2の入力配列またはスカラー。
        dst - 入力配列と同じサイズおよび同じチャンネル数の出力配列。
        mask - 省略可能な演算マスク。これは8ビットシングルチャンネル配列で、変更する出力配列の要素を指定する。
        dtype - 省略可能な出力配列のビット深度。SEE: add, addWeighted, scaleAdd, Mat::convertTo

      • subtract

        public static void subtract​(Mat src1,
                            Mat src2,
                            Mat dst,
                            Mat mask)
        Calculates the per-element difference between two arrays or array and a scalar. The function subtract calculates:
        • 2つの入力配列が同じサイズかつ同じチャンネル数を持つ場合の、2配列の差: \(\texttt{dst}(I) = \texttt{saturate} ( \texttt{src1}(I) - \texttt{src2}(I)) \quad \texttt{if mask}(I) \ne0\)
        • src2 が Scalar から構築されているか、src1.channels() と同じ要素数を持つ場合の、配列とスカラーの差: \(\texttt{dst}(I) = \texttt{saturate} ( \texttt{src1}(I) - \texttt{src2} ) \quad \texttt{if mask}(I) \ne0\)
        • src1 が Scalar から構築されているか、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\) ここで I は配列要素の多次元インデックスである。マルチチャンネル配列の場合、各チャンネルは独立に処理される。
        The first function in the list above can be replaced with matrix expressions: 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. 覚え書き: 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. 覚え書き: (Python) Be careful to difference behaviour between src1/src2 are single number and they are tuple/array. subtract(src,X) means subtract(src,(X,X,X,X)). subtract(src,(X,)) means subtract(src,(X,0,0,0)).
        引数:
        src1 - 第1の入力配列またはスカラー。
        src2 - 第2の入力配列またはスカラー。
        dst - 入力配列と同じサイズおよび同じチャンネル数の出力配列。
        mask - 省略可能な演算マスク。これは8ビットシングルチャンネル配列で、変更する出力配列の要素を指定する。SEE: add, addWeighted, scaleAdd, Mat::convertTo

      • subtract

        public static void subtract​(Mat src1,
                            Mat src2,
                            Mat dst)
        Calculates the per-element difference between two arrays or array and a scalar. The function subtract calculates:
        • 2つの入力配列が同じサイズかつ同じチャンネル数を持つ場合の、2配列の差: \(\texttt{dst}(I) = \texttt{saturate} ( \texttt{src1}(I) - \texttt{src2}(I)) \quad \texttt{if mask}(I) \ne0\)
        • src2 が Scalar から構築されているか、src1.channels() と同じ要素数を持つ場合の、配列とスカラーの差: \(\texttt{dst}(I) = \texttt{saturate} ( \texttt{src1}(I) - \texttt{src2} ) \quad \texttt{if mask}(I) \ne0\)
        • src1 が Scalar から構築されているか、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\) ここで I は配列要素の多次元インデックスである。マルチチャンネル配列の場合、各チャンネルは独立に処理される。
        The first function in the list above can be replaced with matrix expressions: 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. 覚え書き: 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. 覚え書き: (Python) Be careful to difference behaviour between src1/src2 are single number and they are tuple/array. subtract(src,X) means subtract(src,(X,X,X,X)). subtract(src,(X,)) means subtract(src,(X,0,0,0)).
        引数:
        src1 - 第1の入力配列またはスカラー。
        src2 - 第2の入力配列またはスカラー。
        dst - 入力配列と同じサイズおよび同じチャンネル数の出力配列。変更する出力配列の要素。SEE: add, addWeighted, scaleAdd, Mat::convertTo

      • multiply

        public static void multiply​(Mat src1,
                            Mat src2,
                            Mat dst,
                            double scale,
                            int dtype)
        Calculates the per-element scaled product of two arrays. The function multiply calculates the per-element product of two arrays: \(\texttt{dst} (I)= \texttt{saturate} ( \texttt{scale} \cdot \texttt{src1} (I) \cdot \texttt{src2} (I))\) There is also a REF: MatrixExpressions -friendly variant of the first function. See Mat::mul . For a not-per-element matrix product, see gemm . 覚え書き: 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. 覚え書き: (Python) Be careful to difference behaviour between src1/src2 are single number and they are tuple/array. multiply(src,X) means multiply(src,(X,X,X,X)). multiply(src,(X,)) means multiply(src,(X,0,0,0)).
        引数:
        src1 - 第1の入力配列。
        src2 - src1 と同じサイズおよび同じ型の第2の入力配列。
        dst - src1 と同じサイズおよび型の出力配列。
        scale - 省略可能なスケール係数。
        dtype - 省略可能な出力配列のビット深度。SEE: add, subtract, divide, scaleAdd, addWeighted, accumulate, accumulateProduct, accumulateSquare, Mat::convertTo

      • multiply

        public static void multiply​(Mat src1,
                            Mat src2,
                            Mat dst,
                            double scale)
        Calculates the per-element scaled product of two arrays. The function multiply calculates the per-element product of two arrays: \(\texttt{dst} (I)= \texttt{saturate} ( \texttt{scale} \cdot \texttt{src1} (I) \cdot \texttt{src2} (I))\) There is also a REF: MatrixExpressions -friendly variant of the first function. See Mat::mul . For a not-per-element matrix product, see gemm . 覚え書き: 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. 覚え書き: (Python) Be careful to difference behaviour between src1/src2 are single number and they are tuple/array. multiply(src,X) means multiply(src,(X,X,X,X)). multiply(src,(X,)) means multiply(src,(X,0,0,0)).
        引数:
        src1 - 第1の入力配列。
        src2 - src1 と同じサイズおよび同じ型の第2の入力配列。
        dst - src1 と同じサイズおよび型の出力配列。
        scale - 省略可能なスケール係数。 SEE: add, subtract, divide, scaleAdd, addWeighted, accumulate, accumulateProduct, accumulateSquare, Mat::convertTo

      • multiply

        public static void multiply​(Mat src1,
                            Mat src2,
                            Mat dst)
        Calculates the per-element scaled product of two arrays. The function multiply calculates the per-element product of two arrays: \(\texttt{dst} (I)= \texttt{saturate} ( \texttt{scale} \cdot \texttt{src1} (I) \cdot \texttt{src2} (I))\) There is also a REF: MatrixExpressions -friendly variant of the first function. See Mat::mul . For a not-per-element matrix product, see gemm . 覚え書き: 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. 覚え書き: (Python) Be careful to difference behaviour between src1/src2 are single number and they are tuple/array. multiply(src,X) means multiply(src,(X,X,X,X)). multiply(src,(X,)) means multiply(src,(X,0,0,0)).
        引数:
        src1 - 第1の入力配列。
        src2 - src1 と同じサイズおよび同じ型の第2の入力配列。
        dst - src1 と同じサイズ・型の出力配列。 SEE: add, subtract, divide, scaleAdd, addWeighted, accumulate, accumulateProduct, accumulateSquare, Mat::convertTo

      • divide

        public 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. The function cv::divide divides one array by another: \(\texttt{dst(I) = saturate(src1(I)*scale/src2(I))}\) or a scalar by an array when there is no src1 : \(\texttt{dst(I) = saturate(scale/src2(I))}\) Different channels of multi-channel arrays are processed independently. For integer types when src2(I) is zero, dst(I) will also be zero. 覚え書き: In case of floating point data there is no special defined behavior for zero src2(I) values. Regular floating-point division is used. Expect correct IEEE-754 behaviour for floating-point data (with NaN, Inf result values). 覚え書き: 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. 覚え書き: (Python) Be careful to difference behaviour between src1/src2 are single number and they are tuple/array. divide(src,X) means divide(src,(X,X,X,X)). divide(src,(X,)) means divide(src,(X,0,0,0)).
        引数:
        src1 - 第1の入力配列。
        src2 - src1 と同じサイズ・型の2番目の入力配列。
        scale - スカラー係数。
        dst - src2 と同じサイズ・型の出力配列。
        dtype - 出力配列の省略可能なビット深度。-1 の場合、dst のビット深度は src2.depth() となる。ただし配列同士の除算の場合、-1 を渡せるのは src1.depth()==src2.depth() のときに限られる。 SEE: multiply, add, subtract

      • divide

        public static void divide​(Mat src1,
                          Mat src2,
                          Mat dst,
                          double scale)
        Performs per-element division of two arrays or a scalar by an array. The function cv::divide divides one array by another: \(\texttt{dst(I) = saturate(src1(I)*scale/src2(I))}\) or a scalar by an array when there is no src1 : \(\texttt{dst(I) = saturate(scale/src2(I))}\) Different channels of multi-channel arrays are processed independently. For integer types when src2(I) is zero, dst(I) will also be zero. 覚え書き: In case of floating point data there is no special defined behavior for zero src2(I) values. Regular floating-point division is used. Expect correct IEEE-754 behaviour for floating-point data (with NaN, Inf result values). 覚え書き: 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. 覚え書き: (Python) Be careful to difference behaviour between src1/src2 are single number and they are tuple/array. divide(src,X) means divide(src,(X,X,X,X)). divide(src,(X,)) means divide(src,(X,0,0,0)).
        引数:
        src1 - 第1の入力配列。
        src2 - src1 と同じサイズ・型の2番目の入力配列。
        scale - スカラー係数。
        dst - src2 と同じサイズ・型の出力配列。配列同士の除算の場合、-1 を渡せるのは src1.depth()==src2.depth() のときに限られる。 SEE: multiply, add, subtract

      • divide

        public static void divide​(Mat src1,
                          Mat src2,
                          Mat dst)
        Performs per-element division of two arrays or a scalar by an array. The function cv::divide divides one array by another: \(\texttt{dst(I) = saturate(src1(I)*scale/src2(I))}\) or a scalar by an array when there is no src1 : \(\texttt{dst(I) = saturate(scale/src2(I))}\) Different channels of multi-channel arrays are processed independently. For integer types when src2(I) is zero, dst(I) will also be zero. 覚え書き: In case of floating point data there is no special defined behavior for zero src2(I) values. Regular floating-point division is used. Expect correct IEEE-754 behaviour for floating-point data (with NaN, Inf result values). 覚え書き: 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. 覚え書き: (Python) Be careful to difference behaviour between src1/src2 are single number and they are tuple/array. divide(src,X) means divide(src,(X,X,X,X)). divide(src,(X,)) means divide(src,(X,0,0,0)).
        引数:
        src1 - 第1の入力配列。
        src2 - src1 と同じサイズ・型の2番目の入力配列。
        dst - src2 と同じサイズ・型の出力配列。配列同士の除算の場合、-1 を渡せるのは src1.depth()==src2.depth() のときに限られる。 SEE: multiply, add, subtract

      • divide

        public static void divide​(double scale,
                          Mat src2,
                          Mat dst,
                          int dtype)

      • divide

        public static void divide​(double scale,
                          Mat src2,
                          Mat dst)

      • scaleAdd

        public static void scaleAdd​(Mat src1,
                            double alpha,
                            Mat src2,
                            Mat dst)
        Calculates the sum of a scaled array and another array. The function scaleAdd is one of the classical primitive linear algebra operations, known as DAXPY or SAXPY in [BLAS](http://en.wikipedia.org/wiki/Basic_Linear_Algebra_Subprograms). It calculates the sum of a scaled array and another array: \(\texttt{dst} (I)= \texttt{scale} \cdot \texttt{src1} (I) + \texttt{src2} (I)\) The function can also be emulated with a matrix expression, for example: Mat A(3, 3, CV_64F); ... A.row(0) = A.row(1)*2 + A.row(2);
        引数:
        src1 - 第1の入力配列。
        alpha - 1番目の配列に対するスケール係数。
        src2 - src1 と同じサイズ・型の2番目の入力配列。
        dst - src1 と同じサイズ・型の出力配列。 SEE: add, addWeighted, subtract, Mat::dot, Mat::convertTo

      • addWeighted

        public static void addWeighted​(Mat src1,
                               double alpha,
                               Mat src2,
                               double beta,
                               double gamma,
                               Mat dst,
                               int dtype)
        Calculates the weighted sum of two arrays. The function addWeighted calculates the weighted sum of two arrays as follows: \(\texttt{dst} (I)= \texttt{saturate} ( \texttt{src1} (I)* \texttt{alpha} + \texttt{src2} (I)* \texttt{beta} + \texttt{gamma} )\) where I is a multi-dimensional index of array elements. In case of multi-channel arrays, each channel is processed independently. The function can be replaced with a matrix expression: dst = src1*alpha + src2*beta + gamma; 覚え書き: 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 - 第1の入力配列。
        alpha - 1番目の配列要素に対する重み。
        src2 - src1 と同じサイズ・チャンネル数の2番目の入力配列。
        beta - 2番目の配列要素に対する重み。
        gamma - 各和に加算されるスカラー値。
        dst - 入力配列と同じサイズ・チャンネル数を持つ出力配列。
        dtype - 出力配列の省略可能なビット深度。両方の入力配列が同じビット深度を持つ場合、dtype は -1 に設定でき、これは src1.depth() と同等になる。 SEE: add, subtract, scaleAdd, Mat::convertTo

      • addWeighted

        public static void addWeighted​(Mat src1,
                               double alpha,
                               Mat src2,
                               double beta,
                               double gamma,
                               Mat dst)
        Calculates the weighted sum of two arrays. The function addWeighted calculates the weighted sum of two arrays as follows: \(\texttt{dst} (I)= \texttt{saturate} ( \texttt{src1} (I)* \texttt{alpha} + \texttt{src2} (I)* \texttt{beta} + \texttt{gamma} )\) where I is a multi-dimensional index of array elements. In case of multi-channel arrays, each channel is processed independently. The function can be replaced with a matrix expression: dst = src1*alpha + src2*beta + gamma; 覚え書き: 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 - 第1の入力配列。
        alpha - 1番目の配列要素に対する重み。
        src2 - src1 と同じサイズ・チャンネル数の2番目の入力配列。
        beta - 2番目の配列要素に対する重み。
        gamma - 各和に加算されるスカラー値。
        dst - 入力配列と同じサイズ・チャンネル数を持つ出力配列。-1 に設定でき、これは src1.depth() と同等になる。 SEE: add, subtract, scaleAdd, Mat::convertTo

      • convertScaleAbs

        public static void convertScaleAbs​(Mat src,
                                   Mat dst,
                                   double alpha,
                                   double beta)
        Scales, calculates absolute values, and converts the result to 8-bit. On each element of the input array, the function convertScaleAbs performs three operations sequentially: scaling, taking an absolute value, conversion to an unsigned 8-bit type: \(\texttt{dst} (I)= \texttt{saturate\_cast<uchar>} (| \texttt{src} (I)* \texttt{alpha} + \texttt{beta} |)\) In case of multi-channel arrays, the function processes each channel independently. When the output is not 8-bit, the operation can be emulated by calling the Mat::convertTo method (or by using matrix expressions) and then by calculating an absolute value of the result. For example: 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 - 入力配列。
        dst - 出力配列。
        alpha - 省略可能なスケール係数。
        beta - スケールした値に加算される省略可能なデルタ。 SEE: Mat::convertTo, cv::abs(const Mat&)

      • convertScaleAbs

        public static void convertScaleAbs​(Mat src,
                                   Mat dst,
                                   double alpha)
        Scales, calculates absolute values, and converts the result to 8-bit. On each element of the input array, the function convertScaleAbs performs three operations sequentially: scaling, taking an absolute value, conversion to an unsigned 8-bit type: \(\texttt{dst} (I)= \texttt{saturate\_cast<uchar>} (| \texttt{src} (I)* \texttt{alpha} + \texttt{beta} |)\) In case of multi-channel arrays, the function processes each channel independently. When the output is not 8-bit, the operation can be emulated by calling the Mat::convertTo method (or by using matrix expressions) and then by calculating an absolute value of the result. For example: 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 - 入力配列。
        dst - 出力配列。
        alpha - 省略可能なスケール係数。 SEE: Mat::convertTo, cv::abs(const Mat&)

      • convertScaleAbs

        public static void convertScaleAbs​(Mat src,
                                   Mat dst)
        Scales, calculates absolute values, and converts the result to 8-bit. On each element of the input array, the function convertScaleAbs performs three operations sequentially: scaling, taking an absolute value, conversion to an unsigned 8-bit type: \(\texttt{dst} (I)= \texttt{saturate\_cast<uchar>} (| \texttt{src} (I)* \texttt{alpha} + \texttt{beta} |)\) In case of multi-channel arrays, the function processes each channel independently. When the output is not 8-bit, the operation can be emulated by calling the Mat::convertTo method (or by using matrix expressions) and then by calculating an absolute value of the result. For example: 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 - 入力配列。
        dst - 出力配列。 SEE: Mat::convertTo, cv::abs(const Mat&)

      • convertFp16

        @Deprecated
public static void convertFp16​(Mat src,
                               Mat dst)
        Deprecated.
        Use Mat::convertTo with CV_16F instead.
        Converts an array to half precision floating number. This function converts FP32 (single precision floating point) from/to FP16 (half precision floating point). CV_16S format is used to represent FP16 data. There are two use modes (src -> dst): CV_32F -> CV_16S and CV_16S -> CV_32F. The input array has to have type of CV_32F or CV_16S to represent the bit depth. If the input array is neither of them, the function will raise an error. The format of half precision floating point is defined in IEEE 754-2008.
        引数:
        src - 入力配列。
        dst - 出力配列。

      • LUT

        public static void LUT​(Mat src,
                       Mat lut,
                       Mat dst)
        Performs a look-up table transform of an array. The function LUT fills the output array with values from the look-up table. Indices of the entries are taken from the input array. That is, the function processes each element of src as follows: \(\texttt{dst} (I) \leftarrow \texttt{lut(src(I) + d)}\) where \(d = \forkthree{0}{if \(\texttt{src}\) has depth \(\texttt{CV_8U}\) or \(\texttt{CV_16U}\)}{128}{if \(\texttt{src}\) has depth \(\texttt{CV_8S}\)}{32768}{if \(\texttt{src}\) has depth \(\texttt{CV_16S}\)}\)
        引数:
        src - 8ビットまたは16ビット整数要素の入力配列。
        lut - 256要素のルックアップテーブル（src のビット深度が CV_8U または CV_8S の場合）、または65536要素のルックアップテーブル（src のビット深度が CV_16U または CV_16S の場合）。マルチチャンネル入力配列の場合、テーブルはシングルチャンネル（この場合すべてのチャンネルに同じテーブルが使われる）であるか、入力配列と同じチャンネル数を持つ必要がある。
        dst - src と同じサイズ・チャンネル数で、lut と同じビット深度を持つ出力配列。 SEE: convertScaleAbs, Mat::convertTo

      • sumElems

        public static Scalar sumElems​(Mat src)
        Calculates the sum of array elements. The function cv::sum calculates and returns the sum of array elements, independently for each channel.
        引数:
        src - 1から4チャンネルを持つ必要がある入力配列。 SEE: countNonZero, mean, meanStdDev, norm, minMaxLoc, reduce
        戻り値:
        自動生成

      • hasNonZero

        public static boolean hasNonZero​(Mat src)
        Checks for the presence of at least one non-zero array element. The function returns whether there are non-zero elements in src The function do not work with multi-channel arrays. If you need to check non-zero array elements across all the channels, use Mat::reshape first to reinterpret the array as single-channel. Or you may extract the particular channel using either extractImageCOI, or mixChannels, or split. 覚え書き:
        • 非ゼロの配列要素の位置が重要な場合は、REF: findNonZero が役立つ。
        • 非ゼロの配列要素の個数が重要な場合は、REF: countNonZero が役立つ。
        引数:
        src - シングルチャンネル配列。 SEE: mean, meanStdDev, norm, minMaxLoc, calcCovarMatrix SEE: findNonZero, countNonZero
        戻り値:
        自動生成

      • countNonZero

        public static int countNonZero​(Mat src)
        Counts non-zero array elements. The function returns the number of non-zero elements in src : \(\sum _{I: \; \texttt{src} (I) \ne0 } 1\) The function do not work with multi-channel arrays. If you need to count non-zero array elements across all the channels, use Mat::reshape first to reinterpret the array as single-channel. Or you may extract the particular channel using either extractImageCOI, or mixChannels, or split. 覚え書き:
        • 非ゼロ要素が存在するかどうかだけが重要な場合は、REF: hasNonZero が役立つ。
        • 非ゼロの配列要素の位置が重要な場合は、REF: findNonZero が役立つ。
        引数:
        src - シングルチャンネル配列。 SEE: mean, meanStdDev, norm, minMaxLoc, calcCovarMatrix SEE: findNonZero, hasNonZero
        戻り値:
        自動生成

      • findNonZero

        public 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]; The function do not work with multi-channel arrays. If you need to find non-zero elements across all the channels, use Mat::reshape first to reinterpret the array as single-channel. Or you may extract the particular channel using either extractImageCOI, or mixChannels, or split. 覚え書き:
        • 非ゼロの配列要素の個数だけが重要な場合は、REF: countNonZero が役立つ。
        • 非ゼロ要素が存在するかどうかだけが重要な場合は、REF: hasNonZero が役立つ。
        引数:
        src - シングルチャンネル配列
        idx - 出力配列。cv::Mat または std::vector<Point> 型で、入力中の非ゼロインデックスに対応する。 SEE: countNonZero, hasNonZero

      • mean

        public static Scalar mean​(Mat src,
                          Mat mask)
        Calculates an average (mean) of array elements. The function cv::mean calculates the mean value M of array elements, independently for each channel, and return it: \(\begin{array}{l} N = \sum _{I: \; \texttt{mask} (I) \ne 0} 1 \\ M_c = \left ( \sum _{I: \; \texttt{mask} (I) \ne 0}{ \texttt{mtx} (I)_c} \right )/N \end{array}\) When all the mask elements are 0's, the function returns Scalar::all(0)
        引数:
        src - 結果を Scalar_ に格納できるよう、1から4チャンネルを持つべき入力配列。
        mask - 省略可能な操作マスク。 SEE: countNonZero, meanStdDev, norm, minMaxLoc
        戻り値:
        自動生成

      • mean

        public static Scalar mean​(Mat src)
        Calculates an average (mean) of array elements. The function cv::mean calculates the mean value M of array elements, independently for each channel, and return it: \(\begin{array}{l} N = \sum _{I: \; \texttt{mask} (I) \ne 0} 1 \\ M_c = \left ( \sum _{I: \; \texttt{mask} (I) \ne 0}{ \texttt{mtx} (I)_c} \right )/N \end{array}\) When all the mask elements are 0's, the function returns Scalar::all(0)
        引数:
        src - 結果を Scalar_ に格納できるよう、1から4チャンネルを持つべき入力配列。 SEE: countNonZero, meanStdDev, norm, minMaxLoc
        戻り値:
        自動生成

      • meanStdDev

        public static void meanStdDev​(Mat src,
                              MatOfDouble mean,
                              MatOfDouble stddev,
                              Mat mask)
        Calculates a mean and standard deviation of array elements. The function cv::meanStdDev calculates the mean and the standard deviation M of array elements independently for each channel and returns it via the output parameters: \(\begin{array}{l} N = \sum _{I, \texttt{mask} (I) \ne 0} 1 \\ \texttt{mean} _c = \frac{\sum_{ I: \; \texttt{mask}(I) \ne 0} \texttt{src} (I)_c}{N} \\ \texttt{stddev} _c = \sqrt{\frac{\sum_{ I: \; \texttt{mask}(I) \ne 0} \left ( \texttt{src} (I)_c - \texttt{mean} _c \right )^2}{N}} \end{array}\) When all the mask elements are 0's, the function returns mean=stddev=Scalar::all(0). 覚え書き: The calculated standard deviation is only the diagonal of the complete normalized covariance matrix. If the full matrix is needed, you can reshape the multi-channel array M x N to the single-channel array M\*N x mtx.channels() (only possible when the matrix is continuous) and then pass the matrix to calcCovarMatrix .
        引数:
        src - 結果を Scalar_ に格納できるよう、1から4チャンネルを持つべき入力配列。
        mean - 出力パラメータ: 算出された平均値。
        stddev - 出力パラメータ: 算出された標準偏差。
        mask - 省略可能な操作マスク。 SEE: countNonZero, mean, norm, minMaxLoc, calcCovarMatrix

      • meanStdDev

        public static void meanStdDev​(Mat src,
                              MatOfDouble mean,
                              MatOfDouble stddev)
        Calculates a mean and standard deviation of array elements. The function cv::meanStdDev calculates the mean and the standard deviation M of array elements independently for each channel and returns it via the output parameters: \(\begin{array}{l} N = \sum _{I, \texttt{mask} (I) \ne 0} 1 \\ \texttt{mean} _c = \frac{\sum_{ I: \; \texttt{mask}(I) \ne 0} \texttt{src} (I)_c}{N} \\ \texttt{stddev} _c = \sqrt{\frac{\sum_{ I: \; \texttt{mask}(I) \ne 0} \left ( \texttt{src} (I)_c - \texttt{mean} _c \right )^2}{N}} \end{array}\) When all the mask elements are 0's, the function returns mean=stddev=Scalar::all(0). 覚え書き: The calculated standard deviation is only the diagonal of the complete normalized covariance matrix. If the full matrix is needed, you can reshape the multi-channel array M x N to the single-channel array M\*N x mtx.channels() (only possible when the matrix is continuous) and then pass the matrix to calcCovarMatrix .
        引数:
        src - 結果を Scalar_ に格納できるよう、1から4チャンネルを持つべき入力配列。
        mean - 出力パラメータ: 算出された平均値。
        stddev - 出力パラメータ: 算出された標準偏差。 SEE: countNonZero, mean, norm, minMaxLoc, calcCovarMatrix

      • norm

        public static double norm​(Mat src1,
                          int normType,
                          Mat mask)
        Calculates the absolute norm of an array. This version of #norm calculates the absolute norm of src1. The type of norm to calculate is specified using #NormTypes. As example for one array consider the function \(r(x)= \begin{pmatrix} x \\ 1-x \end{pmatrix}, x \in [-1;1]\). The \( L_{1}, L_{2} \) and \( L_{\infty} \) norm for the sample value \(r(-1) = \begin{pmatrix} -1 \\ 2 \end{pmatrix}\) is calculated as follows \(align*} \| r(-1) \|_{L_1} &= |-1| + |2| = 3 \\ \| r(-1) \|_{L_2} &= \sqrt{(-1)^{2} + (2)^{2}} = \sqrt{5} \\ \| r(-1) \|_{L_\infty} &= \max(|-1|,|2|) = 2 \) and for \(r(0.5) = \begin{pmatrix} 0.5 \\ 0.5 \end{pmatrix}\) the calculation is \(align*} \| r(0.5) \|_{L_1} &= |0.5| + |0.5| = 1 \\ \| r(0.5) \|_{L_2} &= \sqrt{(0.5)^{2} + (0.5)^{2}} = \sqrt{0.5} \\ \| r(0.5) \|_{L_\infty} &= \max(|0.5|,|0.5|) = 0.5. \) The following graphic shows all values for the three norm functions \(\| r(x) \|_{L_1}, \| r(x) \|_{L_2}\) and \(\| r(x) \|_{L_\infty}\). It is notable that the \( L_{1} \) norm forms the upper and the \( L_{\infty} \) norm forms the lower border for the example function \( r(x) \). ![Graphs for the different norm functions from the above example](pics/NormTypes_OneArray_1-2-INF.png) When the mask parameter is specified and it is not empty, the norm is If normType is not specified, #NORM_L2 is used. calculated only over the region specified by the mask. Multi-channel input arrays are treated as single-channel arrays, that is, the results for all channels are combined. Hamming norms can only be calculated with CV_8U depth arrays.
        引数:
        src1 - 第1の入力配列。
        normType - ノルムの種類（#NormTypes を参照）。
        mask - 省略可能な操作マスク。src1 と同じサイズで CV_8UC1 型である必要がある。
        戻り値:
        自動生成

      • norm

        public static double norm​(Mat src1,
                          int normType)
        Calculates the absolute norm of an array. This version of #norm calculates the absolute norm of src1. The type of norm to calculate is specified using #NormTypes. As example for one array consider the function \(r(x)= \begin{pmatrix} x \\ 1-x \end{pmatrix}, x \in [-1;1]\). The \( L_{1}, L_{2} \) and \( L_{\infty} \) norm for the sample value \(r(-1) = \begin{pmatrix} -1 \\ 2 \end{pmatrix}\) is calculated as follows \(align*} \| r(-1) \|_{L_1} &= |-1| + |2| = 3 \\ \| r(-1) \|_{L_2} &= \sqrt{(-1)^{2} + (2)^{2}} = \sqrt{5} \\ \| r(-1) \|_{L_\infty} &= \max(|-1|,|2|) = 2 \) and for \(r(0.5) = \begin{pmatrix} 0.5 \\ 0.5 \end{pmatrix}\) the calculation is \(align*} \| r(0.5) \|_{L_1} &= |0.5| + |0.5| = 1 \\ \| r(0.5) \|_{L_2} &= \sqrt{(0.5)^{2} + (0.5)^{2}} = \sqrt{0.5} \\ \| r(0.5) \|_{L_\infty} &= \max(|0.5|,|0.5|) = 0.5. \) The following graphic shows all values for the three norm functions \(\| r(x) \|_{L_1}, \| r(x) \|_{L_2}\) and \(\| r(x) \|_{L_\infty}\). It is notable that the \( L_{1} \) norm forms the upper and the \( L_{\infty} \) norm forms the lower border for the example function \( r(x) \). ![Graphs for the different norm functions from the above example](pics/NormTypes_OneArray_1-2-INF.png) When the mask parameter is specified and it is not empty, the norm is If normType is not specified, #NORM_L2 is used. calculated only over the region specified by the mask. Multi-channel input arrays are treated as single-channel arrays, that is, the results for all channels are combined. Hamming norms can only be calculated with CV_8U depth arrays.
        引数:
        src1 - 第1の入力配列。
        normType - ノルムの種類（#NormTypes を参照）。
        戻り値:
        自動生成

      • norm

        public static double norm​(Mat src1)
        Calculates the absolute norm of an array. This version of #norm calculates the absolute norm of src1. The type of norm to calculate is specified using #NormTypes. As example for one array consider the function \(r(x)= \begin{pmatrix} x \\ 1-x \end{pmatrix}, x \in [-1;1]\). The \( L_{1}, L_{2} \) and \( L_{\infty} \) norm for the sample value \(r(-1) = \begin{pmatrix} -1 \\ 2 \end{pmatrix}\) is calculated as follows \(align*} \| r(-1) \|_{L_1} &= |-1| + |2| = 3 \\ \| r(-1) \|_{L_2} &= \sqrt{(-1)^{2} + (2)^{2}} = \sqrt{5} \\ \| r(-1) \|_{L_\infty} &= \max(|-1|,|2|) = 2 \) and for \(r(0.5) = \begin{pmatrix} 0.5 \\ 0.5 \end{pmatrix}\) the calculation is \(align*} \| r(0.5) \|_{L_1} &= |0.5| + |0.5| = 1 \\ \| r(0.5) \|_{L_2} &= \sqrt{(0.5)^{2} + (0.5)^{2}} = \sqrt{0.5} \\ \| r(0.5) \|_{L_\infty} &= \max(|0.5|,|0.5|) = 0.5. \) The following graphic shows all values for the three norm functions \(\| r(x) \|_{L_1}, \| r(x) \|_{L_2}\) and \(\| r(x) \|_{L_\infty}\). It is notable that the \( L_{1} \) norm forms the upper and the \( L_{\infty} \) norm forms the lower border for the example function \( r(x) \). ![Graphs for the different norm functions from the above example](pics/NormTypes_OneArray_1-2-INF.png) When the mask parameter is specified and it is not empty, the norm is If normType is not specified, #NORM_L2 is used. calculated only over the region specified by the mask. Multi-channel input arrays are treated as single-channel arrays, that is, the results for all channels are combined. Hamming norms can only be calculated with CV_8U depth arrays.
        引数:
        src1 - 第1の入力配列。
        戻り値:
        自動生成

      • norm

        public static double norm​(Mat src1,
                          Mat src2,
                          int normType,
                          Mat mask)
        Calculates an absolute difference norm or a relative difference norm. This version of cv::norm calculates the absolute difference norm or the relative difference norm of arrays src1 and src2. The type of norm to calculate is specified using #NormTypes.
        引数:
        src1 - 第1の入力配列。
        src2 - src1 と同じサイズおよび同じ型の第2の入力配列。
        normType - ノルムの種類（#NormTypes を参照）。
        mask - 省略可能な操作マスク。src1 と同じサイズで CV_8UC1 型である必要がある。
        戻り値:
        自動生成

      • norm

        public static double norm​(Mat src1,
                          Mat src2,
                          int normType)
        Calculates an absolute difference norm or a relative difference norm. This version of cv::norm calculates the absolute difference norm or the relative difference norm of arrays src1 and src2. The type of norm to calculate is specified using #NormTypes.
        引数:
        src1 - 第1の入力配列。
        src2 - src1 と同じサイズおよび同じ型の第2の入力配列。
        normType - ノルムの種類（#NormTypes を参照）。
        戻り値:
        自動生成

      • norm

        public static double norm​(Mat src1,
                          Mat src2)
        Calculates an absolute difference norm or a relative difference norm. This version of cv::norm calculates the absolute difference norm or the relative difference norm of arrays src1 and src2. The type of norm to calculate is specified using #NormTypes.
        引数:
        src1 - 第1の入力配列。
        src2 - src1 と同じサイズおよび同じ型の第2の入力配列。
        戻り値:
        自動生成

      • PSNR

        public static double PSNR​(Mat src1,
                          Mat src2,
                          double R)
        Computes the Peak Signal-to-Noise Ratio (PSNR) image quality metric. This function calculates the Peak Signal-to-Noise Ratio (PSNR) image quality metric in decibels (dB), between two input arrays src1 and src2. The arrays must have the same type. The PSNR is calculated as follows: \( \texttt{PSNR} = 10 \cdot \log_{10}{\left( \frac{R^2}{MSE} \right) } \) where R is the maximum integer value of depth (e.g. 255 in the case of CV_8U data) and MSE is the mean squared error between the two arrays.
        引数:
        src1 - 第1の入力配列。
        src2 - src1 と同じサイズの2番目の入力配列。
        R - 最大ピクセル値（デフォルトは255）
        戻り値:
        自動生成

      • PSNR

        public static double PSNR​(Mat src1,
                          Mat src2)
        Computes the Peak Signal-to-Noise Ratio (PSNR) image quality metric. This function calculates the Peak Signal-to-Noise Ratio (PSNR) image quality metric in decibels (dB), between two input arrays src1 and src2. The arrays must have the same type. The PSNR is calculated as follows: \( \texttt{PSNR} = 10 \cdot \log_{10}{\left( \frac{R^2}{MSE} \right) } \) where R is the maximum integer value of depth (e.g. 255 in the case of CV_8U data) and MSE is the mean squared error between the two arrays.
        引数:
        src1 - 第1の入力配列。
        src2 - src1 と同じサイズの2番目の入力配列。
        戻り値:
        自動生成

      • batchDistance

        public 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
        引数:
        src1 - 自動生成
        src2 - 自動生成
        dist - 自動生成
        dtype - 自動生成
        nidx - 自動生成
        normType - 自動生成
        K - 自動生成
        mask - 自動生成
        update - 自動生成
        crosscheck - 自動生成

      • batchDistance

        public 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
        引数:
        src1 - 自動生成
        src2 - 自動生成
        dist - 自動生成
        dtype - 自動生成
        nidx - 自動生成
        normType - 自動生成
        K - 自動生成
        mask - 自動生成
        update - 自動生成

      • batchDistance

        public 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
        引数:
        src1 - 自動生成
        src2 - 自動生成
        dist - 自動生成
        dtype - 自動生成
        nidx - 自動生成
        normType - 自動生成
        K - 自動生成
        mask - 自動生成

      • batchDistance

        public 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
        引数:
        src1 - 自動生成
        src2 - 自動生成
        dist - 自動生成
        dtype - 自動生成
        nidx - 自動生成
        normType - 自動生成
        K - 自動生成

      • batchDistance

        public 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
        引数:
        src1 - 自動生成
        src2 - 自動生成
        dist - 自動生成
        dtype - 自動生成
        nidx - 自動生成
        normType - 自動生成

      • batchDistance

        public 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
        引数:
        src1 - 自動生成
        src2 - 自動生成
        dist - 自動生成
        dtype - 自動生成
        nidx - 自動生成

      • normalize

        public 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. The function cv::normalize normalizes scale and shift the input array elements so that \(\| \texttt{dst} \| _{L_p}= \texttt{alpha}\) (where p=Inf, 1 or 2) when normType=NORM_INF, NORM_L1, or NORM_L2, respectively; or so that \(\min _I \texttt{dst} (I)= \texttt{alpha} , \, \, \max _I \texttt{dst} (I)= \texttt{beta}\) when normType=NORM_MINMAX (for dense arrays only). The optional mask specifies a sub-array to be normalized. This means that the norm or min-n-max are calculated over the sub-array, and then this sub-array is modified to be normalized. If you want to only use the mask to calculate the norm or min-max but modify the whole array, you can use norm and Mat::convertTo. In case of sparse matrices, only the non-zero values are analyzed and transformed. Because of this, the range transformation for sparse matrices is not allowed since it can shift the zero level. Possible usage with some positive example data: 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); 覚え書き: Due to rounding issues, min-max normalization can result in values outside provided boundaries. If exact range conformity is needed, following workarounds can be used:
        • 倍精度浮動小数点（dtype = CV_64F）を使用する
        • 値を手動でクリップする（cv::max(res, left_bound, res)、cv::min(res, right_bound, res)、または np.clip）
        引数:
        src - 入力配列。
        dst - src と同じサイズの出力配列。
        alpha - 正規化先のノルム値、または範囲正規化の場合は範囲の下限。
        beta - 範囲正規化の場合の範囲の上限。ノルム正規化では使用されない。
        norm_type - 正規化の種類（cv::NormTypes を参照）。
        dtype - 負の場合、出力配列は src と同じ型を持つ。そうでない場合は src と同じチャンネル数で、ビット深度は =CV_MAT_DEPTH(dtype) となる。
        mask - 省略可能な操作マスク。 SEE: norm, Mat::convertTo, SparseMat::convertTo

      • normalize

        public 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. The function cv::normalize normalizes scale and shift the input array elements so that \(\| \texttt{dst} \| _{L_p}= \texttt{alpha}\) (where p=Inf, 1 or 2) when normType=NORM_INF, NORM_L1, or NORM_L2, respectively; or so that \(\min _I \texttt{dst} (I)= \texttt{alpha} , \, \, \max _I \texttt{dst} (I)= \texttt{beta}\) when normType=NORM_MINMAX (for dense arrays only). The optional mask specifies a sub-array to be normalized. This means that the norm or min-n-max are calculated over the sub-array, and then this sub-array is modified to be normalized. If you want to only use the mask to calculate the norm or min-max but modify the whole array, you can use norm and Mat::convertTo. In case of sparse matrices, only the non-zero values are analyzed and transformed. Because of this, the range transformation for sparse matrices is not allowed since it can shift the zero level. Possible usage with some positive example data: 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); 覚え書き: Due to rounding issues, min-max normalization can result in values outside provided boundaries. If exact range conformity is needed, following workarounds can be used:
        • 倍精度浮動小数点（dtype = CV_64F）を使用する
        • 値を手動でクリップする（cv::max(res, left_bound, res)、cv::min(res, right_bound, res)、または np.clip）
        引数:
        src - 入力配列。
        dst - src と同じサイズの出力配列。
        alpha - 正規化先のノルム値、または範囲正規化の場合は範囲の下限。
        beta - 範囲正規化の場合の範囲の上限。ノルム正規化では使用されない。
        norm_type - 正規化の種類（cv::NormTypes を参照）。
        dtype - 負の場合、出力配列は src と同じ型を持つ。そうでない場合は src と同じチャンネル数で、ビット深度は =CV_MAT_DEPTH(dtype) となる。 SEE: norm, Mat::convertTo, SparseMat::convertTo

      • normalize

        public static void normalize​(Mat src,
                             Mat dst,
                             double alpha,
                             double beta,
                             int norm_type)
        Normalizes the norm or value range of an array. The function cv::normalize normalizes scale and shift the input array elements so that \(\| \texttt{dst} \| _{L_p}= \texttt{alpha}\) (where p=Inf, 1 or 2) when normType=NORM_INF, NORM_L1, or NORM_L2, respectively; or so that \(\min _I \texttt{dst} (I)= \texttt{alpha} , \, \, \max _I \texttt{dst} (I)= \texttt{beta}\) when normType=NORM_MINMAX (for dense arrays only). The optional mask specifies a sub-array to be normalized. This means that the norm or min-n-max are calculated over the sub-array, and then this sub-array is modified to be normalized. If you want to only use the mask to calculate the norm or min-max but modify the whole array, you can use norm and Mat::convertTo. In case of sparse matrices, only the non-zero values are analyzed and transformed. Because of this, the range transformation for sparse matrices is not allowed since it can shift the zero level. Possible usage with some positive example data: 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); 覚え書き: Due to rounding issues, min-max normalization can result in values outside provided boundaries. If exact range conformity is needed, following workarounds can be used:
        • 倍精度浮動小数点（dtype = CV_64F）を使用する
        • 値を手動でクリップする（cv::max(res, left_bound, res)、cv::min(res, right_bound, res)、または np.clip）
        引数:
        src - 入力配列。
        dst - src と同じサイズの出力配列。
        alpha - 正規化先のノルム値、または範囲正規化の場合は範囲の下限。
        beta - 範囲正規化の場合の範囲の上限。ノルム正規化では使用されない。
        norm_type - 正規化の種類（cv::NormTypes を参照）。src と同じチャンネル数で、ビット深度は =CV_MAT_DEPTH(dtype) となる。 SEE: norm, Mat::convertTo, SparseMat::convertTo

      • normalize

        public static void normalize​(Mat src,
                             Mat dst,
                             double alpha,
                             double beta)
        Normalizes the norm or value range of an array. The function cv::normalize normalizes scale and shift the input array elements so that \(\| \texttt{dst} \| _{L_p}= \texttt{alpha}\) (where p=Inf, 1 or 2) when normType=NORM_INF, NORM_L1, or NORM_L2, respectively; or so that \(\min _I \texttt{dst} (I)= \texttt{alpha} , \, \, \max _I \texttt{dst} (I)= \texttt{beta}\) when normType=NORM_MINMAX (for dense arrays only). The optional mask specifies a sub-array to be normalized. This means that the norm or min-n-max are calculated over the sub-array, and then this sub-array is modified to be normalized. If you want to only use the mask to calculate the norm or min-max but modify the whole array, you can use norm and Mat::convertTo. In case of sparse matrices, only the non-zero values are analyzed and transformed. Because of this, the range transformation for sparse matrices is not allowed since it can shift the zero level. Possible usage with some positive example data: 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); 覚え書き: Due to rounding issues, min-max normalization can result in values outside provided boundaries. If exact range conformity is needed, following workarounds can be used:
        • 倍精度浮動小数点（dtype = CV_64F）を使用する
        • 値を手動でクリップする（cv::max(res, left_bound, res)、cv::min(res, right_bound, res)、または np.clip）
        引数:
        src - 入力配列。
        dst - src と同じサイズの出力配列。
        alpha - 正規化先のノルム値、または範囲正規化の場合は範囲の下限。
        beta - 範囲正規化の場合の範囲の上限。ノルム正規化では使用されない。src と同じチャンネル数で、ビット深度は =CV_MAT_DEPTH(dtype) となる。 SEE: norm, Mat::convertTo, SparseMat::convertTo

      • normalize

        public static void normalize​(Mat src,
                             Mat dst,
                             double alpha)
        Normalizes the norm or value range of an array. The function cv::normalize normalizes scale and shift the input array elements so that \(\| \texttt{dst} \| _{L_p}= \texttt{alpha}\) (where p=Inf, 1 or 2) when normType=NORM_INF, NORM_L1, or NORM_L2, respectively; or so that \(\min _I \texttt{dst} (I)= \texttt{alpha} , \, \, \max _I \texttt{dst} (I)= \texttt{beta}\) when normType=NORM_MINMAX (for dense arrays only). The optional mask specifies a sub-array to be normalized. This means that the norm or min-n-max are calculated over the sub-array, and then this sub-array is modified to be normalized. If you want to only use the mask to calculate the norm or min-max but modify the whole array, you can use norm and Mat::convertTo. In case of sparse matrices, only the non-zero values are analyzed and transformed. Because of this, the range transformation for sparse matrices is not allowed since it can shift the zero level. Possible usage with some positive example data: 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); 覚え書き: Due to rounding issues, min-max normalization can result in values outside provided boundaries. If exact range conformity is needed, following workarounds can be used:
        • 倍精度浮動小数点（dtype = CV_64F）を使用する
        • 値を手動でクリップする（cv::max(res, left_bound, res)、cv::min(res, right_bound, res)、または np.clip）
        引数:
        src - 入力配列。
        dst - src と同じサイズの出力配列。
        alpha - 正規化先のノルム値、または範囲正規化の場合は範囲の下限。正規化。src と同じチャンネル数で、ビット深度は =CV_MAT_DEPTH(dtype) となる。 SEE: norm, Mat::convertTo, SparseMat::convertTo

      • normalize

        public static void normalize​(Mat src,
                             Mat dst)
        Normalizes the norm or value range of an array. The function cv::normalize normalizes scale and shift the input array elements so that \(\| \texttt{dst} \| _{L_p}= \texttt{alpha}\) (where p=Inf, 1 or 2) when normType=NORM_INF, NORM_L1, or NORM_L2, respectively; or so that \(\min _I \texttt{dst} (I)= \texttt{alpha} , \, \, \max _I \texttt{dst} (I)= \texttt{beta}\) when normType=NORM_MINMAX (for dense arrays only). The optional mask specifies a sub-array to be normalized. This means that the norm or min-n-max are calculated over the sub-array, and then this sub-array is modified to be normalized. If you want to only use the mask to calculate the norm or min-max but modify the whole array, you can use norm and Mat::convertTo. In case of sparse matrices, only the non-zero values are analyzed and transformed. Because of this, the range transformation for sparse matrices is not allowed since it can shift the zero level. Possible usage with some positive example data: 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); 覚え書き: Due to rounding issues, min-max normalization can result in values outside provided boundaries. If exact range conformity is needed, following workarounds can be used:
        • 倍精度浮動小数点（dtype = CV_64F）を使用する
        • 値を手動でクリップする（cv::max(res, left_bound, res)、cv::min(res, right_bound, res)、または np.clip）
        引数:
        src - 入力配列。
        dst - src と同じサイズの出力配列。正規化。正規化。src と同じチャンネル数で、ビット深度は =CV_MAT_DEPTH(dtype) となる。 SEE: norm, Mat::convertTo, SparseMat::convertTo

      • reduceArgMin

        public static void reduceArgMin​(Mat src,
                                Mat dst,
                                int axis,
                                boolean lastIndex)
        Finds indices of min elements along provided axis 覚え書き: - If input or output array is not continuous, this function will create an internal copy. - NaN handling is left unspecified, see patchNaNs(). - The returned index is always in bounds of input matrix.
        引数:
        src - 入力シングルチャンネル配列。
        dst - 縮約対象の軸を除き src と同じ次元数を持つ CV_32SC1 型の出力配列。縮約対象の軸は 1 に設定される。
        lastIndex - 最小値が最初に出現する位置のインデックスを取得するか、最後に出現する位置のインデックスを取得するか。
        axis - 縮約する軸。SEE: reduceArgMax, minMaxLoc, min, max, compare, reduce

      • reduceArgMin

        public static void reduceArgMin​(Mat src,
                                Mat dst,
                                int axis)
        Finds indices of min elements along provided axis 覚え書き: - If input or output array is not continuous, this function will create an internal copy. - NaN handling is left unspecified, see patchNaNs(). - The returned index is always in bounds of input matrix.
        引数:
        src - 入力シングルチャンネル配列。
        dst - 縮約対象の軸を除き src と同じ次元数を持つ CV_32SC1 型の出力配列。縮約対象の軸は 1 に設定される。
        axis - 縮約する軸。SEE: reduceArgMax, minMaxLoc, min, max, compare, reduce

      • reduceArgMax

        public static void reduceArgMax​(Mat src,
                                Mat dst,
                                int axis,
                                boolean lastIndex)
        Finds indices of max elements along provided axis 覚え書き: - If input or output array is not continuous, this function will create an internal copy. - NaN handling is left unspecified, see patchNaNs(). - The returned index is always in bounds of input matrix.
        引数:
        src - 入力シングルチャンネル配列。
        dst - 縮約対象の軸を除き src と同じ次元数を持つ CV_32SC1 型の出力配列。縮約対象の軸は 1 に設定される。
        lastIndex - 最大値が最初に出現する位置のインデックスを取得するか、最後に出現する位置のインデックスを取得するか。
        axis - 縮約する軸。SEE: reduceArgMin, minMaxLoc, min, max, compare, reduce

      • reduceArgMax

        public static void reduceArgMax​(Mat src,
                                Mat dst,
                                int axis)
        Finds indices of max elements along provided axis 覚え書き: - If input or output array is not continuous, this function will create an internal copy. - NaN handling is left unspecified, see patchNaNs(). - The returned index is always in bounds of input matrix.
        引数:
        src - 入力シングルチャンネル配列。
        dst - 縮約対象の軸を除き src と同じ次元数を持つ CV_32SC1 型の出力配列。縮約対象の軸は 1 に設定される。
        axis - 縮約する軸。SEE: reduceArgMin, minMaxLoc, min, max, compare, reduce

      • reduce

        public static void reduce​(Mat src,
                          Mat dst,
                          int dim,
                          int rtype,
                          int dtype)
        Reduces a matrix to a vector. The function #reduce reduces the matrix to a vector by treating the matrix rows/columns as a set of 1D vectors and performing the specified operation on the vectors until a single row/column is obtained. For example, the function can be used to compute horizontal and vertical projections of a raster image. In case of #REDUCE_MAX and #REDUCE_MIN, the output image should have the same type as the source one. In case of #REDUCE_SUM, #REDUCE_SUM2 and #REDUCE_AVG, the output may have a larger element bit-depth to preserve accuracy. And multi-channel arrays are also supported in these two reduction modes. The following code demonstrates its usage for a single channel matrix. SNIPPET: snippets/core_reduce.cpp example And the following code demonstrates its usage for a two-channel matrix. SNIPPET: snippets/core_reduce.cpp example2
        引数:
        src - 入力2次元行列。
        dst - 出力ベクトル。そのサイズと型は dim と dtype 引数で決まる。
        dim - 行列を縮約する方向の次元インデックス。0 は行列を1行に縮約することを意味し、1 は行列を1列に縮約することを意味する。
        rtype - 縮約演算で、#ReduceTypes のいずれかを指定できる。
        dtype - 負の場合、出力ベクトルは入力行列と同じ型になる。そうでない場合、その型は CV_MAKE_TYPE(CV_MAT_DEPTH(dtype), src.channels()) となる。SEE: repeat, reduceArgMin, reduceArgMax

      • reduce

        public static void reduce​(Mat src,
                          Mat dst,
                          int dim,
                          int rtype)
        Reduces a matrix to a vector. The function #reduce reduces the matrix to a vector by treating the matrix rows/columns as a set of 1D vectors and performing the specified operation on the vectors until a single row/column is obtained. For example, the function can be used to compute horizontal and vertical projections of a raster image. In case of #REDUCE_MAX and #REDUCE_MIN, the output image should have the same type as the source one. In case of #REDUCE_SUM, #REDUCE_SUM2 and #REDUCE_AVG, the output may have a larger element bit-depth to preserve accuracy. And multi-channel arrays are also supported in these two reduction modes. The following code demonstrates its usage for a single channel matrix. SNIPPET: snippets/core_reduce.cpp example And the following code demonstrates its usage for a two-channel matrix. SNIPPET: snippets/core_reduce.cpp example2
        引数:
        src - 入力2次元行列。
        dst - 出力ベクトル。そのサイズと型は dim と dtype 引数で決まる。
        dim - 行列を縮約する方向の次元インデックス。0 は行列を1行に縮約することを意味し、1 は行列を1列に縮約することを意味する。
        rtype - 縮約演算で、#ReduceTypes のいずれかを指定できる。そうでない場合、その型は CV_MAKE_TYPE(CV_MAT_DEPTH(dtype), src.channels()) となる。SEE: repeat, reduceArgMin, reduceArgMax

      • merge

        public static void merge​(java.util.List<Mat> mv,
                         Mat dst)
        引数:
        mv - 結合する行列の入力ベクトル。mv 内のすべての行列は同じサイズかつ同じビット深度でなければならない。
        dst - mv[0] と同じサイズかつ同じビット深度の出力配列。チャンネル数は行列配列内の全チャンネル数の合計となる。

      • split

        public static void split​(Mat m,
                         java.util.List<Mat> mv)
        引数:
        m - 入力マルチチャンネル配列。
        mv - 配列の出力ベクトル。必要に応じて配列自体が再確保される。

      • mixChannels

        public static void mixChannels​(java.util.List<Mat> src,
                               java.util.List<Mat> dst,
                               MatOfInt fromTo)
        引数:
        src - 入力配列または行列のベクトル。すべての行列は同じサイズかつ同じビット深度でなければならない。
        dst - 出力配列または行列のベクトル。すべての行列が確保済みでなければならない。そのサイズとビット深度は src[0] と同じでなければならない。
        fromTo - どのチャンネルをどこへコピーするかを指定するインデックス対の配列。fromTo[k\*2] は src における入力チャンネルの0始まりのインデックスで、fromTo[k\*2+1] は dst における出力チャンネルのインデックスである。チャンネル番号は連続して付与される。すなわち最初の入力画像のチャンネルは 0 から src[0].channels()-1 まで、2番目の入力画像のチャンネルは src[0].channels() から src[0].channels() + src[1].channels()-1 まで、というように番号付けされ、出力画像のチャンネルにも同じ方式が用いられる。特別なケースとして、fromTo[k\*2] が負の場合、対応する出力チャンネルは0で埋められる。

      • extractChannel

        public static void extractChannel​(Mat src,
                                  Mat dst,
                                  int coi)
        Extracts a single channel from src (coi is 0-based index)
        引数:
        src - 入力配列
        dst - 出力配列
        coi - 抽出するチャンネルのインデックス SEE: mixChannels, split

      • insertChannel

        public static void insertChannel​(Mat src,
                                 Mat dst,
                                 int coi)
        Inserts a single channel to dst (coi is 0-based index)
        引数:
        src - 入力配列
        dst - 出力配列
        coi - 挿入するチャンネルのインデックス SEE: mixChannels, merge

      • flip

        public static void flip​(Mat src,
                        Mat dst,
                        int flipCode)
        Flips a 2D array around vertical, horizontal, or both axes. The function cv::flip flips the array in one of three different ways (row and column indices are 0-based): \(\texttt{dst} _{ij} = \left\{ \begin{array}{l l} \texttt{src} _{\texttt{src.rows}-i-1,j} & if\; \texttt{flipCode} = 0 \\ \texttt{src} _{i, \texttt{src.cols} -j-1} & if\; \texttt{flipCode} > 0 \\ \texttt{src} _{ \texttt{src.rows} -i-1, \texttt{src.cols} -j-1} & if\; \texttt{flipCode} < 0 \\ \end{array} \right.\) The example scenarios of using the function are the following: Vertical flipping of the image (flipCode == 0) to switch between top-left and bottom-left image origin. This is a typical operation in video processing on Microsoft Windows\* OS. Horizontal flipping of the image with the subsequent horizontal shift and absolute difference calculation to check for a vertical-axis symmetry (flipCode > 0). Simultaneous horizontal and vertical flipping of the image with the subsequent shift and absolute difference calculation to check for a central symmetry (flipCode < 0). Reversing the order of point arrays (flipCode > 0 or flipCode == 0).
        引数:
        src - 入力配列。
        dst - src と同じサイズかつ同じ型の出力配列。
        flipCode - 配列をどのように反転するかを指定するフラグ。0 は x 軸まわりの反転を意味し、正の値(例えば 1)は y 軸まわりの反転を意味する。負の値(例えば -1)は両軸まわりの反転を意味する。SEE: transpose, repeat, completeSymm

      • flipND

        public static void flipND​(Mat src,
                          Mat dst,
                          int axis)
        Flips a n-dimensional at given axis
        引数:
        src - 入力配列
        dst - src と同じ形状を持つ出力配列
        axis - 反転を行う軸。0 <= axis < src.dims。

      • broadcast

        public static void broadcast​(Mat src,
                             Mat shape,
                             Mat dst)
        Broadcast the given Mat to the given shape.
        引数:
        src - 入力配列
        shape - 対象とする形状。CV_32S の数値のリストでなければならない。負の値はサポートされていないことに注意。
        dst - 指定された形状を持つ出力配列

      • rotate

        public static void rotate​(Mat src,
                          Mat dst,
                          int rotateCode)
        Rotates a 2D array in multiples of 90 degrees. The function cv::rotate rotates the array in one of three different ways: Rotate by 90 degrees clockwise (rotateCode = ROTATE_90_CLOCKWISE). Rotate by 180 degrees clockwise (rotateCode = ROTATE_180). Rotate by 270 degrees clockwise (rotateCode = ROTATE_90_COUNTERCLOCKWISE).
        引数:
        src - 入力配列。
        dst - src と同じ型の出力配列。サイズは ROTATE_180 では同じであり、ROTATE_90_CLOCKWISE および ROTATE_90_COUNTERCLOCKWISE では行と列が入れ替わる。
        rotateCode - 配列をどのように回転するかを指定する列挙値。列挙体 #RotateFlags を参照。SEE: transpose, repeat, completeSymm, flip, RotateFlags

      • repeat

        public static void repeat​(Mat src,
                          int ny,
                          int nx,
                          Mat dst)
        Fills the output array with repeated copies of the input array. The function cv::repeat duplicates the input array one or more times along each of the two axes: \(\texttt{dst} _{ij}= \texttt{src} _{i\mod src.rows, \; j\mod src.cols }\) The second variant of the function is more convenient to use with REF: MatrixExpressions.
        引数:
        src - 複製する入力配列。
        ny - src を垂直方向に何回繰り返すかを指定するフラグ。
        nx - src を水平方向に何回繰り返すかを指定するフラグ。
        dst - src と同じ型の出力配列。SEE: cv::reduce

      • hconcat

        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 - 入力配列または行列のベクトル。すべての行列は同じ行数かつ同じビット深度でなければならない。
        dst - 出力配列。src と同じ行数およびビット深度を持ち、列数は src の列数の合計となる。同じビット深度。

      • vconcat

        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 - 入力配列または行列のベクトル。すべての行列は同じ列数かつ同じビット深度でなければならない
        dst - 出力配列。src と同じ列数およびビット深度を持ち、行数は src の行数の合計となる。同じビット深度。

      • bitwise_and

        public 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. The function cv::bitwise_and calculates the per-element bit-wise logical conjunction for: Two arrays when src1 and src2 have the same size: \(\texttt{dst} (I) = \texttt{src1} (I) \wedge \texttt{src2} (I) \quad \texttt{if mask} (I) \ne0\) An array and a scalar when src2 is constructed from Scalar or has the same number of elements as 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 - 第1の入力配列またはスカラー。
        src2 - 第2の入力配列またはスカラー。
        dst - 入力配列と同じサイズかつ同じ型の出力配列。
        mask - 省略可能な演算マスク。8ビットシングルチャンネル配列で、出力配列のうち変更される要素を指定する。

      • bitwise_and

        public 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. The function cv::bitwise_and calculates the per-element bit-wise logical conjunction for: Two arrays when src1 and src2 have the same size: \(\texttt{dst} (I) = \texttt{src1} (I) \wedge \texttt{src2} (I) \quad \texttt{if mask} (I) \ne0\) An array and a scalar when src2 is constructed from Scalar or has the same number of elements as 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 - 第1の入力配列またはスカラー。
        src2 - 第2の入力配列またはスカラー。
        dst - 入力配列と同じサイズかつ同じ型の出力配列。変更される出力配列の要素を指定する。

      • bitwise_or

        public 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. The function cv::bitwise_or calculates the per-element bit-wise logical disjunction for: Two arrays when src1 and src2 have the same size: \(\texttt{dst} (I) = \texttt{src1} (I) \vee \texttt{src2} (I) \quad \texttt{if mask} (I) \ne0\) An array and a scalar when src2 is constructed from Scalar or has the same number of elements as 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 - 第1の入力配列またはスカラー。
        src2 - 第2の入力配列またはスカラー。
        dst - 入力配列と同じサイズかつ同じ型の出力配列。
        mask - 省略可能な演算マスク。8ビットシングルチャンネル配列で、出力配列のうち変更される要素を指定する。

      • bitwise_or

        public 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. The function cv::bitwise_or calculates the per-element bit-wise logical disjunction for: Two arrays when src1 and src2 have the same size: \(\texttt{dst} (I) = \texttt{src1} (I) \vee \texttt{src2} (I) \quad \texttt{if mask} (I) \ne0\) An array and a scalar when src2 is constructed from Scalar or has the same number of elements as 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 - 第1の入力配列またはスカラー。
        src2 - 第2の入力配列またはスカラー。
        dst - 入力配列と同じサイズかつ同じ型の出力配列。変更される出力配列の要素を指定する。

      • bitwise_xor

        public 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. The function cv::bitwise_xor calculates the per-element bit-wise logical "exclusive-or" operation for: Two arrays when src1 and src2 have the same size: \(\texttt{dst} (I) = \texttt{src1} (I) \oplus \texttt{src2} (I) \quad \texttt{if mask} (I) \ne0\) An array and a scalar when src2 is constructed from Scalar or has the same number of elements as 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 - 第1の入力配列またはスカラー。
        src2 - 第2の入力配列またはスカラー。
        dst - 入力配列と同じサイズかつ同じ型の出力配列。
        mask - 省略可能な演算マスク。8ビットシングルチャンネル配列で、出力配列のうち変更される要素を指定する。

      • bitwise_xor

        public 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. The function cv::bitwise_xor calculates the per-element bit-wise logical "exclusive-or" operation for: Two arrays when src1 and src2 have the same size: \(\texttt{dst} (I) = \texttt{src1} (I) \oplus \texttt{src2} (I) \quad \texttt{if mask} (I) \ne0\) An array and a scalar when src2 is constructed from Scalar or has the same number of elements as 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 - 第1の入力配列またはスカラー。
        src2 - 第2の入力配列またはスカラー。
        dst - 入力配列と同じサイズかつ同じ型の出力配列。変更される出力配列の要素を指定する。

      • bitwise_not

        public static void bitwise_not​(Mat src,
                               Mat dst,
                               Mat mask)
        Inverts every bit of an array. The function cv::bitwise_not calculates per-element bit-wise inversion of the input array: \(\texttt{dst} (I) = \neg \texttt{src} (I)\) In case of a floating-point input array, its machine-specific bit representation (usually IEEE754-compliant) is used for the operation. In case of multi-channel arrays, each channel is processed independently.
        引数:
        src - 入力配列。
        dst - 入力配列と同じサイズかつ同じ型の出力配列。
        mask - 省略可能な演算マスク。8ビットシングルチャンネル配列で、出力配列のうち変更される要素を指定する。

      • bitwise_not

        public static void bitwise_not​(Mat src,
                               Mat dst)
        Inverts every bit of an array. The function cv::bitwise_not calculates per-element bit-wise inversion of the input array: \(\texttt{dst} (I) = \neg \texttt{src} (I)\) In case of a floating-point input array, its machine-specific bit representation (usually IEEE754-compliant) is used for the operation. In case of multi-channel arrays, each channel is processed independently.
        引数:
        src - 入力配列。
        dst - 入力配列と同じサイズかつ同じ型の出力配列。変更される出力配列の要素を指定する。

      • absdiff

        public 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. The function cv::absdiff calculates: Absolute difference between two arrays when they have the same size and type: \(\texttt{dst}(I) = \texttt{saturate} (| \texttt{src1}(I) - \texttt{src2}(I)|)\) Absolute difference between an array and a scalar when the second array is constructed from Scalar or has as many elements as the number of channels in 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. 覚え書き: Saturation is not applied when the arrays have the depth CV_32S. You may even get a negative value in the case of overflow. 覚え書き: (Python) Be careful to difference behaviour between src1/src2 are single number and they are tuple/array. absdiff(src,X) means absdiff(src,(X,X,X,X)). absdiff(src,(X,)) means absdiff(src,(X,0,0,0)).
        引数:
        src1 - 第1の入力配列またはスカラー。
        src2 - 第2の入力配列またはスカラー。
        dst - 入力配列と同じサイズかつ同じ型の出力配列。SEE: cv::abs(const Mat&)

      • copyTo

        public 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. When the operation mask is specified, if the Mat::create call shown above reallocates the matrix, the newly allocated matrix is initialized with all zeros before copying the data.
        引数:
        src - 入力行列。
        dst - 出力行列。演算前に適切なサイズや型を持っていない場合、再確保される。
        mask - \*this と同じサイズの演算マスク。その非ゼロ要素はコピーが必要な行列要素を示す。マスクは CV_8U 型でなければならず、1チャンネルまたは複数チャンネルを持つことができる。

      • inRange

        public static void inRange​(Mat src,
                           Scalar lowerb,
                           Scalar upperb,
                           Mat dst)
        Checks if array elements lie between the elements of two other arrays. The function checks the range as follows:
        • シングルチャンネル入力配列のすべての要素について: \(\texttt{dst} (I)= \texttt{lowerb} (I)_0 \leq \texttt{src} (I)_0 \leq \texttt{upperb} (I)_0\)
        • 2チャンネル配列について: \(\texttt{dst} (I)= \texttt{lowerb} (I)_0 \leq \texttt{src} (I)_0 \leq \texttt{upperb} (I)_0 \land \texttt{lowerb} (I)_1 \leq \texttt{src} (I)_1 \leq \texttt{upperb} (I)_1\)
        • 以下同様。
        That is, dst (I) is set to 255 (all 1 -bits) if src (I) is within the specified 1D, 2D, 3D, ... box and 0 otherwise. When the lower and/or upper boundary parameters are scalars, the indexes (I) at lowerb and upperb in the above formulas should be omitted.
        引数:
        src - 第1入力配列。
        lowerb - 下限を含む下限境界の配列またはスカラー。
        upperb - 上限を含む上限境界の配列またはスカラー。
        dst - src と同じサイズで CV_8U 型の出力配列。

      • compare

        public 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. The function compares: Elements of two arrays when src1 and src2 have the same size: \(\texttt{dst} (I) = \texttt{src1} (I) \,\texttt{cmpop}\, \texttt{src2} (I)\) Elements of src1 with a scalar src2 when src2 is constructed from Scalar or has a single element: \(\texttt{dst} (I) = \texttt{src1}(I) \,\texttt{cmpop}\, \texttt{src2}\) src1 with elements of src2 when src1 is constructed from Scalar or has a single element: \(\texttt{dst} (I) = \texttt{src1} \,\texttt{cmpop}\, \texttt{src2} (I)\) When the comparison result is true, the corresponding element of output array is set to 255. The comparison operations can be replaced with the equivalent matrix expressions: Mat dst1 = src1 >= src2; Mat dst2 = src1 < 8; ...
        引数:
        src1 - 第1入力配列またはスカラー。配列の場合は単一チャンネルでなければならない。
        src2 - 第2入力配列またはスカラー。配列の場合は単一チャンネルでなければならない。
        dst - ref CV_8U 型の出力配列で、入力配列と同じサイズかつ同じチャンネル数を持つ。
        cmpop - 配列間の対応関係を指定するフラグ(cv::CmpTypes) SEE: checkRange, min, max, threshold

      • min

        public static void min​(Mat src1,
                       Mat src2,
                       Mat dst)
        Calculates per-element minimum of two arrays or an array and a scalar. The function cv::min calculates the per-element minimum of two arrays: \(\texttt{dst} (I)= \min ( \texttt{src1} (I), \texttt{src2} (I))\) or array and a scalar: \(\texttt{dst} (I)= \min ( \texttt{src1} (I), \texttt{value} )\)
        引数:
        src1 - 第1の入力配列。
        src2 - src1 と同じサイズ・型の2番目の入力配列。
        dst - src1 と同じサイズかつ同じ型の出力配列。SEE: max, compare, inRange, minMaxLoc

      • max

        public static void max​(Mat src1,
                       Mat src2,
                       Mat dst)
        Calculates per-element maximum of two arrays or an array and a scalar. The function cv::max calculates the per-element maximum of two arrays: \(\texttt{dst} (I)= \max ( \texttt{src1} (I), \texttt{src2} (I))\) or array and a scalar: \(\texttt{dst} (I)= \max ( \texttt{src1} (I), \texttt{value} )\)
        引数:
        src1 - 第1の入力配列。
        src2 - src1 と同じサイズかつ同じ型の第2入力配列。
        dst - src1 と同じサイズかつ同じ型の出力配列。SEE: min, compare, inRange, minMaxLoc, REF: MatrixExpressions

      • sqrt

        public static void sqrt​(Mat src,
                        Mat dst)
        Calculates a square root of array elements. The function cv::sqrt calculates a square root of each input array element. In case of multi-channel arrays, each channel is processed independently. The accuracy is approximately the same as of the built-in std::sqrt .
        引数:
        src - 入力浮動小数点配列。
        dst - src と同じサイズかつ同じ型の出力配列。

      • pow

        public static void pow​(Mat src,
                       double power,
                       Mat dst)
        Raises every array element to a power. The function cv::pow raises every element of the input array to power : \(\texttt{dst} (I) = \fork{\texttt{src}(I)^{power}}{if \(\texttt{power}\) is integer}{|\texttt{src}(I)|^{power}}{otherwise}\) So, for a non-integer power exponent, the absolute values of input array elements are used. However, it is possible to get true values for negative values using some extra operations. In the example below, computing the 5th root of array src shows: 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 - 入力配列。
        power - べき乗の指数。
        dst - srcと同じサイズおよび型の出力配列。 SEE: sqrt, exp, log, cartToPolar, polarToCart

      • exp

        public static void exp​(Mat src,
                       Mat dst)
        Calculates the exponent of every array element. The function cv::exp calculates the exponent of every element of the input array: \(\texttt{dst} [I] = e^{ src(I) }\) The maximum relative error is about 7e-6 for single-precision input and less than 1e-10 for double-precision input. Currently, the function converts denormalized values to zeros on output. Special values (NaN, Inf) are not handled.
        引数:
        src - 入力配列。
        dst - srcと同じサイズおよび型の出力配列。 SEE: log, cartToPolar, polarToCart, phase, pow, sqrt, magnitude

      • log

        public static void log​(Mat src,
                       Mat dst)
        Calculates the natural logarithm of every array element. The function cv::log calculates the natural logarithm of every element of the input array: \(\texttt{dst} (I) = \log (\texttt{src}(I)) \) Output on zero, negative and special (NaN, Inf) values is undefined.
        引数:
        src - 入力配列。
        dst - srcと同じサイズおよび型の出力配列。 SEE: exp, cartToPolar, polarToCart, phase, pow, sqrt, magnitude

      • polarToCart

        public 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. The function cv::polarToCart calculates the Cartesian coordinates of each 2D vector represented by the corresponding elements of magnitude and angle: \(\begin{array}{l} \texttt{x} (I) = \texttt{magnitude} (I) \cos ( \texttt{angle} (I)) \\ \texttt{y} (I) = \texttt{magnitude} (I) \sin ( \texttt{angle} (I)) \\ \end{array}\) The relative accuracy of the estimated coordinates is about 1e-6.
        引数:
        magnitude - 2Dベクトルの大きさを格納した入力浮動小数点配列。空の行列(=Mat())でもよく、その場合、関数はすべての大きさを=1とみなす。空でない場合は、angleと同じサイズおよび型でなければならない。
        angle - 2Dベクトルの角度を格納した入力浮動小数点配列。
        x - 2Dベクトルのx座標の出力配列。angleと同じサイズおよび型を持つ。
        y - 2Dベクトルのy座標の出力配列。angleと同じサイズおよび型を持つ。
        angleInDegrees - trueのとき、入力角度は度単位で測られ、そうでなければラジアン単位で測られる。 SEE: cartToPolar, magnitude, phase, exp, log, pow, sqrt

      • polarToCart

        public static void polarToCart​(Mat magnitude,
                               Mat angle,
                               Mat x,
                               Mat y)
        Calculates x and y coordinates of 2D vectors from their magnitude and angle. The function cv::polarToCart calculates the Cartesian coordinates of each 2D vector represented by the corresponding elements of magnitude and angle: \(\begin{array}{l} \texttt{x} (I) = \texttt{magnitude} (I) \cos ( \texttt{angle} (I)) \\ \texttt{y} (I) = \texttt{magnitude} (I) \sin ( \texttt{angle} (I)) \\ \end{array}\) The relative accuracy of the estimated coordinates is about 1e-6.
        引数:
        magnitude - 2Dベクトルの大きさを格納した入力浮動小数点配列。空の行列(=Mat())でもよく、その場合、関数はすべての大きさを=1とみなす。空でない場合は、angleと同じサイズおよび型でなければならない。
        angle - 2Dベクトルの角度を格納した入力浮動小数点配列。
        x - 2Dベクトルのx座標の出力配列。angleと同じサイズおよび型を持つ。
        y - 2Dベクトルのy座標の出力配列。angleと同じサイズおよび型を持つ。 度単位、そうでなければラジアン単位で測られる。 SEE: cartToPolar, magnitude, phase, exp, log, pow, sqrt

      • cartToPolar

        public static void cartToPolar​(Mat x,
                               Mat y,
                               Mat magnitude,
                               Mat angle,
                               boolean angleInDegrees)
        Calculates the magnitude and angle of 2D vectors. The function cv::cartToPolar calculates either the magnitude, angle, or both for every 2D vector (x(I),y(I)): \(\begin{array}{l} \texttt{magnitude} (I)= \sqrt{\texttt{x}(I)^2+\texttt{y}(I)^2} , \\ \texttt{angle} (I)= \texttt{atan2} ( \texttt{y} (I), \texttt{x} (I))[ \cdot180 / \pi ] \end{array}\) The angles are calculated with accuracy about 0.3 degrees. For the point (0,0), the angle is set to 0.
        引数:
        x - x座標の配列。単精度または倍精度の浮動小数点配列でなければならない。
        y - y座標の配列。xと同じサイズおよび同じ型でなければならない。
        magnitude - xと同じサイズおよび型の、大きさの出力配列。
        angle - xと同じサイズおよび型を持つ角度の出力配列。角度はラジアン単位(0から2\*Piまで)または度単位(0から360度まで)で測られる。
        angleInDegrees - 角度をラジアン単位(デフォルト)で測るか度単位で測るかを示すフラグ。 SEE: Sobel, Scharr

      • cartToPolar

        public static void cartToPolar​(Mat x,
                               Mat y,
                               Mat magnitude,
                               Mat angle)
        Calculates the magnitude and angle of 2D vectors. The function cv::cartToPolar calculates either the magnitude, angle, or both for every 2D vector (x(I),y(I)): \(\begin{array}{l} \texttt{magnitude} (I)= \sqrt{\texttt{x}(I)^2+\texttt{y}(I)^2} , \\ \texttt{angle} (I)= \texttt{atan2} ( \texttt{y} (I), \texttt{x} (I))[ \cdot180 / \pi ] \end{array}\) The angles are calculated with accuracy about 0.3 degrees. For the point (0,0), the angle is set to 0.
        引数:
        x - x座標の配列。単精度または倍精度の浮動小数点配列でなければならない。
        y - y座標の配列。xと同じサイズおよび同じ型でなければならない。
        magnitude - xと同じサイズおよび型の、大きさの出力配列。
        angle - xと同じサイズおよび型を持つ角度の出力配列。角度はラジアン単位(0から2\*Piまで)または度単位(0から360度まで)で測られる。 ラジアン単位(デフォルト)、または度単位。 SEE: Sobel, Scharr

      • phase

        public static void phase​(Mat x,
                         Mat y,
                         Mat angle,
                         boolean angleInDegrees)
        Calculates the rotation angle of 2D vectors. The function cv::phase calculates the rotation angle of each 2D vector that is formed from the corresponding elements of x and y : \(\texttt{angle} (I) = \texttt{atan2} ( \texttt{y} (I), \texttt{x} (I))\) The angle estimation accuracy is about 0.3 degrees. When x(I)=y(I)=0 , the corresponding angle(I) is set to 0.
        引数:
        x - 2Dベクトルのx座標の入力浮動小数点配列。
        y - 2Dベクトルのy座標の入力配列。xと同じサイズおよび同じ型でなければならない。
        angle - ベクトル角度の出力配列。xと同じサイズおよび同じ型を持つ。
        angleInDegrees - trueのとき、関数は角度を度単位で計算し、そうでなければラジアン単位で測られる。

      • phase

        public static void phase​(Mat x,
                         Mat y,
                         Mat angle)
        Calculates the rotation angle of 2D vectors. The function cv::phase calculates the rotation angle of each 2D vector that is formed from the corresponding elements of x and y : \(\texttt{angle} (I) = \texttt{atan2} ( \texttt{y} (I), \texttt{x} (I))\) The angle estimation accuracy is about 0.3 degrees. When x(I)=y(I)=0 , the corresponding angle(I) is set to 0.
        引数:
        x - 2Dベクトルのx座標の入力浮動小数点配列。
        y - 2Dベクトルのy座標の入力配列。xと同じサイズおよび同じ型でなければならない。
        angle - ベクトル角度の出力配列。xと同じサイズおよび同じ型を持つ。 度単位、そうでなければラジアン単位で測られる。

      • magnitude

        public static void magnitude​(Mat x,
                             Mat y,
                             Mat magnitude)
        Calculates the magnitude of 2D vectors. The function cv::magnitude calculates the magnitude of 2D vectors formed from the corresponding elements of x and y arrays: \(\texttt{dst} (I) = \sqrt{\texttt{x}(I)^2 + \texttt{y}(I)^2}\)
        引数:
        x - ベクトルのx座標の浮動小数点配列。
        y - ベクトルのy座標の浮動小数点配列。xと同じサイズでなければならない。
        magnitude - xと同じサイズおよび型の出力配列。 SEE: cartToPolar, polarToCart, phase, sqrt

      • checkRange

        public static boolean checkRange​(Mat a,
                                 boolean quiet,
                                 double minVal,
                                 double maxVal)
        Checks every element of an input array for invalid values. The function cv::checkRange checks that every array element is neither NaN nor infinite. When minVal >
        • DBL_MAX かつ maxVal < DBL_MAX の場合、関数は各値がminValとmaxValの間にあることも確認する。マルチチャンネル配列の場合、各チャンネルは独立に処理される。範囲外の値がある場合、最初の外れ値の位置がposに格納される(pos != NULLのとき)。その後、関数はfalseを返す(quiet=trueのとき)か、例外をスローする。
        引数:
        a - 入力配列。
        quiet - 配列要素が範囲外のとき関数が静かにfalseを返すか、例外をスローするかを示すフラグ。 要素。
        minVal - 有効値範囲の下限(この値を含む)。
        maxVal - 有効値範囲の上限(この値を含まない)。
        戻り値:
        自動生成

      • checkRange

        public static boolean checkRange​(Mat a,
                                 boolean quiet,
                                 double minVal)
        Checks every element of an input array for invalid values. The function cv::checkRange checks that every array element is neither NaN nor infinite. When minVal >
        • DBL_MAX かつ maxVal < DBL_MAX の場合、関数は各値がminValとmaxValの間にあることも確認する。マルチチャンネル配列の場合、各チャンネルは独立に処理される。範囲外の値がある場合、最初の外れ値の位置がposに格納される(pos != NULLのとき)。その後、関数はfalseを返す(quiet=trueのとき)か、例外をスローする。
        引数:
        a - 入力配列。
        quiet - 配列要素が範囲外のとき関数が静かにfalseを返すか、例外をスローするかを示すフラグ。 要素。
        minVal - 有効値範囲の下限(この値を含む)。
        戻り値:
        自動生成

      • checkRange

        public static boolean checkRange​(Mat a,
                                 boolean quiet)
        Checks every element of an input array for invalid values. The function cv::checkRange checks that every array element is neither NaN nor infinite. When minVal >
        • DBL_MAX かつ maxVal < DBL_MAX の場合、関数は各値がminValとmaxValの間にあることも確認する。マルチチャンネル配列の場合、各チャンネルは独立に処理される。範囲外の値がある場合、最初の外れ値の位置がposに格納される(pos != NULLのとき)。その後、関数はfalseを返す(quiet=trueのとき)か、例外をスローする。
        引数:
        a - 入力配列。
        quiet - 配列要素が範囲外のとき関数が静かにfalseを返すか、例外をスローするかを示すフラグ。 要素。
        戻り値:
        自動生成

      • checkRange

        public static boolean checkRange​(Mat a)
        Checks every element of an input array for invalid values. The function cv::checkRange checks that every array element is neither NaN nor infinite. When minVal >
        • DBL_MAX かつ maxVal < DBL_MAX の場合、関数は各値がminValとmaxValの間にあることも確認する。マルチチャンネル配列の場合、各チャンネルは独立に処理される。範囲外の値がある場合、最初の外れ値の位置がposに格納される(pos != NULLのとき)。その後、関数はfalseを返す(quiet=trueのとき)か、例外をスローする。
        引数:
        a - 入力配列。 範囲外であるか、例外をスローする。 要素。
        戻り値:
        自動生成

      • patchNaNs

        public static void patchNaNs​(Mat a,
                             double val)
        Replaces NaNs (Not-a-Number values) in a matrix with the specified value. This function modifies the input matrix in-place. The input matrix must be of type CV_32F or CV_64F; other types are not supported.
        引数:
        a - 入出力行列(CV_32FまたはCV_64F型)。
        val - NaNを置き換えるために使う値(デフォルトは0)。

      • patchNaNs

        public static void patchNaNs​(Mat a)
        Replaces NaNs (Not-a-Number values) in a matrix with the specified value. This function modifies the input matrix in-place. The input matrix must be of type CV_32F or CV_64F; other types are not supported.
        引数:
        a - 入出力行列(CV_32FまたはCV_64F型)。

      • gemm

        public static void gemm​(Mat src1,
                        Mat src2,
                        double alpha,
                        Mat src3,
                        double beta,
                        Mat dst,
                        int flags)
        Performs generalized matrix multiplication. The function cv::gemm performs generalized matrix multiplication similar to the gemm functions in BLAS level 3. For example, 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 - 実数(CV_32FC1, CV_64FC1)または複素数(CV_32FC2, CV_64FC2)になり得る、乗算される1つ目の入力行列。
        src2 - src1と同じ型の、乗算される2つ目の入力行列。
        alpha - 行列積の重み。
        src3 - 行列積に加算される3つ目のオプションのデルタ行列。src1およびsrc2と同じ型でなければならない。
        beta - src3の重み。
        dst - 出力行列。適切なサイズと入力行列と同じ型を持つ。
        flags - 演算フラグ(cv::GemmFlags) SEE: mulTransposed, transform

      • gemm

        public static void gemm​(Mat src1,
                        Mat src2,
                        double alpha,
                        Mat src3,
                        double beta,
                        Mat dst)
        Performs generalized matrix multiplication. The function cv::gemm performs generalized matrix multiplication similar to the gemm functions in BLAS level 3. For example, 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 - 実数(CV_32FC1, CV_64FC1)または複素数(CV_32FC2, CV_64FC2)になり得る、乗算される1つ目の入力行列。
        src2 - src1と同じ型の、乗算される2つ目の入力行列。
        alpha - 行列積の重み。
        src3 - 行列積に加算される3つ目のオプションのデルタ行列。src1およびsrc2と同じ型でなければならない。
        beta - src3の重み。
        dst - 出力行列。適切なサイズと入力行列と同じ型を持つ。 SEE: mulTransposed, transform

      • mulTransposed

        public static void mulTransposed​(Mat src,
                                 Mat dst,
                                 boolean aTa,
                                 Mat delta,
                                 double scale,
                                 int dtype)
        Calculates the product of a matrix and its transposition. The function cv::mulTransposed calculates the product of src and its transposition: \(\texttt{dst} = \texttt{scale} ( \texttt{src} - \texttt{delta} )^T ( \texttt{src} - \texttt{delta} )\) if aTa=true, and \(\texttt{dst} = \texttt{scale} ( \texttt{src} - \texttt{delta} ) ( \texttt{src} - \texttt{delta} )^T\) otherwise. The function is used to calculate the covariance matrix. With zero delta, it can be used as a faster substitute for general matrix product A\*B when B=A'
        引数:
        src - 入力シングルチャンネル行列。gemmと異なり、この関数は浮動小数点行列以外も乗算できることに注意。
        dst - 出力正方行列。
        aTa - 乗算の順序を指定するフラグ。下記の説明を参照。
        delta - 乗算の前にsrcから減算されるオプションのデルタ行列。行列が空(delta=noArray())のときは0とみなされ、何も減算されない。srcと同じサイズの場合は単純に減算される。それ以外の場合は、src全体を覆うように「繰り返され」(repeatを参照)てから減算される。デルタ行列が空でないときの型は、作成される出力行列の型と同じでなければならない。下記のdtype引数の説明を参照。
        scale - 行列積のオプションのスケール係数。
        dtype - 出力行列のオプションの型。負の場合、出力行列はsrcと同じ型になる。そうでなければ、type=CV_MAT_DEPTH(dtype)となり、CV_32FまたはCV_64Fのいずれかでなければならない。 SEE: calcCovarMatrix, gemm, repeat, reduce

      • mulTransposed

        public static void mulTransposed​(Mat src,
                                 Mat dst,
                                 boolean aTa,
                                 Mat delta,
                                 double scale)
        Calculates the product of a matrix and its transposition. The function cv::mulTransposed calculates the product of src and its transposition: \(\texttt{dst} = \texttt{scale} ( \texttt{src} - \texttt{delta} )^T ( \texttt{src} - \texttt{delta} )\) if aTa=true, and \(\texttt{dst} = \texttt{scale} ( \texttt{src} - \texttt{delta} ) ( \texttt{src} - \texttt{delta} )^T\) otherwise. The function is used to calculate the covariance matrix. With zero delta, it can be used as a faster substitute for general matrix product A\*B when B=A'
        引数:
        src - 入力シングルチャンネル行列。gemmと異なり、この関数は浮動小数点行列以外も乗算できることに注意。
        dst - 出力正方行列。
        aTa - 乗算の順序を指定するフラグ。下記の説明を参照。
        delta - 乗算の前にsrcから減算されるオプションのデルタ行列。行列が空(delta=noArray())のときは0とみなされ、何も減算されない。srcと同じサイズの場合は単純に減算される。それ以外の場合は、src全体を覆うように「繰り返され」(repeatを参照)てから減算される。デルタ行列が空でないときの型は、作成される出力行列の型と同じでなければならない。下記のdtype引数の説明を参照。
        scale - 行列積のオプションのスケール係数。 出力行列はsrcと同じ型になる。そうでなければ、type=CV_MAT_DEPTH(dtype)となり、CV_32FまたはCV_64Fのいずれかでなければならない。 SEE: calcCovarMatrix, gemm, repeat, reduce

      • mulTransposed

        public static void mulTransposed​(Mat src,
                                 Mat dst,
                                 boolean aTa,
                                 Mat delta)
        Calculates the product of a matrix and its transposition. The function cv::mulTransposed calculates the product of src and its transposition: \(\texttt{dst} = \texttt{scale} ( \texttt{src} - \texttt{delta} )^T ( \texttt{src} - \texttt{delta} )\) if aTa=true, and \(\texttt{dst} = \texttt{scale} ( \texttt{src} - \texttt{delta} ) ( \texttt{src} - \texttt{delta} )^T\) otherwise. The function is used to calculate the covariance matrix. With zero delta, it can be used as a faster substitute for general matrix product A\*B when B=A'
        引数:
        src - 入力シングルチャンネル行列。gemmと異なり、この関数は浮動小数点行列以外も乗算できることに注意。
        dst - 出力正方行列。
        aTa - 乗算の順序を指定するフラグ。下記の説明を参照。
        delta - 乗算の前にsrcから減算されるオプションのデルタ行列。行列が空(delta=noArray())のときは0とみなされ、何も減算されない。srcと同じサイズの場合は単純に減算される。それ以外の場合は、src全体を覆うように「繰り返され」(repeatを参照)てから減算される。デルタ行列が空でないときの型は、作成される出力行列の型と同じでなければならない。下記のdtype引数の説明を参照。 出力行列はsrcと同じ型になる。そうでなければ、type=CV_MAT_DEPTH(dtype)となり、CV_32FまたはCV_64Fのいずれかでなければならない。 SEE: calcCovarMatrix, gemm, repeat, reduce

      • mulTransposed

        public static void mulTransposed​(Mat src,
                                 Mat dst,
                                 boolean aTa)
        Calculates the product of a matrix and its transposition. The function cv::mulTransposed calculates the product of src and its transposition: \(\texttt{dst} = \texttt{scale} ( \texttt{src} - \texttt{delta} )^T ( \texttt{src} - \texttt{delta} )\) if aTa=true, and \(\texttt{dst} = \texttt{scale} ( \texttt{src} - \texttt{delta} ) ( \texttt{src} - \texttt{delta} )^T\) otherwise. The function is used to calculate the covariance matrix. With zero delta, it can be used as a faster substitute for general matrix product A\*B when B=A'
        引数:
        src - 入力シングルチャンネル行列。gemmと異なり、この関数は浮動小数点行列以外も乗算できることに注意。
        dst - 出力正方行列。
        aTa - 乗算の順序を指定するフラグ。下記の説明を参照。 乗算。行列が空(delta=noArray())のときは0とみなされ、何も減算されない。srcと同じサイズの場合は単純に減算される。それ以外の場合は、src全体を覆うように「繰り返され」(repeatを参照)てから減算される。デルタ行列が空でないときの型は、作成される出力行列の型と同じでなければならない。下記のdtype引数の説明を参照。 出力行列はsrcと同じ型になる。そうでなければ、type=CV_MAT_DEPTH(dtype)となり、CV_32FまたはCV_64Fのいずれかでなければならない。 SEE: calcCovarMatrix, gemm, repeat, reduce

      • transpose

        public static void transpose​(Mat src,
                             Mat dst)
        Transposes a matrix. The function cv::transpose transposes the matrix src : \(\texttt{dst} (i,j) = \texttt{src} (j,i)\) 覚え書き: No complex conjugation is done in case of a complex matrix. It should be done separately if needed.
        引数:
        src - 入力配列。
        dst - srcと同じ型の出力配列。

      • transposeND

        public static void transposeND​(Mat src,
                               MatOfInt order,
                               Mat dst)
        Transpose for n-dimensional matrices. 覚え書き: Input should be continuous single-channel matrix.
        引数:
        src - 入力配列。
        order - [0,1,..,N-1]の並べ替え。Nはsrcの軸数。dstのi番目の軸は、入力の軸番号order[i]に対応する。
        dst - srcと同じ型の出力配列。

      • transform

        public static void transform​(Mat src,
                             Mat dst,
                             Mat m)
        Performs the matrix transformation of every array element. The function cv::transform performs the matrix transformation of every element of the array src and stores the results in dst : \(\texttt{dst} (I) = \texttt{m} \cdot \texttt{src} (I)\) (when m.cols=src.channels() ), or \(\texttt{dst} (I) = \texttt{m} \cdot [ \texttt{src} (I); 1]\) (when m.cols=src.channels()+1 ) Every element of the N -channel array src is interpreted as N -element vector that is transformed using the M x N or M x (N+1) matrix m to M-element vector - the corresponding element of the output array dst . The function may be used for geometrical transformation of N -dimensional points, arbitrary linear color space transformation (such as various kinds of RGB to YUV transforms), shuffling the image channels, and so forth.
        引数:
        src - m.colsまたはm.cols-1と同じ数のチャンネル(1から4)を持たなければならない入力配列。
        dst - srcと同じサイズおよびビット深度の出力配列。m.rowsと同じ数のチャンネルを持つ。
        m - 変換用の2x2または2x3の浮動小数点行列。 SEE: perspectiveTransform, getAffineTransform, estimateAffine2D, warpAffine, warpPerspective

      • perspectiveTransform

        public static void perspectiveTransform​(Mat src,
                                        Mat dst,
                                        Mat m)
        Performs the perspective matrix transformation of vectors. The function cv::perspectiveTransform transforms every element of src by treating it as a 2D or 3D vector, in the following way: \((x, y, z) \rightarrow (x'/w, y'/w, z'/w)\) where \((x', y', z', w') = \texttt{mat} \cdot \begin{bmatrix} x & y & z & 1 \end{bmatrix}\) and \(w = \fork{w'}{if \(w' \ne 0\)}{\infty}{otherwise}\) Here a 3D vector transformation is shown. In case of a 2D vector transformation, the z component is omitted. 覚え書き: The function transforms a sparse set of 2D or 3D vectors. If you want to transform an image using perspective transformation, use warpPerspective . If you have an inverse problem, that is, you want to compute the most probable perspective transformation out of several pairs of corresponding points, you can use getPerspectiveTransform or findHomography .
        引数:
        src - 2チャンネルまたは3チャンネルの入力浮動小数点配列。各要素は変換される2D/3Dベクトルである。
        dst - src と同じサイズかつ同じ型の出力配列。
        m - 3x3または4x4の浮動小数点変換行列。 SEE: transform, warpPerspective, getPerspectiveTransform, findHomography

      • completeSymm

        public static void completeSymm​(Mat m,
                                boolean lowerToUpper)
        Copies the lower or the upper half of a square matrix to its another half. The function cv::completeSymm copies the lower or the upper half of a square matrix to its another half. The matrix diagonal remains unchanged:
        • lowerToUpper=false の場合、\(i > j\) について \(\texttt{m}_{ij}=\texttt{m}_{ji}\)
        • lowerToUpper=true の場合、\(i < j\) について \(\texttt{m}_{ij}=\texttt{m}_{ji}\)
        引数:
        m - 入出力の浮動小数点正方行列。
        lowerToUpper - 演算フラグ。trueの場合、下半分が上半分にコピーされる。そうでなければ、上半分が下半分にコピーされる。 SEE: flip, transpose

      • completeSymm

        public static void completeSymm​(Mat m)
        Copies the lower or the upper half of a square matrix to its another half. The function cv::completeSymm copies the lower or the upper half of a square matrix to its another half. The matrix diagonal remains unchanged:
        • lowerToUpper=false の場合、\(i > j\) について \(\texttt{m}_{ij}=\texttt{m}_{ji}\)
        • lowerToUpper=true の場合、\(i < j\) について \(\texttt{m}_{ij}=\texttt{m}_{ji}\)
        引数:
        m - 入出力の浮動小数点正方行列。 上半分。そうでなければ、上半分が下半分にコピーされる。 SEE: flip, transpose

      • setIdentity

        public static void setIdentity​(Mat mtx,
                               Scalar s)
        Initializes a scaled identity matrix. The function cv::setIdentity initializes a scaled identity matrix: \(\texttt{mtx} (i,j)= \fork{\texttt{value}}{ if \(i=j\)}{0}{otherwise}\) The function can also be emulated using the matrix initializers and the matrix expressions: 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 - 初期化する行列(正方行列でなくてもよい)。
        s - 対角要素に代入する値。 SEE: Mat::zeros, Mat::ones, Mat::setTo, Mat::operator=

      • setIdentity

        public static void setIdentity​(Mat mtx)
        Initializes a scaled identity matrix. The function cv::setIdentity initializes a scaled identity matrix: \(\texttt{mtx} (i,j)= \fork{\texttt{value}}{ if \(i=j\)}{0}{otherwise}\) The function can also be emulated using the matrix initializers and the matrix expressions: 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 - 初期化する行列(正方行列でなくてもよい)。 SEE: Mat::zeros, Mat::ones, Mat::setTo, Mat::operator=

      • determinant

        public static double determinant​(Mat mtx)
        Returns the determinant of a square floating-point matrix. The function cv::determinant calculates and returns the determinant of the specified matrix. For small matrices ( mtx.cols=mtx.rows<=3 ), the direct method is used. For larger matrices, the function uses LU factorization with partial pivoting. For symmetric positively-determined matrices, it is also possible to use eigen decomposition to calculate the determinant.
        引数:
        mtx - CV_32FC1 または CV_64FC1 型で正方サイズでなければならない入力行列。 SEE: trace, invert, solve, eigen, REF: MatrixExpressions
        戻り値:
        自動生成

      • trace

        public static Scalar trace​(Mat mtx)
        Returns the trace of a matrix. The function cv::trace returns the sum of the diagonal elements of the matrix mtx . \(\mathrm{tr} ( \texttt{mtx} ) = \sum _i \texttt{mtx} (i,i)\)
        引数:
        mtx - 入力行列。
        戻り値:
        自動生成

      • invert

        public static double invert​(Mat src,
                            Mat dst,
                            int flags)
        Finds the inverse or pseudo-inverse of a matrix. The function cv::invert inverts the matrix src and stores the result in dst . When the matrix src is singular or non-square, the function calculates the pseudo-inverse matrix (the dst matrix) so that norm(src\*dst - I) is minimal, where I is an identity matrix. In case of the #DECOMP_LU method, the function returns non-zero value if the inverse has been successfully calculated and 0 if src is singular. In case of the #DECOMP_SVD method, the function returns the inverse condition number of src (the ratio of the smallest singular value to the largest singular value) and 0 if src is singular. The SVD method calculates a pseudo-inverse matrix if src is singular. Similarly to #DECOMP_LU, the method #DECOMP_CHOLESKY works only with non-singular square matrices that should also be symmetrical and positively defined. In this case, the function stores the inverted matrix in dst and returns non-zero. Otherwise, it returns 0.
        引数:
        src - 入力の浮動小数点 M x N 行列。
        dst - N x M サイズで src と同じ型の出力行列。
        flags - 逆行列の計算手法 (cv::DecompTypes) SEE: solve, SVD
        戻り値:
        自動生成

      • invert

        public static double invert​(Mat src,
                            Mat dst)
        Finds the inverse or pseudo-inverse of a matrix. The function cv::invert inverts the matrix src and stores the result in dst . When the matrix src is singular or non-square, the function calculates the pseudo-inverse matrix (the dst matrix) so that norm(src\*dst - I) is minimal, where I is an identity matrix. In case of the #DECOMP_LU method, the function returns non-zero value if the inverse has been successfully calculated and 0 if src is singular. In case of the #DECOMP_SVD method, the function returns the inverse condition number of src (the ratio of the smallest singular value to the largest singular value) and 0 if src is singular. The SVD method calculates a pseudo-inverse matrix if src is singular. Similarly to #DECOMP_LU, the method #DECOMP_CHOLESKY works only with non-singular square matrices that should also be symmetrical and positively defined. In this case, the function stores the inverted matrix in dst and returns non-zero. Otherwise, it returns 0.
        引数:
        src - 入力の浮動小数点 M x N 行列。
        dst - N x M サイズで src と同じ型の出力行列。 SEE: solve, SVD
        戻り値:
        自動生成

      • solve

        public static boolean solve​(Mat src1,
                            Mat src2,
                            Mat dst,
                            int flags)
        Solves one or more linear systems or least-squares problems. The function cv::solve solves a linear system or least-squares problem (the latter is possible with SVD or QR methods, or by specifying the flag #DECOMP_NORMAL ): \(\texttt{dst} = \arg \min _X \| \texttt{src1} \cdot \texttt{X} - \texttt{src2} \|\) If #DECOMP_LU or #DECOMP_CHOLESKY method is used, the function returns 1 if src1 (or \(\texttt{src1}^T\texttt{src1}\) ) is non-singular. Otherwise, it returns 0. In the latter case, dst is not valid. Other methods find a pseudo-solution in case of a singular left-hand side part. 覚え書き: If you want to find a unity-norm solution of an under-defined singular system \(\texttt{src1}\cdot\texttt{dst}=0\) , the function solve will not do the work. Use SVD::solveZ instead.
        引数:
        src1 - 連立方程式の左辺の入力行列。
        src2 - 連立方程式の右辺の入力行列。
        dst - 出力される解。
        flags - 解法（逆行列の計算手法） (#DecompTypes) SEE: invert, SVD, eigen
        戻り値:
        自動生成

      • solve

        public static boolean solve​(Mat src1,
                            Mat src2,
                            Mat dst)
        Solves one or more linear systems or least-squares problems. The function cv::solve solves a linear system or least-squares problem (the latter is possible with SVD or QR methods, or by specifying the flag #DECOMP_NORMAL ): \(\texttt{dst} = \arg \min _X \| \texttt{src1} \cdot \texttt{X} - \texttt{src2} \|\) If #DECOMP_LU or #DECOMP_CHOLESKY method is used, the function returns 1 if src1 (or \(\texttt{src1}^T\texttt{src1}\) ) is non-singular. Otherwise, it returns 0. In the latter case, dst is not valid. Other methods find a pseudo-solution in case of a singular left-hand side part. 覚え書き: If you want to find a unity-norm solution of an under-defined singular system \(\texttt{src1}\cdot\texttt{dst}=0\) , the function solve will not do the work. Use SVD::solveZ instead.
        引数:
        src1 - 連立方程式の左辺の入力行列。
        src2 - 連立方程式の右辺の入力行列。
        dst - 出力される解。 SEE: invert, SVD, eigen
        戻り値:
        自動生成

      • sort

        public static void sort​(Mat src,
                        Mat dst,
                        int flags)
        Sorts each row or each column of a matrix. The function cv::sort sorts each matrix row or each matrix column in ascending or descending order. So you should pass two operation flags to get desired behaviour. If you want to sort matrix rows or columns lexicographically, you can use STL std::sort generic function with the proper comparison predicate.
        引数:
        src - 入力シングルチャンネル配列。
        dst - src と同じサイズかつ同じ型の出力配列。
        flags - 操作フラグ。#SortFlags の組み合わせ。 SEE: sortIdx, randShuffle

      • sortIdx

        public static void sortIdx​(Mat src,
                           Mat dst,
                           int flags)
        Sorts each row or each column of a matrix. The function cv::sortIdx sorts each matrix row or each matrix column in the ascending or descending order. So you should pass two operation flags to get desired behaviour. Instead of reordering the elements themselves, it stores the indices of sorted elements in the output array. For example: 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 - 入力シングルチャンネル配列。
        dst - src と同じサイズの整数型出力配列。
        flags - 操作フラグ。cv::SortFlags の組み合わせが可能。 SEE: sort, randShuffle

      • solveCubic

        public static int solveCubic​(Mat coeffs,
                             Mat roots)
        Finds the real roots of a cubic equation. The function solveCubic finds the real roots of a cubic equation:
        • coeffs が4要素のベクトルの場合: \(\texttt{coeffs} [0] x^3 + \texttt{coeffs} [1] x^2 + \texttt{coeffs} [2] x + \texttt{coeffs} [3] = 0\)
        • coeffs が3要素のベクトルの場合: \(x^3 + \texttt{coeffs} [0] x^2 + \texttt{coeffs} [1] x + \texttt{coeffs} [2] = 0\)
        The roots are stored in the roots array.
        引数:
        coeffs - 方程式の係数。3または4要素の配列。
        roots - 実数解の出力配列。0, 1, 2 または 3 個の要素を持つ。
        戻り値:
        実数解の個数。-1（すべての実数）、0、1、2、3 のいずれかとなる。

      • solvePoly

        public static double solvePoly​(Mat coeffs,
                               Mat roots,
                               int maxIters)
        Finds the real or complex roots of a polynomial equation. The function cv::solvePoly finds real and complex roots of a polynomial equation: \(\texttt{coeffs} [n] x^{n} + \texttt{coeffs} [n-1] x^{n-1} + ... + \texttt{coeffs} [1] x + \texttt{coeffs} [0] = 0\)
        引数:
        coeffs - 多項式の係数の配列。
        roots - 解の出力（複素数）配列。
        maxIters - アルゴリズムが行う最大反復回数。
        戻り値:
        自動生成

      • solvePoly

        public static double solvePoly​(Mat coeffs,
                               Mat roots)
        Finds the real or complex roots of a polynomial equation. The function cv::solvePoly finds real and complex roots of a polynomial equation: \(\texttt{coeffs} [n] x^{n} + \texttt{coeffs} [n-1] x^{n-1} + ... + \texttt{coeffs} [1] x + \texttt{coeffs} [0] = 0\)
        引数:
        coeffs - 多項式の係数の配列。
        roots - 解の出力（複素数）配列。
        戻り値:
        自動生成

      • eigen

        public static boolean eigen​(Mat src,
                            Mat eigenvalues,
                            Mat eigenvectors)
        Calculates eigenvalues and eigenvectors of a symmetric matrix. The function cv::eigen calculates just eigenvalues, or eigenvalues and eigenvectors of the symmetric matrix src: src*eigenvectors.row(i).t() = eigenvalues.at<srcType>(i)*eigenvectors.row(i).t() 覚え書き: Use cv::eigenNonSymmetric for calculation of real eigenvalues and eigenvectors of non-symmetric matrix.
        引数:
        src - CV_32FC1 または CV_64FC1 型で正方サイズかつ対称 (src ^T^ == src) でなければならない入力行列。
        eigenvalues - src と同じ型の固有値の出力ベクトル。固有値は降順に格納される。
        eigenvectors - 固有ベクトルの出力行列。src と同じサイズおよび型を持つ。固有ベクトルは行列の連続する行として、対応する固有値と同じ順序で格納される。 SEE: eigenNonSymmetric, completeSymm, PCA
        戻り値:
        自動生成

      • eigen

        public static boolean eigen​(Mat src,
                            Mat eigenvalues)
        Calculates eigenvalues and eigenvectors of a symmetric matrix. The function cv::eigen calculates just eigenvalues, or eigenvalues and eigenvectors of the symmetric matrix src: src*eigenvectors.row(i).t() = eigenvalues.at<srcType>(i)*eigenvectors.row(i).t() 覚え書き: Use cv::eigenNonSymmetric for calculation of real eigenvalues and eigenvectors of non-symmetric matrix.
        引数:
        src - CV_32FC1 または CV_64FC1 型で正方サイズかつ対称 (src ^T^ == src) でなければならない入力行列。
        eigenvalues - src と同じ型の固有値の出力ベクトル。固有値は降順に格納される。固有ベクトルは行列の連続する行として、対応する固有値と同じ順序で格納される。 SEE: eigenNonSymmetric, completeSymm, PCA
        戻り値:
        自動生成

      • eigenNonSymmetric

        public static void eigenNonSymmetric​(Mat src,
                                     Mat eigenvalues,
                                     Mat eigenvectors)
        Calculates eigenvalues and eigenvectors of a non-symmetric matrix (real eigenvalues only). 覚え書き: Assumes real eigenvalues. The function calculates eigenvalues and eigenvectors (optional) of the square matrix src: src*eigenvectors.row(i).t() = eigenvalues.at<srcType>(i)*eigenvectors.row(i).t()
        引数:
        src - 入力行列 (CV_32FC1 または CV_64FC1 型)。
        eigenvalues - 固有値の出力ベクトル（型は src と同じ）。
        eigenvectors - 固有ベクトルの出力行列（型は src と同じ）。固有ベクトルは行列の連続する行として、対応する固有値と同じ順序で格納される。 SEE: eigen

      • calcCovarMatrix

        public static void calcCovarMatrix​(Mat samples,
                                   Mat covar,
                                   Mat mean,
                                   int flags,
                                   int ctype)
        覚え書き: use #COVAR_ROWS or #COVAR_COLS flag
        引数:
        samples - 単一行列の行/列として格納されたサンプル。
        covar - ctype 型で正方サイズの共分散行列の出力。
        mean - 入力ベクトルの平均値としての入力または出力（フラグに依存）配列。
        flags - #CovarFlags の組み合わせとしての操作フラグ
        ctype - 行列の型。デフォルトでは 'CV_64F' に等しい。

      • calcCovarMatrix

        public static void calcCovarMatrix​(Mat samples,
                                   Mat covar,
                                   Mat mean,
                                   int flags)
        覚え書き: use #COVAR_ROWS or #COVAR_COLS flag
        引数:
        samples - 単一行列の行/列として格納されたサンプル。
        covar - ctype 型で正方サイズの共分散行列の出力。
        mean - 入力ベクトルの平均値としての入力または出力（フラグに依存）配列。
        flags - #CovarFlags の組み合わせとしての操作フラグ

      • PCACompute

        public static void PCACompute​(Mat data,
                              Mat mean,
                              Mat eigenvectors,
                              int maxComponents)
        wrap PCA::operator()
        引数:
        data - 自動生成
        mean - 自動生成
        eigenvectors - 自動生成
        maxComponents - 自動生成

      • PCACompute

        public static void PCACompute​(Mat data,
                              Mat mean,
                              Mat eigenvectors)
        wrap PCA::operator()
        引数:
        data - 自動生成
        mean - 自動生成
        eigenvectors - 自動生成

      • PCACompute2

        public static void PCACompute2​(Mat data,
                               Mat mean,
                               Mat eigenvectors,
                               Mat eigenvalues,
                               int maxComponents)
        wrap PCA::operator() and add eigenvalues output parameter
        引数:
        data - 自動生成
        mean - 自動生成
        eigenvectors - 自動生成
        eigenvalues - 自動生成
        maxComponents - 自動生成

      • PCACompute2

        public static void PCACompute2​(Mat data,
                               Mat mean,
                               Mat eigenvectors,
                               Mat eigenvalues)
        wrap PCA::operator() and add eigenvalues output parameter
        引数:
        data - 自動生成
        mean - 自動生成
        eigenvectors - 自動生成
        eigenvalues - 自動生成

      • PCACompute

        public static void PCACompute​(Mat data,
                              Mat mean,
                              Mat eigenvectors,
                              double retainedVariance)
        wrap PCA::operator()
        引数:
        data - 自動生成
        mean - 自動生成
        eigenvectors - 自動生成
        retainedVariance - 自動生成

      • PCACompute2

        public static void PCACompute2​(Mat data,
                               Mat mean,
                               Mat eigenvectors,
                               Mat eigenvalues,
                               double retainedVariance)
        wrap PCA::operator() and add eigenvalues output parameter
        引数:
        data - 自動生成
        mean - 自動生成
        eigenvectors - 自動生成
        eigenvalues - 自動生成
        retainedVariance - 自動生成

      • PCAProject

        public static void PCAProject​(Mat data,
                              Mat mean,
                              Mat eigenvectors,
                              Mat result)
        wrap PCA::project
        引数:
        data - 自動生成
        mean - 自動生成
        eigenvectors - 自動生成
        result - 自動生成

      • PCABackProject

        public static void PCABackProject​(Mat data,
                                  Mat mean,
                                  Mat eigenvectors,
                                  Mat result)
        wrap PCA::backProject
        引数:
        data - 自動生成
        mean - 自動生成
        eigenvectors - 自動生成
        result - 自動生成

      • SVDecomp

        public static void SVDecomp​(Mat src,
                            Mat w,
                            Mat u,
                            Mat vt,
                            int flags)
        wrap SVD::compute
        引数:
        src - 自動生成
        w - 自動生成
        u - 自動生成
        vt - 自動生成
        flags - 自動生成

      • SVDecomp

        public static void SVDecomp​(Mat src,
                            Mat w,
                            Mat u,
                            Mat vt)
        wrap SVD::compute
        引数:
        src - 自動生成
        w - 自動生成
        u - 自動生成
        vt - 自動生成

      • SVBackSubst

        public static void SVBackSubst​(Mat w,
                               Mat u,
                               Mat vt,
                               Mat rhs,
                               Mat dst)
        wrap SVD::backSubst
        引数:
        w - 自動生成
        u - 自動生成
        vt - 自動生成
        rhs - 自動生成
        dst - 自動生成

      • Mahalanobis

        public static double Mahalanobis​(Mat v1,
                                 Mat v2,
                                 Mat icovar)
        Calculates the Mahalanobis distance between two vectors. The function cv::Mahalanobis calculates and returns the weighted distance between two vectors: \(d( \texttt{vec1} , \texttt{vec2} )= \sqrt{\sum_{i,j}{\texttt{icovar(i,j)}\cdot(\texttt{vec1}(I)-\texttt{vec2}(I))\cdot(\texttt{vec1(j)}-\texttt{vec2(j)})} }\) The covariance matrix may be calculated using the #calcCovarMatrix function and then inverted using the invert function (preferably using the #DECOMP_SVD method, as the most accurate).
        引数:
        v1 - 1番目の1次元入力ベクトル。
        v2 - 2番目の1次元入力ベクトル。
        icovar - 共分散行列の逆行列。
        戻り値:
        自動生成

      • dft

        public 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. The function cv::dft performs one of the following:
        • N 要素の1次元ベクトルの順方向フーリエ変換: \(Y = F^{(N)} \cdot X,\) ここで \(F^{(N)}_{jk}=\exp(-2\pi i j k/N)\) かつ \(i=\sqrt{-1}\)
        • N 要素の1次元ベクトルの逆フーリエ変換: \(\begin{array}{l} X'= \left (F^{(N)} \right )^{-1} \cdot Y = \left (F^{(N)} \right )^* \cdot y \\ X = (1/N) \cdot X, \end{array}\) ここで \(F^*=\left(\textrm{Re}(F^{(N)})-\textrm{Im}(F^{(N)})\right)^T\)
        • M x N 行列の順方向2次元フーリエ変換: \(Y = F^{(M)} \cdot X \cdot F^{(N)}\)
        • M x N 行列の逆2次元フーリエ変換: \(\begin{array}{l} X'= \left (F^{(M)} \right )^* \cdot Y \cdot \left (F^{(N)} \right )^* \\ X = \frac{1}{M \cdot N} \cdot X' \end{array}\)
        In case of real (single-channel) data, the output spectrum of the forward Fourier transform or input spectrum of the inverse Fourier transform can be represented in a packed format called *CCS* (complex-conjugate-symmetrical). It was borrowed from IPL (Intel\* Image Processing Library). Here is how 2D *CCS* spectrum looks: \(\begin{bmatrix} Re Y_{0,0} & Re Y_{0,1} & Im Y_{0,1} & Re Y_{0,2} & Im Y_{0,2} & \cdots & Re Y_{0,N/2-1} & Im Y_{0,N/2-1} & Re Y_{0,N/2} \\ Re Y_{1,0} & Re Y_{1,1} & Im Y_{1,1} & Re Y_{1,2} & Im Y_{1,2} & \cdots & Re Y_{1,N/2-1} & Im Y_{1,N/2-1} & Re Y_{1,N/2} \\ Im Y_{1,0} & Re Y_{2,1} & Im Y_{2,1} & Re Y_{2,2} & Im Y_{2,2} & \cdots & Re Y_{2,N/2-1} & Im Y_{2,N/2-1} & Im Y_{1,N/2} \\ \hdotsfor{9} \\ Re Y_{M/2-1,0} & Re Y_{M-3,1} & Im Y_{M-3,1} & \hdotsfor{3} & Re Y_{M-3,N/2-1} & Im Y_{M-3,N/2-1}& Re Y_{M/2-1,N/2} \\ Im Y_{M/2-1,0} & Re Y_{M-2,1} & Im Y_{M-2,1} & \hdotsfor{3} & Re Y_{M-2,N/2-1} & Im Y_{M-2,N/2-1}& Im Y_{M/2-1,N/2} \\ Re Y_{M/2,0} & Re Y_{M-1,1} & Im Y_{M-1,1} & \hdotsfor{3} & Re Y_{M-1,N/2-1} & Im Y_{M-1,N/2-1}& Re Y_{M/2,N/2} \end{bmatrix}\) In case of 1D transform of a real vector, the output looks like the first row of the matrix above. So, the function chooses an operation mode depending on the flags and size of the input array:
        • #DFT_ROWS が設定されているか、入力配列が単一の行または単一の列を持つ場合、#DFT_ROWS が設定されているときには関数は行列の各行に対して1次元の順方向または逆変換を実行する。それ以外の場合は2次元変換を実行する。
        • If the input array is real and #DFT_INVERSE is not set, the function performs a forward 1D or 2D transform:
          • #DFT_COMPLEX_OUTPUT が設定されている場合、出力は入力と同じサイズの複素行列となる。
          • #DFT_COMPLEX_OUTPUT が設定されていない場合、出力は入力と同じサイズの実行列となる。2次元変換の場合は、上記のようなパック形式を使用する。単一の1次元変換の場合は、上記の行列の最初の行のようになる。複数の1次元変換（#DFT_ROWS フラグ使用時）の場合は、出力行列の各行が上記の行列の最初の行のようになる。
        • 入力配列が複素数で、#DFT_INVERSE または #DFT_REAL_OUTPUT のいずれも設定されていない場合、出力は入力と同じサイズの複素配列となる。関数は、フラグ DFT_INVERSE および DFT_ROWS に応じて、入力配列全体または入力配列の各行に対して独立に、順方向または逆方向の1次元または2次元変換を実行する。
        • #DFT_INVERSE が設定されていて入力配列が実数であるか、複素数であっても #DFT_REAL_OUTPUT が設定されている場合、出力は入力と同じサイズの実配列となる。関数は、フラグ #DFT_INVERSE および #DFT_ROWS に応じて、入力配列全体または各行に対して個別に1次元または2次元の逆変換を実行する。
        If #DFT_SCALE is set, the scaling is done after the transformation. Unlike dct, the function supports arrays of arbitrary size. But only those arrays are processed efficiently, whose sizes can be factorized in a product of small prime numbers (2, 3, and 5 in the current implementation). Such an efficient DFT size can be calculated using the getOptimalDFTSize method. The sample below illustrates how to calculate a DFT-based convolution of two 2D real arrays: 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:
        • 順方向変換の呼び出しに nonzeroRows != 0 が渡され、かつAとBがそれぞれtempAとtempBの左上隅にコピーされるため、tempAとtempB全体をクリアする必要はない。tempA.cols - A.cols ( tempB.cols - B.cols) の右端の列をクリアするだけでよい。
        • このDFTベースの畳み込みは、特にBがAより著しく小さい場合やその逆の場合、大きな配列全体に適用する必要はない。代わりに、部分ごとに畳み込みを計算できる。これを行うには、出力配列Cを複数のタイルに分割する必要がある。各タイルについて、そのタイルの畳み込みを計算するためにAとBのどの部分が必要かを推定する。Cのタイルが小さすぎると、重複した処理のために速度が大幅に低下する。極端な場合、Cの各タイルが単一ピクセルになると、アルゴリズムは素朴な畳み込みアルゴリズムと等価になる。タイルが大きすぎると、一時配列tempAとtempBが大きくなりすぎ、キャッシュ局所性の悪化によっても速度低下が生じる。したがって、最適なタイルサイズはその中間のどこかにある。
        • Cの異なるタイルを並列に計算でき、それによって畳み込みを部分ごとに行う場合、そのループはスレッド化できる。
        All of the above improvements have been implemented in #matchTemplate and #filter2D . Therefore, by using them, you can get the performance even better than with the above theoretically optimal implementation. Though, those two functions actually calculate cross-correlation, not convolution, so you need to "flip" the second convolution operand B vertically and horizontally using flip . 覚え書き:
        • 離散フーリエ変換を使った例は opencv_source_code/samples/cpp/dft.cpp にある。
        • (Python) dft機能を使ってウィーナー逆畳み込みを実行する例は opencv_source/samples/python/deconvolution.py にある。
        • (Python) フーリエ画像の象限を並べ替える例は opencv_source/samples/python/dft.py にある。
        引数:
        src - 実数または複素数のいずれかであり得る入力配列。
        dst - サイズと型がフラグに依存する出力配列。
        flags - 変換フラグ。#DftFlags の組み合わせを表す。
        nonzeroRows - このパラメータが0でない場合、関数は入力配列の最初の nonzeroRows 行（#DFT_INVERSE が設定されていない場合）または出力配列の最初の nonzeroRows 行（#DFT_INVERSE が設定されている場合）のみが非ゼロを含むと想定する。これにより、関数は残りの行をより効率的に処理して時間を節約できる。この手法は、DFT を用いた配列の相互相関や畳み込みの計算に非常に有用である。 SEE: dct, getOptimalDFTSize, mulSpectrums, filter2D, matchTemplate, flip, cartToPolar, magnitude, phase

      • dft

        public 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. The function cv::dft performs one of the following:
        • N 要素の1次元ベクトルの順方向フーリエ変換: \(Y = F^{(N)} \cdot X,\) ここで \(F^{(N)}_{jk}=\exp(-2\pi i j k/N)\) かつ \(i=\sqrt{-1}\)
        • N 要素の1次元ベクトルの逆フーリエ変換: \(\begin{array}{l} X'= \left (F^{(N)} \right )^{-1} \cdot Y = \left (F^{(N)} \right )^* \cdot y \\ X = (1/N) \cdot X, \end{array}\) ここで \(F^*=\left(\textrm{Re}(F^{(N)})-\textrm{Im}(F^{(N)})\right)^T\)
        • M x N 行列の順方向2次元フーリエ変換: \(Y = F^{(M)} \cdot X \cdot F^{(N)}\)
        • M x N 行列の逆2次元フーリエ変換: \(\begin{array}{l} X'= \left (F^{(M)} \right )^* \cdot Y \cdot \left (F^{(N)} \right )^* \\ X = \frac{1}{M \cdot N} \cdot X' \end{array}\)
        In case of real (single-channel) data, the output spectrum of the forward Fourier transform or input spectrum of the inverse Fourier transform can be represented in a packed format called *CCS* (complex-conjugate-symmetrical). It was borrowed from IPL (Intel\* Image Processing Library). Here is how 2D *CCS* spectrum looks: \(\begin{bmatrix} Re Y_{0,0} & Re Y_{0,1} & Im Y_{0,1} & Re Y_{0,2} & Im Y_{0,2} & \cdots & Re Y_{0,N/2-1} & Im Y_{0,N/2-1} & Re Y_{0,N/2} \\ Re Y_{1,0} & Re Y_{1,1} & Im Y_{1,1} & Re Y_{1,2} & Im Y_{1,2} & \cdots & Re Y_{1,N/2-1} & Im Y_{1,N/2-1} & Re Y_{1,N/2} \\ Im Y_{1,0} & Re Y_{2,1} & Im Y_{2,1} & Re Y_{2,2} & Im Y_{2,2} & \cdots & Re Y_{2,N/2-1} & Im Y_{2,N/2-1} & Im Y_{1,N/2} \\ \hdotsfor{9} \\ Re Y_{M/2-1,0} & Re Y_{M-3,1} & Im Y_{M-3,1} & \hdotsfor{3} & Re Y_{M-3,N/2-1} & Im Y_{M-3,N/2-1}& Re Y_{M/2-1,N/2} \\ Im Y_{M/2-1,0} & Re Y_{M-2,1} & Im Y_{M-2,1} & \hdotsfor{3} & Re Y_{M-2,N/2-1} & Im Y_{M-2,N/2-1}& Im Y_{M/2-1,N/2} \\ Re Y_{M/2,0} & Re Y_{M-1,1} & Im Y_{M-1,1} & \hdotsfor{3} & Re Y_{M-1,N/2-1} & Im Y_{M-1,N/2-1}& Re Y_{M/2,N/2} \end{bmatrix}\) In case of 1D transform of a real vector, the output looks like the first row of the matrix above. So, the function chooses an operation mode depending on the flags and size of the input array:
        • #DFT_ROWS が設定されているか、入力配列が単一の行または単一の列を持つ場合、#DFT_ROWS が設定されているときには関数は行列の各行に対して1次元の順方向または逆変換を実行する。それ以外の場合は2次元変換を実行する。
        • If the input array is real and #DFT_INVERSE is not set, the function performs a forward 1D or 2D transform:
          • #DFT_COMPLEX_OUTPUT が設定されている場合、出力は入力と同じサイズの複素行列となる。
          • #DFT_COMPLEX_OUTPUT が設定されていない場合、出力は入力と同じサイズの実行列となる。2次元変換の場合は、上記のようなパック形式を使用する。単一の1次元変換の場合は、上記の行列の最初の行のようになる。複数の1次元変換（#DFT_ROWS フラグ使用時）の場合は、出力行列の各行が上記の行列の最初の行のようになる。
        • 入力配列が複素数で、#DFT_INVERSE または #DFT_REAL_OUTPUT のいずれも設定されていない場合、出力は入力と同じサイズの複素配列となる。関数は、フラグ DFT_INVERSE および DFT_ROWS に応じて、入力配列全体または入力配列の各行に対して独立に、順方向または逆方向の1次元または2次元変換を実行する。
        • #DFT_INVERSE が設定されていて入力配列が実数であるか、複素数であっても #DFT_REAL_OUTPUT が設定されている場合、出力は入力と同じサイズの実配列となる。関数は、フラグ #DFT_INVERSE および #DFT_ROWS に応じて、入力配列全体または各行に対して個別に1次元または2次元の逆変換を実行する。
        If #DFT_SCALE is set, the scaling is done after the transformation. Unlike dct, the function supports arrays of arbitrary size. But only those arrays are processed efficiently, whose sizes can be factorized in a product of small prime numbers (2, 3, and 5 in the current implementation). Such an efficient DFT size can be calculated using the getOptimalDFTSize method. The sample below illustrates how to calculate a DFT-based convolution of two 2D real arrays: 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:
        • 順方向変換の呼び出しに nonzeroRows != 0 が渡され、かつAとBがそれぞれtempAとtempBの左上隅にコピーされるため、tempAとtempB全体をクリアする必要はない。tempA.cols - A.cols ( tempB.cols - B.cols) の右端の列をクリアするだけでよい。
        • このDFTベースの畳み込みは、特にBがAより著しく小さい場合やその逆の場合、大きな配列全体に適用する必要はない。代わりに、部分ごとに畳み込みを計算できる。これを行うには、出力配列Cを複数のタイルに分割する必要がある。各タイルについて、そのタイルの畳み込みを計算するためにAとBのどの部分が必要かを推定する。Cのタイルが小さすぎると、重複した処理のために速度が大幅に低下する。極端な場合、Cの各タイルが単一ピクセルになると、アルゴリズムは素朴な畳み込みアルゴリズムと等価になる。タイルが大きすぎると、一時配列tempAとtempBが大きくなりすぎ、キャッシュ局所性の悪化によっても速度低下が生じる。したがって、最適なタイルサイズはその中間のどこかにある。
        • Cの異なるタイルを並列に計算でき、それによって畳み込みを部分ごとに行う場合、そのループはスレッド化できる。
        All of the above improvements have been implemented in #matchTemplate and #filter2D . Therefore, by using them, you can get the performance even better than with the above theoretically optimal implementation. Though, those two functions actually calculate cross-correlation, not convolution, so you need to "flip" the second convolution operand B vertically and horizontally using flip . 覚え書き:
        • 離散フーリエ変換を使った例は opencv_source_code/samples/cpp/dft.cpp にある。
        • (Python) dft機能を使ってウィーナー逆畳み込みを実行する例は opencv_source/samples/python/deconvolution.py にある。
        • (Python) フーリエ画像の象限を並べ替える例は opencv_source/samples/python/dft.py にある。
        引数:
        src - 実数または複素数のいずれかであり得る入力配列。
        dst - サイズと型がフラグに依存する出力配列。
        flags - 変換フラグ。#DftFlags の組み合わせを表す。入力配列の最初の nonzeroRows 行（#DFT_INVERSE が設定されていない場合）または出力配列の最初の nonzeroRows 行（#DFT_INVERSE が設定されている場合）のみが非ゼロを含む。これにより、関数は残りの行をより効率的に処理して時間を節約できる。この手法は、DFT を用いた配列の相互相関や畳み込みの計算に非常に有用である。 SEE: dct, getOptimalDFTSize, mulSpectrums, filter2D, matchTemplate, flip, cartToPolar, magnitude, phase

      • dft

        public static void dft​(Mat src,
                       Mat dst)
        Performs a forward or inverse Discrete Fourier transform of a 1D or 2D floating-point array. The function cv::dft performs one of the following:
        • N 要素の1次元ベクトルの順方向フーリエ変換: \(Y = F^{(N)} \cdot X,\) ここで \(F^{(N)}_{jk}=\exp(-2\pi i j k/N)\) かつ \(i=\sqrt{-1}\)
        • N 要素の1次元ベクトルの逆フーリエ変換: \(\begin{array}{l} X'= \left (F^{(N)} \right )^{-1} \cdot Y = \left (F^{(N)} \right )^* \cdot y \\ X = (1/N) \cdot X, \end{array}\) ここで \(F^*=\left(\textrm{Re}(F^{(N)})-\textrm{Im}(F^{(N)})\right)^T\)
        • M x N 行列の順方向2次元フーリエ変換: \(Y = F^{(M)} \cdot X \cdot F^{(N)}\)
        • M x N 行列の逆2次元フーリエ変換: \(\begin{array}{l} X'= \left (F^{(M)} \right )^* \cdot Y \cdot \left (F^{(N)} \right )^* \\ X = \frac{1}{M \cdot N} \cdot X' \end{array}\)
        In case of real (single-channel) data, the output spectrum of the forward Fourier transform or input spectrum of the inverse Fourier transform can be represented in a packed format called *CCS* (complex-conjugate-symmetrical). It was borrowed from IPL (Intel\* Image Processing Library). Here is how 2D *CCS* spectrum looks: \(\begin{bmatrix} Re Y_{0,0} & Re Y_{0,1} & Im Y_{0,1} & Re Y_{0,2} & Im Y_{0,2} & \cdots & Re Y_{0,N/2-1} & Im Y_{0,N/2-1} & Re Y_{0,N/2} \\ Re Y_{1,0} & Re Y_{1,1} & Im Y_{1,1} & Re Y_{1,2} & Im Y_{1,2} & \cdots & Re Y_{1,N/2-1} & Im Y_{1,N/2-1} & Re Y_{1,N/2} \\ Im Y_{1,0} & Re Y_{2,1} & Im Y_{2,1} & Re Y_{2,2} & Im Y_{2,2} & \cdots & Re Y_{2,N/2-1} & Im Y_{2,N/2-1} & Im Y_{1,N/2} \\ \hdotsfor{9} \\ Re Y_{M/2-1,0} & Re Y_{M-3,1} & Im Y_{M-3,1} & \hdotsfor{3} & Re Y_{M-3,N/2-1} & Im Y_{M-3,N/2-1}& Re Y_{M/2-1,N/2} \\ Im Y_{M/2-1,0} & Re Y_{M-2,1} & Im Y_{M-2,1} & \hdotsfor{3} & Re Y_{M-2,N/2-1} & Im Y_{M-2,N/2-1}& Im Y_{M/2-1,N/2} \\ Re Y_{M/2,0} & Re Y_{M-1,1} & Im Y_{M-1,1} & \hdotsfor{3} & Re Y_{M-1,N/2-1} & Im Y_{M-1,N/2-1}& Re Y_{M/2,N/2} \end{bmatrix}\) In case of 1D transform of a real vector, the output looks like the first row of the matrix above. So, the function chooses an operation mode depending on the flags and size of the input array:
        • #DFT_ROWS が設定されているか、入力配列が単一の行または単一の列を持つ場合、#DFT_ROWS が設定されているときには関数は行列の各行に対して1次元の順方向または逆変換を実行する。それ以外の場合は2次元変換を実行する。
        • If the input array is real and #DFT_INVERSE is not set, the function performs a forward 1D or 2D transform:
          • #DFT_COMPLEX_OUTPUT が設定されている場合、出力は入力と同じサイズの複素行列となる。
          • #DFT_COMPLEX_OUTPUT が設定されていない場合、出力は入力と同じサイズの実行列となる。2次元変換の場合は、上記のようなパック形式を使用する。単一の1次元変換の場合は、上記の行列の最初の行のようになる。複数の1次元変換（#DFT_ROWS フラグ使用時）の場合は、出力行列の各行が上記の行列の最初の行のようになる。
        • 入力配列が複素数で、#DFT_INVERSE または #DFT_REAL_OUTPUT のいずれも設定されていない場合、出力は入力と同じサイズの複素配列となる。関数は、フラグ DFT_INVERSE および DFT_ROWS に応じて、入力配列全体または入力配列の各行に対して独立に、順方向または逆方向の1次元または2次元変換を実行する。
        • #DFT_INVERSE が設定されていて入力配列が実数であるか、複素数であっても #DFT_REAL_OUTPUT が設定されている場合、出力は入力と同じサイズの実配列となる。関数は、フラグ #DFT_INVERSE および #DFT_ROWS に応じて、入力配列全体または各行に対して個別に1次元または2次元の逆変換を実行する。
        If #DFT_SCALE is set, the scaling is done after the transformation. Unlike dct, the function supports arrays of arbitrary size. But only those arrays are processed efficiently, whose sizes can be factorized in a product of small prime numbers (2, 3, and 5 in the current implementation). Such an efficient DFT size can be calculated using the getOptimalDFTSize method. The sample below illustrates how to calculate a DFT-based convolution of two 2D real arrays: 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:
        • 順方向変換の呼び出しに nonzeroRows != 0 が渡され、かつAとBがそれぞれtempAとtempBの左上隅にコピーされるため、tempAとtempB全体をクリアする必要はない。tempA.cols - A.cols ( tempB.cols - B.cols) の右端の列をクリアするだけでよい。
        • このDFTベースの畳み込みは、特にBがAより著しく小さい場合やその逆の場合、大きな配列全体に適用する必要はない。代わりに、部分ごとに畳み込みを計算できる。これを行うには、出力配列Cを複数のタイルに分割する必要がある。各タイルについて、そのタイルの畳み込みを計算するためにAとBのどの部分が必要かを推定する。Cのタイルが小さすぎると、重複した処理のために速度が大幅に低下する。極端な場合、Cの各タイルが単一ピクセルになると、アルゴリズムは素朴な畳み込みアルゴリズムと等価になる。タイルが大きすぎると、一時配列tempAとtempBが大きくなりすぎ、キャッシュ局所性の悪化によっても速度低下が生じる。したがって、最適なタイルサイズはその中間のどこかにある。
        • Cの異なるタイルを並列に計算でき、それによって畳み込みを部分ごとに行う場合、そのループはスレッド化できる。
        All of the above improvements have been implemented in #matchTemplate and #filter2D . Therefore, by using them, you can get the performance even better than with the above theoretically optimal implementation. Though, those two functions actually calculate cross-correlation, not convolution, so you need to "flip" the second convolution operand B vertically and horizontally using flip . 覚え書き:
        • 離散フーリエ変換を使った例は opencv_source_code/samples/cpp/dft.cpp にある。
        • (Python) dft機能を使ってウィーナー逆畳み込みを実行する例は opencv_source/samples/python/deconvolution.py にある。
        • (Python) フーリエ画像の象限を並べ替える例は opencv_source/samples/python/dft.py にある。
        引数:
        src - 実数または複素数のいずれかであり得る入力配列。
        dst - サイズと型がフラグに依存する出力配列。入力配列の最初の nonzeroRows 行（#DFT_INVERSE が設定されていない場合）または出力配列の最初の nonzeroRows 行（#DFT_INVERSE が設定されている場合）のみが非ゼロを含む。これにより、関数は残りの行をより効率的に処理して時間を節約できる。この手法は、DFT を用いた配列の相互相関や畳み込みの計算に非常に有用である。 SEE: dct, getOptimalDFTSize, mulSpectrums, filter2D, matchTemplate, flip, cartToPolar, magnitude, phase

      • idft

        public static void idft​(Mat src,
                        Mat dst,
                        int flags,
                        int nonzeroRows)
        Calculates the inverse Discrete Fourier Transform of a 1D or 2D array. idft(src, dst, flags) is equivalent to dft(src, dst, flags | #DFT_INVERSE) . 覚え書き: None of dft and idft scales the result by default. So, you should pass #DFT_SCALE to one of dft or idft explicitly to make these transforms mutually inverse. SEE: dft, dct, idct, mulSpectrums, getOptimalDFTSize
        引数:
        src - 入力の浮動小数点型の実数または複素数配列。
        dst - サイズと型がフラグに依存する出力配列。
        flags - 演算フラグ（dft および #DftFlags を参照）。
        nonzeroRows - 処理する dst の行数。残りの行の内容は未定義となる（dft の説明にある畳み込みのサンプルを参照）。

      • idft

        public static void idft​(Mat src,
                        Mat dst,
                        int flags)
        Calculates the inverse Discrete Fourier Transform of a 1D or 2D array. idft(src, dst, flags) is equivalent to dft(src, dst, flags | #DFT_INVERSE) . 覚え書き: None of dft and idft scales the result by default. So, you should pass #DFT_SCALE to one of dft or idft explicitly to make these transforms mutually inverse. SEE: dft, dct, idct, mulSpectrums, getOptimalDFTSize
        引数:
        src - 入力の浮動小数点型の実数または複素数配列。
        dst - サイズと型がフラグに依存する出力配列。
        flags - 演算フラグ（dft および #DftFlags を参照）。dft の説明にある畳み込みのサンプル。

      • idft

        public static void idft​(Mat src,
                        Mat dst)
        Calculates the inverse Discrete Fourier Transform of a 1D or 2D array. idft(src, dst, flags) is equivalent to dft(src, dst, flags | #DFT_INVERSE) . 覚え書き: None of dft and idft scales the result by default. So, you should pass #DFT_SCALE to one of dft or idft explicitly to make these transforms mutually inverse. SEE: dft, dct, idct, mulSpectrums, getOptimalDFTSize
        引数:
        src - 入力の浮動小数点型の実数または複素数配列。
        dst - サイズと型がフラグに依存する出力配列。dft の説明にある畳み込みのサンプル。

      • dct

        public static void dct​(Mat src,
                       Mat dst,
                       int flags)
        Performs a forward or inverse discrete Cosine transform of 1D or 2D array. The function cv::dct performs a forward or inverse discrete Cosine transform (DCT) of a 1D or 2D floating-point array:
        • N 個の要素からなる1次元ベクトルの順方向コサイン変換: \(Y = C^{(N)} \cdot X\) ただし \(C^{(N)}_{jk}= \sqrt{\alpha_j/N} \cos \left ( \frac{\pi(2k+1)j}{2N} \right )\) であり、\(\alpha_0=1\)、*j > 0* に対して \(\alpha_j=2\)。
        • N 個の要素からなる1次元ベクトルの逆コサイン変換: \(X = \left (C^{(N)} \right )^{-1} \cdot Y = \left (C^{(N)} \right )^T \cdot Y\)（\(C^{(N)}\) は直交行列であるため、\(C^{(N)} \cdot \left(C^{(N)}\right)^T = I\)）
        • M x N 行列の順方向2次元コサイン変換: \(Y = C^{(N)} \cdot X \cdot \left (C^{(N)} \right )^T\)
        • M x N 行列の逆2次元コサイン変換: \(X = \left (C^{(N)} \right )^T \cdot X \cdot C^{(N)}\)
        The function chooses the mode of operation by looking at the flags and size of the input array:
        • (flags & #DCT_INVERSE) == 0 の場合、この関数は順方向の1次元または2次元変換を行う。そうでない場合は、逆方向の1次元または2次元変換となる。
        • (flags & #DCT_ROWS) != 0 の場合、この関数は各行の1次元変換を行う。
        • 配列が単一の列または単一の行である場合、関数は1次元変換を実行する。
        • 上記のいずれにも当てはまらない場合、関数は2次元変換を実行する。
        覚え書き: Currently dct supports even-size arrays (2, 4, 6 ...). For data analysis and approximation, you can pad the array when necessary. Also, the function performance depends very much, and not monotonically, on the array size (see getOptimalDFTSize ). In the current implementation DCT of a vector of size N is calculated via DFT of a vector of size N/2 . Thus, the optimal DCT size N1 >= N can be calculated as: size_t getOptimalDCTSize(size_t N) { return 2*getOptimalDFTSize((N+1)/2); } N1 = getOptimalDCTSize(N);
        引数:
        src - 入力浮動小数点配列。
        dst - src と同じサイズおよび型の出力配列。
        flags - cv::DftFlags (DCT_*) の組み合わせとしての変換フラグ。 SEE: dft, getOptimalDFTSize, idct

      • dct

        public static void dct​(Mat src,
                       Mat dst)
        Performs a forward or inverse discrete Cosine transform of 1D or 2D array. The function cv::dct performs a forward or inverse discrete Cosine transform (DCT) of a 1D or 2D floating-point array:
        • N 個の要素からなる1次元ベクトルの順方向コサイン変換: \(Y = C^{(N)} \cdot X\) ただし \(C^{(N)}_{jk}= \sqrt{\alpha_j/N} \cos \left ( \frac{\pi(2k+1)j}{2N} \right )\) であり、\(\alpha_0=1\)、*j > 0* に対して \(\alpha_j=2\)。
        • N 個の要素からなる1次元ベクトルの逆コサイン変換: \(X = \left (C^{(N)} \right )^{-1} \cdot Y = \left (C^{(N)} \right )^T \cdot Y\)（\(C^{(N)}\) は直交行列であるため、\(C^{(N)} \cdot \left(C^{(N)}\right)^T = I\)）
        • M x N 行列の順方向2次元コサイン変換: \(Y = C^{(N)} \cdot X \cdot \left (C^{(N)} \right )^T\)
        • M x N 行列の逆2次元コサイン変換: \(X = \left (C^{(N)} \right )^T \cdot X \cdot C^{(N)}\)
        The function chooses the mode of operation by looking at the flags and size of the input array:
        • (flags & #DCT_INVERSE) == 0 の場合、この関数は順方向の1次元または2次元変換を行う。そうでない場合は、逆方向の1次元または2次元変換となる。
        • (flags & #DCT_ROWS) != 0 の場合、この関数は各行の1次元変換を行う。
        • 配列が単一の列または単一の行である場合、関数は1次元変換を実行する。
        • 上記のいずれにも当てはまらない場合、関数は2次元変換を実行する。
        覚え書き: Currently dct supports even-size arrays (2, 4, 6 ...). For data analysis and approximation, you can pad the array when necessary. Also, the function performance depends very much, and not monotonically, on the array size (see getOptimalDFTSize ). In the current implementation DCT of a vector of size N is calculated via DFT of a vector of size N/2 . Thus, the optimal DCT size N1 >= N can be calculated as: size_t getOptimalDCTSize(size_t N) { return 2*getOptimalDFTSize((N+1)/2); } N1 = getOptimalDCTSize(N);
        引数:
        src - 入力浮動小数点配列。
        dst - src と同じサイズおよび型の出力配列。 SEE: dft, getOptimalDFTSize, idct

      • idct

        public static void idct​(Mat src,
                        Mat dst,
                        int flags)
        Calculates the inverse Discrete Cosine Transform of a 1D or 2D array. idct(src, dst, flags) is equivalent to dct(src, dst, flags | DCT_INVERSE).
        引数:
        src - 入力の浮動小数点型シングルチャンネル配列。
        dst - src と同じサイズかつ同じ型の出力配列。
        flags - 演算フラグ。 SEE: dct, dft, idft, getOptimalDFTSize

      • idct

        public static void idct​(Mat src,
                        Mat dst)
        Calculates the inverse Discrete Cosine Transform of a 1D or 2D array. idct(src, dst, flags) is equivalent to dct(src, dst, flags | DCT_INVERSE).
        引数:
        src - 入力の浮動小数点型シングルチャンネル配列。
        dst - src と同じサイズおよび型の出力配列。 SEE: dct, dft, idft, getOptimalDFTSize

      • mulSpectrums

        public static void mulSpectrums​(Mat a,
                                Mat b,
                                Mat c,
                                int flags,
                                boolean conjB)
        Performs the per-element multiplication of two Fourier spectrums. The function cv::mulSpectrums performs the per-element multiplication of the two CCS-packed or complex matrices that are results of a real or complex Fourier transform. The function, together with dft and idft, may be used to calculate convolution (pass conjB=false ) or correlation (pass conjB=true ) of two arrays rapidly. When the arrays are complex, they are simply multiplied (per element) with an optional conjugation of the second-array elements. When the arrays are real, they are assumed to be CCS-packed (see dft for details).
        引数:
        a - 第1の入力配列。
        b - src1 と同じサイズおよび型の第2の入力配列。
        c - src1 と同じサイズおよび型の出力配列。
        flags - 演算フラグ。現在サポートされている唯一のフラグは cv::DFT_ROWS であり、これは src1 と src2 の各行が独立した1次元フーリエスペクトルであることを示す。このフラグを使用しない場合は、単に値として 0 を指定する。
        conjB - 乗算の前に第2の入力配列を共役にするか（true）しないか（false）を指定する省略可能なフラグ。

      • mulSpectrums

        public static void mulSpectrums​(Mat a,
                                Mat b,
                                Mat c,
                                int flags)
        Performs the per-element multiplication of two Fourier spectrums. The function cv::mulSpectrums performs the per-element multiplication of the two CCS-packed or complex matrices that are results of a real or complex Fourier transform. The function, together with dft and idft, may be used to calculate convolution (pass conjB=false ) or correlation (pass conjB=true ) of two arrays rapidly. When the arrays are complex, they are simply multiplied (per element) with an optional conjugation of the second-array elements. When the arrays are real, they are assumed to be CCS-packed (see dft for details).
        引数:
        a - 第1の入力配列。
        b - src1 と同じサイズおよび型の第2の入力配列。
        c - src1 と同じサイズおよび型の出力配列。
        flags - 演算フラグ。現在サポートされている唯一のフラグは cv::DFT_ROWS であり、これは src1 と src2 の各行が独立した1次元フーリエスペクトルであることを示す。このフラグを使用しない場合は、単に値として 0 を指定する。 しないか（false）。

      • getOptimalDFTSize

        public static int getOptimalDFTSize​(int vecsize)
        Returns the optimal DFT size for a given vector size. DFT performance is not a monotonic function of a vector size. Therefore, when you calculate convolution of two arrays or perform the spectral analysis of an array, it usually makes sense to pad the input data with zeros to get a bit larger array that can be transformed much faster than the original one. Arrays whose size is a power-of-two (2, 4, 8, 16, 32, ...) are the fastest to process. Though, the arrays whose size is a product of 2's, 3's, and 5's (for example, 300 = 5\*5\*3\*2\*2) are also processed quite efficiently. The function cv::getOptimalDFTSize returns the minimum number N that is greater than or equal to vecsize so that the DFT of a vector of size N can be processed efficiently. In the current implementation N = 2 ^p^ \* 3 ^q^ \* 5 ^r^ for some integer p, q, r. The function returns a negative number if vecsize is too large (very close to INT_MAX ). While the function cannot be used directly to estimate the optimal vector size for DCT transform (since the current DCT implementation supports only even-size vectors), it can be easily processed as getOptimalDFTSize((vecsize+1)/2)\*2.
        引数:
        vecsize - ベクトルのサイズ。 SEE: dft, dct, idft, idct, mulSpectrums
        戻り値:
        自動生成

      • setRNGSeed

        public static void setRNGSeed​(int seed)
        Sets state of default random number generator. The function cv::setRNGSeed sets state of default random number generator to custom value.
        引数:
        seed - デフォルトの乱数生成器の新しい状態 SEE: RNG, randu, randn

      • randu

        public static void randu​(Mat dst,
                         double low,
                         double high)
        Generates a single uniformly-distributed random number or an array of random numbers. Non-template variant of the function fills the matrix dst with uniformly-distributed random numbers from the specified range: \(\texttt{low} _c \leq \texttt{dst} (I)_c < \texttt{high} _c\)
        引数:
        dst - 乱数の出力配列。配列は事前に確保しておく必要がある。
        low - 生成される乱数の下限（含む）。
        high - 生成される乱数の上限（含まない）。 SEE: RNG, randn, theRNG

      • randn

        public static void randn​(Mat dst,
                         double mean,
                         double stddev)
        Fills the array with normally distributed random numbers. The function cv::randn fills the matrix dst with normally distributed random numbers with the specified mean vector and the standard deviation matrix. The generated random numbers are clipped to fit the value range of the output array data type.
        引数:
        dst - 乱数の出力配列。配列は事前に確保しておく必要があり、1〜4チャンネルである必要がある。
        mean - 生成される乱数の平均値（期待値）。
        stddev - 生成される乱数の標準偏差。ベクトル（この場合は対角の標準偏差行列とみなされる）または正方行列のいずれかを指定できる。 SEE: RNG, randu

      • randShuffle

        public static void randShuffle​(Mat dst,
                               double iterFactor)
        Shuffles the array elements randomly. The function cv::randShuffle shuffles the specified 1D array by randomly choosing pairs of elements and swapping them. The number of such swap operations will be dst.rows\*dst.cols\*iterFactor .
        引数:
        dst - 入出力の数値1次元配列。
        iterFactor - ランダムな入れ替え操作の回数を決定するスケール係数（詳細は下記を参照）。 SEE: RNG, sort

      • randShuffle

        public static void randShuffle​(Mat dst)
        Shuffles the array elements randomly. The function cv::randShuffle shuffles the specified 1D array by randomly choosing pairs of elements and swapping them. The number of such swap operations will be dst.rows\*dst.cols\*iterFactor .
        引数:
        dst - 入出力の数値1次元配列。下記）。 SEE: RNG, sort

      • kmeans

        public 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. The function kmeans implements a k-means algorithm that finds the centers of cluster_count clusters and groups the input samples around the clusters. As an output, \(\texttt{bestLabels}_i\) contains a 0-based cluster index for the sample stored in the \(i^{th}\) row of the samples matrix. 覚え書き:
        • (Python) k-meansクラスタリングの例は opencv_source_code/samples/python/kmeans.py にある
        引数:
        data - Data for clustering. An array of N-Dimensional points with float coordinates is needed. Examples of this array can be:
        • Mat points(count, 2, CV_32F);
        • Mat points(count, 1, CV_32FC2);
        • Mat points(1, count, CV_32FC2);
        • std::vector<cv::Point2f> points(sampleCount);
        K - 集合を分割するクラスタ数。
        bestLabels - すべてのサンプルについてクラスタのインデックスを格納する入出力の整数配列。
        criteria - アルゴリズムの終了基準。すなわち、最大反復回数および／または目標とする精度。精度は criteria.epsilon として指定する。ある反復において各クラスタ中心の移動量が criteria.epsilon 未満になり次第、アルゴリズムは停止する。
        attempts - 異なる初期ラベル割り当てを用いてアルゴリズムを実行する回数を指定するフラグ。アルゴリズムは最良のコンパクトさをもたらすラベルを返す（関数の最後の引数を参照）。
        flags - cv::KmeansFlags の値を取り得るフラグ
        centers - クラスタ中心の出力行列。各クラスタ中心につき1行。
        戻り値:
        この関数は、各試行後に \(\sum _i \| \texttt{samples} _i - \texttt{centers} _{ \texttt{labels} _i} \| ^2\) として計算されるコンパクトさの指標を返す。最良（最小）の値が選択され、対応するラベルとコンパクトさの値が関数によって返される。基本的には、この関数のコア部分のみを使用し、試行回数を1に設定し、毎回カスタムアルゴリズムを用いてラベルを初期化し、それらを ( flags = #KMEANS_USE_INITIAL_LABELS ) フラグで渡し、最良（最もコンパクト）なクラスタリングを選択することもできる。

      • kmeans

        public 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. The function kmeans implements a k-means algorithm that finds the centers of cluster_count clusters and groups the input samples around the clusters. As an output, \(\texttt{bestLabels}_i\) contains a 0-based cluster index for the sample stored in the \(i^{th}\) row of the samples matrix. 覚え書き:
        • (Python) k-meansクラスタリングの例は opencv_source_code/samples/python/kmeans.py にある
        引数:
        data - Data for clustering. An array of N-Dimensional points with float coordinates is needed. Examples of this array can be:
        • Mat points(count, 2, CV_32F);
        • Mat points(count, 1, CV_32FC2);
        • Mat points(1, count, CV_32FC2);
        • std::vector<cv::Point2f> points(sampleCount);
        K - 集合を分割するクラスタ数。
        bestLabels - すべてのサンプルについてクラスタのインデックスを格納する入出力の整数配列。
        criteria - アルゴリズムの終了基準。すなわち、最大反復回数および／または目標とする精度。精度は criteria.epsilon として指定する。ある反復において各クラスタ中心の移動量が criteria.epsilon 未満になり次第、アルゴリズムは停止する。
        attempts - 異なる初期ラベル割り当てを用いてアルゴリズムを実行する回数を指定するフラグ。アルゴリズムは最良のコンパクトさをもたらすラベルを返す（関数の最後の引数を参照）。
        flags - cv::KmeansFlags の値を取り得るフラグ
        戻り値:
        この関数は、各試行後に \(\sum _i \| \texttt{samples} _i - \texttt{centers} _{ \texttt{labels} _i} \| ^2\) として計算されるコンパクトさの指標を返す。最良（最小）の値が選択され、対応するラベルとコンパクトさの値が関数によって返される。基本的には、この関数のコア部分のみを使用し、試行回数を1に設定し、毎回カスタムアルゴリズムを用いてラベルを初期化し、それらを ( flags = #KMEANS_USE_INITIAL_LABELS ) フラグで渡し、最良（最もコンパクト）なクラスタリングを選択することもできる。

      • setNumThreads

        public static void setNumThreads​(int nthreads)
        OpenCV will try to set the number of threads for subsequent parallel regions. If threads == 1, OpenCV will disable threading optimizations and run all it's functions sequentially. Passing threads < 0 will reset threads number to system default. The function is not thread-safe. It must not be called in parallel region or concurrent threads. OpenCV will try to run its functions with specified threads number, but some behaviour differs from framework:
        • TBB - ユーザー定義の並列構成は、別途指定がなければ同じスレッド数で実行される。後にユーザーが独自のスケジューラを作成した場合、OpenCVはそれを使用する。
        • OpenMP - 特別な定義済みの挙動はない。
        • Concurrency - threads == 1 の場合、OpenCVはスレッド最適化を無効にし、関数を逐次実行する。
        • GCD - 値 <= 0 のみをサポートする。
        • C= - 特別に定義された動作はない。
        引数:
        nthreads - OpenCV が使用するスレッド数。 SEE: getNumThreads, getThreadNum

      • getNumThreads

        public static int getNumThreads()
        Returns the number of threads used by OpenCV for parallel regions. Always returns 1 if OpenCV is built without threading support. The exact meaning of return value depends on the threading framework used by OpenCV library:
        • TBB - OpenCVが並列領域で使用しようとするスレッド数。OpenCVと競合する tbb::thread_scheduler_init がユーザーコード内に存在する場合、この関数はTBBライブラリが使用するデフォルトのスレッド数を返す。
        • OpenMP - 新しいチームを形成するために使用できるスレッド数の上限。
        • Concurrency - OpenCVが並列領域で使用しようとするスレッド数。
        • GCD - 未サポート。互換性のためにGCDスレッドプールの上限値(512)を返す。
        • C= - 並列領域に対して OpenCV が使用しようとするスレッド数。事前に threads > 0 で setNumThreads が呼び出されている場合はその値、そうでない場合はプロセスが利用可能な論理 CPU 数を返す。 SEE: setNumThreads, getThreadNum
        戻り値:
        自動生成

      • getThreadNum

        @Deprecated
public static int getThreadNum()
        Deprecated.
        Current implementation doesn't corresponding to this documentation. The exact meaning of the return value depends on the threading framework used by OpenCV library:
        • TBB - 現在の4.1 TBBリリースでは未サポート。将来サポートされる可能性がある。
        • OpenMP - 現在のチーム内における、呼び出し元スレッドのスレッド番号。
        • Concurrency - 現在のコンテキストが実行されている仮想プロセッサのID(マスタースレッドでは0、その他では一意の番号となるが、必ずしも1,2,3,...とは限らない)。
        • GCD - システムが呼び出すスレッドのID。並列領域内では決して0を返さない。
        • C= - 現在の並列タスクのインデックス。SEE: setNumThreads, getNumThreads
        Returns the index of the currently executed thread within the current parallel region. Always returns 0 if called outside of parallel region.
        戻り値:
        自動生成

      • getBuildInformation

        public static java.lang.String getBuildInformation()
        Returns full configuration time cmake output. Returned value is raw cmake output including version control system revision, compiler version, compiler flags, enabled modules and third party libraries, etc. Output format depends on target architecture.
        戻り値:
        自動生成

      • getVersionString

        public static java.lang.String getVersionString()
        Returns library version string For example "3.4.1-dev". SEE: getMajorVersion, getMinorVersion, getRevisionVersion
        戻り値:
        自動生成

      • getVersionMajor

        public static int getVersionMajor()
        Returns major library version
        戻り値:
        自動生成

      • getVersionMinor

        public static int getVersionMinor()
        Returns minor library version
        戻り値:
        自動生成

      • getVersionRevision

        public static int getVersionRevision()
        Returns revision field of the library version
        戻り値:
        自動生成

      • getTickCount

        public static long getTickCount()
        Returns the number of ticks. The function returns the number of ticks after the certain event (for example, when the machine was turned on). It can be used to initialize RNG or to measure a function execution time by reading the tick count before and after the function call. SEE: getTickFrequency, TickMeter
        戻り値:
        自動生成

      • getTickFrequency

        public static double getTickFrequency()
        Returns the number of ticks per second. The function returns the number of ticks per second. That is, the following code computes the execution time in seconds: double t = (double)getTickCount(); // do something ... t = ((double)getTickCount() - t)/getTickFrequency(); SEE: getTickCount, TickMeter
        戻り値:
        自動生成

      • getCPUTickCount

        public static long getCPUTickCount()
        Returns the number of CPU ticks. The function returns the current number of CPU ticks on some architectures (such as x86, x64, PowerPC). On other platforms the function is equivalent to getTickCount. It can also be used for very accurate time measurements, as well as for RNG initialization. Note that in case of multi-CPU systems a thread, from which getCPUTickCount is called, can be suspended and resumed at another CPU with its own counter. So, theoretically (and practically) the subsequent calls to the function do not necessary return the monotonously increasing values. Also, since a modern CPU varies the CPU frequency depending on the load, the number of CPU clocks spent in some code cannot be directly converted to time units. Therefore, getTickCount is generally a preferable solution for measuring execution time.
        戻り値:
        自動生成

      • checkHardwareSupport

        public static boolean checkHardwareSupport​(int feature)
        Returns true if the specified feature is supported by the host hardware. The function returns true if the host hardware supports the specified feature. When user calls setUseOptimized(false), the subsequent calls to checkHardwareSupport() will return false until setUseOptimized(true) is called. This way user can dynamically switch on and off the optimized code in OpenCV.
        引数:
        feature - 対象とする機能。cv::CpuFeatures のいずれか
        戻り値:
        自動生成

      • getHardwareFeatureName

        public static java.lang.String getHardwareFeatureName​(int feature)
        Returns feature name by ID Returns empty string if feature is not defined
        引数:
        feature - 自動生成
        戻り値:
        自動生成

      • getCPUFeaturesLine

        public static java.lang.String getCPUFeaturesLine()
        Returns list of CPU features enabled during compilation. Returned value is a string containing space separated list of CPU features with following markers:
        • マーカーなし - ベースライン機能
        • 接頭辞 * - ディスパッチャで有効化された機能
        • 接尾辞 ? - 有効化されているがハードウェアでは利用できない機能
        Example: SSE SSE2 SSE3 *SSE4.1 *SSE4.2 *FP16 *AVX *AVX2 *AVX512-SKX?
        戻り値:
        自動生成

      • getNumberOfCPUs

        public static int getNumberOfCPUs()
        Returns the number of logical CPUs available for the process.
        戻り値:
        自動生成

      • getDefaultAlgorithmHint

        public static int getDefaultAlgorithmHint()

      • setUseOptimized

        public static void setUseOptimized​(boolean onoff)
        Enables or disables the optimized code. The function can be used to dynamically turn on and off optimized dispatched code (code that uses SSE4.2, AVX/AVX2, and other instructions on the platforms that support it). It sets a global flag that is further checked by OpenCV functions. Since the flag is not checked in the inner OpenCV loops, it is only safe to call the function on the very top level in your application where you can be sure that no other OpenCV function is currently executed. By default, the optimized code is enabled unless you disable it in CMake. The current status can be retrieved using useOptimized.
        引数:
        onoff - 最適化されたコードを使用する（onoff=true）か使用しない（onoff=false）かを指定するブール値フラグ。

      • useOptimized

        public static boolean useOptimized()
        Returns the status of optimized code usage. The function returns true if the optimized code is enabled. Otherwise, it returns false.
        戻り値:
        自動生成

      • findFile

        public static java.lang.String findFile​(java.lang.String relative_path,
                                        boolean required,
                                        boolean silentMode)
        Try to find requested data file Search directories: 1. Directories passed via 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 &lt;source&gt;/{,data,samples/data} directories if build directory is detected or the current directory is in source tree. 6. Scan &lt;install&gt;/share/OpenCV directory if install directory is detected. SEE: cv::utils::findDataFile
        引数:
        relative_path - データファイルへの相対パス
        required - 「ファイルが見つからない」場合の処理を指定する。true の場合、関数は情報メッセージを出力し cv::Exception を送出する。false の場合、関数は空の結果を返す
        silentMode - メッセージを無効化する
        戻り値:
        パス (絶対パスまたは現在のディレクトリからの相対パス) を返す。ファイルが見つからない場合は空文字列を返す。

      • findFile

        public static java.lang.String findFile​(java.lang.String relative_path,
                                        boolean required)
        Try to find requested data file Search directories: 1. Directories passed via 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 &lt;source&gt;/{,data,samples/data} directories if build directory is detected or the current directory is in source tree. 6. Scan &lt;install&gt;/share/OpenCV directory if install directory is detected. SEE: cv::utils::findDataFile
        引数:
        relative_path - データファイルへの相対パス
        required - 「ファイルが見つからない」場合の処理を指定する。true の場合、関数は情報メッセージを出力し cv::Exception を送出する。false の場合、関数は空の結果を返す
        戻り値:
        パス (絶対パスまたは現在のディレクトリからの相対パス) を返す。ファイルが見つからない場合は空文字列を返す。

      • findFile

        public static java.lang.String findFile​(java.lang.String relative_path)
        Try to find requested data file Search directories: 1. Directories passed via 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 &lt;source&gt;/{,data,samples/data} directories if build directory is detected or the current directory is in source tree. 6. Scan &lt;install&gt;/share/OpenCV directory if install directory is detected. SEE: cv::utils::findDataFile
        引数:
        relative_path - データファイルへの相対パス。true の場合、関数は情報メッセージを出力し cv::Exception を送出する。false の場合、関数は空の結果を返す
        戻り値:
        パス (絶対パスまたは現在のディレクトリからの相対パス) を返す。ファイルが見つからない場合は空文字列を返す。

      • findFileOrKeep

        public static java.lang.String findFileOrKeep​(java.lang.String relative_path,
                                              boolean silentMode)

      • findFileOrKeep

        public static java.lang.String findFileOrKeep​(java.lang.String relative_path)

      • addSamplesDataSearchPath

        public 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.
        引数:
        path - 使用するサンプルデータへのパス

      • addSamplesDataSearchSubDirectory

        public static void addSamplesDataSearchSubDirectory​(java.lang.String subdir)
        Append samples search data sub directory General usage is to add OpenCV modules name (&lt;opencv_contrib&gt;/modules/&lt;name&gt;/samples/data -> &lt;name&gt;/samples/data + modules/&lt;name&gt;/samples/data). Passed subdirectories are used in LIFO order.
        引数:
        subdir - サンプルデータのサブディレクトリ

      • setErrorVerbosity

        public static void setErrorVerbosity​(boolean verbose)

      • add

        public static void add​(Mat src1,
                       Scalar src2,
                       Mat dst,
                       Mat mask,
                       int dtype)

      • add

        public static void add​(Mat src1,
                       Scalar src2,
                       Mat dst,
                       Mat mask)

      • add

        public static void add​(Mat src1,
                       Scalar src2,
                       Mat dst)

      • subtract

        public static void subtract​(Mat src1,
                            Scalar src2,
                            Mat dst,
                            Mat mask,
                            int dtype)

      • subtract

        public static void subtract​(Mat src1,
                            Scalar src2,
                            Mat dst,
                            Mat mask)

      • subtract

        public static void subtract​(Mat src1,
                            Scalar src2,
                            Mat dst)

      • multiply

        public static void multiply​(Mat src1,
                            Scalar src2,
                            Mat dst,
                            double scale,
                            int dtype)

      • multiply

        public static void multiply​(Mat src1,
                            Scalar src2,
                            Mat dst,
                            double scale)

      • multiply

        public static void multiply​(Mat src1,
                            Scalar src2,
                            Mat dst)

      • divide

        public static void divide​(Mat src1,
                          Scalar src2,
                          Mat dst,
                          double scale,
                          int dtype)

      • divide

        public static void divide​(Mat src1,
                          Scalar src2,
                          Mat dst,
                          double scale)

      • divide

        public static void divide​(Mat src1,
                          Scalar src2,
                          Mat dst)

      • absdiff

        public static void absdiff​(Mat src1,
                           Scalar src2,
                           Mat dst)

      • compare

        public static void compare​(Mat src1,
                           Scalar src2,
                           Mat dst,
                           int cmpop)

      • min

        public static void min​(Mat src1,
                       Scalar src2,
                       Mat dst)

      • max

        public static void max​(Mat src1,
                       Scalar src2,
                       Mat dst)