Renesas GR-PEACH OpenCV Development
/
gr-peach-opencv-project-sd-card_update
Important changes to repositories hosted on mbed.com
Mbed hosted mercurial repositories are deprecated and are due to be permanently deleted in July 2026.
To keep a copy of this software download the repository Zip archive or clone locally using Mercurial.
It is also possible to export all your personal repositories from the account settings page.
Fork of
gr-peach-opencv-project-sd-card
by 
the do
Embed:
(wiki syntax)
Show/hide line numbers
core.hpp
00001 /*M/////////////////////////////////////////////////////////////////////////////////////// 00002 // 00003 // IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING. 00004 // 00005 // By downloading, copying, installing or using the software you agree to this license. 00006 // If you do not agree to this license, do not download, install, 00007 // copy or use the software. 00008 // 00009 // 00010 // License Agreement 00011 // For Open Source Computer Vision Library 00012 // 00013 // Copyright (C) 2000-2015, Intel Corporation, all rights reserved. 00014 // Copyright (C) 2009-2011, Willow Garage Inc., all rights reserved. 00015 // Copyright (C) 2015, OpenCV Foundation, all rights reserved. 00016 // Copyright (C) 2015, Itseez Inc., all rights reserved. 00017 // Third party copyrights are property of their respective owners. 00018 // 00019 // Redistribution and use in source and binary forms, with or without modification, 00020 // are permitted provided that the following conditions are met: 00021 // 00022 // * Redistribution's of source code must retain the above copyright notice, 00023 // this list of conditions and the following disclaimer. 00024 // 00025 // * Redistribution's in binary form must reproduce the above copyright notice, 00026 // this list of conditions and the following disclaimer in the documentation 00027 // and/or other materials provided with the distribution. 00028 // 00029 // * The name of the copyright holders may not be used to endorse or promote products 00030 // derived from this software without specific prior written permission. 00031 // 00032 // This software is provided by the copyright holders and contributors "as is" and 00033 // any express or implied warranties, including, but not limited to, the implied 00034 // warranties of merchantability and fitness for a particular purpose are disclaimed. 00035 // In no event shall the Intel Corporation or contributors be liable for any direct, 00036 // indirect, incidental, special, exemplary, or consequential damages 00037 // (including, but not limited to, procurement of substitute goods or services; 00038 // loss of use, data, or profits; or business interruption) however caused 00039 // and on any theory of liability, whether in contract, strict liability, 00040 // or tort (including negligence or otherwise) arising in any way out of 00041 // the use of this software, even if advised of the possibility of such damage. 00042 // 00043 //M*/ 00044 00045 #ifndef __OPENCV_CORE_HPP__ 00046 #define __OPENCV_CORE_HPP__ 00047 00048 #ifndef __cplusplus 00049 # error core.hpp header must be compiled as C++ 00050 #endif 00051 00052 #include "opencv2/core/cvdef.h" 00053 #include "opencv2/core/version.hpp" 00054 #include "opencv2/core/base.hpp" 00055 #include "opencv2/core/cvstd.hpp" 00056 #include "opencv2/core/traits.hpp" 00057 #include "opencv2/core/matx.hpp" 00058 #include "opencv2/core/types.hpp" 00059 #include "opencv2/core/mat.hpp" 00060 #include "opencv2/core/persistence.hpp" 00061 00062 /** 00063 @defgroup core Core functionality 00064 @{ 00065 @defgroup core_basic Basic structures 00066 @defgroup core_c C structures and operations 00067 @{ 00068 @defgroup core_c_glue Connections with C++ 00069 @} 00070 @defgroup core_array Operations on arrays 00071 @defgroup core_xml XML/YAML Persistence 00072 @defgroup core_cluster Clustering 00073 @defgroup core_utils Utility and system functions and macros 00074 @{ 00075 @defgroup core_utils_sse SSE utilities 00076 @defgroup core_utils_neon NEON utilities 00077 @} 00078 @defgroup core_opengl OpenGL interoperability 00079 @defgroup core_ipp Intel IPP Asynchronous C/C++ Converters 00080 @defgroup core_optim Optimization Algorithms 00081 @defgroup core_directx DirectX interoperability 00082 @defgroup core_eigen Eigen support 00083 @defgroup core_opencl OpenCL support 00084 @defgroup core_va_intel Intel VA-API/OpenCL (CL-VA) interoperability 00085 @defgroup core_hal Hardware Acceleration Layer 00086 @{ 00087 @defgroup core_hal_functions Functions 00088 @defgroup core_hal_interface Interface 00089 @defgroup core_hal_intrin Universal intrinsics 00090 @{ 00091 @defgroup core_hal_intrin_impl Private implementation helpers 00092 @} 00093 @} 00094 @} 00095 */ 00096 00097 namespace cv { 00098 00099 //! @addtogroup core_utils 00100 //! @{ 00101 00102 /*! @brief Class passed to an error. 00103 00104 This class encapsulates all or almost all necessary 00105 information about the error happened in the program. The exception is 00106 usually constructed and thrown implicitly via CV_Error and CV_Error_ macros. 00107 @see error 00108 */ 00109 class CV_EXPORTS Exception : public std::exception 00110 { 00111 public: 00112 /*! 00113 Default constructor 00114 */ 00115 Exception(); 00116 /*! 00117 Full constructor. Normally the constuctor is not called explicitly. 00118 Instead, the macros CV_Error(), CV_Error_() and CV_Assert() are used. 00119 */ 00120 Exception(int _code, const String& _err, const String& _func, const String& _file, int _line); 00121 virtual ~Exception() throw(); 00122 00123 /*! 00124 \return the error description and the context as a text string. 00125 */ 00126 virtual const char *what() const throw(); 00127 void formatMessage(); 00128 00129 String msg; ///< the formatted error message 00130 00131 int code; ///< error code @see CVStatus 00132 String err; ///< error description 00133 String func; ///< function name. Available only when the compiler supports getting it 00134 String file; ///< source file name where the error has occured 00135 int line; ///< line number in the source file where the error has occured 00136 }; 00137 00138 /*! @brief Signals an error and raises the exception. 00139 00140 By default the function prints information about the error to stderr, 00141 then it either stops if cv::setBreakOnError() had been called before or raises the exception. 00142 It is possible to alternate error processing by using cv::redirectError(). 00143 @param exc the exception raisen. 00144 @deprecated drop this version 00145 */ 00146 CV_EXPORTS void error( const Exception& exc ); 00147 00148 enum SortFlags { SORT_EVERY_ROW = 0, //!< each matrix row is sorted independently 00149 SORT_EVERY_COLUMN = 1, //!< each matrix column is sorted 00150 //!< independently; this flag and the previous one are 00151 //!< mutually exclusive. 00152 SORT_ASCENDING = 0, //!< each matrix row is sorted in the ascending 00153 //!< order. 00154 SORT_DESCENDING = 16 //!< each matrix row is sorted in the 00155 //!< descending order; this flag and the previous one are also 00156 //!< mutually exclusive. 00157 }; 00158 00159 //! @} core_utils 00160 00161 //! @addtogroup core 00162 //! @{ 00163 00164 //! Covariation flags 00165 enum CovarFlags { 00166 /** The output covariance matrix is calculated as: 00167 \f[\texttt{scale} \cdot [ \texttt{vects} [0]- \texttt{mean} , \texttt{vects} [1]- \texttt{mean} ,...]^T \cdot [ \texttt{vects} [0]- \texttt{mean} , \texttt{vects} [1]- \texttt{mean} ,...],\f] 00168 The covariance matrix will be nsamples x nsamples. Such an unusual covariance matrix is used 00169 for fast PCA of a set of very large vectors (see, for example, the EigenFaces technique for 00170 face recognition). Eigenvalues of this "scrambled" matrix match the eigenvalues of the true 00171 covariance matrix. The "true" eigenvectors can be easily calculated from the eigenvectors of 00172 the "scrambled" covariance matrix. */ 00173 COVAR_SCRAMBLED = 0, 00174 /**The output covariance matrix is calculated as: 00175 \f[\texttt{scale} \cdot [ \texttt{vects} [0]- \texttt{mean} , \texttt{vects} [1]- \texttt{mean} ,...] \cdot [ \texttt{vects} [0]- \texttt{mean} , \texttt{vects} [1]- \texttt{mean} ,...]^T,\f] 00176 covar will be a square matrix of the same size as the total number of elements in each input 00177 vector. One and only one of COVAR_SCRAMBLED and COVAR_NORMAL must be specified.*/ 00178 COVAR_NORMAL = 1, 00179 /** If the flag is specified, the function does not calculate mean from 00180 the input vectors but, instead, uses the passed mean vector. This is useful if mean has been 00181 pre-calculated or known in advance, or if the covariance matrix is calculated by parts. In 00182 this case, mean is not a mean vector of the input sub-set of vectors but rather the mean 00183 vector of the whole set.*/ 00184 COVAR_USE_AVG = 2, 00185 /** If the flag is specified, the covariance matrix is scaled. In the 00186 "normal" mode, scale is 1./nsamples . In the "scrambled" mode, scale is the reciprocal of the 00187 total number of elements in each input vector. By default (if the flag is not specified), the 00188 covariance matrix is not scaled ( scale=1 ).*/ 00189 COVAR_SCALE = 4, 00190 /** If the flag is 00191 specified, all the input vectors are stored as rows of the samples matrix. mean should be a 00192 single-row vector in this case.*/ 00193 COVAR_ROWS = 8, 00194 /** If the flag is 00195 specified, all the input vectors are stored as columns of the samples matrix. mean should be a 00196 single-column vector in this case.*/ 00197 COVAR_COLS = 16 00198 }; 00199 00200 //! k-Means flags 00201 enum KmeansFlags { 00202 /** Select random initial centers in each attempt.*/ 00203 KMEANS_RANDOM_CENTERS = 0, 00204 /** Use kmeans++ center initialization by Arthur and Vassilvitskii [Arthur2007].*/ 00205 KMEANS_PP_CENTERS = 2, 00206 /** During the first (and possibly the only) attempt, use the 00207 user-supplied labels instead of computing them from the initial centers. For the second and 00208 further attempts, use the random or semi-random centers. Use one of KMEANS_\*_CENTERS flag 00209 to specify the exact method.*/ 00210 KMEANS_USE_INITIAL_LABELS = 1 00211 }; 00212 00213 //! type of line 00214 enum LineTypes { 00215 FILLED = -1, 00216 LINE_4 = 4, //!< 4-connected line 00217 LINE_8 = 8, //!< 8-connected line 00218 LINE_AA = 16 //!< antialiased line 00219 }; 00220 00221 //! Only a subset of Hershey fonts 00222 //! <http://sources.isc.org/utils/misc/hershey-font.txt> are supported 00223 enum HersheyFonts { 00224 FONT_HERSHEY_SIMPLEX = 0, //!< normal size sans-serif font 00225 FONT_HERSHEY_PLAIN = 1, //!< small size sans-serif font 00226 FONT_HERSHEY_DUPLEX = 2, //!< normal size sans-serif font (more complex than FONT_HERSHEY_SIMPLEX) 00227 FONT_HERSHEY_COMPLEX = 3, //!< normal size serif font 00228 FONT_HERSHEY_TRIPLEX = 4, //!< normal size serif font (more complex than FONT_HERSHEY_COMPLEX) 00229 FONT_HERSHEY_COMPLEX_SMALL = 5, //!< smaller version of FONT_HERSHEY_COMPLEX 00230 FONT_HERSHEY_SCRIPT_SIMPLEX = 6, //!< hand-writing style font 00231 FONT_HERSHEY_SCRIPT_COMPLEX = 7, //!< more complex variant of FONT_HERSHEY_SCRIPT_SIMPLEX 00232 FONT_ITALIC = 16 //!< flag for italic font 00233 }; 00234 00235 enum ReduceTypes { REDUCE_SUM = 0, //!< the output is the sum of all rows/columns of the matrix. 00236 REDUCE_AVG = 1, //!< the output is the mean vector of all rows/columns of the matrix. 00237 REDUCE_MAX = 2, //!< the output is the maximum (column/row-wise) of all rows/columns of the matrix. 00238 REDUCE_MIN = 3 //!< the output is the minimum (column/row-wise) of all rows/columns of the matrix. 00239 }; 00240 00241 00242 /** @brief Swaps two matrices 00243 */ 00244 CV_EXPORTS void swap(Mat& a, Mat& b); 00245 /** @overload */ 00246 CV_EXPORTS void swap( UMat& a, UMat& b ); 00247 00248 //! @} core 00249 00250 //! @addtogroup core_array 00251 //! @{ 00252 00253 /** @brief Computes the source location of an extrapolated pixel. 00254 00255 The function computes and returns the coordinate of a donor pixel corresponding to the specified 00256 extrapolated pixel when using the specified extrapolation border mode. For example, if you use 00257 cv::BORDER_WRAP mode in the horizontal direction, cv::BORDER_REFLECT_101 in the vertical direction and 00258 want to compute value of the "virtual" pixel Point(-5, 100) in a floating-point image img , it 00259 looks like: 00260 @code{.cpp} 00261 float val = img.at<float>(borderInterpolate(100, img.rows, cv::BORDER_REFLECT_101), 00262 borderInterpolate(-5, img.cols, cv::BORDER_WRAP)); 00263 @endcode 00264 Normally, the function is not called directly. It is used inside filtering functions and also in 00265 copyMakeBorder. 00266 @param p 0-based coordinate of the extrapolated pixel along one of the axes, likely <0 or >= len 00267 @param len Length of the array along the corresponding axis. 00268 @param borderType Border type, one of the cv::BorderTypes, except for cv::BORDER_TRANSPARENT and 00269 cv::BORDER_ISOLATED . When borderType==cv::BORDER_CONSTANT , the function always returns -1, regardless 00270 of p and len. 00271 00272 @sa copyMakeBorder 00273 */ 00274 CV_EXPORTS_W int borderInterpolate(int p, int len, int borderType); 00275 00276 /** @brief Forms a border around an image. 00277 00278 The function copies the source image into the middle of the destination image. The areas to the 00279 left, to the right, above and below the copied source image will be filled with extrapolated 00280 pixels. This is not what filtering functions based on it do (they extrapolate pixels on-fly), but 00281 what other more complex functions, including your own, may do to simplify image boundary handling. 00282 00283 The function supports the mode when src is already in the middle of dst . In this case, the 00284 function does not copy src itself but simply constructs the border, for example: 00285 00286 @code{.cpp} 00287 // let border be the same in all directions 00288 int border=2; 00289 // constructs a larger image to fit both the image and the border 00290 Mat gray_buf(rgb.rows + border*2, rgb.cols + border*2, rgb.depth()); 00291 // select the middle part of it w/o copying data 00292 Mat gray(gray_canvas, Rect(border, border, rgb.cols, rgb.rows)); 00293 // convert image from RGB to grayscale 00294 cvtColor(rgb, gray, COLOR_RGB2GRAY); 00295 // form a border in-place 00296 copyMakeBorder(gray, gray_buf, border, border, 00297 border, border, BORDER_REPLICATE); 00298 // now do some custom filtering ... 00299 ... 00300 @endcode 00301 @note When the source image is a part (ROI) of a bigger image, the function will try to use the 00302 pixels outside of the ROI to form a border. To disable this feature and always do extrapolation, as 00303 if src was not a ROI, use borderType | BORDER_ISOLATED. 00304 00305 @param src Source image. 00306 @param dst Destination image of the same type as src and the size Size(src.cols+left+right, 00307 src.rows+top+bottom) . 00308 @param top 00309 @param bottom 00310 @param left 00311 @param right Parameter specifying how many pixels in each direction from the source image rectangle 00312 to extrapolate. For example, top=1, bottom=1, left=1, right=1 mean that 1 pixel-wide border needs 00313 to be built. 00314 @param borderType Border type. See borderInterpolate for details. 00315 @param value Border value if borderType==BORDER_CONSTANT . 00316 00317 @sa borderInterpolate 00318 */ 00319 CV_EXPORTS_W void copyMakeBorder(InputArray src, OutputArray dst, 00320 int top, int bottom, int left, int right, 00321 int borderType, const Scalar& value = Scalar() ); 00322 00323 /** @brief Calculates the per-element sum of two arrays or an array and a scalar. 00324 00325 The function add calculates: 00326 - Sum of two arrays when both input arrays have the same size and the same number of channels: 00327 \f[\texttt{dst}(I) = \texttt{saturate} ( \texttt{src1}(I) + \texttt{src2}(I)) \quad \texttt{if mask}(I) \ne0\f] 00328 - Sum of an array and a scalar when src2 is constructed from Scalar or has the same number of 00329 elements as `src1.channels()`: 00330 \f[\texttt{dst}(I) = \texttt{saturate} ( \texttt{src1}(I) + \texttt{src2} ) \quad \texttt{if mask}(I) \ne0\f] 00331 - Sum of a scalar and an array when src1 is constructed from Scalar or has the same number of 00332 elements as `src2.channels()`: 00333 \f[\texttt{dst}(I) = \texttt{saturate} ( \texttt{src1} + \texttt{src2}(I) ) \quad \texttt{if mask}(I) \ne0\f] 00334 where `I` is a multi-dimensional index of array elements. In case of multi-channel arrays, each 00335 channel is processed independently. 00336 00337 The first function in the list above can be replaced with matrix expressions: 00338 @code{.cpp} 00339 dst = src1 + src2; 00340 dst += src1; // equivalent to add(dst, src1, dst); 00341 @endcode 00342 The input arrays and the output array can all have the same or different depths. For example, you 00343 can add a 16-bit unsigned array to a 8-bit signed array and store the sum as a 32-bit 00344 floating-point array. Depth of the output array is determined by the dtype parameter. In the second 00345 and third cases above, as well as in the first case, when src1.depth() == src2.depth(), dtype can 00346 be set to the default -1. In this case, the output array will have the same depth as the input 00347 array, be it src1, src2 or both. 00348 @note Saturation is not applied when the output array has the depth CV_32S. You may even get 00349 result of an incorrect sign in the case of overflow. 00350 @param src1 first input array or a scalar. 00351 @param src2 second input array or a scalar. 00352 @param dst output array that has the same size and number of channels as the input array(s); the 00353 depth is defined by dtype or src1/src2. 00354 @param mask optional operation mask - 8-bit single channel array, that specifies elements of the 00355 output array to be changed. 00356 @param dtype optional depth of the output array (see the discussion below). 00357 @sa subtract, addWeighted, scaleAdd, Mat::convertTo 00358 */ 00359 CV_EXPORTS_W void add(InputArray src1, InputArray src2, OutputArray dst, 00360 InputArray mask = noArray(), int dtype = -1); 00361 00362 /** @brief Calculates the per-element difference between two arrays or array and a scalar. 00363 00364 The function subtract calculates: 00365 - Difference between two arrays, when both input arrays have the same size and the same number of 00366 channels: 00367 \f[\texttt{dst}(I) = \texttt{saturate} ( \texttt{src1}(I) - \texttt{src2}(I)) \quad \texttt{if mask}(I) \ne0\f] 00368 - Difference between an array and a scalar, when src2 is constructed from Scalar or has the same 00369 number of elements as `src1.channels()`: 00370 \f[\texttt{dst}(I) = \texttt{saturate} ( \texttt{src1}(I) - \texttt{src2} ) \quad \texttt{if mask}(I) \ne0\f] 00371 - Difference between a scalar and an array, when src1 is constructed from Scalar or has the same 00372 number of elements as `src2.channels()`: 00373 \f[\texttt{dst}(I) = \texttt{saturate} ( \texttt{src1} - \texttt{src2}(I) ) \quad \texttt{if mask}(I) \ne0\f] 00374 - The reverse difference between a scalar and an array in the case of `SubRS`: 00375 \f[\texttt{dst}(I) = \texttt{saturate} ( \texttt{src2} - \texttt{src1}(I) ) \quad \texttt{if mask}(I) \ne0\f] 00376 where I is a multi-dimensional index of array elements. In case of multi-channel arrays, each 00377 channel is processed independently. 00378 00379 The first function in the list above can be replaced with matrix expressions: 00380 @code{.cpp} 00381 dst = src1 - src2; 00382 dst -= src1; // equivalent to subtract(dst, src1, dst); 00383 @endcode 00384 The input arrays and the output array can all have the same or different depths. For example, you 00385 can subtract to 8-bit unsigned arrays and store the difference in a 16-bit signed array. Depth of 00386 the output array is determined by dtype parameter. In the second and third cases above, as well as 00387 in the first case, when src1.depth() == src2.depth(), dtype can be set to the default -1. In this 00388 case the output array will have the same depth as the input array, be it src1, src2 or both. 00389 @note Saturation is not applied when the output array has the depth CV_32S. You may even get 00390 result of an incorrect sign in the case of overflow. 00391 @param src1 first input array or a scalar. 00392 @param src2 second input array or a scalar. 00393 @param dst output array of the same size and the same number of channels as the input array. 00394 @param mask optional operation mask; this is an 8-bit single channel array that specifies elements 00395 of the output array to be changed. 00396 @param dtype optional depth of the output array 00397 @sa add, addWeighted, scaleAdd, Mat::convertTo 00398 */ 00399 CV_EXPORTS_W void subtract(InputArray src1, InputArray src2, OutputArray dst, 00400 InputArray mask = noArray(), int dtype = -1); 00401 00402 00403 /** @brief Calculates the per-element scaled product of two arrays. 00404 00405 The function multiply calculates the per-element product of two arrays: 00406 00407 \f[\texttt{dst} (I)= \texttt{saturate} ( \texttt{scale} \cdot \texttt{src1} (I) \cdot \texttt{src2} (I))\f] 00408 00409 There is also a @ref MatrixExpressions -friendly variant of the first function. See Mat::mul . 00410 00411 For a not-per-element matrix product, see gemm . 00412 00413 @note Saturation is not applied when the output array has the depth 00414 CV_32S. You may even get result of an incorrect sign in the case of 00415 overflow. 00416 @param src1 first input array. 00417 @param src2 second input array of the same size and the same type as src1. 00418 @param dst output array of the same size and type as src1. 00419 @param scale optional scale factor. 00420 @param dtype optional depth of the output array 00421 @sa add, subtract, divide, scaleAdd, addWeighted, accumulate, accumulateProduct, accumulateSquare, 00422 Mat::convertTo 00423 */ 00424 CV_EXPORTS_W void multiply(InputArray src1, InputArray src2, 00425 OutputArray dst, double scale = 1, int dtype = -1); 00426 00427 /** @brief Performs per-element division of two arrays or a scalar by an array. 00428 00429 The functions divide divide one array by another: 00430 \f[\texttt{dst(I) = saturate(src1(I)*scale/src2(I))}\f] 00431 or a scalar by an array when there is no src1 : 00432 \f[\texttt{dst(I) = saturate(scale/src2(I))}\f] 00433 00434 When src2(I) is zero, dst(I) will also be zero. Different channels of 00435 multi-channel arrays are processed independently. 00436 00437 @note Saturation is not applied when the output array has the depth CV_32S. You may even get 00438 result of an incorrect sign in the case of overflow. 00439 @param src1 first input array. 00440 @param src2 second input array of the same size and type as src1. 00441 @param scale scalar factor. 00442 @param dst output array of the same size and type as src2. 00443 @param dtype optional depth of the output array; if -1, dst will have depth src2.depth(), but in 00444 case of an array-by-array division, you can only pass -1 when src1.depth()==src2.depth(). 00445 @sa multiply, add, subtract 00446 */ 00447 CV_EXPORTS_W void divide(InputArray src1, InputArray src2, OutputArray dst, 00448 double scale = 1, int dtype = -1); 00449 00450 /** @overload */ 00451 CV_EXPORTS_W void divide(double scale, InputArray src2, 00452 OutputArray dst, int dtype = -1); 00453 00454 /** @brief Calculates the sum of a scaled array and another array. 00455 00456 The function scaleAdd is one of the classical primitive linear algebra operations, known as DAXPY 00457 or SAXPY in [BLAS](http://en.wikipedia.org/wiki/Basic_Linear_Algebra_Subprograms). It calculates 00458 the sum of a scaled array and another array: 00459 \f[\texttt{dst} (I)= \texttt{scale} \cdot \texttt{src1} (I) + \texttt{src2} (I)\f] 00460 The function can also be emulated with a matrix expression, for example: 00461 @code{.cpp} 00462 Mat A(3, 3, CV_64F); 00463 ... 00464 A.row(0) = A.row(1)*2 + A.row(2); 00465 @endcode 00466 @param src1 first input array. 00467 @param alpha scale factor for the first array. 00468 @param src2 second input array of the same size and type as src1. 00469 @param dst output array of the same size and type as src1. 00470 @sa add, addWeighted, subtract, Mat::dot, Mat::convertTo 00471 */ 00472 CV_EXPORTS_W void scaleAdd(InputArray src1, double alpha, InputArray src2, OutputArray dst); 00473 00474 /** @brief Calculates the weighted sum of two arrays. 00475 00476 The function addWeighted calculates the weighted sum of two arrays as follows: 00477 \f[\texttt{dst} (I)= \texttt{saturate} ( \texttt{src1} (I)* \texttt{alpha} + \texttt{src2} (I)* \texttt{beta} + \texttt{gamma} )\f] 00478 where I is a multi-dimensional index of array elements. In case of multi-channel arrays, each 00479 channel is processed independently. 00480 The function can be replaced with a matrix expression: 00481 @code{.cpp} 00482 dst = src1*alpha + src2*beta + gamma; 00483 @endcode 00484 @note Saturation is not applied when the output array has the depth CV_32S. You may even get 00485 result of an incorrect sign in the case of overflow. 00486 @param src1 first input array. 00487 @param alpha weight of the first array elements. 00488 @param src2 second input array of the same size and channel number as src1. 00489 @param beta weight of the second array elements. 00490 @param gamma scalar added to each sum. 00491 @param dst output array that has the same size and number of channels as the input arrays. 00492 @param dtype optional depth of the output array; when both input arrays have the same depth, dtype 00493 can be set to -1, which will be equivalent to src1.depth(). 00494 @sa add, subtract, scaleAdd, Mat::convertTo 00495 */ 00496 CV_EXPORTS_W void addWeighted(InputArray src1, double alpha, InputArray src2, 00497 double beta, double gamma, OutputArray dst, int dtype = -1); 00498 00499 /** @brief Scales, calculates absolute values, and converts the result to 8-bit. 00500 00501 On each element of the input array, the function convertScaleAbs 00502 performs three operations sequentially: scaling, taking an absolute 00503 value, conversion to an unsigned 8-bit type: 00504 \f[\texttt{dst} (I)= \texttt{saturate\_cast<uchar>} (| \texttt{src} (I)* \texttt{alpha} + \texttt{beta} |)\f] 00505 In case of multi-channel arrays, the function processes each channel 00506 independently. When the output is not 8-bit, the operation can be 00507 emulated by calling the Mat::convertTo method (or by using matrix 00508 expressions) and then by calculating an absolute value of the result. 00509 For example: 00510 @code{.cpp} 00511 Mat_<float> A(30,30); 00512 randu(A, Scalar(-100), Scalar(100)); 00513 Mat_<float> B = A*5 + 3; 00514 B = abs(B); 00515 // Mat_<float> B = abs(A*5+3) will also do the job, 00516 // but it will allocate a temporary matrix 00517 @endcode 00518 @param src input array. 00519 @param dst output array. 00520 @param alpha optional scale factor. 00521 @param beta optional delta added to the scaled values. 00522 @sa Mat::convertTo, cv::abs(const Mat&) 00523 */ 00524 CV_EXPORTS_W void convertScaleAbs(InputArray src, OutputArray dst, 00525 double alpha = 1, double beta = 0); 00526 00527 /** @brief Performs a look-up table transform of an array. 00528 00529 The function LUT fills the output array with values from the look-up table. Indices of the entries 00530 are taken from the input array. That is, the function processes each element of src as follows: 00531 \f[\texttt{dst} (I) \leftarrow \texttt{lut(src(I) + d)}\f] 00532 where 00533 \f[d = \fork{0}{if \(\texttt{src}\) has depth \(\texttt{CV_8U}\)}{128}{if \(\texttt{src}\) has depth \(\texttt{CV_8S}\)}\f] 00534 @param src input array of 8-bit elements. 00535 @param lut look-up table of 256 elements; in case of multi-channel input array, the table should 00536 either have a single channel (in this case the same table is used for all channels) or the same 00537 number of channels as in the input array. 00538 @param dst output array of the same size and number of channels as src, and the same depth as lut. 00539 @sa convertScaleAbs, Mat::convertTo 00540 */ 00541 CV_EXPORTS_W void LUT(InputArray src, InputArray lut, OutputArray dst); 00542 00543 /** @brief Calculates the sum of array elements. 00544 00545 The functions sum calculate and return the sum of array elements, 00546 independently for each channel. 00547 @param src input array that must have from 1 to 4 channels. 00548 @sa countNonZero, mean, meanStdDev, norm, minMaxLoc, reduce 00549 */ 00550 CV_EXPORTS_AS(sumElems) Scalar sum(InputArray src); 00551 00552 /** @brief Counts non-zero array elements. 00553 00554 The function returns the number of non-zero elements in src : 00555 \f[\sum _{I: \; \texttt{src} (I) \ne0 } 1\f] 00556 @param src single-channel array. 00557 @sa mean, meanStdDev, norm, minMaxLoc, calcCovarMatrix 00558 */ 00559 CV_EXPORTS_W int countNonZero( InputArray src ); 00560 00561 /** @brief Returns the list of locations of non-zero pixels 00562 00563 Given a binary matrix (likely returned from an operation such 00564 as threshold(), compare(), >, ==, etc, return all of 00565 the non-zero indices as a cv::Mat or std::vector<cv::Point> (x,y) 00566 For example: 00567 @code{.cpp} 00568 cv::Mat binaryImage; // input, binary image 00569 cv::Mat locations; // output, locations of non-zero pixels 00570 cv::findNonZero(binaryImage, locations); 00571 00572 // access pixel coordinates 00573 Point pnt = locations.at<Point>(i); 00574 @endcode 00575 or 00576 @code{.cpp} 00577 cv::Mat binaryImage; // input, binary image 00578 vector<Point> locations; // output, locations of non-zero pixels 00579 cv::findNonZero(binaryImage, locations); 00580 00581 // access pixel coordinates 00582 Point pnt = locations[i]; 00583 @endcode 00584 @param src single-channel array (type CV_8UC1) 00585 @param idx the output array, type of cv::Mat or std::vector<Point>, corresponding to non-zero indices in the input 00586 */ 00587 CV_EXPORTS_W void findNonZero( InputArray src, OutputArray idx ); 00588 00589 /** @brief Calculates an average (mean) of array elements. 00590 00591 The function mean calculates the mean value M of array elements, 00592 independently for each channel, and return it: 00593 \f[\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}\f] 00594 When all the mask elements are 0's, the functions return Scalar::all(0) 00595 @param src input array that should have from 1 to 4 channels so that the result can be stored in 00596 Scalar_ . 00597 @param mask optional operation mask. 00598 @sa countNonZero, meanStdDev, norm, minMaxLoc 00599 */ 00600 CV_EXPORTS_W Scalar mean(InputArray src, InputArray mask = noArray()); 00601 00602 /** Calculates a mean and standard deviation of array elements. 00603 00604 The function meanStdDev calculates the mean and the standard deviation M 00605 of array elements independently for each channel and returns it via the 00606 output parameters: 00607 \f[\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}\f] 00608 When all the mask elements are 0's, the functions return 00609 mean=stddev=Scalar::all(0). 00610 @note The calculated standard deviation is only the diagonal of the 00611 complete normalized covariance matrix. If the full matrix is needed, you 00612 can reshape the multi-channel array M x N to the single-channel array 00613 M\*N x mtx.channels() (only possible when the matrix is continuous) and 00614 then pass the matrix to calcCovarMatrix . 00615 @param src input array that should have from 1 to 4 channels so that the results can be stored in 00616 Scalar_ 's. 00617 @param mean output parameter: calculated mean value. 00618 @param stddev output parameter: calculateded standard deviation. 00619 @param mask optional operation mask. 00620 @sa countNonZero, mean, norm, minMaxLoc, calcCovarMatrix 00621 */ 00622 CV_EXPORTS_W void meanStdDev(InputArray src, OutputArray mean, OutputArray stddev, 00623 InputArray mask=noArray()); 00624 00625 /** @brief Calculates an absolute array norm, an absolute difference norm, or a 00626 relative difference norm. 00627 00628 The functions norm calculate an absolute norm of src1 (when there is no 00629 src2 ): 00630 00631 \f[norm = \forkthree{\|\texttt{src1}\|_{L_{\infty}} = \max _I | \texttt{src1} (I)|}{if \(\texttt{normType} = \texttt{NORM_INF}\) } 00632 { \| \texttt{src1} \| _{L_1} = \sum _I | \texttt{src1} (I)|}{if \(\texttt{normType} = \texttt{NORM_L1}\) } 00633 { \| \texttt{src1} \| _{L_2} = \sqrt{\sum_I \texttt{src1}(I)^2} }{if \(\texttt{normType} = \texttt{NORM_L2}\) }\f] 00634 00635 or an absolute or relative difference norm if src2 is there: 00636 00637 \f[norm = \forkthree{\|\texttt{src1}-\texttt{src2}\|_{L_{\infty}} = \max _I | \texttt{src1} (I) - \texttt{src2} (I)|}{if \(\texttt{normType} = \texttt{NORM_INF}\) } 00638 { \| \texttt{src1} - \texttt{src2} \| _{L_1} = \sum _I | \texttt{src1} (I) - \texttt{src2} (I)|}{if \(\texttt{normType} = \texttt{NORM_L1}\) } 00639 { \| \texttt{src1} - \texttt{src2} \| _{L_2} = \sqrt{\sum_I (\texttt{src1}(I) - \texttt{src2}(I))^2} }{if \(\texttt{normType} = \texttt{NORM_L2}\) }\f] 00640 00641 or 00642 00643 \f[norm = \forkthree{\frac{\|\texttt{src1}-\texttt{src2}\|_{L_{\infty}} }{\|\texttt{src2}\|_{L_{\infty}} }}{if \(\texttt{normType} = \texttt{NORM_RELATIVE_INF}\) } 00644 { \frac{\|\texttt{src1}-\texttt{src2}\|_{L_1} }{\|\texttt{src2}\|_{L_1}} }{if \(\texttt{normType} = \texttt{NORM_RELATIVE_L1}\) } 00645 { \frac{\|\texttt{src1}-\texttt{src2}\|_{L_2} }{\|\texttt{src2}\|_{L_2}} }{if \(\texttt{normType} = \texttt{NORM_RELATIVE_L2}\) }\f] 00646 00647 The functions norm return the calculated norm. 00648 00649 When the mask parameter is specified and it is not empty, the norm is 00650 calculated only over the region specified by the mask. 00651 00652 A multi-channel input arrays are treated as a single-channel, that is, 00653 the results for all channels are combined. 00654 00655 @param src1 first input array. 00656 @param normType type of the norm (see cv::NormTypes). 00657 @param mask optional operation mask; it must have the same size as src1 and CV_8UC1 type. 00658 */ 00659 CV_EXPORTS_W double norm(InputArray src1, int normType = NORM_L2, InputArray mask = noArray()); 00660 00661 /** @overload 00662 @param src1 first input array. 00663 @param src2 second input array of the same size and the same type as src1. 00664 @param normType type of the norm (cv::NormTypes). 00665 @param mask optional operation mask; it must have the same size as src1 and CV_8UC1 type. 00666 */ 00667 CV_EXPORTS_W double norm(InputArray src1, InputArray src2, 00668 int normType = NORM_L2, InputArray mask = noArray()); 00669 /** @overload 00670 @param src first input array. 00671 @param normType type of the norm (see cv::NormTypes). 00672 */ 00673 CV_EXPORTS double norm( const SparseMat& src, int normType ); 00674 00675 /** @brief computes PSNR image/video quality metric 00676 00677 see http://en.wikipedia.org/wiki/Peak_signal-to-noise_ratio for details 00678 @todo document 00679 */ 00680 CV_EXPORTS_W double PSNR(InputArray src1, InputArray src2); 00681 00682 /** @brief naive nearest neighbor finder 00683 00684 see http://en.wikipedia.org/wiki/Nearest_neighbor_search 00685 @todo document 00686 */ 00687 CV_EXPORTS_W void batchDistance(InputArray src1, InputArray src2, 00688 OutputArray dist, int dtype, OutputArray nidx, 00689 int normType = NORM_L2, int K = 0, 00690 InputArray mask = noArray(), int update = 0, 00691 bool crosscheck = false); 00692 00693 /** @brief Normalizes the norm or value range of an array. 00694 00695 The functions normalize scale and shift the input array elements so that 00696 \f[\| \texttt{dst} \| _{L_p}= \texttt{alpha}\f] 00697 (where p=Inf, 1 or 2) when normType=NORM_INF, NORM_L1, or NORM_L2, respectively; or so that 00698 \f[\min _I \texttt{dst} (I)= \texttt{alpha} , \, \, \max _I \texttt{dst} (I)= \texttt{beta}\f] 00699 00700 when normType=NORM_MINMAX (for dense arrays only). The optional mask specifies a sub-array to be 00701 normalized. This means that the norm or min-n-max are calculated over the sub-array, and then this 00702 sub-array is modified to be normalized. If you want to only use the mask to calculate the norm or 00703 min-max but modify the whole array, you can use norm and Mat::convertTo. 00704 00705 In case of sparse matrices, only the non-zero values are analyzed and transformed. Because of this, 00706 the range transformation for sparse matrices is not allowed since it can shift the zero level. 00707 00708 Possible usage with some positive example data: 00709 @code{.cpp} 00710 vector<double> positiveData = { 2.0, 8.0, 10.0 }; 00711 vector<double> normalizedData_l1, normalizedData_l2, normalizedData_inf, normalizedData_minmax; 00712 00713 // Norm to probability (total count) 00714 // sum(numbers) = 20.0 00715 // 2.0 0.1 (2.0/20.0) 00716 // 8.0 0.4 (8.0/20.0) 00717 // 10.0 0.5 (10.0/20.0) 00718 normalize(positiveData, normalizedData_l1, 1.0, 0.0, NORM_L1); 00719 00720 // Norm to unit vector: ||positiveData|| = 1.0 00721 // 2.0 0.15 00722 // 8.0 0.62 00723 // 10.0 0.77 00724 normalize(positiveData, normalizedData_l2, 1.0, 0.0, NORM_L2); 00725 00726 // Norm to max element 00727 // 2.0 0.2 (2.0/10.0) 00728 // 8.0 0.8 (8.0/10.0) 00729 // 10.0 1.0 (10.0/10.0) 00730 normalize(positiveData, normalizedData_inf, 1.0, 0.0, NORM_INF); 00731 00732 // Norm to range [0.0;1.0] 00733 // 2.0 0.0 (shift to left border) 00734 // 8.0 0.75 (6.0/8.0) 00735 // 10.0 1.0 (shift to right border) 00736 normalize(positiveData, normalizedData_minmax, 1.0, 0.0, NORM_MINMAX); 00737 @endcode 00738 00739 @param src input array. 00740 @param dst output array of the same size as src . 00741 @param alpha norm value to normalize to or the lower range boundary in case of the range 00742 normalization. 00743 @param beta upper range boundary in case of the range normalization; it is not used for the norm 00744 normalization. 00745 @param norm_type normalization type (see cv::NormTypes). 00746 @param dtype when negative, the output array has the same type as src; otherwise, it has the same 00747 number of channels as src and the depth =CV_MAT_DEPTH(dtype). 00748 @param mask optional operation mask. 00749 @sa norm, Mat::convertTo, SparseMat::convertTo 00750 */ 00751 CV_EXPORTS_W void normalize( InputArray src, InputOutputArray dst, double alpha = 1, double beta = 0, 00752 int norm_type = NORM_L2, int dtype = -1, InputArray mask = noArray()); 00753 00754 /** @overload 00755 @param src input array. 00756 @param dst output array of the same size as src . 00757 @param alpha norm value to normalize to or the lower range boundary in case of the range 00758 normalization. 00759 @param normType normalization type (see cv::NormTypes). 00760 */ 00761 CV_EXPORTS void normalize( const SparseMat& src, SparseMat& dst, double alpha, int normType ); 00762 00763 /** @brief Finds the global minimum and maximum in an array. 00764 00765 The functions minMaxLoc find the minimum and maximum element values and their positions. The 00766 extremums are searched across the whole array or, if mask is not an empty array, in the specified 00767 array region. 00768 00769 The functions do not work with multi-channel arrays. If you need to find minimum or maximum 00770 elements across all the channels, use Mat::reshape first to reinterpret the array as 00771 single-channel. Or you may extract the particular channel using either extractImageCOI , or 00772 mixChannels , or split . 00773 @param src input single-channel array. 00774 @param minVal pointer to the returned minimum value; NULL is used if not required. 00775 @param maxVal pointer to the returned maximum value; NULL is used if not required. 00776 @param minLoc pointer to the returned minimum location (in 2D case); NULL is used if not required. 00777 @param maxLoc pointer to the returned maximum location (in 2D case); NULL is used if not required. 00778 @param mask optional mask used to select a sub-array. 00779 @sa max, min, compare, inRange, extractImageCOI, mixChannels, split, Mat::reshape 00780 */ 00781 CV_EXPORTS_W void minMaxLoc(InputArray src, CV_OUT double* minVal, 00782 CV_OUT double* maxVal = 0, CV_OUT Point* minLoc = 0, 00783 CV_OUT Point* maxLoc = 0, InputArray mask = noArray()); 00784 00785 00786 /** @brief Finds the global minimum and maximum in an array 00787 00788 The function minMaxIdx finds the minimum and maximum element values and their positions. The 00789 extremums are searched across the whole array or, if mask is not an empty array, in the specified 00790 array region. The function does not work with multi-channel arrays. If you need to find minimum or 00791 maximum elements across all the channels, use Mat::reshape first to reinterpret the array as 00792 single-channel. Or you may extract the particular channel using either extractImageCOI , or 00793 mixChannels , or split . In case of a sparse matrix, the minimum is found among non-zero elements 00794 only. 00795 @note When minIdx is not NULL, it must have at least 2 elements (as well as maxIdx), even if src is 00796 a single-row or single-column matrix. In OpenCV (following MATLAB) each array has at least 2 00797 dimensions, i.e. single-column matrix is Mx1 matrix (and therefore minIdx/maxIdx will be 00798 (i1,0)/(i2,0)) and single-row matrix is 1xN matrix (and therefore minIdx/maxIdx will be 00799 (0,j1)/(0,j2)). 00800 @param src input single-channel array. 00801 @param minVal pointer to the returned minimum value; NULL is used if not required. 00802 @param maxVal pointer to the returned maximum value; NULL is used if not required. 00803 @param minIdx pointer to the returned minimum location (in nD case); NULL is used if not required; 00804 Otherwise, it must point to an array of src.dims elements, the coordinates of the minimum element 00805 in each dimension are stored there sequentially. 00806 @param maxIdx pointer to the returned maximum location (in nD case). NULL is used if not required. 00807 @param mask specified array region 00808 */ 00809 CV_EXPORTS void minMaxIdx(InputArray src, double* minVal, double* maxVal = 0, 00810 int* minIdx = 0, int* maxIdx = 0, InputArray mask = noArray()); 00811 00812 /** @overload 00813 @param a input single-channel array. 00814 @param minVal pointer to the returned minimum value; NULL is used if not required. 00815 @param maxVal pointer to the returned maximum value; NULL is used if not required. 00816 @param minIdx pointer to the returned minimum location (in nD case); NULL is used if not required; 00817 Otherwise, it must point to an array of src.dims elements, the coordinates of the minimum element 00818 in each dimension are stored there sequentially. 00819 @param maxIdx pointer to the returned maximum location (in nD case). NULL is used if not required. 00820 */ 00821 CV_EXPORTS void minMaxLoc(const SparseMat& a, double* minVal, 00822 double* maxVal, int* minIdx = 0, int* maxIdx = 0); 00823 00824 /** @brief Reduces a matrix to a vector. 00825 00826 The function reduce reduces the matrix to a vector by treating the matrix rows/columns as a set of 00827 1D vectors and performing the specified operation on the vectors until a single row/column is 00828 obtained. For example, the function can be used to compute horizontal and vertical projections of a 00829 raster image. In case of REDUCE_SUM and REDUCE_AVG , the output may have a larger element 00830 bit-depth to preserve accuracy. And multi-channel arrays are also supported in these two reduction 00831 modes. 00832 @param src input 2D matrix. 00833 @param dst output vector. Its size and type is defined by dim and dtype parameters. 00834 @param dim dimension index along which the matrix is reduced. 0 means that the matrix is reduced to 00835 a single row. 1 means that the matrix is reduced to a single column. 00836 @param rtype reduction operation that could be one of cv::ReduceTypes 00837 @param dtype when negative, the output vector will have the same type as the input matrix, 00838 otherwise, its type will be CV_MAKE_TYPE(CV_MAT_DEPTH(dtype), src.channels()). 00839 @sa repeat 00840 */ 00841 CV_EXPORTS_W void reduce(InputArray src, OutputArray dst, int dim, int rtype, int dtype = -1); 00842 00843 /** @brief Creates one multi-channel array out of several single-channel ones. 00844 00845 The function merge merges several arrays to make a single multi-channel array. That is, each 00846 element of the output array will be a concatenation of the elements of the input arrays, where 00847 elements of i-th input array are treated as mv[i].channels()-element vectors. 00848 00849 The function cv::split does the reverse operation. If you need to shuffle channels in some other 00850 advanced way, use cv::mixChannels. 00851 @param mv input array of matrices to be merged; all the matrices in mv must have the same 00852 size and the same depth. 00853 @param count number of input matrices when mv is a plain C array; it must be greater than zero. 00854 @param dst output array of the same size and the same depth as mv[0]; The number of channels will 00855 be equal to the parameter count. 00856 @sa mixChannels, split, Mat::reshape 00857 */ 00858 CV_EXPORTS void merge(const Mat* mv, size_t count, OutputArray dst); 00859 00860 /** @overload 00861 @param mv input vector of matrices to be merged; all the matrices in mv must have the same 00862 size and the same depth. 00863 @param dst output array of the same size and the same depth as mv[0]; The number of channels will 00864 be the total number of channels in the matrix array. 00865 */ 00866 CV_EXPORTS_W void merge(InputArrayOfArrays mv, OutputArray dst); 00867 00868 /** @brief Divides a multi-channel array into several single-channel arrays. 00869 00870 The functions split split a multi-channel array into separate single-channel arrays: 00871 \f[\texttt{mv} [c](I) = \texttt{src} (I)_c\f] 00872 If you need to extract a single channel or do some other sophisticated channel permutation, use 00873 mixChannels . 00874 @param src input multi-channel array. 00875 @param mvbegin output array; the number of arrays must match src.channels(); the arrays themselves are 00876 reallocated, if needed. 00877 @sa merge, mixChannels, cvtColor 00878 */ 00879 CV_EXPORTS void split(const Mat& src, Mat* mvbegin); 00880 00881 /** @overload 00882 @param m input multi-channel array. 00883 @param mv output vector of arrays; the arrays themselves are reallocated, if needed. 00884 */ 00885 CV_EXPORTS_W void split(InputArray m, OutputArrayOfArrays mv); 00886 00887 /** @brief Copies specified channels from input arrays to the specified channels of 00888 output arrays. 00889 00890 The function cv::mixChannels provides an advanced mechanism for shuffling image channels. 00891 00892 cv::split and cv::merge and some forms of cv::cvtColor are partial cases of cv::mixChannels . 00893 00894 In the example below, the code splits a 4-channel BGRA image into a 3-channel BGR (with B and R 00895 channels swapped) and a separate alpha-channel image: 00896 @code{.cpp} 00897 Mat bgra( 100, 100, CV_8UC4, Scalar(255,0,0,255) ); 00898 Mat bgr( bgra.rows, bgra.cols, CV_8UC3 ); 00899 Mat alpha( bgra.rows, bgra.cols, CV_8UC1 ); 00900 00901 // forming an array of matrices is a quite efficient operation, 00902 // because the matrix data is not copied, only the headers 00903 Mat out[] = { bgr, alpha }; 00904 // bgra[0] -> bgr[2], bgra[1] -> bgr[1], 00905 // bgra[2] -> bgr[0], bgra[3] -> alpha[0] 00906 int from_to[] = { 0,2, 1,1, 2,0, 3,3 }; 00907 mixChannels( &bgra, 1, out, 2, from_to, 4 ); 00908 @endcode 00909 @note Unlike many other new-style C++ functions in OpenCV (see the introduction section and 00910 Mat::create ), cv::mixChannels requires the output arrays to be pre-allocated before calling the 00911 function. 00912 @param src input array or vector of matrices; all of the matrices must have the same size and the 00913 same depth. 00914 @param nsrcs number of matrices in `src`. 00915 @param dst output array or vector of matrices; all the matrices **must be allocated**; their size and 00916 depth must be the same as in `src[0]`. 00917 @param ndsts number of matrices in `dst`. 00918 @param fromTo array of index pairs specifying which channels are copied and where; fromTo[k\*2] is 00919 a 0-based index of the input channel in src, fromTo[k\*2+1] is an index of the output channel in 00920 dst; the continuous channel numbering is used: the first input image channels are indexed from 0 to 00921 src[0].channels()-1, the second input image channels are indexed from src[0].channels() to 00922 src[0].channels() + src[1].channels()-1, and so on, the same scheme is used for the output image 00923 channels; as a special case, when fromTo[k\*2] is negative, the corresponding output channel is 00924 filled with zero . 00925 @param npairs number of index pairs in `fromTo`. 00926 @sa cv::split, cv::merge, cv::cvtColor 00927 */ 00928 CV_EXPORTS void mixChannels(const Mat* src, size_t nsrcs, Mat* dst, size_t ndsts, 00929 const int* fromTo, size_t npairs); 00930 00931 /** @overload 00932 @param src input array or vector of matrices; all of the matrices must have the same size and the 00933 same depth. 00934 @param dst output array or vector of matrices; all the matrices **must be allocated**; their size and 00935 depth must be the same as in src[0]. 00936 @param fromTo array of index pairs specifying which channels are copied and where; fromTo[k\*2] is 00937 a 0-based index of the input channel in src, fromTo[k\*2+1] is an index of the output channel in 00938 dst; the continuous channel numbering is used: the first input image channels are indexed from 0 to 00939 src[0].channels()-1, the second input image channels are indexed from src[0].channels() to 00940 src[0].channels() + src[1].channels()-1, and so on, the same scheme is used for the output image 00941 channels; as a special case, when fromTo[k\*2] is negative, the corresponding output channel is 00942 filled with zero . 00943 @param npairs number of index pairs in fromTo. 00944 */ 00945 CV_EXPORTS void mixChannels(InputArrayOfArrays src, InputOutputArrayOfArrays dst, 00946 const int* fromTo, size_t npairs); 00947 00948 /** @overload 00949 @param src input array or vector of matrices; all of the matrices must have the same size and the 00950 same depth. 00951 @param dst output array or vector of matrices; all the matrices **must be allocated**; their size and 00952 depth must be the same as in src[0]. 00953 @param fromTo array of index pairs specifying which channels are copied and where; fromTo[k\*2] is 00954 a 0-based index of the input channel in src, fromTo[k\*2+1] is an index of the output channel in 00955 dst; the continuous channel numbering is used: the first input image channels are indexed from 0 to 00956 src[0].channels()-1, the second input image channels are indexed from src[0].channels() to 00957 src[0].channels() + src[1].channels()-1, and so on, the same scheme is used for the output image 00958 channels; as a special case, when fromTo[k\*2] is negative, the corresponding output channel is 00959 filled with zero . 00960 */ 00961 CV_EXPORTS_W void mixChannels(InputArrayOfArrays src, InputOutputArrayOfArrays dst, 00962 const std::vector<int>& fromTo); 00963 00964 /** @brief extracts a single channel from src (coi is 0-based index) 00965 @todo document 00966 */ 00967 CV_EXPORTS_W void extractChannel(InputArray src, OutputArray dst, int coi); 00968 00969 /** @brief inserts a single channel to dst (coi is 0-based index) 00970 @todo document 00971 */ 00972 CV_EXPORTS_W void insertChannel(InputArray src, InputOutputArray dst, int coi); 00973 00974 /** @brief Flips a 2D array around vertical, horizontal, or both axes. 00975 00976 The function flip flips the array in one of three different ways (row 00977 and column indices are 0-based): 00978 \f[\texttt{dst} _{ij} = 00979 \left\{ 00980 \begin{array}{l l} 00981 \texttt{src} _{\texttt{src.rows}-i-1,j} & if\; \texttt{flipCode} = 0 \\ 00982 \texttt{src} _{i, \texttt{src.cols} -j-1} & if\; \texttt{flipCode} > 0 \\ 00983 \texttt{src} _{ \texttt{src.rows} -i-1, \texttt{src.cols} -j-1} & if\; \texttt{flipCode} < 0 \\ 00984 \end{array} 00985 \right.\f] 00986 The example scenarios of using the function are the following: 00987 * Vertical flipping of the image (flipCode == 0) to switch between 00988 top-left and bottom-left image origin. This is a typical operation 00989 in video processing on Microsoft Windows\* OS. 00990 * Horizontal flipping of the image with the subsequent horizontal 00991 shift and absolute difference calculation to check for a 00992 vertical-axis symmetry (flipCode > 0). 00993 * Simultaneous horizontal and vertical flipping of the image with 00994 the subsequent shift and absolute difference calculation to check 00995 for a central symmetry (flipCode < 0). 00996 * Reversing the order of point arrays (flipCode > 0 or 00997 flipCode == 0). 00998 @param src input array. 00999 @param dst output array of the same size and type as src. 01000 @param flipCode a flag to specify how to flip the array; 0 means 01001 flipping around the x-axis and positive value (for example, 1) means 01002 flipping around y-axis. Negative value (for example, -1) means flipping 01003 around both axes. 01004 @sa transpose , repeat , completeSymm 01005 */ 01006 CV_EXPORTS_W void flip(InputArray src, OutputArray dst, int flipCode); 01007 01008 /** @brief Fills the output array with repeated copies of the input array. 01009 01010 The functions repeat duplicate the input array one or more times along each of the two axes: 01011 \f[\texttt{dst} _{ij}= \texttt{src} _{i\mod src.rows, \; j\mod src.cols }\f] 01012 The second variant of the function is more convenient to use with @ref MatrixExpressions. 01013 @param src input array to replicate. 01014 @param dst output array of the same type as src. 01015 @param ny Flag to specify how many times the src is repeated along the 01016 vertical axis. 01017 @param nx Flag to specify how many times the src is repeated along the 01018 horizontal axis. 01019 @sa reduce 01020 */ 01021 CV_EXPORTS_W void repeat(InputArray src, int ny, int nx, OutputArray dst); 01022 01023 /** @overload 01024 @param src input array to replicate. 01025 @param ny Flag to specify how many times the src is repeated along the 01026 vertical axis. 01027 @param nx Flag to specify how many times the src is repeated along the 01028 horizontal axis. 01029 */ 01030 CV_EXPORTS Mat repeat(const Mat& src, int ny, int nx); 01031 01032 /** @brief Applies horizontal concatenation to given matrices. 01033 01034 The function horizontally concatenates two or more cv::Mat matrices (with the same number of rows). 01035 @code{.cpp} 01036 cv::Mat matArray[] = { cv::Mat(4, 1, CV_8UC1, cv::Scalar(1)), 01037 cv::Mat(4, 1, CV_8UC1, cv::Scalar(2)), 01038 cv::Mat(4, 1, CV_8UC1, cv::Scalar(3)),}; 01039 01040 cv::Mat out; 01041 cv::hconcat( matArray, 3, out ); 01042 //out: 01043 //[1, 2, 3; 01044 // 1, 2, 3; 01045 // 1, 2, 3; 01046 // 1, 2, 3] 01047 @endcode 01048 @param src input array or vector of matrices. all of the matrices must have the same number of rows and the same depth. 01049 @param nsrc number of matrices in src. 01050 @param dst output array. It has the same number of rows and depth as the src, and the sum of cols of the src. 01051 @sa cv::vconcat(const Mat*, size_t, OutputArray), @sa cv::vconcat(InputArrayOfArrays, OutputArray) and @sa cv::vconcat(InputArray, InputArray, OutputArray) 01052 */ 01053 CV_EXPORTS void hconcat(const Mat* src, size_t nsrc, OutputArray dst); 01054 /** @overload 01055 @code{.cpp} 01056 cv::Mat_<float> A = (cv::Mat_<float>(3, 2) << 1, 4, 01057 2, 5, 01058 3, 6); 01059 cv::Mat_<float> B = (cv::Mat_<float>(3, 2) << 7, 10, 01060 8, 11, 01061 9, 12); 01062 01063 cv::Mat C; 01064 cv::hconcat(A, B, C); 01065 //C: 01066 //[1, 4, 7, 10; 01067 // 2, 5, 8, 11; 01068 // 3, 6, 9, 12] 01069 @endcode 01070 @param src1 first input array to be considered for horizontal concatenation. 01071 @param src2 second input array to be considered for horizontal concatenation. 01072 @param dst output array. It has the same number of rows and depth as the src1 and src2, and the sum of cols of the src1 and src2. 01073 */ 01074 CV_EXPORTS void hconcat(InputArray src1, InputArray src2, OutputArray dst); 01075 /** @overload 01076 @code{.cpp} 01077 std::vector<cv::Mat> matrices = { cv::Mat(4, 1, CV_8UC1, cv::Scalar(1)), 01078 cv::Mat(4, 1, CV_8UC1, cv::Scalar(2)), 01079 cv::Mat(4, 1, CV_8UC1, cv::Scalar(3)),}; 01080 01081 cv::Mat out; 01082 cv::hconcat( matrices, out ); 01083 //out: 01084 //[1, 2, 3; 01085 // 1, 2, 3; 01086 // 1, 2, 3; 01087 // 1, 2, 3] 01088 @endcode 01089 @param src input array or vector of matrices. all of the matrices must have the same number of rows and the same depth. 01090 @param dst output array. It has the same number of rows and depth as the src, and the sum of cols of the src. 01091 same depth. 01092 */ 01093 CV_EXPORTS_W void hconcat(InputArrayOfArrays src, OutputArray dst); 01094 01095 /** @brief Applies vertical concatenation to given matrices. 01096 01097 The function vertically concatenates two or more cv::Mat matrices (with the same number of cols). 01098 @code{.cpp} 01099 cv::Mat matArray[] = { cv::Mat(1, 4, CV_8UC1, cv::Scalar(1)), 01100 cv::Mat(1, 4, CV_8UC1, cv::Scalar(2)), 01101 cv::Mat(1, 4, CV_8UC1, cv::Scalar(3)),}; 01102 01103 cv::Mat out; 01104 cv::vconcat( matArray, 3, out ); 01105 //out: 01106 //[1, 1, 1, 1; 01107 // 2, 2, 2, 2; 01108 // 3, 3, 3, 3] 01109 @endcode 01110 @param src input array or vector of matrices. all of the matrices must have the same number of cols and the same depth. 01111 @param nsrc number of matrices in src. 01112 @param dst output array. It has the same number of cols and depth as the src, and the sum of rows of the src. 01113 @sa cv::hconcat(const Mat*, size_t, OutputArray), @sa cv::hconcat(InputArrayOfArrays, OutputArray) and @sa cv::hconcat(InputArray, InputArray, OutputArray) 01114 */ 01115 CV_EXPORTS void vconcat(const Mat* src, size_t nsrc, OutputArray dst); 01116 /** @overload 01117 @code{.cpp} 01118 cv::Mat_<float> A = (cv::Mat_<float>(3, 2) << 1, 7, 01119 2, 8, 01120 3, 9); 01121 cv::Mat_<float> B = (cv::Mat_<float>(3, 2) << 4, 10, 01122 5, 11, 01123 6, 12); 01124 01125 cv::Mat C; 01126 cv::vconcat(A, B, C); 01127 //C: 01128 //[1, 7; 01129 // 2, 8; 01130 // 3, 9; 01131 // 4, 10; 01132 // 5, 11; 01133 // 6, 12] 01134 @endcode 01135 @param src1 first input array to be considered for vertical concatenation. 01136 @param src2 second input array to be considered for vertical concatenation. 01137 @param dst output array. It has the same number of cols and depth as the src1 and src2, and the sum of rows of the src1 and src2. 01138 */ 01139 CV_EXPORTS void vconcat(InputArray src1, InputArray src2, OutputArray dst); 01140 /** @overload 01141 @code{.cpp} 01142 std::vector<cv::Mat> matrices = { cv::Mat(1, 4, CV_8UC1, cv::Scalar(1)), 01143 cv::Mat(1, 4, CV_8UC1, cv::Scalar(2)), 01144 cv::Mat(1, 4, CV_8UC1, cv::Scalar(3)),}; 01145 01146 cv::Mat out; 01147 cv::vconcat( matrices, out ); 01148 //out: 01149 //[1, 1, 1, 1; 01150 // 2, 2, 2, 2; 01151 // 3, 3, 3, 3] 01152 @endcode 01153 @param src input array or vector of matrices. all of the matrices must have the same number of cols and the same depth 01154 @param dst output array. It has the same number of cols and depth as the src, and the sum of rows of the src. 01155 same depth. 01156 */ 01157 CV_EXPORTS_W void vconcat(InputArrayOfArrays src, OutputArray dst); 01158 01159 /** @brief computes bitwise conjunction of the two arrays (dst = src1 & src2) 01160 Calculates the per-element bit-wise conjunction of two arrays or an 01161 array and a scalar. 01162 01163 The function calculates the per-element bit-wise logical conjunction for: 01164 * Two arrays when src1 and src2 have the same size: 01165 \f[\texttt{dst} (I) = \texttt{src1} (I) \wedge \texttt{src2} (I) \quad \texttt{if mask} (I) \ne0\f] 01166 * An array and a scalar when src2 is constructed from Scalar or has 01167 the same number of elements as `src1.channels()`: 01168 \f[\texttt{dst} (I) = \texttt{src1} (I) \wedge \texttt{src2} \quad \texttt{if mask} (I) \ne0\f] 01169 * A scalar and an array when src1 is constructed from Scalar or has 01170 the same number of elements as `src2.channels()`: 01171 \f[\texttt{dst} (I) = \texttt{src1} \wedge \texttt{src2} (I) \quad \texttt{if mask} (I) \ne0\f] 01172 In case of floating-point arrays, their machine-specific bit 01173 representations (usually IEEE754-compliant) are used for the operation. 01174 In case of multi-channel arrays, each channel is processed 01175 independently. In the second and third cases above, the scalar is first 01176 converted to the array type. 01177 @param src1 first input array or a scalar. 01178 @param src2 second input array or a scalar. 01179 @param dst output array that has the same size and type as the input 01180 arrays. 01181 @param mask optional operation mask, 8-bit single channel array, that 01182 specifies elements of the output array to be changed. 01183 */ 01184 CV_EXPORTS_W void bitwise_and(InputArray src1, InputArray src2, 01185 OutputArray dst, InputArray mask = noArray()); 01186 01187 /** @brief Calculates the per-element bit-wise disjunction of two arrays or an 01188 array and a scalar. 01189 01190 The function calculates the per-element bit-wise logical disjunction for: 01191 * Two arrays when src1 and src2 have the same size: 01192 \f[\texttt{dst} (I) = \texttt{src1} (I) \vee \texttt{src2} (I) \quad \texttt{if mask} (I) \ne0\f] 01193 * An array and a scalar when src2 is constructed from Scalar or has 01194 the same number of elements as `src1.channels()`: 01195 \f[\texttt{dst} (I) = \texttt{src1} (I) \vee \texttt{src2} \quad \texttt{if mask} (I) \ne0\f] 01196 * A scalar and an array when src1 is constructed from Scalar or has 01197 the same number of elements as `src2.channels()`: 01198 \f[\texttt{dst} (I) = \texttt{src1} \vee \texttt{src2} (I) \quad \texttt{if mask} (I) \ne0\f] 01199 In case of floating-point arrays, their machine-specific bit 01200 representations (usually IEEE754-compliant) are used for the operation. 01201 In case of multi-channel arrays, each channel is processed 01202 independently. In the second and third cases above, the scalar is first 01203 converted to the array type. 01204 @param src1 first input array or a scalar. 01205 @param src2 second input array or a scalar. 01206 @param dst output array that has the same size and type as the input 01207 arrays. 01208 @param mask optional operation mask, 8-bit single channel array, that 01209 specifies elements of the output array to be changed. 01210 */ 01211 CV_EXPORTS_W void bitwise_or(InputArray src1, InputArray src2, 01212 OutputArray dst, InputArray mask = noArray()); 01213 01214 /** @brief Calculates the per-element bit-wise "exclusive or" operation on two 01215 arrays or an array and a scalar. 01216 01217 The function calculates the per-element bit-wise logical "exclusive-or" 01218 operation for: 01219 * Two arrays when src1 and src2 have the same size: 01220 \f[\texttt{dst} (I) = \texttt{src1} (I) \oplus \texttt{src2} (I) \quad \texttt{if mask} (I) \ne0\f] 01221 * An array and a scalar when src2 is constructed from Scalar or has 01222 the same number of elements as `src1.channels()`: 01223 \f[\texttt{dst} (I) = \texttt{src1} (I) \oplus \texttt{src2} \quad \texttt{if mask} (I) \ne0\f] 01224 * A scalar and an array when src1 is constructed from Scalar or has 01225 the same number of elements as `src2.channels()`: 01226 \f[\texttt{dst} (I) = \texttt{src1} \oplus \texttt{src2} (I) \quad \texttt{if mask} (I) \ne0\f] 01227 In case of floating-point arrays, their machine-specific bit 01228 representations (usually IEEE754-compliant) are used for the operation. 01229 In case of multi-channel arrays, each channel is processed 01230 independently. In the 2nd and 3rd cases above, the scalar is first 01231 converted to the array type. 01232 @param src1 first input array or a scalar. 01233 @param src2 second input array or a scalar. 01234 @param dst output array that has the same size and type as the input 01235 arrays. 01236 @param mask optional operation mask, 8-bit single channel array, that 01237 specifies elements of the output array to be changed. 01238 */ 01239 CV_EXPORTS_W void bitwise_xor(InputArray src1, InputArray src2, 01240 OutputArray dst, InputArray mask = noArray()); 01241 01242 /** @brief Inverts every bit of an array. 01243 01244 The function calculates per-element bit-wise inversion of the input 01245 array: 01246 \f[\texttt{dst} (I) = \neg \texttt{src} (I)\f] 01247 In case of a floating-point input array, its machine-specific bit 01248 representation (usually IEEE754-compliant) is used for the operation. In 01249 case of multi-channel arrays, each channel is processed independently. 01250 @param src input array. 01251 @param dst output array that has the same size and type as the input 01252 array. 01253 @param mask optional operation mask, 8-bit single channel array, that 01254 specifies elements of the output array to be changed. 01255 */ 01256 CV_EXPORTS_W void bitwise_not(InputArray src, OutputArray dst, 01257 InputArray mask = noArray()); 01258 01259 /** @brief Calculates the per-element absolute difference between two arrays or between an array and a scalar. 01260 01261 The function absdiff calculates: 01262 * Absolute difference between two arrays when they have the same 01263 size and type: 01264 \f[\texttt{dst}(I) = \texttt{saturate} (| \texttt{src1}(I) - \texttt{src2}(I)|)\f] 01265 * Absolute difference between an array and a scalar when the second 01266 array is constructed from Scalar or has as many elements as the 01267 number of channels in `src1`: 01268 \f[\texttt{dst}(I) = \texttt{saturate} (| \texttt{src1}(I) - \texttt{src2} |)\f] 01269 * Absolute difference between a scalar and an array when the first 01270 array is constructed from Scalar or has as many elements as the 01271 number of channels in `src2`: 01272 \f[\texttt{dst}(I) = \texttt{saturate} (| \texttt{src1} - \texttt{src2}(I) |)\f] 01273 where I is a multi-dimensional index of array elements. In case of 01274 multi-channel arrays, each channel is processed independently. 01275 @note Saturation is not applied when the arrays have the depth CV_32S. 01276 You may even get a negative value in the case of overflow. 01277 @param src1 first input array or a scalar. 01278 @param src2 second input array or a scalar. 01279 @param dst output array that has the same size and type as input arrays. 01280 @sa cv::abs(const Mat&) 01281 */ 01282 CV_EXPORTS_W void absdiff(InputArray src1, InputArray src2, OutputArray dst); 01283 01284 /** @brief Checks if array elements lie between the elements of two other arrays. 01285 01286 The function checks the range as follows: 01287 - For every element of a single-channel input array: 01288 \f[\texttt{dst} (I)= \texttt{lowerb} (I)_0 \leq \texttt{src} (I)_0 \leq \texttt{upperb} (I)_0\f] 01289 - For two-channel arrays: 01290 \f[\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\f] 01291 - and so forth. 01292 01293 That is, dst (I) is set to 255 (all 1 -bits) if src (I) is within the 01294 specified 1D, 2D, 3D, ... box and 0 otherwise. 01295 01296 When the lower and/or upper boundary parameters are scalars, the indexes 01297 (I) at lowerb and upperb in the above formulas should be omitted. 01298 @param src first input array. 01299 @param lowerb inclusive lower boundary array or a scalar. 01300 @param upperb inclusive upper boundary array or a scalar. 01301 @param dst output array of the same size as src and CV_8U type. 01302 */ 01303 CV_EXPORTS_W void inRange(InputArray src, InputArray lowerb, 01304 InputArray upperb, OutputArray dst); 01305 01306 /** @brief Performs the per-element comparison of two arrays or an array and scalar value. 01307 01308 The function compares: 01309 * Elements of two arrays when src1 and src2 have the same size: 01310 \f[\texttt{dst} (I) = \texttt{src1} (I) \,\texttt{cmpop}\, \texttt{src2} (I)\f] 01311 * Elements of src1 with a scalar src2 when src2 is constructed from 01312 Scalar or has a single element: 01313 \f[\texttt{dst} (I) = \texttt{src1}(I) \,\texttt{cmpop}\, \texttt{src2}\f] 01314 * src1 with elements of src2 when src1 is constructed from Scalar or 01315 has a single element: 01316 \f[\texttt{dst} (I) = \texttt{src1} \,\texttt{cmpop}\, \texttt{src2} (I)\f] 01317 When the comparison result is true, the corresponding element of output 01318 array is set to 255. The comparison operations can be replaced with the 01319 equivalent matrix expressions: 01320 @code{.cpp} 01321 Mat dst1 = src1 >= src2; 01322 Mat dst2 = src1 < 8; 01323 ... 01324 @endcode 01325 @param src1 first input array or a scalar; when it is an array, it must have a single channel. 01326 @param src2 second input array or a scalar; when it is an array, it must have a single channel. 01327 @param dst output array of type ref CV_8U that has the same size and the same number of channels as 01328 the input arrays. 01329 @param cmpop a flag, that specifies correspondence between the arrays (cv::CmpTypes) 01330 @sa checkRange, min, max, threshold 01331 */ 01332 CV_EXPORTS_W void compare(InputArray src1, InputArray src2, OutputArray dst, int cmpop); 01333 01334 /** @brief Calculates per-element minimum of two arrays or an array and a scalar. 01335 01336 The functions min calculate the per-element minimum of two arrays: 01337 \f[\texttt{dst} (I)= \min ( \texttt{src1} (I), \texttt{src2} (I))\f] 01338 or array and a scalar: 01339 \f[\texttt{dst} (I)= \min ( \texttt{src1} (I), \texttt{value} )\f] 01340 @param src1 first input array. 01341 @param src2 second input array of the same size and type as src1. 01342 @param dst output array of the same size and type as src1. 01343 @sa max, compare, inRange, minMaxLoc 01344 */ 01345 CV_EXPORTS_W void min(InputArray src1, InputArray src2, OutputArray dst); 01346 /** @overload 01347 needed to avoid conflicts with const _Tp& std::min(const _Tp&, const _Tp&, _Compare) 01348 */ 01349 CV_EXPORTS void min(const Mat& src1, const Mat& src2, Mat& dst); 01350 /** @overload 01351 needed to avoid conflicts with const _Tp& std::min(const _Tp&, const _Tp&, _Compare) 01352 */ 01353 CV_EXPORTS void min(const UMat& src1, const UMat& src2, UMat& dst); 01354 01355 /** @brief Calculates per-element maximum of two arrays or an array and a scalar. 01356 01357 The functions max calculate the per-element maximum of two arrays: 01358 \f[\texttt{dst} (I)= \max ( \texttt{src1} (I), \texttt{src2} (I))\f] 01359 or array and a scalar: 01360 \f[\texttt{dst} (I)= \max ( \texttt{src1} (I), \texttt{value} )\f] 01361 @param src1 first input array. 01362 @param src2 second input array of the same size and type as src1 . 01363 @param dst output array of the same size and type as src1. 01364 @sa min, compare, inRange, minMaxLoc, @ref MatrixExpressions 01365 */ 01366 CV_EXPORTS_W void max(InputArray src1, InputArray src2, OutputArray dst); 01367 /** @overload 01368 needed to avoid conflicts with const _Tp& std::min(const _Tp&, const _Tp&, _Compare) 01369 */ 01370 CV_EXPORTS void max(const Mat& src1, const Mat& src2, Mat& dst); 01371 /** @overload 01372 needed to avoid conflicts with const _Tp& std::min(const _Tp&, const _Tp&, _Compare) 01373 */ 01374 CV_EXPORTS void max(const UMat& src1, const UMat& src2, UMat& dst); 01375 01376 /** @brief Calculates a square root of array elements. 01377 01378 The functions sqrt calculate a square root of each input array element. 01379 In case of multi-channel arrays, each channel is processed 01380 independently. The accuracy is approximately the same as of the built-in 01381 std::sqrt . 01382 @param src input floating-point array. 01383 @param dst output array of the same size and type as src. 01384 */ 01385 CV_EXPORTS_W void sqrt(InputArray src, OutputArray dst); 01386 01387 /** @brief Raises every array element to a power. 01388 01389 The function pow raises every element of the input array to power : 01390 \f[\texttt{dst} (I) = \fork{\texttt{src}(I)^{power}}{if \(\texttt{power}\) is integer}{|\texttt{src}(I)|^{power}}{otherwise}\f] 01391 01392 So, for a non-integer power exponent, the absolute values of input array 01393 elements are used. However, it is possible to get true values for 01394 negative values using some extra operations. In the example below, 01395 computing the 5th root of array src shows: 01396 @code{.cpp} 01397 Mat mask = src < 0; 01398 pow(src, 1./5, dst); 01399 subtract(Scalar::all(0), dst, dst, mask); 01400 @endcode 01401 For some values of power, such as integer values, 0.5 and -0.5, 01402 specialized faster algorithms are used. 01403 01404 Special values (NaN, Inf) are not handled. 01405 @param src input array. 01406 @param power exponent of power. 01407 @param dst output array of the same size and type as src. 01408 @sa sqrt, exp, log, cartToPolar, polarToCart 01409 */ 01410 CV_EXPORTS_W void pow(InputArray src, double power, OutputArray dst); 01411 01412 /** @brief Calculates the exponent of every array element. 01413 01414 The function exp calculates the exponent of every element of the input 01415 array: 01416 \f[\texttt{dst} [I] = e^{ src(I) }\f] 01417 01418 The maximum relative error is about 7e-6 for single-precision input and 01419 less than 1e-10 for double-precision input. Currently, the function 01420 converts denormalized values to zeros on output. Special values (NaN, 01421 Inf) are not handled. 01422 @param src input array. 01423 @param dst output array of the same size and type as src. 01424 @sa log , cartToPolar , polarToCart , phase , pow , sqrt , magnitude 01425 */ 01426 CV_EXPORTS_W void exp(InputArray src, OutputArray dst); 01427 01428 /** @brief Calculates the natural logarithm of every array element. 01429 01430 The function log calculates the natural logarithm of the absolute value 01431 of every element of the input array: 01432 \f[\texttt{dst} (I) = \fork{\log |\texttt{src}(I)|}{if \(\texttt{src}(I) \ne 0\) }{\texttt{C}}{otherwise}\f] 01433 01434 where C is a large negative number (about -700 in the current 01435 implementation). The maximum relative error is about 7e-6 for 01436 single-precision input and less than 1e-10 for double-precision input. 01437 Special values (NaN, Inf) are not handled. 01438 @param src input array. 01439 @param dst output array of the same size and type as src . 01440 @sa exp, cartToPolar, polarToCart, phase, pow, sqrt, magnitude 01441 */ 01442 CV_EXPORTS_W void log(InputArray src, OutputArray dst); 01443 01444 /** @brief Calculates x and y coordinates of 2D vectors from their magnitude and angle. 01445 01446 The function polarToCart calculates the Cartesian coordinates of each 2D 01447 vector represented by the corresponding elements of magnitude and angle: 01448 \f[\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}\f] 01449 01450 The relative accuracy of the estimated coordinates is about 1e-6. 01451 @param magnitude input floating-point array of magnitudes of 2D vectors; 01452 it can be an empty matrix (=Mat()), in this case, the function assumes 01453 that all the magnitudes are =1; if it is not empty, it must have the 01454 same size and type as angle. 01455 @param angle input floating-point array of angles of 2D vectors. 01456 @param x output array of x-coordinates of 2D vectors; it has the same 01457 size and type as angle. 01458 @param y output array of y-coordinates of 2D vectors; it has the same 01459 size and type as angle. 01460 @param angleInDegrees when true, the input angles are measured in 01461 degrees, otherwise, they are measured in radians. 01462 @sa cartToPolar, magnitude, phase, exp, log, pow, sqrt 01463 */ 01464 CV_EXPORTS_W void polarToCart(InputArray magnitude, InputArray angle, 01465 OutputArray x, OutputArray y, bool angleInDegrees = false); 01466 01467 /** @brief Calculates the magnitude and angle of 2D vectors. 01468 01469 The function cartToPolar calculates either the magnitude, angle, or both 01470 for every 2D vector (x(I),y(I)): 01471 \f[\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}\f] 01472 01473 The angles are calculated with accuracy about 0.3 degrees. For the point 01474 (0,0), the angle is set to 0. 01475 @param x array of x-coordinates; this must be a single-precision or 01476 double-precision floating-point array. 01477 @param y array of y-coordinates, that must have the same size and same type as x. 01478 @param magnitude output array of magnitudes of the same size and type as x. 01479 @param angle output array of angles that has the same size and type as 01480 x; the angles are measured in radians (from 0 to 2\*Pi) or in degrees (0 to 360 degrees). 01481 @param angleInDegrees a flag, indicating whether the angles are measured 01482 in radians (which is by default), or in degrees. 01483 @sa Sobel, Scharr 01484 */ 01485 CV_EXPORTS_W void cartToPolar(InputArray x, InputArray y, 01486 OutputArray magnitude, OutputArray angle, 01487 bool angleInDegrees = false); 01488 01489 /** @brief Calculates the rotation angle of 2D vectors. 01490 01491 The function phase calculates the rotation angle of each 2D vector that 01492 is formed from the corresponding elements of x and y : 01493 \f[\texttt{angle} (I) = \texttt{atan2} ( \texttt{y} (I), \texttt{x} (I))\f] 01494 01495 The angle estimation accuracy is about 0.3 degrees. When x(I)=y(I)=0 , 01496 the corresponding angle(I) is set to 0. 01497 @param x input floating-point array of x-coordinates of 2D vectors. 01498 @param y input array of y-coordinates of 2D vectors; it must have the 01499 same size and the same type as x. 01500 @param angle output array of vector angles; it has the same size and 01501 same type as x . 01502 @param angleInDegrees when true, the function calculates the angle in 01503 degrees, otherwise, they are measured in radians. 01504 */ 01505 CV_EXPORTS_W void phase(InputArray x, InputArray y, OutputArray angle, 01506 bool angleInDegrees = false); 01507 01508 /** @brief Calculates the magnitude of 2D vectors. 01509 01510 The function magnitude calculates the magnitude of 2D vectors formed 01511 from the corresponding elements of x and y arrays: 01512 \f[\texttt{dst} (I) = \sqrt{\texttt{x}(I)^2 + \texttt{y}(I)^2}\f] 01513 @param x floating-point array of x-coordinates of the vectors. 01514 @param y floating-point array of y-coordinates of the vectors; it must 01515 have the same size as x. 01516 @param magnitude output array of the same size and type as x. 01517 @sa cartToPolar, polarToCart, phase, sqrt 01518 */ 01519 CV_EXPORTS_W void magnitude(InputArray x, InputArray y, OutputArray magnitude); 01520 01521 /** @brief Checks every element of an input array for invalid values. 01522 01523 The functions checkRange check that every array element is neither NaN nor infinite. When minVal > 01524 -DBL_MAX and maxVal < DBL_MAX, the functions also check that each value is between minVal and 01525 maxVal. In case of multi-channel arrays, each channel is processed independently. If some values 01526 are out of range, position of the first outlier is stored in pos (when pos != NULL). Then, the 01527 functions either return false (when quiet=true) or throw an exception. 01528 @param a input array. 01529 @param quiet a flag, indicating whether the functions quietly return false when the array elements 01530 are out of range or they throw an exception. 01531 @param pos optional output parameter, when not NULL, must be a pointer to array of src.dims 01532 elements. 01533 @param minVal inclusive lower boundary of valid values range. 01534 @param maxVal exclusive upper boundary of valid values range. 01535 */ 01536 CV_EXPORTS_W bool checkRange(InputArray a, bool quiet = true, CV_OUT Point* pos = 0, 01537 double minVal = -DBL_MAX, double maxVal = DBL_MAX); 01538 01539 /** @brief converts NaN's to the given number 01540 */ 01541 CV_EXPORTS_W void patchNaNs(InputOutputArray a, double val = 0); 01542 01543 /** @brief Performs generalized matrix multiplication. 01544 01545 The function performs generalized matrix multiplication similar to the 01546 gemm functions in BLAS level 3. For example, 01547 `gemm(src1, src2, alpha, src3, beta, dst, GEMM_1_T + GEMM_3_T)` 01548 corresponds to 01549 \f[\texttt{dst} = \texttt{alpha} \cdot \texttt{src1} ^T \cdot \texttt{src2} + \texttt{beta} \cdot \texttt{src3} ^T\f] 01550 01551 In case of complex (two-channel) data, performed a complex matrix 01552 multiplication. 01553 01554 The function can be replaced with a matrix expression. For example, the 01555 above call can be replaced with: 01556 @code{.cpp} 01557 dst = alpha*src1.t()*src2 + beta*src3.t(); 01558 @endcode 01559 @param src1 first multiplied input matrix that could be real(CV_32FC1, 01560 CV_64FC1) or complex(CV_32FC2, CV_64FC2). 01561 @param src2 second multiplied input matrix of the same type as src1. 01562 @param alpha weight of the matrix product. 01563 @param src3 third optional delta matrix added to the matrix product; it 01564 should have the same type as src1 and src2. 01565 @param beta weight of src3. 01566 @param dst output matrix; it has the proper size and the same type as 01567 input matrices. 01568 @param flags operation flags (cv::GemmFlags) 01569 @sa mulTransposed , transform 01570 */ 01571 CV_EXPORTS_W void gemm(InputArray src1, InputArray src2, double alpha, 01572 InputArray src3, double beta, OutputArray dst, int flags = 0); 01573 01574 /** @brief Calculates the product of a matrix and its transposition. 01575 01576 The function mulTransposed calculates the product of src and its 01577 transposition: 01578 \f[\texttt{dst} = \texttt{scale} ( \texttt{src} - \texttt{delta} )^T ( \texttt{src} - \texttt{delta} )\f] 01579 if aTa=true , and 01580 \f[\texttt{dst} = \texttt{scale} ( \texttt{src} - \texttt{delta} ) ( \texttt{src} - \texttt{delta} )^T\f] 01581 otherwise. The function is used to calculate the covariance matrix. With 01582 zero delta, it can be used as a faster substitute for general matrix 01583 product A\*B when B=A' 01584 @param src input single-channel matrix. Note that unlike gemm, the 01585 function can multiply not only floating-point matrices. 01586 @param dst output square matrix. 01587 @param aTa Flag specifying the multiplication ordering. See the 01588 description below. 01589 @param delta Optional delta matrix subtracted from src before the 01590 multiplication. When the matrix is empty ( delta=noArray() ), it is 01591 assumed to be zero, that is, nothing is subtracted. If it has the same 01592 size as src , it is simply subtracted. Otherwise, it is "repeated" (see 01593 repeat ) to cover the full src and then subtracted. Type of the delta 01594 matrix, when it is not empty, must be the same as the type of created 01595 output matrix. See the dtype parameter description below. 01596 @param scale Optional scale factor for the matrix product. 01597 @param dtype Optional type of the output matrix. When it is negative, 01598 the output matrix will have the same type as src . Otherwise, it will be 01599 type=CV_MAT_DEPTH(dtype) that should be either CV_32F or CV_64F . 01600 @sa calcCovarMatrix, gemm, repeat, reduce 01601 */ 01602 CV_EXPORTS_W void mulTransposed( InputArray src, OutputArray dst, bool aTa, 01603 InputArray delta = noArray(), 01604 double scale = 1, int dtype = -1 ); 01605 01606 /** @brief Transposes a matrix. 01607 01608 The function transpose transposes the matrix src : 01609 \f[\texttt{dst} (i,j) = \texttt{src} (j,i)\f] 01610 @note No complex conjugation is done in case of a complex matrix. It it 01611 should be done separately if needed. 01612 @param src input array. 01613 @param dst output array of the same type as src. 01614 */ 01615 CV_EXPORTS_W void transpose(InputArray src, OutputArray dst); 01616 01617 /** @brief Performs the matrix transformation of every array element. 01618 01619 The function transform performs the matrix transformation of every 01620 element of the array src and stores the results in dst : 01621 \f[\texttt{dst} (I) = \texttt{m} \cdot \texttt{src} (I)\f] 01622 (when m.cols=src.channels() ), or 01623 \f[\texttt{dst} (I) = \texttt{m} \cdot [ \texttt{src} (I); 1]\f] 01624 (when m.cols=src.channels()+1 ) 01625 01626 Every element of the N -channel array src is interpreted as N -element 01627 vector that is transformed using the M x N or M x (N+1) matrix m to 01628 M-element vector - the corresponding element of the output array dst . 01629 01630 The function may be used for geometrical transformation of 01631 N -dimensional points, arbitrary linear color space transformation (such 01632 as various kinds of RGB to YUV transforms), shuffling the image 01633 channels, and so forth. 01634 @param src input array that must have as many channels (1 to 4) as 01635 m.cols or m.cols-1. 01636 @param dst output array of the same size and depth as src; it has as 01637 many channels as m.rows. 01638 @param m transformation 2x2 or 2x3 floating-point matrix. 01639 @sa perspectiveTransform, getAffineTransform, estimateRigidTransform, warpAffine, warpPerspective 01640 */ 01641 CV_EXPORTS_W void transform(InputArray src, OutputArray dst, InputArray m ); 01642 01643 /** @brief Performs the perspective matrix transformation of vectors. 01644 01645 The function perspectiveTransform transforms every element of src by 01646 treating it as a 2D or 3D vector, in the following way: 01647 \f[(x, y, z) \rightarrow (x'/w, y'/w, z'/w)\f] 01648 where 01649 \f[(x', y', z', w') = \texttt{mat} \cdot \begin{bmatrix} x & y & z & 1 \end{bmatrix}\f] 01650 and 01651 \f[w = \fork{w'}{if \(w' \ne 0\)}{\infty}{otherwise}\f] 01652 01653 Here a 3D vector transformation is shown. In case of a 2D vector 01654 transformation, the z component is omitted. 01655 01656 @note The function transforms a sparse set of 2D or 3D vectors. If you 01657 want to transform an image using perspective transformation, use 01658 warpPerspective . If you have an inverse problem, that is, you want to 01659 compute the most probable perspective transformation out of several 01660 pairs of corresponding points, you can use getPerspectiveTransform or 01661 findHomography . 01662 @param src input two-channel or three-channel floating-point array; each 01663 element is a 2D/3D vector to be transformed. 01664 @param dst output array of the same size and type as src. 01665 @param m 3x3 or 4x4 floating-point transformation matrix. 01666 @sa transform, warpPerspective, getPerspectiveTransform, findHomography 01667 */ 01668 CV_EXPORTS_W void perspectiveTransform(InputArray src, OutputArray dst, InputArray m ); 01669 01670 /** @brief Copies the lower or the upper half of a square matrix to another half. 01671 01672 The function completeSymm copies the lower half of a square matrix to 01673 its another half. The matrix diagonal remains unchanged: 01674 * \f$\texttt{mtx}_{ij}=\texttt{mtx}_{ji}\f$ for \f$i > j\f$ if 01675 lowerToUpper=false 01676 * \f$\texttt{mtx}_{ij}=\texttt{mtx}_{ji}\f$ for \f$i < j\f$ if 01677 lowerToUpper=true 01678 @param mtx input-output floating-point square matrix. 01679 @param lowerToUpper operation flag; if true, the lower half is copied to 01680 the upper half. Otherwise, the upper half is copied to the lower half. 01681 @sa flip, transpose 01682 */ 01683 CV_EXPORTS_W void completeSymm(InputOutputArray mtx, bool lowerToUpper = false); 01684 01685 /** @brief Initializes a scaled identity matrix. 01686 01687 The function setIdentity initializes a scaled identity matrix: 01688 \f[\texttt{mtx} (i,j)= \fork{\texttt{value}}{ if \(i=j\)}{0}{otherwise}\f] 01689 01690 The function can also be emulated using the matrix initializers and the 01691 matrix expressions: 01692 @code 01693 Mat A = Mat::eye(4, 3, CV_32F)*5; 01694 // A will be set to [[5, 0, 0], [0, 5, 0], [0, 0, 5], [0, 0, 0]] 01695 @endcode 01696 @param mtx matrix to initialize (not necessarily square). 01697 @param s value to assign to diagonal elements. 01698 @sa Mat::zeros, Mat::ones, Mat::setTo, Mat::operator= 01699 */ 01700 CV_EXPORTS_W void setIdentity(InputOutputArray mtx, const Scalar& s = Scalar(1)); 01701 01702 /** @brief Returns the determinant of a square floating-point matrix. 01703 01704 The function determinant calculates and returns the determinant of the 01705 specified matrix. For small matrices ( mtx.cols=mtx.rows<=3 ), the 01706 direct method is used. For larger matrices, the function uses LU 01707 factorization with partial pivoting. 01708 01709 For symmetric positively-determined matrices, it is also possible to use 01710 eigen decomposition to calculate the determinant. 01711 @param mtx input matrix that must have CV_32FC1 or CV_64FC1 type and 01712 square size. 01713 @sa trace, invert, solve, eigen, @ref MatrixExpressions 01714 */ 01715 CV_EXPORTS_W double determinant(InputArray mtx); 01716 01717 /** @brief Returns the trace of a matrix. 01718 01719 The function trace returns the sum of the diagonal elements of the 01720 matrix mtx . 01721 \f[\mathrm{tr} ( \texttt{mtx} ) = \sum _i \texttt{mtx} (i,i)\f] 01722 @param mtx input matrix. 01723 */ 01724 CV_EXPORTS_W Scalar trace(InputArray mtx); 01725 01726 /** @brief Finds the inverse or pseudo-inverse of a matrix. 01727 01728 The function invert inverts the matrix src and stores the result in dst 01729 . When the matrix src is singular or non-square, the function calculates 01730 the pseudo-inverse matrix (the dst matrix) so that norm(src\*dst - I) is 01731 minimal, where I is an identity matrix. 01732 01733 In case of the DECOMP_LU method, the function returns non-zero value if 01734 the inverse has been successfully calculated and 0 if src is singular. 01735 01736 In case of the DECOMP_SVD method, the function returns the inverse 01737 condition number of src (the ratio of the smallest singular value to the 01738 largest singular value) and 0 if src is singular. The SVD method 01739 calculates a pseudo-inverse matrix if src is singular. 01740 01741 Similarly to DECOMP_LU, the method DECOMP_CHOLESKY works only with 01742 non-singular square matrices that should also be symmetrical and 01743 positively defined. In this case, the function stores the inverted 01744 matrix in dst and returns non-zero. Otherwise, it returns 0. 01745 01746 @param src input floating-point M x N matrix. 01747 @param dst output matrix of N x M size and the same type as src. 01748 @param flags inversion method (cv::DecompTypes) 01749 @sa solve, SVD 01750 */ 01751 CV_EXPORTS_W double invert(InputArray src, OutputArray dst, int flags = DECOMP_LU); 01752 01753 /** @brief Solves one or more linear systems or least-squares problems. 01754 01755 The function solve solves a linear system or least-squares problem (the 01756 latter is possible with SVD or QR methods, or by specifying the flag 01757 DECOMP_NORMAL ): 01758 \f[\texttt{dst} = \arg \min _X \| \texttt{src1} \cdot \texttt{X} - \texttt{src2} \|\f] 01759 01760 If DECOMP_LU or DECOMP_CHOLESKY method is used, the function returns 1 01761 if src1 (or \f$\texttt{src1}^T\texttt{src1}\f$ ) is non-singular. Otherwise, 01762 it returns 0. In the latter case, dst is not valid. Other methods find a 01763 pseudo-solution in case of a singular left-hand side part. 01764 01765 @note If you want to find a unity-norm solution of an under-defined 01766 singular system \f$\texttt{src1}\cdot\texttt{dst}=0\f$ , the function solve 01767 will not do the work. Use SVD::solveZ instead. 01768 01769 @param src1 input matrix on the left-hand side of the system. 01770 @param src2 input matrix on the right-hand side of the system. 01771 @param dst output solution. 01772 @param flags solution (matrix inversion) method (cv::DecompTypes) 01773 @sa invert, SVD, eigen 01774 */ 01775 CV_EXPORTS_W bool solve(InputArray src1, InputArray src2, 01776 OutputArray dst, int flags = DECOMP_LU); 01777 01778 /** @brief Sorts each row or each column of a matrix. 01779 01780 The function sort sorts each matrix row or each matrix column in 01781 ascending or descending order. So you should pass two operation flags to 01782 get desired behaviour. If you want to sort matrix rows or columns 01783 lexicographically, you can use STL std::sort generic function with the 01784 proper comparison predicate. 01785 01786 @param src input single-channel array. 01787 @param dst output array of the same size and type as src. 01788 @param flags operation flags, a combination of cv::SortFlags 01789 @sa sortIdx, randShuffle 01790 */ 01791 CV_EXPORTS_W void sort(InputArray src, OutputArray dst, int flags); 01792 01793 /** @brief Sorts each row or each column of a matrix. 01794 01795 The function sortIdx sorts each matrix row or each matrix column in the 01796 ascending or descending order. So you should pass two operation flags to 01797 get desired behaviour. Instead of reordering the elements themselves, it 01798 stores the indices of sorted elements in the output array. For example: 01799 @code 01800 Mat A = Mat::eye(3,3,CV_32F), B; 01801 sortIdx(A, B, SORT_EVERY_ROW + SORT_ASCENDING); 01802 // B will probably contain 01803 // (because of equal elements in A some permutations are possible): 01804 // [[1, 2, 0], [0, 2, 1], [0, 1, 2]] 01805 @endcode 01806 @param src input single-channel array. 01807 @param dst output integer array of the same size as src. 01808 @param flags operation flags that could be a combination of cv::SortFlags 01809 @sa sort, randShuffle 01810 */ 01811 CV_EXPORTS_W void sortIdx(InputArray src, OutputArray dst, int flags); 01812 01813 /** @brief Finds the real roots of a cubic equation. 01814 01815 The function solveCubic finds the real roots of a cubic equation: 01816 - if coeffs is a 4-element vector: 01817 \f[\texttt{coeffs} [0] x^3 + \texttt{coeffs} [1] x^2 + \texttt{coeffs} [2] x + \texttt{coeffs} [3] = 0\f] 01818 - if coeffs is a 3-element vector: 01819 \f[x^3 + \texttt{coeffs} [0] x^2 + \texttt{coeffs} [1] x + \texttt{coeffs} [2] = 0\f] 01820 01821 The roots are stored in the roots array. 01822 @param coeffs equation coefficients, an array of 3 or 4 elements. 01823 @param roots output array of real roots that has 1 or 3 elements. 01824 */ 01825 CV_EXPORTS_W int solveCubic(InputArray coeffs, OutputArray roots); 01826 01827 /** @brief Finds the real or complex roots of a polynomial equation. 01828 01829 The function solvePoly finds real and complex roots of a polynomial equation: 01830 \f[\texttt{coeffs} [n] x^{n} + \texttt{coeffs} [n-1] x^{n-1} + ... + \texttt{coeffs} [1] x + \texttt{coeffs} [0] = 0\f] 01831 @param coeffs array of polynomial coefficients. 01832 @param roots output (complex) array of roots. 01833 @param maxIters maximum number of iterations the algorithm does. 01834 */ 01835 CV_EXPORTS_W double solvePoly(InputArray coeffs, OutputArray roots, int maxIters = 300); 01836 01837 /** @brief Calculates eigenvalues and eigenvectors of a symmetric matrix. 01838 01839 The functions eigen calculate just eigenvalues, or eigenvalues and eigenvectors of the symmetric 01840 matrix src: 01841 @code 01842 src*eigenvectors.row(i).t() = eigenvalues.at<srcType>(i)*eigenvectors.row(i).t() 01843 @endcode 01844 @note in the new and the old interfaces different ordering of eigenvalues and eigenvectors 01845 parameters is used. 01846 @param src input matrix that must have CV_32FC1 or CV_64FC1 type, square size and be symmetrical 01847 (src ^T^ == src). 01848 @param eigenvalues output vector of eigenvalues of the same type as src; the eigenvalues are stored 01849 in the descending order. 01850 @param eigenvectors output matrix of eigenvectors; it has the same size and type as src; the 01851 eigenvectors are stored as subsequent matrix rows, in the same order as the corresponding 01852 eigenvalues. 01853 @sa completeSymm , PCA 01854 */ 01855 CV_EXPORTS_W bool eigen(InputArray src, OutputArray eigenvalues, 01856 OutputArray eigenvectors = noArray()); 01857 01858 /** @brief Calculates the covariance matrix of a set of vectors. 01859 01860 The functions calcCovarMatrix calculate the covariance matrix and, optionally, the mean vector of 01861 the set of input vectors. 01862 @param samples samples stored as separate matrices 01863 @param nsamples number of samples 01864 @param covar output covariance matrix of the type ctype and square size. 01865 @param mean input or output (depending on the flags) array as the average value of the input vectors. 01866 @param flags operation flags as a combination of cv::CovarFlags 01867 @param ctype type of the matrixl; it equals 'CV_64F' by default. 01868 @sa PCA, mulTransposed, Mahalanobis 01869 @todo InputArrayOfArrays 01870 */ 01871 CV_EXPORTS void calcCovarMatrix( const Mat* samples, int nsamples, Mat& covar, Mat& mean, 01872 int flags, int ctype = CV_64F); 01873 01874 /** @overload 01875 @note use cv::COVAR_ROWS or cv::COVAR_COLS flag 01876 @param samples samples stored as rows/columns of a single matrix. 01877 @param covar output covariance matrix of the type ctype and square size. 01878 @param mean input or output (depending on the flags) array as the average value of the input vectors. 01879 @param flags operation flags as a combination of cv::CovarFlags 01880 @param ctype type of the matrixl; it equals 'CV_64F' by default. 01881 */ 01882 CV_EXPORTS_W void calcCovarMatrix( InputArray samples, OutputArray covar, 01883 InputOutputArray mean, int flags, int ctype = CV_64F); 01884 01885 /** wrap PCA::operator() */ 01886 CV_EXPORTS_W void PCACompute(InputArray data, InputOutputArray mean, 01887 OutputArray eigenvectors, int maxComponents = 0); 01888 01889 /** wrap PCA::operator() */ 01890 CV_EXPORTS_W void PCACompute(InputArray data, InputOutputArray mean, 01891 OutputArray eigenvectors, double retainedVariance); 01892 01893 /** wrap PCA::project */ 01894 CV_EXPORTS_W void PCAProject(InputArray data, InputArray mean, 01895 InputArray eigenvectors, OutputArray result); 01896 01897 /** wrap PCA::backProject */ 01898 CV_EXPORTS_W void PCABackProject(InputArray data, InputArray mean, 01899 InputArray eigenvectors, OutputArray result); 01900 01901 /** wrap SVD::compute */ 01902 CV_EXPORTS_W void SVDecomp( InputArray src, OutputArray w, OutputArray u, OutputArray vt, int flags = 0 ); 01903 01904 /** wrap SVD::backSubst */ 01905 CV_EXPORTS_W void SVBackSubst( InputArray w, InputArray u, InputArray vt, 01906 InputArray rhs, OutputArray dst ); 01907 01908 /** @brief Calculates the Mahalanobis distance between two vectors. 01909 01910 The function Mahalanobis calculates and returns the weighted distance between two vectors: 01911 \f[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)})} }\f] 01912 The covariance matrix may be calculated using the cv::calcCovarMatrix function and then inverted using 01913 the invert function (preferably using the cv::DECOMP_SVD method, as the most accurate). 01914 @param v1 first 1D input vector. 01915 @param v2 second 1D input vector. 01916 @param icovar inverse covariance matrix. 01917 */ 01918 CV_EXPORTS_W double Mahalanobis(InputArray v1, InputArray v2, InputArray icovar); 01919 01920 /** @brief Performs a forward or inverse Discrete Fourier transform of a 1D or 2D floating-point array. 01921 01922 The function performs one of the following: 01923 - Forward the Fourier transform of a 1D vector of N elements: 01924 \f[Y = F^{(N)} \cdot X,\f] 01925 where \f$F^{(N)}_{jk}=\exp(-2\pi i j k/N)\f$ and \f$i=\sqrt{-1}\f$ 01926 - Inverse the Fourier transform of a 1D vector of N elements: 01927 \f[\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] 01928 where \f$F^*=\left(\textrm{Re}(F^{(N)})-\textrm{Im}(F^{(N)})\right)^T\f$ 01929 - Forward the 2D Fourier transform of a M x N matrix: 01930 \f[Y = F^{(M)} \cdot X \cdot F^{(N)}\f] 01931 - Inverse the 2D Fourier transform of a M x N matrix: 01932 \f[\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}\f] 01933 01934 In case of real (single-channel) data, the output spectrum of the forward Fourier transform or input 01935 spectrum of the inverse Fourier transform can be represented in a packed format called *CCS* 01936 (complex-conjugate-symmetrical). It was borrowed from IPL (Intel\* Image Processing Library). Here 01937 is how 2D *CCS* spectrum looks: 01938 \f[\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}\f] 01939 01940 In case of 1D transform of a real vector, the output looks like the first row of the matrix above. 01941 01942 So, the function chooses an operation mode depending on the flags and size of the input array: 01943 - If DFT_ROWS is set or the input array has a single row or single column, the function 01944 performs a 1D forward or inverse transform of each row of a matrix when DFT_ROWS is set. 01945 Otherwise, it performs a 2D transform. 01946 - If the input array is real and DFT_INVERSE is not set, the function performs a forward 1D or 01947 2D transform: 01948 - When DFT_COMPLEX_OUTPUT is set, the output is a complex matrix of the same size as 01949 input. 01950 - When DFT_COMPLEX_OUTPUT is not set, the output is a real matrix of the same size as 01951 input. In case of 2D transform, it uses the packed format as shown above. In case of a 01952 single 1D transform, it looks like the first row of the matrix above. In case of 01953 multiple 1D transforms (when using the DFT_ROWS flag), each row of the output matrix 01954 looks like the first row of the matrix above. 01955 - If the input array is complex and either DFT_INVERSE or DFT_REAL_OUTPUT are not set, the 01956 output is a complex array of the same size as input. The function performs a forward or 01957 inverse 1D or 2D transform of the whole input array or each row of the input array 01958 independently, depending on the flags DFT_INVERSE and DFT_ROWS. 01959 - When DFT_INVERSE is set and the input array is real, or it is complex but DFT_REAL_OUTPUT 01960 is set, the output is a real array of the same size as input. The function performs a 1D or 2D 01961 inverse transformation of the whole input array or each individual row, depending on the flags 01962 DFT_INVERSE and DFT_ROWS. 01963 01964 If DFT_SCALE is set, the scaling is done after the transformation. 01965 01966 Unlike dct , the function supports arrays of arbitrary size. But only those arrays are processed 01967 efficiently, whose sizes can be factorized in a product of small prime numbers (2, 3, and 5 in the 01968 current implementation). Such an efficient DFT size can be calculated using the getOptimalDFTSize 01969 method. 01970 01971 The sample below illustrates how to calculate a DFT-based convolution of two 2D real arrays: 01972 @code 01973 void convolveDFT(InputArray A, InputArray B, OutputArray C) 01974 { 01975 // reallocate the output array if needed 01976 C.create(abs(A.rows - B.rows)+1, abs(A.cols - B.cols)+1, A.type()); 01977 Size dftSize; 01978 // calculate the size of DFT transform 01979 dftSize.width = getOptimalDFTSize(A.cols + B.cols - 1); 01980 dftSize.height = getOptimalDFTSize(A.rows + B.rows - 1); 01981 01982 // allocate temporary buffers and initialize them with 0's 01983 Mat tempA(dftSize, A.type(), Scalar::all(0)); 01984 Mat tempB(dftSize, B.type(), Scalar::all(0)); 01985 01986 // copy A and B to the top-left corners of tempA and tempB, respectively 01987 Mat roiA(tempA, Rect(0,0,A.cols,A.rows)); 01988 A.copyTo(roiA); 01989 Mat roiB(tempB, Rect(0,0,B.cols,B.rows)); 01990 B.copyTo(roiB); 01991 01992 // now transform the padded A & B in-place; 01993 // use "nonzeroRows" hint for faster processing 01994 dft(tempA, tempA, 0, A.rows); 01995 dft(tempB, tempB, 0, B.rows); 01996 01997 // multiply the spectrums; 01998 // the function handles packed spectrum representations well 01999 mulSpectrums(tempA, tempB, tempA); 02000 02001 // transform the product back from the frequency domain. 02002 // Even though all the result rows will be non-zero, 02003 // you need only the first C.rows of them, and thus you 02004 // pass nonzeroRows == C.rows 02005 dft(tempA, tempA, DFT_INVERSE + DFT_SCALE, C.rows); 02006 02007 // now copy the result back to C. 02008 tempA(Rect(0, 0, C.cols, C.rows)).copyTo(C); 02009 02010 // all the temporary buffers will be deallocated automatically 02011 } 02012 @endcode 02013 To optimize this sample, consider the following approaches: 02014 - Since nonzeroRows != 0 is passed to the forward transform calls and since A and B are copied to 02015 the top-left corners of tempA and tempB, respectively, it is not necessary to clear the whole 02016 tempA and tempB. It is only necessary to clear the tempA.cols - A.cols ( tempB.cols - B.cols) 02017 rightmost columns of the matrices. 02018 - This DFT-based convolution does not have to be applied to the whole big arrays, especially if B 02019 is significantly smaller than A or vice versa. Instead, you can calculate convolution by parts. 02020 To do this, you need to split the output array C into multiple tiles. For each tile, estimate 02021 which parts of A and B are required to calculate convolution in this tile. If the tiles in C are 02022 too small, the speed will decrease a lot because of repeated work. In the ultimate case, when 02023 each tile in C is a single pixel, the algorithm becomes equivalent to the naive convolution 02024 algorithm. If the tiles are too big, the temporary arrays tempA and tempB become too big and 02025 there is also a slowdown because of bad cache locality. So, there is an optimal tile size 02026 somewhere in the middle. 02027 - If different tiles in C can be calculated in parallel and, thus, the convolution is done by 02028 parts, the loop can be threaded. 02029 02030 All of the above improvements have been implemented in matchTemplate and filter2D . Therefore, by 02031 using them, you can get the performance even better than with the above theoretically optimal 02032 implementation. Though, those two functions actually calculate cross-correlation, not convolution, 02033 so you need to "flip" the second convolution operand B vertically and horizontally using flip . 02034 @note 02035 - An example using the discrete fourier transform can be found at 02036 opencv_source_code/samples/cpp/dft.cpp 02037 - (Python) An example using the dft functionality to perform Wiener deconvolution can be found 02038 at opencv_source/samples/python/deconvolution.py 02039 - (Python) An example rearranging the quadrants of a Fourier image can be found at 02040 opencv_source/samples/python/dft.py 02041 @param src input array that could be real or complex. 02042 @param dst output array whose size and type depends on the flags . 02043 @param flags transformation flags, representing a combination of the cv::DftFlags 02044 @param nonzeroRows when the parameter is not zero, the function assumes that only the first 02045 nonzeroRows rows of the input array (DFT_INVERSE is not set) or only the first nonzeroRows of the 02046 output array (DFT_INVERSE is set) contain non-zeros, thus, the function can handle the rest of the 02047 rows more efficiently and save some time; this technique is very useful for calculating array 02048 cross-correlation or convolution using DFT. 02049 @sa dct , getOptimalDFTSize , mulSpectrums, filter2D , matchTemplate , flip , cartToPolar , 02050 magnitude , phase 02051 */ 02052 CV_EXPORTS_W void dft(InputArray src, OutputArray dst, int flags = 0, int nonzeroRows = 0); 02053 02054 /** @brief Calculates the inverse Discrete Fourier Transform of a 1D or 2D array. 02055 02056 idft(src, dst, flags) is equivalent to dft(src, dst, flags | DFT_INVERSE) . 02057 @note None of dft and idft scales the result by default. So, you should pass DFT_SCALE to one of 02058 dft or idft explicitly to make these transforms mutually inverse. 02059 @sa dft, dct, idct, mulSpectrums, getOptimalDFTSize 02060 @param src input floating-point real or complex array. 02061 @param dst output array whose size and type depend on the flags. 02062 @param flags operation flags (see dft and cv::DftFlags). 02063 @param nonzeroRows number of dst rows to process; the rest of the rows have undefined content (see 02064 the convolution sample in dft description. 02065 */ 02066 CV_EXPORTS_W void idft(InputArray src, OutputArray dst, int flags = 0, int nonzeroRows = 0); 02067 02068 /** @brief Performs a forward or inverse discrete Cosine transform of 1D or 2D array. 02069 02070 The function dct performs a forward or inverse discrete Cosine transform (DCT) of a 1D or 2D 02071 floating-point array: 02072 - Forward Cosine transform of a 1D vector of N elements: 02073 \f[Y = C^{(N)} \cdot X\f] 02074 where 02075 \f[C^{(N)}_{jk}= \sqrt{\alpha_j/N} \cos \left ( \frac{\pi(2k+1)j}{2N} \right )\f] 02076 and 02077 \f$\alpha_0=1\f$, \f$\alpha_j=2\f$ for *j > 0*. 02078 - Inverse Cosine transform of a 1D vector of N elements: 02079 \f[X = \left (C^{(N)} \right )^{-1} \cdot Y = \left (C^{(N)} \right )^T \cdot Y\f] 02080 (since \f$C^{(N)}\f$ is an orthogonal matrix, \f$C^{(N)} \cdot \left(C^{(N)}\right)^T = I\f$ ) 02081 - Forward 2D Cosine transform of M x N matrix: 02082 \f[Y = C^{(N)} \cdot X \cdot \left (C^{(N)} \right )^T\f] 02083 - Inverse 2D Cosine transform of M x N matrix: 02084 \f[X = \left (C^{(N)} \right )^T \cdot X \cdot C^{(N)}\f] 02085 02086 The function chooses the mode of operation by looking at the flags and size of the input array: 02087 - If (flags & DCT_INVERSE) == 0 , the function does a forward 1D or 2D transform. Otherwise, it 02088 is an inverse 1D or 2D transform. 02089 - If (flags & DCT_ROWS) != 0 , the function performs a 1D transform of each row. 02090 - If the array is a single column or a single row, the function performs a 1D transform. 02091 - If none of the above is true, the function performs a 2D transform. 02092 02093 @note Currently dct supports even-size arrays (2, 4, 6 ...). For data analysis and approximation, you 02094 can pad the array when necessary. 02095 Also, the function performance depends very much, and not monotonically, on the array size (see 02096 getOptimalDFTSize ). In the current implementation DCT of a vector of size N is calculated via DFT 02097 of a vector of size N/2 . Thus, the optimal DCT size N1 >= N can be calculated as: 02098 @code 02099 size_t getOptimalDCTSize(size_t N) { return 2*getOptimalDFTSize((N+1)/2); } 02100 N1 = getOptimalDCTSize(N); 02101 @endcode 02102 @param src input floating-point array. 02103 @param dst output array of the same size and type as src . 02104 @param flags transformation flags as a combination of cv::DftFlags (DCT_*) 02105 @sa dft , getOptimalDFTSize , idct 02106 */ 02107 CV_EXPORTS_W void dct(InputArray src, OutputArray dst, int flags = 0); 02108 02109 /** @brief Calculates the inverse Discrete Cosine Transform of a 1D or 2D array. 02110 02111 idct(src, dst, flags) is equivalent to dct(src, dst, flags | DCT_INVERSE). 02112 @param src input floating-point single-channel array. 02113 @param dst output array of the same size and type as src. 02114 @param flags operation flags. 02115 @sa dct, dft, idft, getOptimalDFTSize 02116 */ 02117 CV_EXPORTS_W void idct(InputArray src, OutputArray dst, int flags = 0); 02118 02119 /** @brief Performs the per-element multiplication of two Fourier spectrums. 02120 02121 The function mulSpectrums performs the per-element multiplication of the two CCS-packed or complex 02122 matrices that are results of a real or complex Fourier transform. 02123 02124 The function, together with dft and idft , may be used to calculate convolution (pass conjB=false ) 02125 or correlation (pass conjB=true ) of two arrays rapidly. When the arrays are complex, they are 02126 simply multiplied (per element) with an optional conjugation of the second-array elements. When the 02127 arrays are real, they are assumed to be CCS-packed (see dft for details). 02128 @param a first input array. 02129 @param b second input array of the same size and type as src1 . 02130 @param c output array of the same size and type as src1 . 02131 @param flags operation flags; currently, the only supported flag is cv::DFT_ROWS, which indicates that 02132 each row of src1 and src2 is an independent 1D Fourier spectrum. If you do not want to use this flag, then simply add a `0` as value. 02133 @param conjB optional flag that conjugates the second input array before the multiplication (true) 02134 or not (false). 02135 */ 02136 CV_EXPORTS_W void mulSpectrums(InputArray a, InputArray b, OutputArray c, 02137 int flags, bool conjB = false); 02138 02139 /** @brief Returns the optimal DFT size for a given vector size. 02140 02141 DFT performance is not a monotonic function of a vector size. Therefore, when you calculate 02142 convolution of two arrays or perform the spectral analysis of an array, it usually makes sense to 02143 pad the input data with zeros to get a bit larger array that can be transformed much faster than the 02144 original one. Arrays whose size is a power-of-two (2, 4, 8, 16, 32, ...) are the fastest to process. 02145 Though, the arrays whose size is a product of 2's, 3's, and 5's (for example, 300 = 5\*5\*3\*2\*2) 02146 are also processed quite efficiently. 02147 02148 The function getOptimalDFTSize returns the minimum number N that is greater than or equal to vecsize 02149 so that the DFT of a vector of size N can be processed efficiently. In the current implementation N 02150 = 2 ^p^ \* 3 ^q^ \* 5 ^r^ for some integer p, q, r. 02151 02152 The function returns a negative number if vecsize is too large (very close to INT_MAX ). 02153 02154 While the function cannot be used directly to estimate the optimal vector size for DCT transform 02155 (since the current DCT implementation supports only even-size vectors), it can be easily processed 02156 as getOptimalDFTSize((vecsize+1)/2)\*2. 02157 @param vecsize vector size. 02158 @sa dft , dct , idft , idct , mulSpectrums 02159 */ 02160 CV_EXPORTS_W int getOptimalDFTSize(int vecsize); 02161 02162 /** @brief Returns the default random number generator. 02163 02164 The function theRNG returns the default random number generator. For each thread, there is a 02165 separate random number generator, so you can use the function safely in multi-thread environments. 02166 If you just need to get a single random number using this generator or initialize an array, you can 02167 use randu or randn instead. But if you are going to generate many random numbers inside a loop, it 02168 is much faster to use this function to retrieve the generator and then use RNG::operator _Tp() . 02169 @sa RNG, randu, randn 02170 */ 02171 CV_EXPORTS RNG& theRNG(); 02172 02173 /** @brief Generates a single uniformly-distributed random number or an array of random numbers. 02174 02175 Non-template variant of the function fills the matrix dst with uniformly-distributed 02176 random numbers from the specified range: 02177 \f[\texttt{low} _c \leq \texttt{dst} (I)_c < \texttt{high} _c\f] 02178 @param dst output array of random numbers; the array must be pre-allocated. 02179 @param low inclusive lower boundary of the generated random numbers. 02180 @param high exclusive upper boundary of the generated random numbers. 02181 @sa RNG, randn, theRNG 02182 */ 02183 CV_EXPORTS_W void randu(InputOutputArray dst, InputArray low, InputArray high); 02184 02185 /** @brief Fills the array with normally distributed random numbers. 02186 02187 The function randn fills the matrix dst with normally distributed random numbers with the specified 02188 mean vector and the standard deviation matrix. The generated random numbers are clipped to fit the 02189 value range of the output array data type. 02190 @param dst output array of random numbers; the array must be pre-allocated and have 1 to 4 channels. 02191 @param mean mean value (expectation) of the generated random numbers. 02192 @param stddev standard deviation of the generated random numbers; it can be either a vector (in 02193 which case a diagonal standard deviation matrix is assumed) or a square matrix. 02194 @sa RNG, randu 02195 */ 02196 CV_EXPORTS_W void randn(InputOutputArray dst, InputArray mean, InputArray stddev); 02197 02198 /** @brief Shuffles the array elements randomly. 02199 02200 The function randShuffle shuffles the specified 1D array by randomly choosing pairs of elements and 02201 swapping them. The number of such swap operations will be dst.rows\*dst.cols\*iterFactor . 02202 @param dst input/output numerical 1D array. 02203 @param iterFactor scale factor that determines the number of random swap operations (see the details 02204 below). 02205 @param rng optional random number generator used for shuffling; if it is zero, theRNG () is used 02206 instead. 02207 @sa RNG, sort 02208 */ 02209 CV_EXPORTS_W void randShuffle(InputOutputArray dst, double iterFactor = 1., RNG* rng = 0); 02210 02211 /** @brief Principal Component Analysis 02212 02213 The class is used to calculate a special basis for a set of vectors. The 02214 basis will consist of eigenvectors of the covariance matrix calculated 02215 from the input set of vectors. The class %PCA can also transform 02216 vectors to/from the new coordinate space defined by the basis. Usually, 02217 in this new coordinate system, each vector from the original set (and 02218 any linear combination of such vectors) can be quite accurately 02219 approximated by taking its first few components, corresponding to the 02220 eigenvectors of the largest eigenvalues of the covariance matrix. 02221 Geometrically it means that you calculate a projection of the vector to 02222 a subspace formed by a few eigenvectors corresponding to the dominant 02223 eigenvalues of the covariance matrix. And usually such a projection is 02224 very close to the original vector. So, you can represent the original 02225 vector from a high-dimensional space with a much shorter vector 02226 consisting of the projected vector's coordinates in the subspace. Such a 02227 transformation is also known as Karhunen-Loeve Transform, or KLT. 02228 See http://en.wikipedia.org/wiki/Principal_component_analysis 02229 02230 The sample below is the function that takes two matrices. The first 02231 function stores a set of vectors (a row per vector) that is used to 02232 calculate PCA. The second function stores another "test" set of vectors 02233 (a row per vector). First, these vectors are compressed with PCA, then 02234 reconstructed back, and then the reconstruction error norm is computed 02235 and printed for each vector. : 02236 02237 @code{.cpp} 02238 using namespace cv; 02239 02240 PCA compressPCA(const Mat& pcaset, int maxComponents, 02241 const Mat& testset, Mat& compressed) 02242 { 02243 PCA pca(pcaset, // pass the data 02244 Mat(), // we do not have a pre-computed mean vector, 02245 // so let the PCA engine to compute it 02246 PCA::DATA_AS_ROW, // indicate that the vectors 02247 // are stored as matrix rows 02248 // (use PCA::DATA_AS_COL if the vectors are 02249 // the matrix columns) 02250 maxComponents // specify, how many principal components to retain 02251 ); 02252 // if there is no test data, just return the computed basis, ready-to-use 02253 if( !testset.data ) 02254 return pca; 02255 CV_Assert( testset.cols == pcaset.cols ); 02256 02257 compressed.create(testset.rows, maxComponents, testset.type()); 02258 02259 Mat reconstructed; 02260 for( int i = 0; i < testset.rows; i++ ) 02261 { 02262 Mat vec = testset.row(i), coeffs = compressed.row(i), reconstructed; 02263 // compress the vector, the result will be stored 02264 // in the i-th row of the output matrix 02265 pca.project(vec, coeffs); 02266 // and then reconstruct it 02267 pca.backProject(coeffs, reconstructed); 02268 // and measure the error 02269 printf("%d. diff = %g\n", i, norm(vec, reconstructed, NORM_L2)); 02270 } 02271 return pca; 02272 } 02273 @endcode 02274 @sa calcCovarMatrix, mulTransposed, SVD, dft, dct 02275 */ 02276 class CV_EXPORTS PCA 02277 { 02278 public: 02279 enum Flags { DATA_AS_ROW = 0, //!< indicates that the input samples are stored as matrix rows 02280 DATA_AS_COL = 1, //!< indicates that the input samples are stored as matrix columns 02281 USE_AVG = 2 //! 02282 }; 02283 02284 /** @brief default constructor 02285 02286 The default constructor initializes an empty %PCA structure. The other 02287 constructors initialize the structure and call PCA::operator()(). 02288 */ 02289 PCA(); 02290 02291 /** @overload 02292 @param data input samples stored as matrix rows or matrix columns. 02293 @param mean optional mean value; if the matrix is empty (@c noArray()), 02294 the mean is computed from the data. 02295 @param flags operation flags; currently the parameter is only used to 02296 specify the data layout (PCA::Flags) 02297 @param maxComponents maximum number of components that %PCA should 02298 retain; by default, all the components are retained. 02299 */ 02300 PCA(InputArray data, InputArray mean, int flags, int maxComponents = 0); 02301 02302 /** @overload 02303 @param data input samples stored as matrix rows or matrix columns. 02304 @param mean optional mean value; if the matrix is empty (noArray()), 02305 the mean is computed from the data. 02306 @param flags operation flags; currently the parameter is only used to 02307 specify the data layout (PCA::Flags) 02308 @param retainedVariance Percentage of variance that PCA should retain. 02309 Using this parameter will let the PCA decided how many components to 02310 retain but it will always keep at least 2. 02311 */ 02312 PCA(InputArray data, InputArray mean, int flags, double retainedVariance); 02313 02314 /** @brief performs %PCA 02315 02316 The operator performs %PCA of the supplied dataset. It is safe to reuse 02317 the same PCA structure for multiple datasets. That is, if the structure 02318 has been previously used with another dataset, the existing internal 02319 data is reclaimed and the new eigenvalues, @ref eigenvectors , and @ref 02320 mean are allocated and computed. 02321 02322 The computed eigenvalues are sorted from the largest to the smallest and 02323 the corresponding eigenvectors are stored as eigenvectors rows. 02324 02325 @param data input samples stored as the matrix rows or as the matrix 02326 columns. 02327 @param mean optional mean value; if the matrix is empty (noArray()), 02328 the mean is computed from the data. 02329 @param flags operation flags; currently the parameter is only used to 02330 specify the data layout. (Flags) 02331 @param maxComponents maximum number of components that PCA should 02332 retain; by default, all the components are retained. 02333 */ 02334 PCA& operator()(InputArray data, InputArray mean, int flags, int maxComponents = 0); 02335 02336 /** @overload 02337 @param data input samples stored as the matrix rows or as the matrix 02338 columns. 02339 @param mean optional mean value; if the matrix is empty (noArray()), 02340 the mean is computed from the data. 02341 @param flags operation flags; currently the parameter is only used to 02342 specify the data layout. (PCA::Flags) 02343 @param retainedVariance Percentage of variance that %PCA should retain. 02344 Using this parameter will let the %PCA decided how many components to 02345 retain but it will always keep at least 2. 02346 */ 02347 PCA& operator()(InputArray data, InputArray mean, int flags, double retainedVariance); 02348 02349 /** @brief Projects vector(s) to the principal component subspace. 02350 02351 The methods project one or more vectors to the principal component 02352 subspace, where each vector projection is represented by coefficients in 02353 the principal component basis. The first form of the method returns the 02354 matrix that the second form writes to the result. So the first form can 02355 be used as a part of expression while the second form can be more 02356 efficient in a processing loop. 02357 @param vec input vector(s); must have the same dimensionality and the 02358 same layout as the input data used at %PCA phase, that is, if 02359 DATA_AS_ROW are specified, then `vec.cols==data.cols` 02360 (vector dimensionality) and `vec.rows` is the number of vectors to 02361 project, and the same is true for the PCA::DATA_AS_COL case. 02362 */ 02363 Mat project(InputArray vec) const; 02364 02365 /** @overload 02366 @param vec input vector(s); must have the same dimensionality and the 02367 same layout as the input data used at PCA phase, that is, if 02368 DATA_AS_ROW are specified, then `vec.cols==data.cols` 02369 (vector dimensionality) and `vec.rows` is the number of vectors to 02370 project, and the same is true for the PCA::DATA_AS_COL case. 02371 @param result output vectors; in case of PCA::DATA_AS_COL, the 02372 output matrix has as many columns as the number of input vectors, this 02373 means that `result.cols==vec.cols` and the number of rows match the 02374 number of principal components (for example, `maxComponents` parameter 02375 passed to the constructor). 02376 */ 02377 void project(InputArray vec, OutputArray result) const; 02378 02379 /** @brief Reconstructs vectors from their PC projections. 02380 02381 The methods are inverse operations to PCA::project. They take PC 02382 coordinates of projected vectors and reconstruct the original vectors. 02383 Unless all the principal components have been retained, the 02384 reconstructed vectors are different from the originals. But typically, 02385 the difference is small if the number of components is large enough (but 02386 still much smaller than the original vector dimensionality). As a 02387 result, PCA is used. 02388 @param vec coordinates of the vectors in the principal component 02389 subspace, the layout and size are the same as of PCA::project output 02390 vectors. 02391 */ 02392 Mat backProject(InputArray vec) const; 02393 02394 /** @overload 02395 @param vec coordinates of the vectors in the principal component 02396 subspace, the layout and size are the same as of PCA::project output 02397 vectors. 02398 @param result reconstructed vectors; the layout and size are the same as 02399 of PCA::project input vectors. 02400 */ 02401 void backProject(InputArray vec, OutputArray result) const; 02402 02403 /** @brief write and load PCA matrix 02404 02405 */ 02406 void write(FileStorage& fs ) const; 02407 void read(const FileNode& fs); 02408 02409 Mat eigenvectors; //!< eigenvectors of the covariation matrix 02410 Mat eigenvalues; //!< eigenvalues of the covariation matrix 02411 Mat mean; //!< mean value subtracted before the projection and added after the back projection 02412 }; 02413 02414 /** @example pca.cpp 02415 An example using %PCA for dimensionality reduction while maintaining an amount of variance 02416 */ 02417 02418 /** 02419 @brief Linear Discriminant Analysis 02420 @todo document this class 02421 */ 02422 class CV_EXPORTS LDA 02423 { 02424 public: 02425 /** @brief constructor 02426 Initializes a LDA with num_components (default 0). 02427 */ 02428 explicit LDA(int num_components = 0); 02429 02430 /** Initializes and performs a Discriminant Analysis with Fisher's 02431 Optimization Criterion on given data in src and corresponding labels 02432 in labels. If 0 (or less) number of components are given, they are 02433 automatically determined for given data in computation. 02434 */ 02435 LDA(InputArrayOfArrays src, InputArray labels, int num_components = 0); 02436 02437 /** Serializes this object to a given filename. 02438 */ 02439 void save(const String& filename) const; 02440 02441 /** Deserializes this object from a given filename. 02442 */ 02443 void load(const String& filename); 02444 02445 /** Serializes this object to a given cv::FileStorage. 02446 */ 02447 void save(FileStorage& fs) const; 02448 02449 /** Deserializes this object from a given cv::FileStorage. 02450 */ 02451 void load(const FileStorage& node); 02452 02453 /** destructor 02454 */ 02455 ~LDA(); 02456 02457 /** Compute the discriminants for data in src (row aligned) and labels. 02458 */ 02459 void compute(InputArrayOfArrays src, InputArray labels); 02460 02461 /** Projects samples into the LDA subspace. 02462 src may be one or more row aligned samples. 02463 */ 02464 Mat project(InputArray src); 02465 02466 /** Reconstructs projections from the LDA subspace. 02467 src may be one or more row aligned projections. 02468 */ 02469 Mat reconstruct(InputArray src); 02470 02471 /** Returns the eigenvectors of this LDA. 02472 */ 02473 Mat eigenvectors() const { return _eigenvectors; } 02474 02475 /** Returns the eigenvalues of this LDA. 02476 */ 02477 Mat eigenvalues() const { return _eigenvalues; } 02478 02479 static Mat subspaceProject(InputArray W, InputArray mean, InputArray src); 02480 static Mat subspaceReconstruct(InputArray W, InputArray mean, InputArray src); 02481 02482 protected: 02483 bool _dataAsRow; // unused, but needed for 3.0 ABI compatibility. 02484 int _num_components; 02485 Mat _eigenvectors; 02486 Mat _eigenvalues; 02487 void lda(InputArrayOfArrays src, InputArray labels); 02488 }; 02489 02490 /** @brief Singular Value Decomposition 02491 02492 Class for computing Singular Value Decomposition of a floating-point 02493 matrix. The Singular Value Decomposition is used to solve least-square 02494 problems, under-determined linear systems, invert matrices, compute 02495 condition numbers, and so on. 02496 02497 If you want to compute a condition number of a matrix or an absolute value of 02498 its determinant, you do not need `u` and `vt`. You can pass 02499 flags=SVD::NO_UV|... . Another flag SVD::FULL_UV indicates that full-size u 02500 and vt must be computed, which is not necessary most of the time. 02501 02502 @sa invert, solve, eigen, determinant 02503 */ 02504 class CV_EXPORTS SVD 02505 { 02506 public: 02507 enum Flags { 02508 /** allow the algorithm to modify the decomposed matrix; it can save space and speed up 02509 processing. currently ignored. */ 02510 MODIFY_A = 1, 02511 /** indicates that only a vector of singular values `w` is to be processed, while u and vt 02512 will be set to empty matrices */ 02513 NO_UV = 2, 02514 /** when the matrix is not square, by default the algorithm produces u and vt matrices of 02515 sufficiently large size for the further A reconstruction; if, however, FULL_UV flag is 02516 specified, u and vt will be full-size square orthogonal matrices.*/ 02517 FULL_UV = 4 02518 }; 02519 02520 /** @brief the default constructor 02521 02522 initializes an empty SVD structure 02523 */ 02524 SVD(); 02525 02526 /** @overload 02527 initializes an empty SVD structure and then calls SVD::operator() 02528 @param src decomposed matrix. 02529 @param flags operation flags (SVD::Flags) 02530 */ 02531 SVD( InputArray src, int flags = 0 ); 02532 02533 /** @brief the operator that performs SVD. The previously allocated u, w and vt are released. 02534 02535 The operator performs the singular value decomposition of the supplied 02536 matrix. The u,`vt` , and the vector of singular values w are stored in 02537 the structure. The same SVD structure can be reused many times with 02538 different matrices. Each time, if needed, the previous u,`vt` , and w 02539 are reclaimed and the new matrices are created, which is all handled by 02540 Mat::create. 02541 @param src decomposed matrix. 02542 @param flags operation flags (SVD::Flags) 02543 */ 02544 SVD& operator ()( InputArray src, int flags = 0 ); 02545 02546 /** @brief decomposes matrix and stores the results to user-provided matrices 02547 02548 The methods/functions perform SVD of matrix. Unlike SVD::SVD constructor 02549 and SVD::operator(), they store the results to the user-provided 02550 matrices: 02551 02552 @code{.cpp} 02553 Mat A, w, u, vt; 02554 SVD::compute(A, w, u, vt); 02555 @endcode 02556 02557 @param src decomposed matrix 02558 @param w calculated singular values 02559 @param u calculated left singular vectors 02560 @param vt transposed matrix of right singular values 02561 @param flags operation flags - see SVD::SVD. 02562 */ 02563 static void compute( InputArray src, OutputArray w, 02564 OutputArray u, OutputArray vt, int flags = 0 ); 02565 02566 /** @overload 02567 computes singular values of a matrix 02568 @param src decomposed matrix 02569 @param w calculated singular values 02570 @param flags operation flags - see SVD::Flags. 02571 */ 02572 static void compute( InputArray src, OutputArray w, int flags = 0 ); 02573 02574 /** @brief performs back substitution 02575 */ 02576 static void backSubst( InputArray w, InputArray u, 02577 InputArray vt, InputArray rhs, 02578 OutputArray dst ); 02579 02580 /** @brief solves an under-determined singular linear system 02581 02582 The method finds a unit-length solution x of a singular linear system 02583 A\*x = 0. Depending on the rank of A, there can be no solutions, a 02584 single solution or an infinite number of solutions. In general, the 02585 algorithm solves the following problem: 02586 \f[dst = \arg \min _{x: \| x \| =1} \| src \cdot x \|\f] 02587 @param src left-hand-side matrix. 02588 @param dst found solution. 02589 */ 02590 static void solveZ( InputArray src, OutputArray dst ); 02591 02592 /** @brief performs a singular value back substitution. 02593 02594 The method calculates a back substitution for the specified right-hand 02595 side: 02596 02597 \f[\texttt{x} = \texttt{vt} ^T \cdot diag( \texttt{w} )^{-1} \cdot \texttt{u} ^T \cdot \texttt{rhs} \sim \texttt{A} ^{-1} \cdot \texttt{rhs}\f] 02598 02599 Using this technique you can either get a very accurate solution of the 02600 convenient linear system, or the best (in the least-squares terms) 02601 pseudo-solution of an overdetermined linear system. 02602 02603 @param rhs right-hand side of a linear system (u\*w\*v')\*dst = rhs to 02604 be solved, where A has been previously decomposed. 02605 02606 @param dst found solution of the system. 02607 02608 @note Explicit SVD with the further back substitution only makes sense 02609 if you need to solve many linear systems with the same left-hand side 02610 (for example, src ). If all you need is to solve a single system 02611 (possibly with multiple rhs immediately available), simply call solve 02612 add pass DECOMP_SVD there. It does absolutely the same thing. 02613 */ 02614 void backSubst( InputArray rhs, OutputArray dst ) const; 02615 02616 /** @todo document */ 02617 template<typename _Tp, int m, int n, int nm> static 02618 void compute( const Matx<_Tp, m, n>& a, Matx<_Tp, nm, 1>& w, Matx<_Tp, m, nm>& u, Matx<_Tp, n, nm>& vt ); 02619 02620 /** @todo document */ 02621 template<typename _Tp, int m, int n, int nm> static 02622 void compute( const Matx<_Tp, m, n>& a, Matx<_Tp, nm, 1>& w ); 02623 02624 /** @todo document */ 02625 template<typename _Tp, int m, int n, int nm, int nb> static 02626 void backSubst( const Matx<_Tp, nm, 1>& w, const Matx<_Tp, m, nm>& u, const Matx<_Tp, n, nm>& vt, const Matx<_Tp, m, nb>& rhs, Matx<_Tp, n, nb>& dst ); 02627 02628 Mat u, w, vt; 02629 }; 02630 02631 /** @brief Random Number Generator 02632 02633 Random number generator. It encapsulates the state (currently, a 64-bit 02634 integer) and has methods to return scalar random values and to fill 02635 arrays with random values. Currently it supports uniform and Gaussian 02636 (normal) distributions. The generator uses Multiply-With-Carry 02637 algorithm, introduced by G. Marsaglia ( 02638 <http://en.wikipedia.org/wiki/Multiply-with-carry> ). 02639 Gaussian-distribution random numbers are generated using the Ziggurat 02640 algorithm ( <http://en.wikipedia.org/wiki/Ziggurat_algorithm> ), 02641 introduced by G. Marsaglia and W. W. Tsang. 02642 */ 02643 class CV_EXPORTS RNG 02644 { 02645 public: 02646 enum { UNIFORM = 0, 02647 NORMAL = 1 02648 }; 02649 02650 /** @brief constructor 02651 02652 These are the RNG constructors. The first form sets the state to some 02653 pre-defined value, equal to 2\*\*32-1 in the current implementation. The 02654 second form sets the state to the specified value. If you passed state=0 02655 , the constructor uses the above default value instead to avoid the 02656 singular random number sequence, consisting of all zeros. 02657 */ 02658 RNG(); 02659 /** @overload 02660 @param state 64-bit value used to initialize the RNG. 02661 */ 02662 RNG(uint64 state); 02663 /**The method updates the state using the MWC algorithm and returns the 02664 next 32-bit random number.*/ 02665 unsigned next(); 02666 02667 /**Each of the methods updates the state using the MWC algorithm and 02668 returns the next random number of the specified type. In case of integer 02669 types, the returned number is from the available value range for the 02670 specified type. In case of floating-point types, the returned value is 02671 from [0,1) range. 02672 */ 02673 operator uchar(); 02674 /** @overload */ 02675 operator schar(); 02676 /** @overload */ 02677 operator ushort(); 02678 /** @overload */ 02679 operator short(); 02680 /** @overload */ 02681 operator unsigned(); 02682 /** @overload */ 02683 operator int(); 02684 /** @overload */ 02685 operator float(); 02686 /** @overload */ 02687 operator double(); 02688 02689 /** @brief returns a random integer sampled uniformly from [0, N). 02690 02691 The methods transform the state using the MWC algorithm and return the 02692 next random number. The first form is equivalent to RNG::next . The 02693 second form returns the random number modulo N , which means that the 02694 result is in the range [0, N) . 02695 */ 02696 unsigned operator ()(); 02697 /** @overload 02698 @param N upper non-inclusive boundary of the returned random number. 02699 */ 02700 unsigned operator ()(unsigned N); 02701 02702 /** @brief returns uniformly distributed integer random number from [a,b) range 02703 02704 The methods transform the state using the MWC algorithm and return the 02705 next uniformly-distributed random number of the specified type, deduced 02706 from the input parameter type, from the range [a, b) . There is a nuance 02707 illustrated by the following sample: 02708 02709 @code{.cpp} 02710 RNG rng; 02711 02712 // always produces 0 02713 double a = rng.uniform(0, 1); 02714 02715 // produces double from [0, 1) 02716 double a1 = rng.uniform((double)0, (double)1); 02717 02718 // produces float from [0, 1) 02719 double b = rng.uniform(0.f, 1.f); 02720 02721 // produces double from [0, 1) 02722 double c = rng.uniform(0., 1.); 02723 02724 // may cause compiler error because of ambiguity: 02725 // RNG::uniform(0, (int)0.999999)? or RNG::uniform((double)0, 0.99999)? 02726 double d = rng.uniform(0, 0.999999); 02727 @endcode 02728 02729 The compiler does not take into account the type of the variable to 02730 which you assign the result of RNG::uniform . The only thing that 02731 matters to the compiler is the type of a and b parameters. So, if you 02732 want a floating-point random number, but the range boundaries are 02733 integer numbers, either put dots in the end, if they are constants, or 02734 use explicit type cast operators, as in the a1 initialization above. 02735 @param a lower inclusive boundary of the returned random numbers. 02736 @param b upper non-inclusive boundary of the returned random numbers. 02737 */ 02738 int uniform(int a, int b); 02739 /** @overload */ 02740 float uniform(float a, float b); 02741 /** @overload */ 02742 double uniform(double a, double b); 02743 02744 /** @brief Fills arrays with random numbers. 02745 02746 @param mat 2D or N-dimensional matrix; currently matrices with more than 02747 4 channels are not supported by the methods, use Mat::reshape as a 02748 possible workaround. 02749 @param distType distribution type, RNG::UNIFORM or RNG::NORMAL. 02750 @param a first distribution parameter; in case of the uniform 02751 distribution, this is an inclusive lower boundary, in case of the normal 02752 distribution, this is a mean value. 02753 @param b second distribution parameter; in case of the uniform 02754 distribution, this is a non-inclusive upper boundary, in case of the 02755 normal distribution, this is a standard deviation (diagonal of the 02756 standard deviation matrix or the full standard deviation matrix). 02757 @param saturateRange pre-saturation flag; for uniform distribution only; 02758 if true, the method will first convert a and b to the acceptable value 02759 range (according to the mat datatype) and then will generate uniformly 02760 distributed random numbers within the range [saturate(a), saturate(b)), 02761 if saturateRange=false, the method will generate uniformly distributed 02762 random numbers in the original range [a, b) and then will saturate them, 02763 it means, for example, that 02764 <tt>theRNG().fill(mat_8u, RNG::UNIFORM, -DBL_MAX, DBL_MAX)</tt> will likely 02765 produce array mostly filled with 0's and 255's, since the range (0, 255) 02766 is significantly smaller than [-DBL_MAX, DBL_MAX). 02767 02768 Each of the methods fills the matrix with the random values from the 02769 specified distribution. As the new numbers are generated, the RNG state 02770 is updated accordingly. In case of multiple-channel images, every 02771 channel is filled independently, which means that RNG cannot generate 02772 samples from the multi-dimensional Gaussian distribution with 02773 non-diagonal covariance matrix directly. To do that, the method 02774 generates samples from multi-dimensional standard Gaussian distribution 02775 with zero mean and identity covariation matrix, and then transforms them 02776 using transform to get samples from the specified Gaussian distribution. 02777 */ 02778 void fill( InputOutputArray mat, int distType, InputArray a, InputArray b, bool saturateRange = false ); 02779 02780 /** @brief Returns the next random number sampled from the Gaussian distribution 02781 @param sigma standard deviation of the distribution. 02782 02783 The method transforms the state using the MWC algorithm and returns the 02784 next random number from the Gaussian distribution N(0,sigma) . That is, 02785 the mean value of the returned random numbers is zero and the standard 02786 deviation is the specified sigma . 02787 */ 02788 double gaussian(double sigma); 02789 02790 uint64 state; 02791 }; 02792 02793 /** @brief Mersenne Twister random number generator 02794 02795 Inspired by http://www.math.sci.hiroshima-u.ac.jp/~m-mat/MT/MT2002/CODES/mt19937ar.c 02796 @todo document 02797 */ 02798 class CV_EXPORTS RNG_MT19937 02799 { 02800 public: 02801 RNG_MT19937(); 02802 RNG_MT19937(unsigned s); 02803 void seed(unsigned s); 02804 02805 unsigned next(); 02806 02807 operator int(); 02808 operator unsigned(); 02809 operator float(); 02810 operator double(); 02811 02812 unsigned operator ()(unsigned N); 02813 unsigned operator ()(); 02814 02815 /** @brief returns uniformly distributed integer random number from [a,b) range 02816 02817 */ 02818 int uniform(int a, int b); 02819 /** @brief returns uniformly distributed floating-point random number from [a,b) range 02820 02821 */ 02822 float uniform(float a, float b); 02823 /** @brief returns uniformly distributed double-precision floating-point random number from [a,b) range 02824 02825 */ 02826 double uniform(double a, double b); 02827 02828 private: 02829 enum PeriodParameters {N = 624, M = 397}; 02830 unsigned state[N]; 02831 int mti; 02832 }; 02833 02834 //! @} core_array 02835 02836 //! @addtogroup core_cluster 02837 //! @{ 02838 02839 /** @example kmeans.cpp 02840 An example on K-means clustering 02841 */ 02842 02843 /** @brief Finds centers of clusters and groups input samples around the clusters. 02844 02845 The function kmeans implements a k-means algorithm that finds the centers of cluster_count clusters 02846 and groups the input samples around the clusters. As an output, \f$\texttt{labels}_i\f$ contains a 02847 0-based cluster index for the sample stored in the \f$i^{th}\f$ row of the samples matrix. 02848 02849 @note 02850 - (Python) An example on K-means clustering can be found at 02851 opencv_source_code/samples/python/kmeans.py 02852 @param data Data for clustering. An array of N-Dimensional points with float coordinates is needed. 02853 Examples of this array can be: 02854 - Mat points(count, 2, CV_32F); 02855 - Mat points(count, 1, CV_32FC2); 02856 - Mat points(1, count, CV_32FC2); 02857 - std::vector<cv::Point2f> points(sampleCount); 02858 @param K Number of clusters to split the set by. 02859 @param bestLabels Input/output integer array that stores the cluster indices for every sample. 02860 @param criteria The algorithm termination criteria, that is, the maximum number of iterations and/or 02861 the desired accuracy. The accuracy is specified as criteria.epsilon. As soon as each of the cluster 02862 centers moves by less than criteria.epsilon on some iteration, the algorithm stops. 02863 @param attempts Flag to specify the number of times the algorithm is executed using different 02864 initial labellings. The algorithm returns the labels that yield the best compactness (see the last 02865 function parameter). 02866 @param flags Flag that can take values of cv::KmeansFlags 02867 @param centers Output matrix of the cluster centers, one row per each cluster center. 02868 @return The function returns the compactness measure that is computed as 02869 \f[\sum _i \| \texttt{samples} _i - \texttt{centers} _{ \texttt{labels} _i} \| ^2\f] 02870 after every attempt. The best (minimum) value is chosen and the corresponding labels and the 02871 compactness value are returned by the function. Basically, you can use only the core of the 02872 function, set the number of attempts to 1, initialize labels each time using a custom algorithm, 02873 pass them with the ( flags = KMEANS_USE_INITIAL_LABELS ) flag, and then choose the best 02874 (most-compact) clustering. 02875 */ 02876 CV_EXPORTS_W double kmeans( InputArray data, int K, InputOutputArray bestLabels, 02877 TermCriteria criteria, int attempts, 02878 int flags, OutputArray centers = noArray() ); 02879 02880 //! @} core_cluster 02881 02882 //! @addtogroup core_basic 02883 //! @{ 02884 02885 /////////////////////////////// Formatted output of cv::Mat /////////////////////////// 02886 02887 /** @todo document */ 02888 class CV_EXPORTS Formatted 02889 { 02890 public: 02891 virtual const char* next() = 0; 02892 virtual void reset() = 0; 02893 virtual ~Formatted (); 02894 }; 02895 02896 /** @todo document */ 02897 class CV_EXPORTS Formatter 02898 { 02899 public: 02900 enum { FMT_DEFAULT = 0, 02901 FMT_MATLAB = 1, 02902 FMT_CSV = 2, 02903 FMT_PYTHON = 3, 02904 FMT_NUMPY = 4, 02905 FMT_C = 5 02906 }; 02907 02908 virtual ~Formatter (); 02909 02910 virtual Ptr<Formatted> format(const Mat& mtx) const = 0; 02911 02912 virtual void set32fPrecision(int p = 8) = 0; 02913 virtual void set64fPrecision(int p = 16) = 0; 02914 virtual void setMultiline(bool ml = true) = 0; 02915 02916 static Ptr<Formatter> get(int fmt = FMT_DEFAULT); 02917 02918 }; 02919 02920 static inline 02921 String& operator << (String& out, Ptr<Formatted> fmtd) 02922 { 02923 fmtd->reset(); 02924 for(const char* str = fmtd->next(); str; str = fmtd->next()) 02925 out += cv::String(str); 02926 return out; 02927 } 02928 02929 static inline 02930 String& operator << (String& out, const Mat& mtx) 02931 { 02932 return out << Formatter::get()->format(mtx); 02933 } 02934 02935 //////////////////////////////////////// Algorithm //////////////////////////////////// 02936 02937 class CV_EXPORTS Algorithm; 02938 02939 template<typename _Tp> struct ParamType {}; 02940 02941 02942 /** @brief This is a base class for all more or less complex algorithms in OpenCV 02943 02944 especially for classes of algorithms, for which there can be multiple implementations. The examples 02945 are stereo correspondence (for which there are algorithms like block matching, semi-global block 02946 matching, graph-cut etc.), background subtraction (which can be done using mixture-of-gaussians 02947 models, codebook-based algorithm etc.), optical flow (block matching, Lucas-Kanade, Horn-Schunck 02948 etc.). 02949 02950 Here is example of SIFT use in your application via Algorithm interface: 02951 @code 02952 #include "opencv2/opencv.hpp" 02953 #include "opencv2/xfeatures2d.hpp" 02954 using namespace cv::xfeatures2d; 02955 02956 Ptr<Feature2D> sift = SIFT::create(); 02957 FileStorage fs("sift_params.xml", FileStorage::READ); 02958 if( fs.isOpened() ) // if we have file with parameters, read them 02959 { 02960 sift->read(fs["sift_params"]); 02961 fs.release(); 02962 } 02963 else // else modify the parameters and store them; user can later edit the file to use different parameters 02964 { 02965 sift->setContrastThreshold(0.01f); // lower the contrast threshold, compared to the default value 02966 { 02967 WriteStructContext ws(fs, "sift_params", CV_NODE_MAP); 02968 sift->write(fs); 02969 } 02970 } 02971 Mat image = imread("myimage.png", 0), descriptors; 02972 vector<KeyPoint> keypoints; 02973 sift->detectAndCompute(image, noArray(), keypoints, descriptors); 02974 @endcode 02975 */ 02976 class CV_EXPORTS_W Algorithm 02977 { 02978 public: 02979 Algorithm(); 02980 virtual ~Algorithm(); 02981 02982 /** @brief Clears the algorithm state 02983 */ 02984 CV_WRAP virtual void clear() {} 02985 02986 /** @brief Stores algorithm parameters in a file storage 02987 */ 02988 virtual void write(FileStorage& fs) const { (void)fs; } 02989 02990 /** @brief Reads algorithm parameters from a file storage 02991 */ 02992 virtual void read(const FileNode& fn) { (void)fn; } 02993 02994 /** @brief Returns true if the Algorithm is empty (e.g. in the very beginning or after unsuccessful read 02995 */ 02996 virtual bool empty() const { return false; } 02997 02998 /** @brief Reads algorithm from the file node 02999 03000 This is static template method of Algorithm. It's usage is following (in the case of SVM): 03001 @code 03002 Ptr<SVM> svm = Algorithm::read<SVM>(fn); 03003 @endcode 03004 In order to make this method work, the derived class must overwrite Algorithm::read(const 03005 FileNode& fn) and also have static create() method without parameters 03006 (or with all the optional parameters) 03007 */ 03008 template<typename _Tp> static Ptr<_Tp> read(const FileNode& fn) 03009 { 03010 Ptr<_Tp> obj = _Tp::create(); 03011 obj->read(fn); 03012 return !obj->empty() ? obj : Ptr<_Tp>(); 03013 } 03014 03015 /** @brief Loads algorithm from the file 03016 03017 @param filename Name of the file to read. 03018 @param objname The optional name of the node to read (if empty, the first top-level node will be used) 03019 03020 This is static template method of Algorithm. It's usage is following (in the case of SVM): 03021 @code 03022 Ptr<SVM> svm = Algorithm::load<SVM>("my_svm_model.xml"); 03023 @endcode 03024 In order to make this method work, the derived class must overwrite Algorithm::read(const 03025 FileNode& fn). 03026 */ 03027 template<typename _Tp> static Ptr<_Tp> load(const String& filename, const String& objname=String()) 03028 { 03029 FileStorage fs(filename, FileStorage::READ); 03030 FileNode fn = objname.empty() ? fs.getFirstTopLevelNode() : fs[objname]; 03031 Ptr<_Tp> obj = _Tp::create(); 03032 obj->read(fn); 03033 return !obj->empty() ? obj : Ptr<_Tp>(); 03034 } 03035 03036 /** @brief Loads algorithm from a String 03037 03038 @param strModel The string variable containing the model you want to load. 03039 @param objname The optional name of the node to read (if empty, the first top-level node will be used) 03040 03041 This is static template method of Algorithm. It's usage is following (in the case of SVM): 03042 @code 03043 Ptr<SVM> svm = Algorithm::loadFromString<SVM>(myStringModel); 03044 @endcode 03045 */ 03046 template<typename _Tp> static Ptr<_Tp> loadFromString(const String& strModel, const String& objname=String()) 03047 { 03048 FileStorage fs(strModel, FileStorage::READ + FileStorage::MEMORY); 03049 FileNode fn = objname.empty() ? fs.getFirstTopLevelNode() : fs[objname]; 03050 Ptr<_Tp> obj = _Tp::create(); 03051 obj->read(fn); 03052 return !obj->empty() ? obj : Ptr<_Tp>(); 03053 } 03054 03055 /** Saves the algorithm to a file. 03056 In order to make this method work, the derived class must implement Algorithm::write(FileStorage& fs). */ 03057 CV_WRAP virtual void save(const String& filename) const; 03058 03059 /** Returns the algorithm string identifier. 03060 This string is used as top level xml/yml node tag when the object is saved to a file or string. */ 03061 CV_WRAP virtual String getDefaultName() const; 03062 }; 03063 03064 struct Param { 03065 enum { INT=0, BOOLEAN=1, REAL=2, STRING=3, MAT=4, MAT_VECTOR=5, ALGORITHM=6, FLOAT=7, 03066 UNSIGNED_INT=8, UINT64=9, UCHAR=11 }; 03067 }; 03068 03069 03070 03071 template<> struct ParamType<bool> 03072 { 03073 typedef bool const_param_type; 03074 typedef bool member_type; 03075 03076 enum { type = Param::BOOLEAN }; 03077 }; 03078 03079 template<> struct ParamType<int> 03080 { 03081 typedef int const_param_type; 03082 typedef int member_type; 03083 03084 enum { type = Param::INT }; 03085 }; 03086 03087 template<> struct ParamType<double> 03088 { 03089 typedef double const_param_type; 03090 typedef double member_type; 03091 03092 enum { type = Param::REAL }; 03093 }; 03094 03095 template<> struct ParamType<String> 03096 { 03097 typedef const String& const_param_type; 03098 typedef String member_type; 03099 03100 enum { type = Param::STRING }; 03101 }; 03102 03103 template<> struct ParamType<Mat> 03104 { 03105 typedef const Mat& const_param_type; 03106 typedef Mat member_type; 03107 03108 enum { type = Param::MAT }; 03109 }; 03110 03111 template<> struct ParamType<std::vector<Mat> > 03112 { 03113 typedef const std::vector<Mat>& const_param_type; 03114 typedef std::vector<Mat> member_type; 03115 03116 enum { type = Param::MAT_VECTOR }; 03117 }; 03118 03119 template<> struct ParamType<Algorithm> 03120 { 03121 typedef const Ptr<Algorithm>& const_param_type; 03122 typedef Ptr<Algorithm> member_type; 03123 03124 enum { type = Param::ALGORITHM }; 03125 }; 03126 03127 template<> struct ParamType<float> 03128 { 03129 typedef float const_param_type; 03130 typedef float member_type; 03131 03132 enum { type = Param::FLOAT }; 03133 }; 03134 03135 template<> struct ParamType<unsigned> 03136 { 03137 typedef unsigned const_param_type; 03138 typedef unsigned member_type; 03139 03140 enum { type = Param::UNSIGNED_INT }; 03141 }; 03142 03143 template<> struct ParamType<uint64> 03144 { 03145 typedef uint64 const_param_type; 03146 typedef uint64 member_type; 03147 03148 enum { type = Param::UINT64 }; 03149 }; 03150 03151 template<> struct ParamType<uchar> 03152 { 03153 typedef uchar const_param_type; 03154 typedef uchar member_type; 03155 03156 enum { type = Param::UCHAR }; 03157 }; 03158 03159 //! @} core_basic 03160 03161 } //namespace cv 03162 03163 #include "opencv2/core/operations.hpp" 03164 #include "opencv2/core/cvstd.inl.hpp" 03165 #include "opencv2/core/utility.hpp" 03166 #include "opencv2/core/optim.hpp" 03167 03168 #endif /*__OPENCV_CORE_HPP__*/ 03169
Generated on Tue Jul 12 2022 14:46:30 by
1.7.2