fixed some mistakes in gpu docs

doc/gpu_data_structures.tex

@@ -10,4 +10,6 @@ Creates continuous matrix in GPU memory.
 \cvarg{cols}{Column count.}
 \cvarg{type}{Type of the matrix.}
 \cvarg{m}{Destination matrix. Will be only reshaped if it has proper type and area (\texttt{rows} $\times$ \texttt{cols}).}
-\end{description}
+\end{description}
\ No newline at end of file
+
+Matrix is called continuous if its elements are stored continuously, i.e. wuthout gaps in the end of each row.
\ No newline at end of file

doc/gpu_image_processing.tex

@@ -2,7 +2,7 @@
 
 
 \cvCppFunc{gpu::meanShiftFiltering}
-Performs mean-shift filtering.
+Performs mean-shift filtering for each point of the source image. It maps each point of the source image into another point, and as the result we have new color and new position of each point.
 
 \cvdefCpp{void meanShiftFiltering(const GpuMat\& src, GpuMat\& dst,\par
   int sp, int sr,\par
@@ -11,7 +11,7 @@ Performs mean-shift filtering.
 
 \begin{description}
 \cvarg{src}{Source image. Only \texttt{CV\_8UC4} images are supported for now.}
-\cvarg{dst}{Destination image. Will have the same size and type as \texttt{src}. Each pixel \texttt{(x,y)} of the destination image will contain color of the converged point started from \texttt{(x,y)} pixel of the source image.}
+\cvarg{dst}{Destination image, containing color of mapped points. Will have the same size and type as \texttt{src}.}
 \cvarg{sp}{Spatial window radius.}
 \cvarg{sr}{Color window radius.}
 \cvarg{criteria}{Termination criteria. See \hyperref[TermCriteria]{cv::TermCriteria}.}
@@ -19,7 +19,7 @@ Performs mean-shift filtering.
 
 
 \cvCppFunc{gpu::meanShiftProc}
-Performs mean-shift procedure and stores information about converged points in two images.
+Performs mean-shift procedure and stores information about processed points (i.e. their colors and positions) into two images. 
 
 \cvdefCpp{void meanShiftProc(const GpuMat\& src, GpuMat\& dstr, GpuMat\& dstsp,\par
   int sp, int sr,\par
@@ -28,13 +28,15 @@ Performs mean-shift procedure and stores information about converged points in t
 
 \begin{description}
 \cvarg{src}{Source image. Only \texttt{CV\_8UC4} images are supported for now.}
-\cvarg{dstr}{Destination image. Will have the same size and type as \texttt{src}. Each pixel \texttt{(x,y)} of the destination image will contain color of converged point started from \texttt{(x,y)} pixel of the source image.}
-\cvarg{dstsp}{\texttt{CV\_16SC2} matrix, which will contain coordinates of converged points and have the same size as \texttt{src}.}
+\cvarg{dstr}{Destination image, containing color of mapped points. Will have the same size and type as \texttt{src}.}
+\cvarg{dstsp}{Destination image, containing position of mapped points. Will have the same size as \texttt{src} and \texttt{CV\_16SC2} type.}
 \cvarg{sp}{Spatial window radius.}
 \cvarg{sr}{Color window radius.}
 \cvarg{criteria}{Termination criteria. See \hyperref[TermCriteria]{cv::TermCriteria}.}
 \end{description}
 
+See also: \cvCppCross{gpu::meanShiftFiltering}.
+
 
 \cvCppFunc{gpu::meanShiftSegmentation}
 Performs mean-shift segmentation of the source image and eleminates small segments.
@@ -75,7 +77,7 @@ Computes squared integral image.
 \cvdefCpp{void sqrIntegral(const GpuMat\& src, GpuMat\& sqsum);}
 \begin{description}
 \cvarg{src}{Source image. Only \texttt{CV\_8UC1} images are supported for now.}
-\cvarg{sqsum}{Squared integral image. Will contain 64-bit floating point values packed into 64U.}
+\cvarg{sqsum}{Squared integral image. Will contain 64-bit unsigned integer values packed into \texttt{CV\_64FC1}.}
 \end{description}
 
 
@@ -138,7 +140,7 @@ Performs per-element multiplication of two Fourier spectrums.
 \cvarg{b}{Second spectrum. Must have the same size and type as \texttt{a}.}
 \cvarg{c}{Destination spectrum.}
 \cvarg{flags}{Mock paramter is kept for CPU/GPU interfaces similarity.}
-\cvarg{conjB}{Optional flag which indicates the second spectrum must be conjugated before the multiplcation.}
+\cvarg{conjB}{Optional flag which indicates the second spectrum must be conjugated before the multiplication.}
 \end{description}
 
 Only full (i.e. not packed) \texttt{CV\_32FC2} complex spectrums in the interleaved format are supported for now.
@@ -158,7 +160,7 @@ Performs per-element multiplication of two Fourier spectrums and scales the resu
 \cvarg{c}{Destination spectrum.}
 \cvarg{flags}{Mock paramter is kept for CPU/GPU interfaces similarity.}
 \cvarg{scale}{Scale constant.}
-\cvarg{conjB}{Optional flag which indicates the second spectrum must be conjugated before the multiplcation.}
+\cvarg{conjB}{Optional flag which indicates the second spectrum must be conjugated before the multiplication.}
 \end{description}
 
 Only full (i.e. not packed) \texttt{CV\_32FC2} complex spectrums in the interleaved format are supported for now.
@@ -167,7 +169,7 @@ See also: \cvCppCross{mulSpectrums}.
 
 
 \cvCppFunc{gpu::dft}
-Performs a forward or inverse discrete Fourier transform (1D or 2D) of floating point matrix.
+Performs a forward or inverse discrete Fourier transform (1D or 2D) of floating point matrix. Can handle real matrices (\texttt{CV\_32FC1}) and complex matrices in the interleaved format (\texttt{CV\_32FC2}).
 
 \cvdefCpp{void dft(const GpuMat\& src, GpuMat\& dst, Size dft\_size, int flags=0);}
 
@@ -188,7 +190,7 @@ The source matrix should be continuous, otherwise reallocation and data copying
 \begin{itemize}
   \item If the source matrix is complex and the output isn't specified as real then the destination matrix will be complex, will have \texttt{dft\_size} size and \texttt{CV\_32FC2} type. It will contain full result of the DFT (forward or inverse).
   \item If the source matrix is complex and the output is specified as real then function assumes that its input is the result of the forward transform (see next item). The destionation matrix will have \texttt{dft\_size} size and \texttt{CV\_32FC1} type. It will contain result of the inverse DFT.
-  \item If the source matrix is real (i.e. its type is \texttt{CV\_32FC1}) then forward DFT will be performed. The result of the DFT will be packed into complex (\texttt{CV\_32FC2}) matrix so its width will be \texttt{dft\_size.width / 2 + 1}, but if the source is a single column then height will be reduced.
+  \item If the source matrix is real (i.e. its type is \texttt{CV\_32FC1}) then forward DFT will be performed. The result of the DFT will be packed into complex (\texttt{CV\_32FC2}) matrix so its width will be \texttt{dft\_size.width / 2 + 1}, but if the source is a single column then height will be reduced instead of width.
 \end{itemize}
 
 See also: \cvCppCross{dft}.
@@ -207,7 +209,7 @@ void convolve(const GpuMat\& image, const GpuMat\& templ, GpuMat\& result,\par
 \cvarg{templ}{Template image. Must have size not greater then \texttt{image} size and be the same type as \texttt{image}.}
 \cvarg{result}{Result image. Will have the same size and type as \texttt{image}.}
 \cvarg{ccorr}{Flags which indicates cross-correlation must be evaluated instead of convolution.}
-\cvarg{buf}{Optional buffer to decrease memory reallocation count (for many calls with the same sizes).}
+\cvarg{buf}{Optional buffer to avoid extra memory allocations (for many calls with the same sizes).}
 \end{description}
 
 
@@ -244,17 +246,18 @@ Computes a proximity map for a raster template and an image where the template i
   GpuMat\& result, int method);}
 
 \begin{description}
-\cvarg{image}{Source image. 32F and 8U images (1..4 channels) are supported for now.}
+\cvarg{image}{Source image. \texttt{CV\_32F} and \texttt{CV\_8U} depth images (1..4 channels) are supported for now.}
 \cvarg{templ}{Template image. Must have the same size and type as \texttt{image}.}
-\cvarg{result}{Map containing comparison results (32FC1). If \texttt{image} is $W \times H$ and
+\cvarg{result}{Map containing comparison results (\texttt{CV\_32FC1}). If \texttt{image} is $W \times H$ and
 \texttt{templ} is $w \times h$ then \texttt{result} must be $(W-w+1) \times (H-h+1)$.}
 \cvarg{method}{Specifies the way which the template must be compared with the image.}
 \end{description}
-Following methods are supported for the 8U images for now:
+
+Following methods are supported for the \texttt{CV\_8U} depth images for now:
 \begin{itemize}
 \item CV\_TM\_SQDIFF \item CV\_TM\_SQDIFF\_NORMED \item CV\_TM\_CCORR \item CV\_TM\_CCORR\_NORMED \item CV\_TM\_CCOEFF \item CV\_TM\_CCOEFF\_NORMED 
 \end{itemize}
-Following methods are supported for the 32F images for now:
+Following methods are supported for the \texttt{CV\_32F} images for now:
 \begin{itemize}
 \item CV\_TM\_SQDIFF \item CV\_TM\_CCORR
 \end{itemize}

doc/gpu_matrix_operations.tex

@@ -18,7 +18,7 @@ Flips a 2D matrix around vertical, horizontal or both axes.
 
 \cvdefCpp{void flip(const GpuMat\& a, GpuMat\& b, int flipCode);}
 \begin{description}
-\cvarg{a}{Source matrix. Only \texttt{CV\_8UC1} and \texttt{CV\_8UC4} matrixes are supported for now.}
+\cvarg{a}{Source matrix. Only \texttt{CV\_8UC1} and \texttt{CV\_8UC4} matrices are supported for now.}
 \cvarg{b}{Destination matrix.}
 \cvarg{flipCode}{Specifies how to flip the source:
 \begin{description}
@@ -32,7 +32,8 @@ See also: \cvCppCross{flip}.
 
 
 \cvCppFunc{gpu::LUT}
-Transforms the source matrix into the destination matrix using given look-up table: \texttt{dst(I) = lut(src(I))}.
+Transforms the source matrix into the destination matrix using given look-up table: 
+\[dst(I) = lut(src(I))\]
 
 \cvdefCpp{void LUT(const GpuMat\& src, const Mat\& lut, GpuMat\& dst);}
 \begin{description}
@@ -108,7 +109,7 @@ void magnitude(const GpuMat\& x, const GpuMat\& y, GpuMat\& magnitude,\par
 \cvarg{x}{Source matrix, containing real components (\texttt{CV\_32FC1}).}
 \cvarg{y}{Source matrix, containing imaginary components (\texttt{CV\_32FC1}).}
 \cvarg{magnitude}{Destination matrix of float magnitudes (\texttt{CV\_32FC1}).}
-\cvarg{stream}{Sream for the asynchronous version.}
+\cvarg{stream}{Stream for the asynchronous version.}
 \end{description}
 
 See also: \cvCppCross{magnitude}.
@@ -130,7 +131,7 @@ void magnitudeSqr(const GpuMat\& x, const GpuMat\& y, GpuMat\& magnitude,\par
 \cvarg{x}{Source matrix, containing real components (\texttt{CV\_32FC1}).}
 \cvarg{y}{Source matrix, containing imaginary components (\texttt{CV\_32FC1}).}
 \cvarg{magnitude}{Destination matrix of float magnitude squares (\texttt{CV\_32FC1}).}
-\cvarg{stream}{Sream for the asynchronous version.}
+\cvarg{stream}{Stream for the asynchronous version.}
 \end{description}
 
 
@@ -146,7 +147,7 @@ void phase(const GpuMat\& x, const GpuMat\& y, GpuMat\& angle,\par
 \cvarg{y}{Source matrix, containing imaginary components (\texttt{CV\_32FC1}).}
 \cvarg{angle}{Destionation matrix of angles (\texttt{CV\_32FC1}).}
 \cvarg{angleInDegress}{Flag which indicates angles must be evaluated in degress.}
-\cvarg{stream}{Sream for the asynchronous version.}
+\cvarg{stream}{Stream for the asynchronous version.}
 \end{description}
 
 See also: \cvCppCross{phase}.
@@ -165,7 +166,7 @@ void cartToPolar(const GpuMat\& x, const GpuMat\& y, GpuMat\& magnitude,\par
 \cvarg{magnitude}{Destination matrix of float magnituds (\texttt{CV\_32FC1}).}
 \cvarg{angle}{Destionation matrix of angles (\texttt{CV\_32FC1}).}
 \cvarg{angleInDegress}{Flag which indicates angles must be evaluated in degress.}
-\cvarg{stream}{Sream for the asynchronous version.}
+\cvarg{stream}{Stream for the asynchronous version.}
 \end{description}
 
 See also: \cvCppCross{cartToPolar}.
@@ -185,7 +186,7 @@ void polarToCart(const GpuMat\& magnitude, const GpuMat\& angle,\par
 \cvarg{x}{Destination matrix of real components (\texttt{CV\_32FC1}).}
 \cvarg{y}{Destination matrix of imaginary components (\texttt{CV\_32FC1}).}
 \cvarg{angleInDegress}{Flag which indicates angles are in degress.}
-\cvarg{stream}{Sream for the asynchronous version.}
+\cvarg{stream}{Stream for the asynchronous version.}
 \end{description}
 
 See also: \cvCppCross{polarToCart}.
\ No newline at end of file

doc/gpu_matrix_reductions.tex

@@ -41,8 +41,8 @@ Returns sum of matrix elements.
 Scalar sum(const GpuMat\& src, GpuMat\& buf);}
 
 \begin{description}
-\cvarg{src}{Source image of any depth excepting \texttt{CV\_64F}, single-channel.}
-\cvarg{buf}{Optional buffer. It's resized automatically.}
+\cvarg{src}{Source image of any depth except \texttt{CV\_64F}, single-channel.}
+\cvarg{buf}{Optional buffer to avoid extra memory allocations. It's resized automatically.}
 \end{description}
 
 See also: \cvCppCross{sum}.
@@ -54,8 +54,8 @@ Returns squared sum of matrix elements.
 \cvdefCpp{Scalar sqrSum(const GpuMat\& src);\newline
 Scalar sqrSum(const GpuMat\& src, GpuMat\& buf);}
 \begin{description}
-\cvarg{src}{Source image of any depth excepting \texttt{CV\_64F}, single-channel.}
-\cvarg{buf}{Optional buffer. It's resized automatically.}
+\cvarg{src}{Source image of any depth except \texttt{CV\_64F}, single-channel.}
+\cvarg{buf}{Optional buffer to avoid extra memory allocations. It's resized automatically.}
 \end{description}
 
 
@@ -71,7 +71,7 @@ void minMax(const GpuMat\& src, double* minVal, double* maxVal,\par
 \cvarg{minVal}{Pointer to returned minimum value. \texttt{NULL} if not required.}
 \cvarg{maxVal}{Pointer to returned maximum value. \texttt{NULL} if not required.}
 \cvarg{mask}{Optional mask to select a sub-matrix.}
-\cvarg{buf}{Optional buffer. It's resized automatically.}
+\cvarg{buf}{Optional buffer to avoid extra memory allocations. It's resized automatically.}
 \end{description}
 
 Function doesn't work with \texttt{CV\_64F} images on GPU with compute capability $<$ 1.3.\newline
@@ -94,8 +94,8 @@ void minMaxLoc(const GpuMat\& src, double* minVal, double* maxVal,\par
 \cvarg{minValLoc}{Pointer to returned minimum location. \texttt{NULL} if not required.}
 \cvarg{maxValLoc}{Pointer to returned maximum location. \texttt{NULL} if not required.}
 \cvarg{mask}{Optional mask to select a sub-matrix.}
-\cvarg{valbuf}{Optional values buffer. It's resized automatically.}
-\cvarg{locbuf}{Optional location buffer. It's resized automatically.}
+\cvarg{valbuf}{Optional values buffer to avoid extra memory allocations. It's resized automatically.}
+\cvarg{locbuf}{Optional locations buffer to avoid extra memory allocations. It's resized automatically.}
 \end{description}
 
 Function doesn't work with \texttt{CV\_64F} images on GPU with compute capability $<$ 1.3.\newline
@@ -109,7 +109,7 @@ Counts non-zero matrix elements.
 int countNonZero(const GpuMat\& src, GpuMat\& buf);}
 \begin{description}
 \cvarg{src}{Single-channel source image.}
-\cvarg{buf}{Optional buffer. It's resized automatically.}
+\cvarg{buf}{Optional buffer to avoid extra memory allocations. It's resized automatically.}
 \end{description}
 
 Function doesn't work with \texttt{CV\_64F} images on GPU with compute capability $<$ 1.3.\newline

doc/gpu_object_detection.tex

@@ -54,7 +54,7 @@ private:
 }
 \end{lstlisting}
 
-Interfaces of all methods are kept similar to CPU HOG descriptor and detector's analogues as much as possible.
+Interfaces of all methods are kept similar to CPU HOG descriptor and detector analogues as much as possible.
 
 
 \cvCppFunc{gpu::HOGDescriptor::HOGDescriptor}
@@ -68,7 +68,7 @@ Creates HOG descriptor and detector.
 
 \begin{description}
 \cvarg{win\_size}{Detection window size. Must be aligned to block size and block stride.}
-\cvarg{block\_size}{Block size in cells. Only (2,2) is supported for now.}
+\cvarg{block\_size}{Block size in pixels. Must be aligned to cell size. Only (16,16) is supported for now.}
 \cvarg{block\_stride}{Block stride. Must be a multiple of cell size.}
 \cvarg{cell\_size}{Cell size. Only (8, 8) is supported for now.}
 \cvarg{nbins}{Number of bins. Only 9 bins per cell is supported for now.}
@@ -116,7 +116,7 @@ Returns coefficients of the classifier trained for people detection (for 64x128
 
 
 \cvCppFunc{gpu::HOGDescriptor::detect}
-Perfroms object detection without increasing detection window.
+Perfroms object detection without multiscale window.
 
 \cvdefCpp{void detect(const GpuMat\& img, vector<Point>\& found\_locations,\par
              double hit\_threshold=0, Size win\_stride=Size(),\par
@@ -125,14 +125,14 @@ Perfroms object detection without increasing detection window.
 \begin{description}
 \cvarg{img}{Source image. \texttt{CV\_8UC1} and \texttt{CV\_8UC4}types are supported for now.}
 \cvarg{found\_locations}{Will contain left-top corner points of detected objects boundaries.}
-\cvarg{hit\_threshold}{Threshold for the distance between features and classifying plane. Usually it's 0, and should be specfied in the detector coefficients (as the last free coefficient), but if the free coefficient is missed (it's allowed) you can specify it manually here.}
+\cvarg{hit\_threshold}{Threshold for the distance between features and SVM classifying plane. Usually it's 0 and should be specfied in the detector coefficients (as the last free coefficient), but if the free coefficient is omitted (it's allowed) you can specify it manually here.}
 \cvarg{win\_stride}{Window stride. Must be a multiple of block stride.}
 \cvarg{padding}{Mock parameter to keep CPU interface compatibility. Must be (0,0).}
 \end{description}
 
 
 \cvCppFunc{gpu::HOGDescriptor::detectMultiScale}
-Perfroms object detection several times with preliminary increase of detection window.
+Perfroms object detection with multiscale window.
 
 \cvdefCpp{void detectMultiScale(const GpuMat\& img, vector<Rect>\& found\_locations,\par
                       double hit\_threshold=0, Size win\_stride=Size(),\par
@@ -142,7 +142,7 @@ Perfroms object detection several times with preliminary increase of detection w
 \begin{description}
 \cvarg{img}{Source image. See \cvCppCross{gpu::HOGDescriptor::detect} for type limitations.}
 \cvarg{found\_locations}{Will contain detected objects boundaries.}
-\cvarg{hit\_threshold}{The threshold for the distance between features and classifying plane. See \cvCppCross{gpu::HOGDescriptor::detect} for details.}
+\cvarg{hit\_threshold}{The threshold for the distance between features and SVM classifying plane. See \cvCppCross{gpu::HOGDescriptor::detect} for details.}
 \cvarg{win\_stride}{Window stride. Must be a multiple of block stride.}
 \cvarg{padding}{Mock parameter to keep CPU interface compatibility. Must be (0,0).}
 \cvarg{scale0}{Coefficient of the detection window increase.}
@@ -152,7 +152,7 @@ See \cvCppCross{groupRectangles}.}
 
 
 \cvCppFunc{gpu::HOGDescriptor::getDescriptors}
-Returns block descriptors computed for the whole image. 
+Returns block descriptors computed for the whole image. It's mainly used for classifier learning purposes.
 
 \cvdefCpp{void getDescriptors(const GpuMat\& img, Size win\_stride,\par
                     GpuMat\& descriptors,\par

doc/gpu_per_element_operations.tex

@@ -34,7 +34,7 @@ Subtracts matrix from another matrix (or scalar from matrix).
 \cvdefCpp{void subtract(const GpuMat\& a, const Scalar\& sc, GpuMat\& c);}
 \begin{description}
 \cvarg{a}{Source matrix.  \texttt{CV\_32FC1} and \texttt{CV\_32FC2} matrixes are supported for now.}
-\cvarg{b}{Scalar to be subtracted from the source matrix \texttt{a}.}
+\cvarg{b}{Scalar to be subtracted from the source matrix elements.}
 \cvarg{c}{Destination matrix. Will have the same size and type as \texttt{a}.}
 \end{description}
 
@@ -118,7 +118,7 @@ Computes per-element absolute difference of two matrices (or of matrix and scala
 \cvdefCpp{void absdiff(const GpuMat\& a, const Scalar\& s, GpuMat\& c);}
 \begin{description}
 \cvarg{a}{Source matrix. \texttt{CV\_32FC1} matrixes are supported for now.}
-\cvarg{b}{Scalar to be multiplied by.}
+\cvarg{b}{Scalar to be subtracted from the source matrix elements.}
 \cvarg{c}{Destination matrix. Will have the same size and type as \texttt{a}.}
 \end{description}