updated gpu docs (monowidth font for types)

doc/gpu_image_processing.tex

@@ -10,7 +10,7 @@ Performs mean-shift filtering.
   + TermCriteria::EPS, 5, 1));}
 
 \begin{description}
-\cvarg{src}{Source image. Only 8UC4 images are supported for now.}
+\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{sp}{Spatial window radius.}
 \cvarg{sr}{Color window radius.}
@@ -27,9 +27,9 @@ Performs mean-shift procedure and stores information about converged points in t
   + TermCriteria::EPS, 5, 1));}
 
 \begin{description}
-\cvarg{src}{Source image. Only 8UC4 images are supported for now.}
+\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}{16SC2 matrix, which will contain coordinates of converged points and have the same size as \texttt{src}.}
+\cvarg{dstsp}{\texttt{CV\_16SC2} matrix, which will contain coordinates of converged points and have the same size as \texttt{src}.}
 \cvarg{sp}{Spatial window radius.}
 \cvarg{sr}{Color window radius.}
 \cvarg{criteria}{Termination criteria. See \hyperref[TermCriteria]{cv::TermCriteria}.}
@@ -45,7 +45,7 @@ Performs mean-shift segmentation of the source image and eleminates small segmen
   + TermCriteria::EPS, 5, 1));}
 
 \begin{description}
-\cvarg{src}{Source image. Only 8UC4 images are supported for now.}
+\cvarg{src}{Source image. Only \texttt{CV\_8UC4} images are supported for now.}
 \cvarg{dst}{Segmented image. Will have the same size and type as \texttt{src}.}
 \cvarg{sp}{Spatial window radius.}
 \cvarg{sr}{Color window radius.}
@@ -61,9 +61,9 @@ Computes integral image and squared integral image.
 void integral(const GpuMat\& src, GpuMat\& sum, GpuMat\& sqsum);}
 
 \begin{description}
-\cvarg{src}{Source image. Only 8UC1 images are supported for now.}
-\cvarg{sum}{Integral image. Will contain 32-bit unsigned integer values packed into 32SC1.}
-\cvarg{sqsum}{Squared integral image. Will have 32FC1 type.}
+\cvarg{src}{Source image. Only \texttt{CV\_8UC1} images are supported for now.}
+\cvarg{sum}{Integral image. Will contain 32-bit unsigned integer values packed into \texttt{CV\_32SC1}.}
+\cvarg{sqsum}{Squared integral image. Will have \texttt{CV\_32FC1} type.}
 \end{description}
 
 See also: \cvCppCross{integral}.
@@ -74,7 +74,7 @@ Computes squared integral image.
 
 \cvdefCpp{void sqrIntegral(const GpuMat\& src, GpuMat\& sqsum);}
 \begin{description}
-\cvarg{src}{Source image. Only 8UC1 images are supported for now.}
+\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.}
 \end{description}
 
@@ -84,8 +84,8 @@ Computes vertical (column) sum.
 
 \cvdefCpp{void columnSum(const GpuMat\& src, GpuMat\& sum);}
 \begin{description}
-\cvarg{src}{Source image. Only 32FC1 images are supported for now.}
-\cvarg{sum}{Destination image. Will have 32FC1 type.}
+\cvarg{src}{Source image. Only \texttt{CV\_32FC1} images are supported for now.}
+\cvarg{sum}{Destination image. Will have \texttt{CV\_32FC1} type.}
 \end{description}
 
 
@@ -97,8 +97,8 @@ Computes Harris cornerness criteria at each image pixel.
   int borderType=BORDER\_REFLECT101);}
 
 \begin{description}
-\cvarg{src}{Source image. Only 8UC1 and 32FC1 images are supported for now.}
-\cvarg{dst}{Destination image. Will have the same size and 32FC1 type and contain cornerness values.}
+\cvarg{src}{Source image. Only \texttt{CV\_8UC1} and \texttt{CV\_32FC1} images are supported for now.}
+\cvarg{dst}{Destination image. Will have the same size and \texttt{CV\_32FC1} type and contain cornerness values.}
 \cvarg{blockSize}{Neighborhood size.}
 \cvarg{ksize}{Aperture parameter for the Sobel operator.}
 \cvarg{k}{Harris detector free parameter.}
@@ -116,8 +116,8 @@ Computes minimum eigen value of 2x2 derivative covariation matrix at each pixel
   int borderType=BORDER\_REFLECT101);}
 
 \begin{description}
-\cvarg{src}{Source image. Only 8UC1 and 32FC1 images are supported for now.}
-\cvarg{dst}{Destination image. Will have the same size and 32FC1 type and contain cornerness values.}
+\cvarg{src}{Source image. Only \texttt{CV\_8UC1} and \texttt{CV\_32FC1} images are supported for now.}
+\cvarg{dst}{Destination image. Will have the same size and \texttt{CV\_32FC1} type and contain cornerness values.}
 \cvarg{blockSize}{Neighborhood size.}
 \cvarg{ksize}{Aperture parameter for the Sobel operator.}
 \cvarg{k}{Harris detector free parameter.}
@@ -141,7 +141,7 @@ Performs per-element multiplication of two Fourier spectrums.
 \cvarg{conjB}{Optional flag which indicates the second spectrum must be conjugated before the multiplcation.}
 \end{description}
 
-Only full (i.e. not packed) 32FC2 complex spectrums in the interleaved format are supported for now.
+Only full (i.e. not packed) \texttt{CV\_32FC2} complex spectrums in the interleaved format are supported for now.
 
 See also: \cvCppCross{mulSpectrums}.
 
@@ -161,7 +161,7 @@ Performs per-element multiplication of two Fourier spectrums and scales the resu
 \cvarg{conjB}{Optional flag which indicates the second spectrum must be conjugated before the multiplcation.}
 \end{description}
 
-Only full (i.e. not packed) 32FC2 complex spectrums in the interleaved format are supported for now.
+Only full (i.e. not packed) \texttt{CV\_32FC2} complex spectrums in the interleaved format are supported for now.
 
 See also: \cvCppCross{mulSpectrums}.
 
@@ -186,9 +186,9 @@ Performs a forward or inverse discrete Fourier transform (1D or 2D) of floating
 
 The source matrix should be continuous, otherwise reallocation and data copying will be performed. Function chooses the operation mode depending on the flags, size and channel count of the source matrix:
 \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 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 32FC1 type. It will contain result of the inverse DFT.
-  \item If the source matrix is real (i.e. its type is 32FC1) then forward DFT will be performed. The result of the DFT will be packed into complex (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 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.
 \end{itemize}
 
 See also: \cvCppCross{dft}.
@@ -203,7 +203,7 @@ void convolve(const GpuMat\& image, const GpuMat\& templ, GpuMat\& result,\par
   bool ccorr, ConvolveBuf\& buf);}
 
 \begin{description}
-\cvarg{image}{Source image. Only 32FC1 images are supported for now.}
+\cvarg{image}{Source image. Only \texttt{CV\_32FC1} images are supported for now.}
 \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.}

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 8UC1 and 8UC4 matrixes are supported for now.}
+\cvarg{a}{Source matrix. Only \texttt{CV\_8UC1} and \texttt{CV\_8UC4} matrixes are supported for now.}
 \cvarg{b}{Destination matrix.}
 \cvarg{flipCode}{Specifies how to flip the source:
 \begin{description}
@@ -36,8 +36,8 @@ Transforms the source matrix into the destination matrix using given look-up tab
 
 \cvdefCpp{void LUT(const GpuMat\& src, const Mat\& lut, GpuMat\& dst);}
 \begin{description}
-\cvarg{src}{Source matrix. 8UC1 and 8UC3 matrixes are supported for now.}
-\cvarg{lut}{Look-up table. Must be continuous, 8U depth matrix. Its area must satisfy to \texttt{lut.rows} $\times$ \texttt{lut.cols} = 256.}
+\cvarg{src}{Source matrix. \texttt{CV\_8UC1} and \texttt{CV\_8UC3} matrixes are supported for now.}
+\cvarg{lut}{Look-up table. Must be continuous, \texttt{CV\_8U} depth matrix. Its area must satisfy to \texttt{lut.rows} $\times$ \texttt{lut.cols} = 256 condition.}
 \cvarg{dst}{Destination matrix. Will have the same depth as \texttt{lut} and the same number of channels as \texttt{src}.}
 \end{description}
 
@@ -97,17 +97,17 @@ Computes magnitudes of complex matrix elements.
 
 \cvdefCpp{void magnitude(const GpuMat\& x, GpuMat\& magnitude);}
 \begin{description}
-\cvarg{x}{Source complex matrix in the interleaved format (32FC2). }
-\cvarg{magnitude}{Destination matrix of float magnitudes (32FC1).}
+\cvarg{x}{Source complex matrix in the interleaved format (\texttt{CV\_32FC2}). }
+\cvarg{magnitude}{Destination matrix of float magnitudes (\texttt{CV\_32FC1}).}
 \end{description}
 
 \cvdefCpp{void magnitude(const GpuMat\& x, const GpuMat\& y, GpuMat\& magnitude);\newline
 void magnitude(const GpuMat\& x, const GpuMat\& y, GpuMat\& magnitude,\par
   const Stream\& stream);}
 \begin{description}
-\cvarg{x}{Source matrix, containing real components (32FC1).}
-\cvarg{y}{Source matrix, containing imaginary components (32FC1).}
-\cvarg{magnitude}{Destination matrix of float magnitudes (32FC1).}
+\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.}
 \end{description}
 
@@ -119,17 +119,17 @@ Computes squared magnitudes of complex matrix elements.
 
 \cvdefCpp{void magnitudeSqr(const GpuMat\& x, GpuMat\& magnitude);}
 \begin{description}
-\cvarg{x}{Source complex matrix in the interleaved format (32FC2). }
-\cvarg{magnitude}{Destination matrix of float magnitude squares (32FC1).}
+\cvarg{x}{Source complex matrix in the interleaved format (\texttt{CV\_32FC2}). }
+\cvarg{magnitude}{Destination matrix of float magnitude squares (\texttt{CV\_32FC1}).}
 \end{description}
 
 \cvdefCpp{void magnitudeSqr(const GpuMat\& x, const GpuMat\& y, GpuMat\& magnitude);\newline
 void magnitudeSqr(const GpuMat\& x, const GpuMat\& y, GpuMat\& magnitude,\par
   const Stream\& stream);}
 \begin{description}
-\cvarg{x}{Source matrix, containing real components (32FC1).}
-\cvarg{y}{Source matrix, containing imaginary components (32FC1).}
-\cvarg{magnitude}{Destination matrix of float magnitude squares (32FC1).}
+\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.}
 \end{description}
 
@@ -142,9 +142,9 @@ Computes polar angles of complex matrix elements.
 void phase(const GpuMat\& x, const GpuMat\& y, GpuMat\& angle,\par
   bool angleInDegrees, const Stream\& stream);}
 \begin{description}
-\cvarg{x}{Source matrix, containing real components (32FC1).}
-\cvarg{y}{Source matrix, containing imaginary components (32FC1).}
-\cvarg{angle}{Destionation matrix of angles (32FC1).}
+\cvarg{x}{Source matrix, containing real components (\texttt{CV\_32FC1}).}
+\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.}
 \end{description}
@@ -160,10 +160,10 @@ Converts Cartesian coordinates into polar.
 void cartToPolar(const GpuMat\& x, const GpuMat\& y, GpuMat\& magnitude,\par
   GpuMat\& angle, bool angleInDegrees, const Stream\& stream);}
 \begin{description}
-\cvarg{x}{Source matrix, containing real components (32FC1).}
-\cvarg{y}{Source matrix, containing imaginary components (32FC1).}
-\cvarg{magnitude}{Destination matrix of float magnituds (32FC1).}
-\cvarg{angle}{Destionation matrix of angles (32FC1).}
+\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 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.}
 \end{description}
@@ -180,10 +180,10 @@ void polarToCart(const GpuMat\& magnitude, const GpuMat\& angle,\par
   GpuMat\& x, GpuMat\& y, bool angleInDegrees,\par
   const Stream\& stream);}
 \begin{description}
-\cvarg{magnitude}{Source matrix, containing magnitudes (32FC1).}
-\cvarg{angle}{Source matrix, containing angles (32FC1).}
-\cvarg{x}{Destination matrix of real components (32FC1).}
-\cvarg{y}{Destination matrix of imaginary components (32FC1).}
+\cvarg{magnitude}{Source matrix, containing magnitudes (\texttt{CV\_32FC1}).}
+\cvarg{angle}{Source matrix, containing angles (\texttt{CV\_32FC1}).}
+\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.}
 \end{description}

doc/gpu_matrix_reductions.tex

@@ -6,7 +6,7 @@ Computes mean value and standard deviation of matrix elements.
 
 \cvdefCpp{void meanStdDev(const GpuMat\& mtx, Scalar\& mean, Scalar\& stddev);}
 \begin{description}
-\cvarg{mtx}{Source matrix. 8UC1 matrices are supported for now.}
+\cvarg{mtx}{Source matrix. \texttt{CV\_8UC1} matrices are supported for now.}
 \cvarg{mean}{Mean value.}
 \cvarg{stddev}{Standard deviation value.}
 \end{description}
@@ -19,14 +19,14 @@ Returns norm of matrix (or of two matrices difference).
 
 \cvdefCpp{double norm(const GpuMat\& src1, int normType=NORM\_L2);}
 \begin{description}
-\cvarg{src1}{Source matrix. 8UC1 matrices are supported for now.}
+\cvarg{src1}{Source matrix. \texttt{CV\_8UC1} matrices are supported for now.}
 \cvarg{normType}{Norm type. \texttt{NORM\_L1}, \texttt{NORM\_L2} and \texttt{NORM\_INF} are supported for now.}
 \end{description}
 
 \cvdefCpp{double norm(const GpuMat\& src1, const GpuMat\& src2,\par
   int normType=NORM\_L2);}
 \begin{description}
-\cvarg{src1}{First source matrix. 8UC1 matrices are supported for now.}
+\cvarg{src1}{First source matrix. \texttt{CV\_8UC1} matrices are supported for now.}
 \cvarg{src2}{Second source matrix. Must have the same size and type as \texttt{src1}}.
 \cvarg{normType}{Norm type. \texttt{NORM\_L1}, \texttt{NORM\_L2} and \texttt{NORM\_INF} are supported for now.}
 \end{description}
@@ -41,7 +41,7 @@ Returns sum of matrix elements.
 Scalar sum(const GpuMat\& src, GpuMat\& buf);}
 
 \begin{description}
-\cvarg{src}{Source image of any depth excepting 64F, single-channel.}
+\cvarg{src}{Source image of any depth excepting \texttt{CV\_64F}, single-channel.}
 \cvarg{buf}{Optional buffer. It's resized automatically.}
 \end{description}
 
@@ -54,7 +54,7 @@ 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 64F, single-channel.}
+\cvarg{src}{Source image of any depth excepting \texttt{CV\_64F}, single-channel.}
 \cvarg{buf}{Optional buffer. It's resized automatically.}
 \end{description}
 
@@ -74,7 +74,7 @@ void minMax(const GpuMat\& src, double* minVal, double* maxVal,\par
 \cvarg{buf}{Optional buffer. It's resized automatically.}
 \end{description}
 
-Function doesn't work with 64F images on GPU with compute capability $<$ 1.3.\newline
+Function doesn't work with \texttt{CV\_64F} images on GPU with compute capability $<$ 1.3.\newline
 See also: \cvCppCross{minMaxLoc}.
 
 
@@ -98,7 +98,7 @@ void minMaxLoc(const GpuMat\& src, double* minVal, double* maxVal,\par
 \cvarg{locbuf}{Optional location buffer. It's resized automatically.}
 \end{description}
 
-Function doesn't work with 64F images on GPU with compute capability $<$ 1.3.\newline
+Function doesn't work with \texttt{CV\_64F} images on GPU with compute capability $<$ 1.3.\newline
 See also: \cvCppCross{minMaxLoc}.
 
 
@@ -112,5 +112,5 @@ int countNonZero(const GpuMat\& src, GpuMat\& buf);}
 \cvarg{buf}{Optional buffer. It's resized automatically.}
 \end{description}
 
-Function doesn't work with 64F images on GPU with compute capability $<$ 1.3.\newline
+Function doesn't work with \texttt{CV\_64F} images on GPU with compute capability $<$ 1.3.\newline
 See also: \cvCppCross{countNonZero}.

doc/gpu_object_detection.tex

@@ -123,7 +123,7 @@ Perfroms object detection without increasing detection window.
              Size padding=Size());}
 
 \begin{description}
-\cvarg{img}{Source image. 8UC1 and 8UC4 types are supported for now.}
+\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{win\_stride}{Window stride. Must be a multiple of block stride.}

doc/gpu_per_element_operations.tex

@@ -6,14 +6,14 @@ Computes matrix-matrix or matrix-scalar sum.
 
 \cvdefCpp{void add(const GpuMat\& a, const GpuMat\& b, GpuMat\& c);}
 \begin{description}
-\cvarg{a}{First source matrix. 8UC1, 8UC4, 32SC1 and 32FC2 matrices are supported for now.}
+\cvarg{a}{First source matrix. \texttt{CV\_8UC1}, \texttt{CV\_8UC4}, \texttt{CV\_32SC1} and \texttt{CV\_32FC1} matrices are supported for now.}
 \cvarg{b}{Second source matrix. Must have the same size and type as \texttt{a}.}
 \cvarg{c}{Destination matrix. Will have the same size and type as \texttt{a}.}
 \end{description}
 
 \cvdefCpp{void add(const GpuMat\& a, const Scalar\& sc, GpuMat\& c);}
 \begin{description}
-\cvarg{a}{Source matrix. 32FC1 and 32FC2 matrixes are supported for now.}
+\cvarg{a}{Source matrix. \texttt{CV\_32FC1} and \texttt{CV\_32FC2} matrixes are supported for now.}
 \cvarg{b}{Source scalar to be added to the source matrix.}
 \cvarg{c}{Destination matrix. Will have the same size and type as \texttt{a}.}
 \end{description}
@@ -26,14 +26,14 @@ Subtracts matrix from another matrix (or scalar from matrix).
 
 \cvdefCpp{void subtract(const GpuMat\& a, const GpuMat\& b, GpuMat\& c);}
 \begin{description}
-\cvarg{a}{First source matrix. 8UC1, 8UC4, 32SC1 and 32FC2 matrices are supported for now.}
+\cvarg{a}{First source matrix. \texttt{CV\_8UC1}, \texttt{CV\_8UC4}, \texttt{CV\_32SC1} and \texttt{CV\_32FC1} matrices are supported for now.}
 \cvarg{b}{Second source matrix. Must have the same size and type as \texttt{a}.}
 \cvarg{c}{Destination matrix. Will have the same size and type as \texttt{a}.}
 \end{description}
 
 \cvdefCpp{void subtract(const GpuMat\& a, const Scalar\& sc, GpuMat\& c);}
 \begin{description}
-\cvarg{a}{Source matrix.  32FC1 and 32FC2 matrixes are supported for now.}
+\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{c}{Destination matrix. Will have the same size and type as \texttt{a}.}
 \end{description}
@@ -46,14 +46,14 @@ Computes per-element product of two matrices (or of matrix and scalar).
 
 \cvdefCpp{void multiply(const GpuMat\& a, const GpuMat\& b, GpuMat\& c);}
 \begin{description}
-\cvarg{a}{First source matrix. 8UC1, 8UC4, 32SC1 and 32FC2 matrices are supported for now.}
+\cvarg{a}{First source matrix. \texttt{CV\_8UC1}, \texttt{CV\_8UC4}, \texttt{CV\_32SC1} and \texttt{CV\_32FC1} matrices are supported for now.}
 \cvarg{b}{Second source matrix. Must have the same size and type as \texttt{a}.}
 \cvarg{c}{Destionation matrix. Will have the same size and type as \texttt{a}.}
 \end{description}
 
 \cvdefCpp{void multiply(const GpuMat\& a, const Scalar\& sc, GpuMat\& c);}
 \begin{description}
-\cvarg{a}{Source matrix.  32FC1 and 32FC2 matrixes are supported for now.}
+\cvarg{a}{Source matrix.  \texttt{CV\_32FC1} and \texttt{CV\_32FC2} matrixes are supported for now.}
 \cvarg{b}{Scalar to be multiplied by.}
 \cvarg{c}{Destination matrix. Will have the same size and type as \texttt{a}.}
 \end{description}
@@ -66,14 +66,14 @@ Performs per-element division of two matrices (or division of matrix by scalar).
 
 \cvdefCpp{void divide(const GpuMat\& a, const GpuMat\& b, GpuMat\& c);}
 \begin{description}
-\cvarg{a}{First source matrix. 8UC1, 8UC4, 32SC1 and 32FC2 matrices are supported for now.}
+\cvarg{a}{First source matrix. \texttt{CV\_8UC1}, \texttt{CV\_8UC4}, \texttt{CV\_32SC1} and \texttt{CV\_32FC1} matrices are supported for now.}
 \cvarg{b}{Second source matrix. Must have the same size and type as \texttt{a}.}
 \cvarg{c}{Destionation matrix. Will have the same size and type as \texttt{a}.}
 \end{description}
 
 \cvdefCpp{void divide(const GpuMat\& a, const Scalar\& sc, GpuMat\& c);}
 \begin{description}
-\cvarg{a}{Source matrix.  32FC1 and 32FC2 matrixes are supported for now.}
+\cvarg{a}{Source matrix.  \texttt{CV\_32FC1} and \texttt{CV\_32FC2} matrixes are supported for now.}
 \cvarg{b}{Scalar to be divided by.}
 \cvarg{c}{Destination matrix. Will have the same size and type as \texttt{a}.}
 \end{description}
@@ -86,7 +86,7 @@ Computes exponent of each matrix element.
 
 \cvdefCpp{void exp(const GpuMat\& a, GpuMat\& b);}
 \begin{description}
-\cvarg{a}{Source matrix. 32FC1 matrixes are supported for now.}
+\cvarg{a}{Source matrix. \texttt{CV\_32FC1} matrixes are supported for now.}
 \cvarg{b}{Destination matrix. Will have the same size and type as \texttt{a}.}
 \end{description}
 
@@ -98,7 +98,7 @@ Computes natural logarithm of absolute value of each matrix element.
 
 \cvdefCpp{void log(const GpuMat\& a, GpuMat\& b);}
 \begin{description}
-\cvarg{a}{Source matrix. 32FC1 matrixes are supported for now.}
+\cvarg{a}{Source matrix. \texttt{CV\_32FC1} matrixes are supported for now.}
 \cvarg{b}{Destination matrix. Will have the same size and type as \texttt{a}.}
 \end{description}
 
@@ -110,14 +110,14 @@ Computes per-element absolute difference of two matrices (or of matrix and scala
 
 \cvdefCpp{void absdiff(const GpuMat\& a, const GpuMat\& b, GpuMat\& c);}
 \begin{description}
-\cvarg{a}{First source matrix. 8UC1, 8UC4, 32SC1 and 32FC2 matrices are supported for now.}
+\cvarg{a}{First source matrix. \texttt{CV\_8UC1}, \texttt{CV\_8UC4}, \texttt{CV\_32SC1} and \texttt{CV\_32FC1} matrices are supported for now.}
 \cvarg{b}{Second source matrix. Must have the same size and type as \texttt{a}.}
 \cvarg{c}{Destionation matrix. Will have the same size and type as \texttt{a}.}
 \end{description}
 
 \cvdefCpp{void absdiff(const GpuMat\& a, const Scalar\& s, GpuMat\& c);}
 \begin{description}
-\cvarg{a}{Source matrix. 32FC1 matrixes are supported for now.}
+\cvarg{a}{Source matrix. \texttt{CV\_32FC1} matrixes are supported for now.}
 \cvarg{b}{Scalar to be multiplied by.}
 \cvarg{c}{Destination matrix. Will have the same size and type as \texttt{a}.}
 \end{description}
@@ -130,9 +130,9 @@ Compares elements of two matrices.
 
 \cvdefCpp{void compare(const GpuMat\& a, const GpuMat\& b, GpuMat\& c, int cmpop);}
 \begin{description}
-\cvarg{a}{First source matrix. 8UC4 and 32FC1 matrices are supported for now.}
+\cvarg{a}{First source matrix. \texttt{CV\_8UC4} and \texttt{CV\_32FC1} matrices are supported for now.}
 \cvarg{b}{Second source matrix. Must have the same size and type as \texttt{a}.}
-\cvarg{c}{Destination matrix. Will have the same size as \texttt{a} and be 8UC1 type.}
+\cvarg{c}{Destination matrix. Will have the same size as \texttt{a} and be \texttt{CV\_8UC1} type.}
 \cvarg{cmpop}{Flag specifying the relation between the elements to be checked:
 \begin{description}
 \cvarg{CMP\_EQ}{$=$}