restructured gpu modules docs

doc/gpu_data_structures.tex

+\section{Data Structures}
+
+
+\cvCppFunc{gpu::createContinuous}
+Creates continuous matrix in GPU memory.
+
+\cvdefCpp{void createContinuous(int rows, int cols, int type, GpuMat\& m);}
+\begin{description}
+\cvarg{rows}{Row count.}
+\cvarg{cols}{Column count.}
+\cvarg{type}{Type of the matrix.}
+\cvarg{m}{Destination matrix. Will be reshaped only if it has proper type and area ($rows \times cols$).}
+\end{description}
\ No newline at end of file

doc/gpu_matrix_operations.tex

+\section{Operations on Matrices}
+
+
+\cvCppFunc{gpu::transpose}
+Transposes the matrix.
+
+\cvdefCpp{void transpose(const GpuMat\& src, GpuMat\& dst);}
+\begin{description}
+\cvarg{src}{Source matrix. Elements sizes 1, 4, 8 bytes are supported for now.}
+\cvarg{dst}{Destination matrix.}
+\end{description}
+
+See also: \cvCppCross{transpose}.
+
+
+\cvCppFunc{gpu::flip}
+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{b}{Destination matrix.}
+\cvarg{flipCode}{Specifies how to flip the source:
+\begin{description}
+\cvarg{0}{Flip around x-axis.}
+\cvarg{$>$0}{Flip around y-axis.}
+\cvarg{$<$0}{Flip around both axes.}
+\end{description}}
+\end{description}
+
+See also: \cvCppCross{flip}.
+
+\cvCppFunc{gpu::merge}
+Makes multi-channel matrix out of several single-channel matrices.
+
+\cvdefCpp{void merge(const GpuMat* src, size\_t n, GpuMat\& dst);\newline
+void merge(const GpuMat* src, size\_t n, GpuMat\& dst,\par
+  const Stream\& stream);\newline\newline
+void merge(const vector$<$GpuMat$>$\& src, GpuMat\& dst);\newline
+void merge(const vector$<$GpuMat$>$\& src, GpuMat\& dst,\par
+  const Stream\& stream);}
+\begin{description}
+\cvarg{src}{Vector or pointer to array of the source matrices.}
+\cvarg{n}{Number of source matrices.}
+\cvarg{dst}{Destination matrix.}
+\cvarg{stream}{Stream for the asynchronous versions.}
+\end{description}
+
+See also: \cvCppCross{merge}.
+
+
+\cvCppFunc{gpu::split}
+Copies each plane of a multi-channel matrix into an array.
+
+\cvdefCpp{void split(const GpuMat\& src, GpuMat* dst);\newline
+void split(const GpuMat\& src, GpuMat* dst, const Stream\& stream);\newline\newline
+void split(const GpuMat\& src, vector$<$GpuMat$>$\& dst);\newline
+void split(const GpuMat\& src, vector$<$GpuMat$>$\& dst,\par
+  const Stream\& stream);}
+\begin{description}
+\cvarg{src}{Source matrix.}
+\cvarg{dst}{Destination vector or pointer to array of single-channel matrices.}
+\cvarg{stream}{Stream for the asynchronous versions.}
+\end{description}
+
+See also: \cvCppCross{split}.
+
+
+\cvCppFunc{gpu::magnitude}
+Computes magnitude of complex vector.
+
+\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).}
+\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{stream}{Sream for the asynchronous version.}
+\end{description}
+
+See also: \cvCppCross{magnitude}.
+
+
+\cvCppFunc{gpu::magnitudeSqr}
+Computes squared magnitude of complex vector.
+
+\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).}
+\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{stream}{Sream for the asynchronous version.}
+\end{description}
+
+
+\cvCppFunc{gpu::phase}
+Computes polar angle of each complex value.
+
+\cvdefCpp{void phase(const GpuMat\& x, const GpuMat\& y, GpuMat\& angle,\par
+  bool angleInDegrees=false);\newline
+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{angleInDegress}{Flag which indicates angles must be evaluated in degress.}
+\cvarg{stream}{Sream for the asynchronous version.}
+\end{description}
+
+See also: \cvCppCross{phase}.
+
+
+\cvCppFunc{gpu::cartToPolar}
+Converts Cartesian coordinates into polar.
+
+\cvdefCpp{void cartToPolar(const GpuMat\& x, const GpuMat\& y, GpuMat\& magnitude,\par
+  GpuMat\& angle, bool angleInDegrees=false);\newline
+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{angleInDegress}{Flag which indicates angles must be evaluated in degress.}
+\cvarg{stream}{Sream for the asynchronous version.}
+\end{description}
+
+See also: \cvCppCross{cartToPolar}.
+
+
+\cvCppFunc{gpu::polarToCart}
+Converts polar coordinates into Cartesian.
+
+\cvdefCpp{void polarToCart(const GpuMat\& magnitude, const GpuMat\& angle,\par
+  GpuMat\& x, GpuMat\& y, bool angleInDegrees=false);\newline
+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{angleInDegress}{Flag which indicates angles are in degress.}
+\cvarg{stream}{Sream for the asynchronous version.}
+\end{description}
+
+See also: \cvCppCross{polarToCart}.
\ No newline at end of file

doc/gpu_matrix_reductions.tex

+\section{Matrix Reductions}
+
+
+\cvCppFunc{gpu::sum}
+Returns sum of array elements.
+
+\cvdefCpp{Scalar sum(const GpuMat\& src);\newline
+Scalar sum(const GpuMat\& src, GpuMat\& buf);}
+
+\begin{description}
+\cvarg{src}{Source image of any depth excepting 64F, single-channel.}
+\cvarg{buf}{Optional buffer. It's resized automatically.}
+\end{description}
+
+See also: \cvCppCross{sum}.
+
+
+\cvCppFunc{gpu::sqrSum}
+Returns squared sum of array 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{buf}{Optional buffer. It's resized automatically.}
+\end{description}
+
+
+\cvCppFunc{gpu::minMax}
+Finds global minimum and maximum array elements and returns their values.
+
+\cvdefCpp{void minMax(const GpuMat\& src, double* minVal,\par
+  double* maxVal=0, const GpuMat\& mask=GpuMat());\newline
+void minMax(const GpuMat\& src, double* minVal, double* maxVal,\par
+  const GpuMat\& mask, GpuMat\& buf);}
+\begin{description}
+\cvarg{src}{Single-channel source image.}
+\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-array.}
+\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
+See also: \cvCppCross{minMaxLoc}.
+
+
+\cvCppFunc{gpu::minMaxLoc}
+Finds global minimum and maximum array elements and returns their values with locations.
+
+\cvdefCpp{void minMaxLoc(const GpuMat\& src, double\* minVal, double* maxVal=0,\par
+  Point* minLoc=0, Point* maxLoc=0,\par
+  const GpuMat\& mask=GpuMat());\newline
+void minMaxLoc(const GpuMat\& src, double* minVal, double* maxVal,\par
+  Point* minLoc, Point* maxLoc, const GpuMat\& mask,\par
+  GpuMat\& valbuf, GpuMat\& locbuf);}
+\begin{description}
+\cvarg{src}{Single-channel source image.}
+\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{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-array.}
+\cvarg{valbuf}{Optional values buffer. It's resized automatically.}
+\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
+See also: \cvCppCross{minMaxLoc}.
+
+
+\cvCppFunc{gpu::countNonZero}
+Counts non-zero array elements.
+
+\cvdefCpp{int countNonZero(const GpuMat\& src);\newline
+int countNonZero(const GpuMat\& src, GpuMat\& buf);}
+\begin{description}
+\cvarg{src}{Single-channel source image.}
+\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
+See also: \cvCppCross{countNonZero}.
\ No newline at end of file

doc/gpu_object_detection.tex

+\section{Object Detection}
+
+
+\cvclass{gpu::HOGDescriptor}
+Histogram of Oriented Gradients descriptor and detector.
+
+\begin{lstlisting}
+struct CV_EXPORTS HOGDescriptor
+{
+    enum { DEFAULT_WIN_SIGMA = -1 };
+    enum { DEFAULT_NLEVELS = 64 };
+    enum { DESCR_FORMAT_ROW_BY_ROW, DESCR_FORMAT_COL_BY_COL };
+
+    HOGDescriptor(Size win_size=Size(64, 128), Size block_size=Size(16, 16),
+                  Size block_stride=Size(8, 8), Size cell_size=Size(8, 8),
+                  int nbins=9, double win_sigma=DEFAULT_WIN_SIGMA,
+                  double threshold_L2hys=0.2, bool gamma_correction=true,
+                  int nlevels=DEFAULT_NLEVELS);
+
+    size_t getDescriptorSize() const;
+    size_t getBlockHistogramSize() const;
+
+    void setSVMDetector(const vector<float>& detector);
+
+    static vector<float> getDefaultPeopleDetector();
+    static vector<float> getPeopleDetector48x96();
+    static vector<float> getPeopleDetector64x128();
+
+    void detect(const GpuMat& img, vector<Point>& found_locations, 
+                double hit_threshold=0, Size win_stride=Size(), 
+                Size padding=Size());
+
+    void detectMultiScale(const GpuMat& img, vector<Rect>& found_locations,
+                          double hit_threshold=0, Size win_stride=Size(), 
+                          Size padding=Size(), double scale0=1.05, 
+                          int group_threshold=2);
+
+    void getDescriptors(const GpuMat& img, Size win_stride, 
+                        GpuMat& descriptors,
+                        int descr_format=DESCR_FORMAT_COL_BY_COL);
+
+    Size win_size;
+    Size block_size;
+    Size block_stride;
+    Size cell_size;
+    int nbins;
+    double win_sigma;
+    double threshold_L2hys;
+    bool gamma_correction;
+    int nlevels;
+
+private:
+    // Hidden
+}
+\end{lstlisting}
+
+Interfaces of all methods are kept similar to CPU HOG descriptor and detector's analogues as much as possible.
+
+
+\cvCppFunc{gpu::HOGDescriptor::HOGDescriptor}
+Creates HOG descriptor and detector.
+
+\cvdefCpp{HOGDescriptor(Size win\_size=Size(64, 128), Size block\_size=Size(16, 16),\par
+          Size block\_stride=Size(8, 8), Size cell\_size=Size(8, 8),\par
+          int nbins=9, double win\_sigma=DEFAULT\_WIN\_SIGMA,\par
+          double threshold\_L2hys=0.2, bool gamma\_correction=true,\par
+          int nlevels=DEFAULT\_NLEVELS);}
+
+\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\_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.}
+\cvarg{win\_sigma}{Gaussian smoothing window parameter.}
+\cvarg{threshold\_L2Hys}{L2-Hys normalization method shrinkage.}
+\cvarg{gamma\_correction}{Do gamma correction preprocessing or not.}
+\cvarg{nlevels}{Maximum number of detection window increases.}
+\end{description}
+
+
+\cvCppFunc{gpu::HOGDescriptor::getDescriptorSize}
+Returns number of coefficients required for the classification.
+
+\cvdefCpp{size\_t getDescriptorSize() const;}
+
+
+\cvCppFunc{gpu::HOGDescriptor::getBlockHistogramSize}
+Returns block histogram size.
+
+\cvdefCpp{size\_t getBlockHistogramSize() const;}
+
+
+\cvCppFunc{gpu::HOGDescriptor::setSVMDetector}
+Sets coefficients for the linear SVM classifier. 
+
+\cvdefCpp{void setSVMDetector(const vector<float>\& detector);}
+
+
+\cvCppFunc{gpu::HOGDescriptor::getDefaultPeopleDetector}
+Returns coefficients of the classifier trained for people detection (for default window size).
+
+\cvdefCpp{static vector<float> getDefaultPeopleDetector();}
+
+
+\cvCppFunc{gpu::HOGDescriptor::getPeopleDetector48x96}
+Returns coefficients of the classifier trained for people detection (for 48x96 windows).
+
+\cvdefCpp{static vector<float> getPeopleDetector48x96();}
+
+
+\cvCppFunc{gpu::HOGDescriptor::getPeopleDetector64x128}
+Returns coefficients of the classifier trained for people detection (for 64x128 windows).
+
+\cvdefCpp{static vector<float> getPeopleDetector64x128();}
+
+
+\cvCppFunc{gpu::HOGDescriptor::detect}
+Perfroms object detection without increasing detection window.
+
+\cvdefCpp{void detect(const GpuMat\& img, vector<Point>\& found\_locations,\par
+             double hit\_threshold=0, Size win\_stride=Size(),\par
+             Size padding=Size());}
+
+\begin{description}
+\cvarg{img}{Source image. 8UC1 and 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.}
+\cvarg{padding}{Mock parameter to keep CPU interface compatibility. Must be (0,0).}
+\end{description}
+
+
+\cvCppFunc{gpu::HOGDescriptor::detectMultiScale}
+Perfroms object detection with increasing detection window.
+
+\cvdefCpp{void detectMultiScale(const GpuMat\& img, vector<Rect>\& found\_locations,\par
+                      double hit\_threshold=0, Size win\_stride=Size(),\par
+                      Size padding=Size(), double scale0=1.05,\par
+                      int group\_threshold=2);}
+
+\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{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.}
+\cvarg{group\_threshold}{After detection some objects could be covered by many rectangles. This coefficient regulates similarity threshold. 0 means don't perform grouping.\newline
+See \cvCppCross{groupRectangles}.}
+\end{description}
+
+
+\cvCppFunc{gpu::HOGDescriptor::getDescriptors}
+Returns block descriptors computed for the whole image. 
+
+\cvdefCpp{void getDescriptors(const GpuMat\& img, Size win\_stride,\par
+                    GpuMat\& descriptors,\par
+                    int descr\_format=DESCR\_FORMAT\_COL\_BY\_COL);}
+
+\begin{description}
+\cvarg{img}{Source image. See \cvCppCross{gpu::HOGDescriptor::detect} for type limitations.}
+\cvarg{win\_stride}{Window stride. Must be a multiple of block stride.}
+\cvarg{descriptors}{2D array of descriptors.}
+\cvarg{descr\_format}{Descriptor storage format: 
+\begin{description}
+    \cvarg{DESCR\_FORMAT\_ROW\_BY\_ROW}{Row-major order.}
+    \cvarg{DESCR\_FORMAT\_COL\_BY\_COL}{Column-major order.}
+\end{description}}
+\end{description}
\ No newline at end of file

doc/gpu_per_element_operations.tex

+\section{Per-element Operations.}
+
+
+\cvCppFunc{add}
+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 matrixes 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. 32SC1 and 32FC2 matrixes are supported for now.}
+\cvarg{b}{Source scalar.}
+\cvarg{c}{Destination matrix. Will have the same size and type as \texttt{a}.}
+\end{description}
+
+See also: \cvCppCross{add}.
+
+
+\cvfunc{cv::gpu::bitwise\_not}\label{cppfunc.gpu.bitwise.not}
+Performs per-element bitwise inversion.
+
+\cvdefCpp{void bitwise\_not(const GpuMat\& src, GpuMat\& dst,\par
+  const GpuMat\& mask=GpuMat());\newline
+void bitwise\_not(const GpuMat\& src, GpuMat\& dst,\par
+  const GpuMat\& mask, const Stream\& stream);}
+
+\begin{description}
+\cvarg{src}{Source matrix.}
+\cvarg{dst}{Destination matrix. Will have the same size and type as \texttt{src}.}
+\cvarg{mask}{Optional operation mask. 8-bit single channel image.}
+\cvarg{stream}{Stream for the asynchronous version.}
+\end{description}
+
+See also: \hyperref[cppfunc.bitwise.not]{cv::bitwise\_not}.
+
+
+\cvfunc{cv::gpu::bitwise\_or}\label{cppfunc.gpu.bitwise.or}
+Performs per-element bitwise disjunction of two matrices.
+
+\cvdefCpp{void bitwise\_or(const GpuMat\& src1, const GpuMat\& src2, GpuMat\& dst,\par
+  const GpuMat\& mask=GpuMat());\newline
+void bitwise\_or(const GpuMat\& src1, const GpuMat\& src2, GpuMat\& dst,\par
+  const GpuMat\& mask, const Stream\& stream);}
+
+\begin{description}
+\cvarg{src1}{First source matrix.}
+\cvarg{src2}{Second source matrix. It must have the same size and type as \texttt{src1}.}
+\cvarg{dst}{Destination matrix. Will have the same size and type as \texttt{src1}.}
+\cvarg{mask}{Optional operation mask. 8-bit single channel image.}
+\cvarg{stream}{Stream for the asynchronous version.}
+\end{description}
+
+See also: \hyperref[cppfunc.bitwise.or]{cv::bitwise\_or}.
+
+
+\cvfunc{cv::gpu::bitwise\_and}\label{cppfunc.gpu.bitwise.and}
+Performs per-element bitwise conjunction of two matrices.
+
+\cvdefCpp{void bitwise\_and(const GpuMat\& src1, const GpuMat\& src2, GpuMat\& dst,\par
+  const GpuMat\& mask=GpuMat());\newline
+void bitwise\_and(const GpuMat\& src1, const GpuMat\& src2, GpuMat\& dst,\par
+  const GpuMat\& mask, const Stream\& stream);}
+
+\begin{description}
+\cvarg{src1}{First source matrix.}
+\cvarg{src2}{Second source matrix. It must have the same size and type as \texttt{src1}.}
+\cvarg{dst}{Destination matrix. Will have the same size and type as \texttt{src1}.}
+\cvarg{mask}{Optional operation mask. 8-bit single channel image.}
+\cvarg{stream}{Stream for the asynchronous version.}
+\end{description}
+
+See also: \hyperref[cppfunc.bitwise.and]{cv::bitwise\_and}.
+
+
+\cvfunc{cv::gpu::bitwise\_xor}\label{cppfunc.gpu.bitwise.xor}
+Performs per-element bitwise "exclusive or" of two matrices.
+
+\cvdefCpp{void bitwise\_xor(const GpuMat\& src1, const GpuMat\& src2, GpuMat\& dst,\par
+  const GpuMat\& mask=GpuMat());\newline
+void bitwise\_xor(const GpuMat\& src1, const GpuMat\& src2, GpuMat\& dst,\par
+  const GpuMat\& mask, const Stream\& stream);}
+
+\begin{description}
+\cvarg{src1}{First source matrix.}
+\cvarg{src2}{Second source matrix. It must have the same size and type as \texttt{src1}.}
+\cvarg{dst}{Destination matrix. Will have the same size and type as \texttt{src1}.}
+\cvarg{mask}{Optional operation mask. 8-bit single channel image.}
+\cvarg{stream}{Stream for the asynchronous version.}
+\end{description}
+
+See also: \hyperref[cppfunc.bitwise.xor]{cv::bitwise\_xor}.
\ No newline at end of file

doc/opencvref_body.tex

@@ -64,12 +64,12 @@
 \renewcommand{\curModule}{gpu}
 %\input{gpu_introduction}
 \input{gpu_initialization}
-\input{gpu}
-%\input{gpu_datastructures}
-%\input{gpu_matrixoperations}
-%\input{gpu_imageproc}
-%\input{gpu_matrixreductions}
-%\input{gpu_objectdetection}
+\input{gpu_data_structures}
+\input{gpu_matrix_operations}
+\input{gpu_per_element_operations}
+\input{gpu_image_processing}
+\input{gpu_matrix_reductions}
+\input{gpu_object_detection}
 \input{gpu_features2d}
 \input{gpu_image_filtering}
 \fi