--- /dev/null
+\section{Camera Calibration and 3d Reconstruction}
+
+
+\cvclass{gpu::StereoBM\_GPU}
+The class for computing stereo correspondence using block matching algorithm.
+
+\begin{lstlisting}
+class StereoBM_GPU
+{
+public:
+ enum { BASIC_PRESET = 0, PREFILTER_XSOBEL = 1 };
+
+ enum { DEFAULT_NDISP = 64, DEFAULT_WINSZ = 19 };
+
+ StereoBM_GPU();
+ StereoBM_GPU(int preset, int ndisparities = DEFAULT_NDISP,
+ int winSize = DEFAULT_WINSZ);
+
+ void operator() (const GpuMat& left, const GpuMat& right,
+ GpuMat& disparity);
+ void operator() (const GpuMat& left, const GpuMat& right,
+ GpuMat& disparity, const Stream & stream);
+
+ static bool checkIfGpuCallReasonable();
+
+ int preset;
+ int ndisp;
+ int winSize;
+
+ float avergeTexThreshold;
+
+ ...
+};
+\end{lstlisting}
+
+The class computes the disparity map using block matching algorithm. The class also does some pre- and post- processing steps: sobel prefilter (if use \texttt{PREFILTER\_XSOBEL} preset) and textureless threshold post processing (if \texttt{avergeTexThreshold} $>$ 0). If \texttt{avergeTexThreshold = 0} post procesing is disabled, otherwise disparity is set 0 in each point \texttt{(x, y)} where for left image $\sum HorizontalGradiensInWindow(x, y, winSize) < (winSize \cdot winSize) \cdot avergeTexThreshold$ i.e. input left image is low textured.
+
+
+\cvfunc{cv::gpu::StereoBM\_GPU::StereoBM\_GPU}\label{cppfunc.gpu.StereoBM.StereoBM}
+StereoBM\_GPU constructors.
+
+\cvdefCpp{
+StereoBM\_GPU::StereoBM\_GPU();\newline
+StereoBM\_GPU::StereoBM\_GPU(int preset, \par int ndisparities = DEFAULT\_NDISP, \par int winSize = DEFAULT\_WINSZ);
+}
+
+\begin{description}
+\cvarg{preset}{Camera-specific preset:}
+\begin{description}
+ \cvarg{BASIC\_PRESET}{Without preprocessing.}
+ \cvarg{PREFILTER\_XSOBEL}{Sobel prefilter.}
+\end{description}
+\cvarg{ndisparities}{Number of disparities. Must be multiple of 8 and less then 256.}
+\cvarg{winSize}{SAD window size.}
+\end{description}
+
+
+\cvfunc{cv::gpu::StereoBM\_GPU::operator ()}\label{cppfunc.gpu.StereoBM.operator()}
+The stereo correspondence operator. Finds the disparity for the specified rectified stereo pair.
+
+\cvdefCpp{
+void StereoBM\_GPU::operator() (const GpuMat\& left, const GpuMat\& right, \par GpuMat\& disparity);\newline
+void StereoBM\_GPU::operator() (const GpuMat\& left, const GpuMat\& right, \par GpuMat\& disparity, const Stream\& stream);
+}
+
+\begin{description}
+\cvarg{left}{Left image; supports only \texttt{CV\_8UC1} type.}
+\cvarg{right}{Right image with the same size and the same type as the left one.}
+\cvarg{disparity}{Output disparity map. It will be \texttt{CV\_8UC1} image with the same size as the input images.}
+\cvarg{stream}{Stream for the asynchronous version.}
+\end{description}
+
+
+\cvfunc{cv::gpu::StereoBM\_GPU::checkIfGpuCallReasonable}\label{cppfunc.gpu.StereoBM.checkIfGpuCallReasonable}
+Some heuristics that tries to estmate if current GPU will be faster then CPU in this algorithm. It queries current active device.
+
+\cvdefCpp{
+bool StereoBM\_GPU::checkIfGpuCallReasonable();
+}
+
+
+\cvclass{gpu::StereoBeliefPropagation}
+The class for computing stereo correspondence using belief propagation algorithm.
+
+\begin{lstlisting}
+class StereoBeliefPropagation
+{
+public:
+ enum { DEFAULT_NDISP = 64 };
+ enum { DEFAULT_ITERS = 5 };
+ enum { DEFAULT_LEVELS = 5 };
+
+ static void estimateRecommendedParams(int width, int height,
+ int& ndisp, int& iters, int& levels);
+
+ explicit StereoBeliefPropagation(int ndisp = DEFAULT_NDISP,
+ int iters = DEFAULT_ITERS,
+ int levels = DEFAULT_LEVELS,
+ int msg_type = CV_32F);
+ StereoBeliefPropagation(int ndisp, int iters, int levels,
+ float max_data_term, float data_weight,
+ float max_disc_term, float disc_single_jump,
+ int msg_type = CV_32F);
+
+ void operator()(const GpuMat& left, const GpuMat& right,
+ GpuMat& disparity);
+ void operator()(const GpuMat& left, const GpuMat& right,
+ GpuMat& disparity, Stream& stream);
+ void operator()(const GpuMat& data, GpuMat& disparity);
+ void operator()(const GpuMat& data, GpuMat& disparity, Stream& stream);
+
+ int ndisp;
+
+ int iters;
+ int levels;
+
+ float max_data_term;
+ float data_weight;
+ float max_disc_term;
+ float disc_single_jump;
+
+ int msg_type;
+
+ ...
+};
+\end{lstlisting}
+
+The class implements Pedro F. Felzenszwalb algorithm \cite{felzenszwalb_bp}. It can compute own data cost (using truncated linear model) or use user-provided data cost.
+
+
+\cvCppFunc{gpu::StereoBeliefPropagation::StereoBeliefPropagation}
+StereoBeliefPropagation constructors.
+
+\cvdefCpp{
+StereoBeliefPropagation::StereoBeliefPropagation(\par int ndisp = DEFAULT\_NDISP, int iters = DEFAULT\_ITERS, \par int levels = DEFAULT\_LEVELS, int msg\_type = CV\_32F);\newline
+StereoBeliefPropagation::StereoBeliefPropagation(\par int ndisp, int iters, int levels, \par float max\_data\_term, float data\_weight, \par float max\_disc\_term, float disc\_single\_jump, \par int msg\_type = CV\_32F);
+}
+
+\begin{description}
+\cvarg{ndisp}{Number of disparities.}
+\cvarg{iters}{Number of BP iterations on each level.}
+\cvarg{levels}{Number of levels.}
+\cvarg{max\_data\_term}{Truncation of data cost.}
+\cvarg{data\_weight}{Data weight.}
+\cvarg{max\_disc\_term}{Truncation of discontinuity.}
+\cvarg{disc\_single\_jump}{Discontinuity single jump.}
+\cvarg{msg\_type}{Type for messages. Supports \texttt{CV\_16SC1} and \texttt{CV\_32FC1}.}
+\end{description}
+
+\texttt{StereoBeliefPropagation} uses truncated linear model for the data cost and discontinuity term:
+\[
+DataCost = data\_weight \cdot \min(\lvert I_2-I_1 \rvert, max\_data\_term)
+\]
+\[
+DiscTerm = \min(disc\_single\_jump \cdot \lvert f_1-f_2 \rvert, max\_disc\_term)
+\]
+
+For more details please see \cite{felzenszwalb_bp}.
+
+By default \texttt{StereoBeliefPropagation} uses floating-point arithmetics and \texttt{CV\_32FC1} type for messages. But also it can use fixed-point arithmetics and \texttt{CV\_16SC1} type for messages for better perfomance.
+
+
+\cvCppFunc{gpu::StereoBeliefPropagation::estimateRecommendedParams}
+Some heuristics that tries to compute parameters (\texttt{ndisp}, \texttt{iters} and \texttt{levels}) for specified image size (\texttt{width} and \texttt{height}).
+
+\cvdefCpp{
+void StereoBeliefPropagation::estimateRecommendedParams(\par int width, int height, int\& ndisp, int\& iters, int\& levels);
+}
+
+
+\cvCppFunc{gpu::StereoBeliefPropagation::operator ()}
+The stereo correspondence operator. Finds the disparity for the specified rectified stereo pair or data cost.
+
+\cvdefCpp{
+void StereoBeliefPropagation::operator()(\par const GpuMat\& left, const GpuMat\& right, \par GpuMat\& disparity);\newline
+void StereoBeliefPropagation::operator()(\par const GpuMat\& left, const GpuMat\& right, \par GpuMat\& disparity, Stream\& stream);
+}
+
+\begin{description}
+\cvarg{left}{Left image; supports \texttt{CV\_8UC1}, \texttt{CV\_8UC3} and \texttt{CV\_8UC4} types.}
+\cvarg{right}{Right image with the same size and the same type as the left one.}
+\cvarg{disparity}{Output disparity map. If \texttt{disparity} is empty output type will be \texttt{CV\_16SC1}, otherwise output type will be \texttt{disparity.type()}.}
+\cvarg{stream}{Stream for the asynchronous version.}
+\end{description}
+
+\cvdefCpp{
+void StereoBeliefPropagation::operator()(\par const GpuMat\& data, GpuMat\& disparity);\newline
+void StereoBeliefPropagation::operator()(\par const GpuMat\& data, GpuMat\& disparity, Stream\& stream);
+}
+
+\begin{description}
+\cvarg{data}{The user specified data cost. It must have \texttt{msg\_type} type and $\texttt{imgRows} \cdot \texttt{ndisp} \times \texttt{imgCols}$ size.}
+\cvarg{disparity}{Output disparity map. If \texttt{disparity} is empty output type will be \texttt{CV\_16SC1}, otherwise output type will be \texttt{disparity.type()}.}
+\cvarg{stream}{Stream for the asynchronous version.}
+\end{description}
+
+
+\cvclass{gpu::StereoConstantSpaceBP}
+The class for computing stereo correspondence using constant space belief propagation algorithm.
+
+\begin{lstlisting}
+class StereoConstantSpaceBP
+{
+public:
+ enum { DEFAULT_NDISP = 128 };
+ enum { DEFAULT_ITERS = 8 };
+ enum { DEFAULT_LEVELS = 4 };
+ enum { DEFAULT_NR_PLANE = 4 };
+
+ static void estimateRecommendedParams(int width, int height,
+ int& ndisp, int& iters, int& levels, int& nr_plane);
+
+ explicit StereoConstantSpaceBP(int ndisp = DEFAULT_NDISP,
+ int iters = DEFAULT_ITERS,
+ int levels = DEFAULT_LEVELS,
+ int nr_plane = DEFAULT_NR_PLANE,
+ int msg_type = CV_32F);
+ StereoConstantSpaceBP(int ndisp, int iters, int levels, int nr_plane,
+ float max_data_term, float data_weight,
+ float max_disc_term, float disc_single_jump,
+ int min_disp_th = 0,
+ int msg_type = CV_32F);
+
+ void operator()(const GpuMat& left, const GpuMat& right,
+ GpuMat& disparity);
+ void operator()(const GpuMat& left, const GpuMat& right,
+ GpuMat& disparity, Stream& stream);
+
+ int ndisp;
+
+ int iters;
+ int levels;
+
+ int nr_plane;
+
+ float max_data_term;
+ float data_weight;
+ float max_disc_term;
+ float disc_single_jump;
+
+ int min_disp_th;
+
+ int msg_type;
+
+ bool use_local_init_data_cost;
+
+ ...
+};
+\end{lstlisting}
+
+The class implements Q. Yang algorithm \cite{qx_csbp}. \texttt{StereoConstantSpaceBP} can use global minimum or local minimum selection method. By default it use local minimum selection method (\texttt{use\_local\_init\_data\_cost = true}).
+
+
+\cvCppFunc{gpu::StereoConstantSpaceBP::StereoConstantSpaceBP}
+StereoConstantSpaceBP constructors.
+
+\cvdefCpp{
+StereoConstantSpaceBP::StereoConstantSpaceBP(int ndisp = DEFAULT\_NDISP, \par int iters = DEFAULT\_ITERS, int levels = DEFAULT\_LEVELS, \par int nr\_plane = DEFAULT\_NR\_PLANE, int msg\_type = CV\_32F);\newline
+StereoConstantSpaceBP::StereoConstantSpaceBP(int ndisp, int iters, \par int levels, int nr\_plane, \par float max\_data\_term, float data\_weight, \par float max\_disc\_term, float disc\_single\_jump, \par int min\_disp\_th = 0, int msg\_type = CV\_32F);
+}
+
+\begin{description}
+\cvarg{ndisp}{Number of disparities.}
+\cvarg{iters}{Number of BP iterations on each level.}
+\cvarg{levels}{Number of levels.}
+\cvarg{nr\_plane}{Number of disparity levels on the first level}
+\cvarg{max\_data\_term}{Truncation of data cost.}
+\cvarg{data\_weight}{Data weight.}
+\cvarg{max\_disc\_term}{Truncation of discontinuity.}
+\cvarg{disc\_single\_jump}{Discontinuity single jump.}
+\cvarg{min\_disp\_th}{Minimal disparity threshold.}
+\cvarg{msg\_type}{Type for messages. Supports \texttt{CV\_16SC1} and \texttt{CV\_32FC1}.}
+\end{description}
+
+\texttt{StereoConstantSpaceBP} uses truncated linear model for the data cost and discontinuity term:
+\[
+DataCost = data\_weight \cdot \min(\lvert I_2-I_1 \rvert, max\_data\_term)
+\]
+\[
+DiscTerm = \min(disc\_single\_jump \cdot \lvert f_1-f_2 \rvert, max\_disc\_term)
+\]
+
+For more details please see \cite{qx_csbp}.
+
+By default \texttt{StereoConstantSpaceBP} uses floating-point arithmetics and \texttt{CV\_32FC1} type for messages. But also it can use fixed-point arithmetics and \texttt{CV\_16SC1} type for messages for better perfomance.
+
+
+\cvCppFunc{gpu::StereoConstantSpaceBP::estimateRecommendedParams}
+Some heuristics that tries to compute parameters (\texttt{ndisp}, \texttt{iters}, \texttt{levels} and \texttt{nr\_plane}) for specified image size (\texttt{width} and \texttt{height}).
+
+\cvdefCpp{
+void StereoConstantSpaceBP::estimateRecommendedParams(\par int width, int height, \par int\& ndisp, int\& iters, int\& levels, int\& nr\_plane);
+}
+
+\cvCppFunc{gpu::StereoConstantSpaceBP::operator ()}
+The stereo correspondence operator. Finds the disparity for the specified rectified stereo pair.
+
+\cvdefCpp{
+void StereoConstantSpaceBP::operator()(\par const GpuMat\& left, const GpuMat\& right, \par GpuMat\& disparity);\newline
+void StereoConstantSpaceBP::operator()(\par const GpuMat\& left, const GpuMat\& right, \par GpuMat\& disparity, Stream\& stream);
+}
+
+\begin{description}
+\cvarg{left}{Left image; supports \texttt{CV\_8UC1}, \texttt{CV\_8UC3} and \texttt{CV\_8UC4} types.}
+\cvarg{right}{Right image with the same size and the same type as the left one.}
+\cvarg{disparity}{Output disparity map. If \texttt{disparity} is empty output type will be \texttt{CV\_16SC1}, otherwise output type will be \texttt{disparity.type()}.}
+\cvarg{stream}{Stream for the asynchronous version.}
+\end{description}
+
+
+\cvclass{gpu::DisparityBilateralFilter}
+The class for disparity map refinement using joint bilateral filtering.
+
+\begin{lstlisting}
+class CV_EXPORTS DisparityBilateralFilter
+{
+public:
+ enum { DEFAULT_NDISP = 64 };
+ enum { DEFAULT_RADIUS = 3 };
+ enum { DEFAULT_ITERS = 1 };
+
+ explicit DisparityBilateralFilter(int ndisp = DEFAULT_NDISP,
+ int radius = DEFAULT_RADIUS, int iters = DEFAULT_ITERS);
+
+ DisparityBilateralFilter(int ndisp, int radius, int iters,
+ float edge_threshold, float max_disc_threshold,
+ float sigma_range);
+
+ void operator()(const GpuMat& disparity, const GpuMat& image,
+ GpuMat& dst);
+ void operator()(const GpuMat& disparity, const GpuMat& image,
+ GpuMat& dst, Stream& stream);
+
+ ...
+};
+\end{lstlisting}
+
+The class implements disparity map refinement using joint bilateral filtering given a single color image described in \cite{qx_csbp}.
+
+
+\cvCppFunc{gpu::DisparityBilateralFilter::DisparityBilateralFilter}
+DisparityBilateralFilter constructors
+
+\cvdefCpp{
+DisparityBilateralFilter::DisparityBilateralFilter(\par int ndisp = DEFAULT\_NDISP, int radius = DEFAULT\_RADIUS, \par int iters = DEFAULT\_ITERS);\newline
+DisparityBilateralFilter::DisparityBilateralFilter(\par int ndisp, int radius, int iters, \par float edge\_threshold, float max\_disc\_threshold, \par float sigma\_range);
+}
+
+\begin{description}
+\cvarg{ndisp}{Number of disparities.}
+\cvarg{radius}{Filter radius.}
+\cvarg{iters}{Number of iterations.}
+\cvarg{edge\_threshold}{Truncation of data continuity.}
+\cvarg{max\_disc\_threshold}{Truncation of disparity continuity.}
+\cvarg{sigma\_range}{Filter range.}
+\end{description}
+
+
+\cvCppFunc{gpu::DisparityBilateralFilter::operator ()}
+Refines disparity map using joint bilateral filtering.
+
+\cvdefCpp{
+void DisparityBilateralFilter::operator()(\par const GpuMat\& disparity, const GpuMat\& image, GpuMat\& dst);\newline
+void DisparityBilateralFilter::operator()(\par const GpuMat\& disparity, const GpuMat\& image, GpuMat\& dst, \par Stream\& stream);
+}
+
+\begin{description}
+\cvarg{disparity}{Input disparity map; supports \texttt{CV\_8UC1} and \texttt{CV\_16SC1} types.}
+\cvarg{image}{Input image; supports \texttt{CV\_8UC1} and \texttt{CV\_8UC3} types.}
+\cvarg{dst}{Destination disparity map; will have the same size and type as \texttt{disparity}.}
+\cvarg{stream}{Stream for the asynchronous version.}
+\end{description}
+
+\cvCppFunc{gpu::drawColorDisp}
+Does coloring of disparity image.
+
+\cvdefCpp{
+void drawColorDisp(const GpuMat\& src\_disp, GpuMat\& dst\_disp, int ndisp);\newline
+void drawColorDisp(const GpuMat\& src\_disp, GpuMat\& dst\_disp, int ndisp, \par const Stream\& stream);
+}
+
+\begin{description}
+\cvarg{src\_disp}{Source disparity image. Supports \texttt{CV\_8UC1} and \texttt{CV\_16SC1} types.}
+\cvarg{dst\_disp}{Output disparity image. Will have the same size as \texttt{src\_disp} and \texttt{CV\_8UC4} type in \texttt{BGRA} format (alpha = 255).}
+\cvarg{ndisp}{Number of disparities.}
+\cvarg{stream}{Stream for the asynchronous version.}
+\end{description}
+
+This function converts $[0..ndisp)$ interval to $[0..240, 1, 1]$ in \texttt{HSV} color space, than convert \texttt{HSV} color space to \texttt{RGB}.
+
+
+\cvCppFunc{gpu::reprojectImageTo3D}
+Reprojects disparity image to 3D space.
+
+\cvdefCpp{
+void reprojectImageTo3D(const GpuMat\& disp, GpuMat\& xyzw, \par const Mat\& Q);\newline
+void reprojectImageTo3D(const GpuMat\& disp, GpuMat\& xyzw, \par const Mat\& Q, const Stream\& stream);
+}
+
+\begin{description}
+\cvarg{disp}{Input disparity image; supports \texttt{CV\_8U} and \texttt{CV\_16S} types.}
+\cvarg{xyzw}{Output 4-channel floating-point image of the same size as \texttt{disp}. Each element of \texttt{xyzw(x,y)} will contain the 3D coordinates \texttt{(x,y,z,1)} of the point \texttt{(x,y)}, computed from the disparity map.}
+\cvarg{Q}{$4 \times 4$ perspective transformation matrix that can be obtained via \cvCross{StereoRectify}{stereoRectify}.}
+\cvarg{stream}{Stream for the asynchronous version.}
+\end{description}
+
+See also: \cvCppCross{reprojectImageTo3D}.
-\section{Feature detection and description}\r
+\section{Feature Detection and Description}\r
+\r
\r
\cvclass{gpu::SURFParams\_GPU}\r
Various SURF algorithm parameters. \r
};\r
\end{lstlisting}\r
\r
+\r
\cvclass{gpu::SURF\_GPU}\r
Class for extracting Speeded Up Robust Features from an image.\r
\r
\r
The class \texttt{SURF\_GPU} implements Speeded Up Robust Features descriptor. There is fast multi-scale Hessian keypoint detector that can be used to find the keypoints (which is the default option), but the descriptors can be also computed for the user-specified keypoints. Supports only 8 bit grayscale images.\r
\r
-The class \texttt{SURF\_GPU} can store results to GPU and CPU memory and provides static functions to convert results between CPU and GPU version (\texttt{uploadKeypoints}, \texttt{downloadKeypoints}, \texttt{downloadDescriptors}). CPU results has the same format as \hyperref[cv.class.SURF]{cv::SURF} results. GPU results is stored to \texttt{GpuMat}. \texttt{keypoints} matrix is one row matrix with \texttt{CV\_32FC6} type. It contains 6 float values per feature: \texttt{x, y, size, response, angle, octave}. \texttt{descriptors} matrix is \texttt{nFeatures} x \texttt{descriptorSize} matrix with \texttt{CV\_32FC1} type.\r
+The class \texttt{SURF\_GPU} can store results to GPU and CPU memory and provides static functions to convert results between CPU and GPU version (\texttt{uploadKeypoints}, \texttt{downloadKeypoints}, \texttt{downloadDescriptors}). CPU results has the same format as \hyperref[cv.class.SURF]{cv::SURF} results. GPU results are stored to \texttt{GpuMat}. \texttt{keypoints} matrix is one row matrix with \texttt{CV\_32FC6} type. It contains 6 float values per feature: \texttt{x, y, size, response, angle, octave}. \texttt{descriptors} matrix is $\texttt{nFeatures} \times \texttt{descriptorSize}$ matrix with \texttt{CV\_32FC1} type.\r
\r
The class \texttt{SURF\_GPU} uses some buffers and provides access to it. All buffers can be safely released between function calls. \r
\r
+See also: \hyperref[cv.class.SURF]{cv::SURF}.\r
+\r
+\r
\cvclass{gpu::BruteForceMatcher\_GPU}\r
Brute-force descriptor matcher. For each descriptor in the first set, this matcher finds the closest descriptor in the second set by trying each one. This descriptor matcher supports masking permissible matches between descriptor sets.\r
\r
};\r
\end{lstlisting}\r
\r
-The class \texttt{BruteForceMatcher\_GPU} has the similar interface with class \hyperref[cv.class.DescriptorMatcher]{cv::DescriptorMatcher}. It has two groups of match methods: for matching descriptors of one image with other image or with image set. Also all functions have alternative: save results to GPU memory or to CPU memory. \texttt{BruteForceMatcher\_GPU} is templated on the distance metric as \hyperref[cv.class.BruteForceMatcher]{cv::BruteForceMatcher}, but supports only \texttt{L1} and \texttt{L2} distance types.\r
+The class \texttt{BruteForceMatcher\_GPU} has the similar interface to class \hyperref[cv.class.DescriptorMatcher]{cv::DescriptorMatcher}. It has two groups of match methods: for matching descriptors of one image with other image or with image set. Also all functions have alternative: save results to GPU memory or to CPU memory.\r
+\r
+\texttt{Distance} template parameter is kept for CPU/GPU interfaces similarity. \texttt{BruteForceMatcher\_GPU} supports only \texttt{L1<float>} and \texttt{L2<float>} distance types.\r
+\r
+See also: \hyperref[cv.class.DescriptorMatcher]{cv::DescriptorMatcher}, \hyperref[cv.class.BruteForceMatcher]{cv::BruteForceMatcher}.\r
+\r
+\r
+\cvfunc{cv::gpu::BruteForceMatcher\_GPU::match}\label{cppfunc.gpu.BruteForceMatcher.match}\r
+Finds the best match for each descriptor from a query set with train descriptors.\r
\r
-\cvfunc{gpu::BruteForceMatcher\_GPU::match}\label{cppfunc.gpu.BruteForceMatcher.match}\r
-Find the best match for each descriptor from a query set with train descriptors. This function is equivalent of \cvCppCross{DescriptorMatcher::match}.\r
-\cvdefCpp{\r
-void match(const GpuMat\& queryDescs, \par const GpuMat\& trainDescs, \par std::vector<DMatch>\& matches, \par const GpuMat\& mask = GpuMat());\r
-}\r
\cvdefCpp{\r
+void match(const GpuMat\& queryDescs, \par const GpuMat\& trainDescs, \par std::vector<DMatch>\& matches, \par const GpuMat\& mask = GpuMat());\newline\r
void match(const GpuMat\& queryDescs, \par std::vector<DMatch>\& matches, \par const std::vector<GpuMat>\& masks = std::vector<GpuMat>());\r
}\r
\r
-\cvfunc{gpu::BruteForceMatcher\_GPU::matchSingle}\label{cppfunc.gpu.BruteForceMatcher.matchSingle}\r
-Find one best match for each query descriptor. Results stored to GPU memory.\r
+See also: \cvCppCross{DescriptorMatcher::match}.\r
+\r
+\r
+\cvfunc{cv::gpu::BruteForceMatcher\_GPU::matchSingle}\label{cppfunc.gpu.BruteForceMatcher.matchSingle}\r
+Finds the best match for each query descriptor. Results will be stored to GPU memory.\r
+\r
\cvdefCpp{\r
void matchSingle(const GpuMat\& queryDescs, \par const GpuMat\& trainDescs, \par GpuMat\& trainIdx, \par GpuMat\& distance, \par const GpuMat\& mask = GpuMat());\r
}\r
+\r
\begin{description}\r
\cvarg{queryDescs} {Query set of descriptors.}\r
\cvarg{trainDescs} {Train set of descriptors. This will not be added to train descriptors collection stored in class object.}\r
-\cvarg{trainIdx} {One row \texttt{CV\_32SC1} matrix. Will contain best train index for each query. If some query descriptor masked out in \texttt{mask} it will contain -1.}\r
-\cvarg{distance} {One row \texttt{CV\_32FC1} matrix. Will contain best distance for each query. If some query descriptor masked out in \texttt{mask} it will contain \texttt{FLT\_MAX}.}\r
+\cvarg{trainIdx} {One row \texttt{CV\_32SC1} matrix. Will contain the best train index for each query. If some query descriptors masked out in \texttt{mask} it will contain -1.}\r
+\cvarg{distance} {One row \texttt{CV\_32FC1} matrix. Will contain the best distance for each query. If some query descriptors masked out in \texttt{mask} it will contain \texttt{FLT\_MAX}.}\r
\cvarg{mask}{Mask specifying permissible matches between input query and train matrices of descriptors.}\r
\end{description}\r
\r
-\cvfunc{gpu::BruteForceMatcher\_GPU::matchCollection}\label{cppfunc.gpu.BruteForceMatcher.matchCollection}\r
-Find one best match for each query descriptor from train collection. Results stored to GPU memory.\r
+\r
+\cvfunc{cv::gpu::BruteForceMatcher\_GPU::matchCollection}\label{cppfunc.gpu.BruteForceMatcher.matchCollection}\r
+Find the best match for each query descriptor from train collection. Results will be stored to GPU memory.\r
+\r
\cvdefCpp{\r
void matchCollection(const GpuMat\& queryDescs, \par const GpuMat\& trainCollection, \par GpuMat\& trainIdx, \par GpuMat\& imgIdx, \par GpuMat\& distance, \par const GpuMat\& maskCollection);\r
}\r
+\r
\begin{description}\r
\cvarg{queryDescs} {Query set of descriptors.}\r
-\cvarg{trainCollection} {\texttt{GpuMat} with train collection. It can be obtained from train descriptors collection that was set using \texttt{add} method by \hyperref[cppfunc.gpu.BruteForceMatcher.makeGpuCollection]{makeGpuCollection}. Or it can contain user defined collection. It must be one row matrix, each element is a \texttt{DevMem2D} that points to one train descriptors matrix (matrix must have \texttt{CV\_32FC1} type).}\r
-\cvarg{trainIdx} {One row \texttt{CV\_32SC1} matrix. Will contain best train index for each query. If some query descriptor masked out in \texttt{mask} it will contain -1.}\r
-\cvarg{imgIdx} {One row \texttt{CV\_32SC1} matrix. Will contain image train index for each query. If some query descriptor masked out in \texttt{mask} it will contain -1.}\r
-\cvarg{distance} {One row \texttt{CV\_32FC1} matrix. Will contain best distance for each query. If some query descriptor masked out in \texttt{mask} it will contain \texttt{FLT\_MAX}.}\r
-\cvarg{maskCollection}{\texttt{GpuMat} with set of masks. It can be obtained from \texttt{std::vector<GpuMat>} by \hyperref[cppfunc.gpu.BruteForceMatcher.makeGpuCollection]{makeGpuCollection}. Or it can contain user defined mask set. It must be empty matrix or one row matrix, each element is a \texttt{PtrStep} that points to one mask (must have \texttt{CV\_8UC1} type).}\r
+\cvarg{trainCollection} {\texttt{GpuMat} containing train collection. It can be obtained from train descriptors collection that was set using \texttt{add} method by \hyperref[cppfunc.gpu.BruteForceMatcher.makeGpuCollection]{makeGpuCollection}. Or it can contain user defined collection. It must be one row matrix, each element is a \texttt{DevMem2D} that points to one train descriptors matrix.}\r
+\cvarg{trainIdx} {One row \texttt{CV\_32SC1} matrix. Will contain the best train index for each query. If some query descriptors masked out in \texttt{maskCollection} it will contain -1.}\r
+\cvarg{imgIdx} {One row \texttt{CV\_32SC1} matrix. Will contain image train index for each query. If some query descriptors masked out in \texttt{maskCollection} it will contain -1.}\r
+\cvarg{distance} {One row \texttt{CV\_32FC1} matrix. Will contain the best distance for each query. If some query descriptors masked out in \texttt{maskCollection} it will contain \texttt{FLT\_MAX}.}\r
+\cvarg{maskCollection}{\texttt{GpuMat} containing set of masks. It can be obtained from \texttt{std::vector<GpuMat>} by \hyperref[cppfunc.gpu.BruteForceMatcher.makeGpuCollection]{makeGpuCollection}. Or it can contain user defined mask set. It must be empty matrix or one row matrix, each element is a \texttt{PtrStep} that points to one mask.}\r
\end{description}\r
\r
-\cvfunc{gpu::BruteForceMatcher\_GPU::makeGpuCollection}\label{cppfunc.gpu.BruteForceMatcher.makeGpuCollection}\r
-Make gpu collection of train descriptors and masks in suitable format for \hyperref[cppfunc.gpu.BruteForceMatcher.matchCollection]{matchCollection} function.\r
+\r
+\cvfunc{cv::gpu::BruteForceMatcher\_GPU::makeGpuCollection}\label{cppfunc.gpu.BruteForceMatcher.makeGpuCollection}\r
+Makes gpu collection of train descriptors and masks in suitable format for \hyperref[cppfunc.gpu.BruteForceMatcher.matchCollection]{matchCollection} function.\r
+\r
\cvdefCpp{\r
void makeGpuCollection(GpuMat\& trainCollection, \par GpuMat\& maskCollection, \par const vector<GpuMat>\& masks = std::vector<GpuMat>());\r
}\r
\r
-\cvfunc{gpu::BruteForceMatcher\_GPU::matchDownload}\label{cppfunc.gpu.BruteForceMatcher.matchDownload}\r
-Download \texttt{trainIdx}, \texttt{imgIdx} and \texttt{distance} matrices obtained by \hyperref[cppfunc.gpu.BruteForceMatcher.matchSingle]{matchSingle} or \hyperref[cppfunc.gpu.BruteForceMatcher.matchCollection]{matchCollection} to CPU vector with \hyperref[cv.class.DMatch]{cv::DMatch}.\r
-\cvdefCpp{\r
-static void matchDownload(const GpuMat\& trainIdx, \par const GpuMat\& distance, \par std::vector<DMatch>\& matches);\r
-}\r
+\r
+\cvfunc{cv::gpu::BruteForceMatcher\_GPU::matchDownload}\label{cppfunc.gpu.BruteForceMatcher.matchDownload}\r
+Downloads \texttt{trainIdx}, \texttt{imgIdx} and \texttt{distance} matrices obtained via \hyperref[cppfunc.gpu.BruteForceMatcher.matchSingle]{matchSingle} or \hyperref[cppfunc.gpu.BruteForceMatcher.matchCollection]{matchCollection} to CPU vector with \hyperref[cv.class.DMatch]{cv::DMatch}.\r
+\r
\cvdefCpp{\r
-static void matchDownload(const GpuMat\& trainIdx, \par GpuMat\& imgIdx, \par const GpuMat\& distance, \par std::vector<DMatch>\& matches);\r
+void matchDownload(const GpuMat\& trainIdx, \par const GpuMat\& distance, \par std::vector<DMatch>\& matches); \newline\r
+void matchDownload(const GpuMat\& trainIdx, \par GpuMat\& imgIdx, \par const GpuMat\& distance, \par std::vector<DMatch>\& matches);\r
}\r
\r
-\cvfunc{gpu::BruteForceMatcher\_GPU::knnMatch}\label{cppfunc.gpu.BruteForceMatcher.knnMatch}\r
-Find the k best matches for each descriptor from a query set with train descriptors. Found k (or less if not possible) matches are returned in distance increasing order. This function is equivalent of \cvCppCross{DescriptorMatcher::knnMatch}.\r
+\r
+\cvfunc{cv::gpu::BruteForceMatcher\_GPU::knnMatch}\label{cppfunc.gpu.BruteForceMatcher.knnMatch}\r
+Finds the k best matches for each descriptor from a query set with train descriptors. Found k (or less if not possible) matches are returned in distance increasing order.\r
+\r
\cvdefCpp{\r
void knnMatch(const GpuMat\& queryDescs, \par const GpuMat\& trainDescs, \par std::vector< std::vector<DMatch> >\& matches, \par int k, \par const GpuMat\& mask = GpuMat(), \par bool compactResult = false);\r
}\r
void knnMatch(const GpuMat\& queryDescs, \par std::vector< std::vector<DMatch> >\& matches, \par int k, \par const std::vector<GpuMat>\& masks = std::vector<GpuMat>(), \par bool compactResult = false );\r
}\r
\r
-\cvfunc{gpu::BruteForceMatcher\_GPU::knnMatch}\label{cppfunc.gpu.BruteForceMatcher.knnMatchSingle}\r
-Find the k best matches for each descriptor from a query set with train descriptors. Found k (or less if not possible) matches are returned in distance increasing order. Results stored to GPU memory.\r
+See also: \cvCppCross{DescriptorMatcher::knnMatch}.\r
+\r
+\r
+\cvfunc{cv::gpu::BruteForceMatcher\_GPU::knnMatch}\label{cppfunc.gpu.BruteForceMatcher.knnMatchSingle}\r
+Finds the k best matches for each descriptor from a query set with train descriptors. Found k (or less if not possible) matches are returned in distance increasing order. Results will be stored to GPU memory.\r
+\r
\cvdefCpp{\r
void knnMatch(const GpuMat\& queryDescs, \par const GpuMat\& trainDescs, \par GpuMat\& trainIdx, \par GpuMat\& distance, \par GpuMat\& allDist, \par int k, \par const GpuMat\& mask = GpuMat());\r
}\r
+\r
\begin{description}\r
\cvarg{queryDescs} {Query set of descriptors.}\r
\cvarg{trainDescs} {Train set of descriptors. This will not be added to train descriptors collection stored in class object.}\r
-\cvarg{trainIdx} {Matrix \texttt{nQueries} x \texttt{k} with type \texttt{CV\_32SC1}. \texttt{trainIdx.at<int>(queryIdx, i)} will contain index of i'th best trains. If some query descriptor masked out in \texttt{mask} it will contain -1.}\r
-\cvarg{distance} {Matrix \texttt{nQuery} x \texttt{k} with type \texttt{CV\_32FC1}. Will contain distance for each query and i'th best trains. If some query descriptor masked out in \texttt{mask} it will contain \texttt{FLT\_MAX}.}\r
-\cvarg{allDist} {Buffer to store all distances between query descriptors and train descriptors. It have size \texttt{nQuery} x \texttt{nTrain} and \texttt{CV\_32F} type. \texttt{allDist.at<float>(queryIdx, trainIdx)} will contain \texttt{FLT\_MAX}, if \texttt{trainIdx} is one from k best, otherwise it will contain distance between \texttt{queryIdx} and \texttt{trainIdx} descriptors.}\r
-\cvarg{k}{Count of best matches will be found per each query descriptor (or less if it's not possible).}\r
+\cvarg{trainIdx} {Matrix with $\texttt{nQueries} \times \texttt{k}$ size and \texttt{CV\_32SC1} type. \texttt{trainIdx.at<int>(queryIdx, i)} will contain index of the i'th best trains. If some query descriptors masked out in \texttt{mask} it will contain -1.}\r
+\cvarg{distance} {Matrix with $\texttt{nQuery} \times \texttt{k}$ and \texttt{CV\_32FC1} type. Will contain distance for each query and the i'th best trains. If some query descriptors masked out in \texttt{mask} it will contain \texttt{FLT\_MAX}.}\r
+\cvarg{allDist} {Buffer to store all distances between query descriptors and train descriptors. It will have $\texttt{nQuery} \times \texttt{nTrain}$ size and \texttt{CV\_32FC1} type. \texttt{allDist.at<float>(queryIdx, trainIdx)} will contain \texttt{FLT\_MAX}, if \texttt{trainIdx} is one from k best, otherwise it will contain distance between \texttt{queryIdx} and \texttt{trainIdx} descriptors.}\r
+\cvarg{k}{Number of the best matches will be found per each query descriptor (or less if it's not possible).}\r
\cvarg{mask}{Mask specifying permissible matches between input query and train matrices of descriptors.}\r
\end{description}\r
\r
-\cvfunc{gpu::BruteForceMatcher\_GPU::knnMatchDownload}\label{cppfunc.gpu.BruteForceMatcher.knnMatchDownload}\r
-Download \texttt{trainIdx} and \texttt{distance} matrices obtained by \hyperref[cppfunc.gpu.BruteForceMatcher.knnMatchSingle]{knnMatch} to CPU vector with \hyperref[cv.class.DMatch]{cv::DMatch}. If \texttt{compactResult} is true \texttt{matches} vector will not contain matches for fully masked out query descriptors.\r
+\r
+\cvfunc{cv::gpu::BruteForceMatcher\_GPU::knnMatchDownload}\label{cppfunc.gpu.BruteForceMatcher.knnMatchDownload}\r
+Downloads \texttt{trainIdx} and \texttt{distance} matrices obtained via \hyperref[cppfunc.gpu.BruteForceMatcher.knnMatchSingle]{knnMatch} to CPU vector with \hyperref[cv.class.DMatch]{cv::DMatch}. If \texttt{compactResult} is true \texttt{matches} vector will not contain matches for fully masked out query descriptors.\r
+\r
\cvdefCpp{\r
-static void knnMatchDownload(const GpuMat\& trainIdx, \par const GpuMat\& distance, \par std::vector< std::vector<DMatch> >\& matches, \par bool compactResult = false);\r
+void knnMatchDownload(const GpuMat\& trainIdx, \par const GpuMat\& distance, \par std::vector< std::vector<DMatch> >\& matches, \par bool compactResult = false);\r
}\r
\r
-\cvfunc{gpu::BruteForceMatcher\_GPU::radiusMatch}\label{cppfunc.gpu.BruteForceMatcher.radiusMatch}\r
-Find the best matches for each query descriptor which have distance less than given threshold. Found matches are returned in distance increasing order. This function is equivalent of \cvCppCross{DescriptorMatcher::radiusMatch}. Works only on device with Compute Capability \texttt{>=} 1.1.\r
+\r
+\cvfunc{cv::gpu::BruteForceMatcher\_GPU::radiusMatch}\label{cppfunc.gpu.BruteForceMatcher.radiusMatch}\r
+Finds the best matches for each query descriptor which have distance less than given threshold. Found matches are returned in distance increasing order.\r
+\r
\cvdefCpp{\r
void radiusMatch(const GpuMat\& queryDescs, \par const GpuMat\& trainDescs, \par std::vector< std::vector<DMatch> >\& matches, \par float maxDistance, \par const GpuMat\& mask = GpuMat(), \par bool compactResult = false);\r
}\r
void radiusMatch(const GpuMat\& queryDescs, \par std::vector< std::vector<DMatch> >\& matches, \par float maxDistance, \par const std::vector<GpuMat>\& masks = std::vector<GpuMat>(), \par bool compactResult = false);\r
}\r
\r
-\cvfunc{gpu::BruteForceMatcher\_GPU::radiusMatch}\label{cppfunc.gpu.BruteForceMatcher.radiusMatchSingle}\r
-Find the best matches for each query descriptor which have distance less than given threshold. Results stored to GPU memory. Results are not sorted by distance increasing order. Works only on device with Compute Capability \texttt{>=} 1.1.\r
+This function works only on devices with Compute Capability $>=$ 1.1.\r
+\r
+See also: \cvCppCross{DescriptorMatcher::radiusMatch}.\r
+\r
+\r
+\cvfunc{cv::gpu::BruteForceMatcher\_GPU::radiusMatch}\label{cppfunc.gpu.BruteForceMatcher.radiusMatchSingle}\r
+Finds the best matches for each query descriptor which have distance less than given threshold. Results will be stored to GPU memory.\r
+\r
\cvdefCpp{\r
void radiusMatch(const GpuMat\& queryDescs, \par const GpuMat\& trainDescs, \par GpuMat\& trainIdx, \par GpuMat\& nMatches, \par GpuMat\& distance, \par float maxDistance, \par const GpuMat\& mask = GpuMat());\r
}\r
+\r
\begin{description}\r
\cvarg{queryDescs} {Query set of descriptors.}\r
\cvarg{trainDescs} {Train set of descriptors. This will not be added to train descriptors collection stored in class object.}\r
-\cvarg{trainIdx} {\texttt{trainIdx.at<int>(queryIdx, i)} will contain i'th train index \newline\texttt{(i < min(nMatches.at<unsigned int>(0, queryIdx), trainIdx.cols)}. If \texttt{trainIdx} is empty, it will be created with size \texttt{nQuery} x \texttt{nTrain}. Or it can be allocated by user (it must have \texttt{nQuery} rows and \texttt{CV\_32SC1} type). Cols can be less than \texttt{nTrain}, but it can be that matcher won't find all matches, because it haven't enough memory to store results.}\r
+\cvarg{trainIdx} {\texttt{trainIdx.at<int>(queryIdx, i)} will contain i'th train index \newline\texttt{(i < min(nMatches.at<unsigned int>(0, queryIdx), trainIdx.cols)}. If \texttt{trainIdx} is empty, it will be created with size $\texttt{nQuery} \times \texttt{nTrain}$. Or it can be allocated by user (it must have \texttt{nQuery} rows and \texttt{CV\_32SC1} type). Cols can be less than \texttt{nTrain}, but it can be that matcher won't find all matches, because it haven't enough memory to store results.}\r
\cvarg{nMatches} {\texttt{nMatches.at<unsigned int>(0, queryIdx)} will contain matches count for \texttt{queryIdx}. Carefully, \texttt{nMatches} can be greater than \texttt{trainIdx.cols} - it means that matcher didn't find all matches, because it didn't have enough memory.}\r
-\cvarg{distance} {\texttt{distance.at<int>(queryIdx, i)} will contain i'th distance \newline\texttt{(i < min(nMatches.at<unsigned int>(0, queryIdx), trainIdx.cols)}. If \texttt{trainIdx} is empty, it will be created with size \texttt{nQuery} x \texttt{nTrain}. Otherwise it must be also allocated by user (it must have the same size as \texttt{trainIdx} and \texttt{CV\_32FC1} type).}\r
-\cvarg{maxDistance}{The threshold to found match distances.}\r
+\cvarg{distance} {\texttt{distance.at<int>(queryIdx, i)} will contain i'th distance \newline\texttt{(i < min(nMatches.at<unsigned int>(0, queryIdx), trainIdx.cols)}. If \texttt{trainIdx} is empty, it will be created with size $\texttt{nQuery} \times \texttt{nTrain}$. Otherwise it must be also allocated by user (it must have the same size as \texttt{trainIdx} and \texttt{CV\_32FC1} type).}\r
+\cvarg{maxDistance}{Distance threshold.}\r
\cvarg{mask}{Mask specifying permissible matches between input query and train matrices of descriptors.}\r
\end{description}\r
\r
-\cvfunc{gpu::BruteForceMatcher\_GPU::radiusMatchDownload}\label{cppfunc.gpu.BruteForceMatcher.radiusMatchDownload}\r
-Download \texttt{trainIdx}, \texttt{nMatches} and \texttt{distance} matrices obtained by \hyperref[cppfunc.gpu.BruteForceMatcher.radiusMatchSingle]{radiusMatch} to CPU vector with \hyperref[cv.class.DMatch]{cv::DMatch}. If \texttt{compactResult} is true \texttt{matches} vector will not contain matches for fully masked out query descriptors.\r
+In contrast to \hyperref[cppfunc.gpu.BruteForceMatcher.radiusMatch]{cv::gpu::BruteForceMather\_GPU::radiusMatch} results are not sorted by distance increasing order.\r
+\r
+This function works only on devices with Compute Capability $>=$ 1.1.\r
+\r
+\cvfunc{cv::gpu::BruteForceMatcher\_GPU::radiusMatchDownload}\label{cppfunc.gpu.BruteForceMatcher.radiusMatchDownload}\r
+Downloads \texttt{trainIdx}, \texttt{nMatches} and \texttt{distance} matrices obtained via \hyperref[cppfunc.gpu.BruteForceMatcher.radiusMatchSingle]{radiusMatch} to CPU vector with \hyperref[cv.class.DMatch]{cv::DMatch}. If \texttt{compactResult} is true \texttt{matches} vector will not contain matches for fully masked out query descriptors.\r
+\r
\cvdefCpp{\r
-static void radiusMatchDownload(const GpuMat\& trainIdx, \par const GpuMat\& nMatches, \par const GpuMat\& distance, \par std::vector< std::vector<DMatch> >\& matches, \par bool compactResult = false);\r
+void radiusMatchDownload(const GpuMat\& trainIdx, \par const GpuMat\& nMatches, \par const GpuMat\& distance, \par std::vector< std::vector<DMatch> >\& matches, \par bool compactResult = false);\r
}\r
\r
See also: \hyperref[section.cpp.cpu.ImageFiltering]{Image Filtering}\r
\r
+\r
\cvclass{gpu::BaseRowFilter\_GPU}\label{class.gpu.BaseRowFilter}\r
-The base class for linear or non-linear filters that process rows of 2D arrays. Such filters are used for the "horizontal" filtering parts in separable filters.\r
+The base class for linear or non-linear filters that processes rows of 2D arrays. Such filters are used for the "horizontal" filtering passes in separable filters.\r
\r
\begin{lstlisting}\r
class BaseRowFilter_GPU\r
};\r
\end{lstlisting}\r
\r
+\r
\cvclass{gpu::BaseColumnFilter\_GPU}\label{class.gpu.BaseColumnFilter}\r
-The base class for linear or non-linear filters that process columns of 2D arrays. Such filters are used for the "vertical" filtering parts in separable filters.\r
+The base class for linear or non-linear filters that processes columns of 2D arrays. Such filters are used for the "vertical" filtering passes in separable filters.\r
\r
\begin{lstlisting}\r
class BaseColumnFilter_GPU\r
};\r
\end{lstlisting}\r
\r
+\r
\cvclass{gpu::BaseFilter\_GPU}\label{class.gpu.BaseFilter}\r
The base class for non-separable 2D filters. \r
\r
};\r
\end{lstlisting}\r
\r
+\r
\cvclass{gpu::FilterEngine\_GPU}\label{class.gpu.FilterEngine}\r
The base class for Filter Engine.\r
\r
\r
The class can be used to apply an arbitrary filtering operation to an image. It contains all the necessary intermediate buffers. Pointers to the initialized \texttt{FilterEngine\_GPU} instances are returned by various \texttt{create*Filter\_GPU} functions, see below, and they are used inside high-level functions such as \cvCppCross{gpu::filter2D}, \cvCppCross{gpu::erode}, \cvCppCross{gpu::Sobel} etc.\r
\r
-By using \texttt{FilterEngine\_GPU} instead functions you can avoid unnessesary memory allocation for intermediate buffers and get much better performance:\r
+By using \texttt{FilterEngine\_GPU} instead of functions you can avoid unnecessary memory allocation for intermediate buffers and get much better performance:\r
\r
\begin{lstlisting}\r
while (...)\r
\r
The GPU filters doesn't support the in-place mode.\r
\r
-See also: \hyperref[class.gpu.BaseRowFilter]{BaseRowFilter\_GPU}, \hyperref[class.gpu.BaseColumnFilter]{BaseColumnFilter\_GPU}, \hyperref[class.gpu.BaseFilter]{BaseFilter\_GPU}, \hyperref[cppfunc.gpu.createFilter2D]{createFilter2D\_GPU}, \hyperref[cppfunc.gpu.createSeparableFilter]{createSeparableFilter\_GPU}, \hyperref[cppfunc.gpu.createBoxFilter]{createBoxFilter\_GPU}, \hyperref[cppfunc.gpu.createMorphologyFilter]{createMorphologyFilter\_GPU}, \hyperref[cppfunc.gpu.createLinearFilter]{createLinearFilter\_GPU}, \hyperref[cppfunc.gpu.createSeparableLinearFilter]{createSeparableLinearFilter\_GPU}, \hyperref[cppfunc.gpu.createDerivFilter]{createDerivFilter\_GPU}, \hyperref[cppfunc.gpu.createGaussianFilter]{createGaussianFilter\_GPU}\r
+See also: \hyperref[class.gpu.BaseRowFilter]{cv::gpu::BaseRowFilter\_GPU}, \hyperref[class.gpu.BaseColumnFilter]{cv::gpu::BaseColumnFilter\_GPU}, \hyperref[class.gpu.BaseFilter]{cv::gpu::BaseFilter\_GPU}, \hyperref[cppfunc.gpu.createFilter2D]{cv::gpu::createFilter2D\_GPU}, \hyperref[cppfunc.gpu.createSeparableFilter]{cv::gpu::createSeparableFilter\_GPU}, \hyperref[cppfunc.gpu.createBoxFilter]{cv::gpu::createBoxFilter\_GPU}, \hyperref[cppfunc.gpu.createMorphologyFilter]{cv::gpu::createMorphologyFilter\_GPU}, \hyperref[cppfunc.gpu.createLinearFilter]{cv::gpu::createLinearFilter\_GPU}, \hyperref[cppfunc.gpu.createSeparableLinearFilter]{cv::gpu::createSeparableLinearFilter\_GPU}, \hyperref[cppfunc.gpu.createDerivFilter]{cv::gpu::createDerivFilter\_GPU}, \hyperref[cppfunc.gpu.createGaussianFilter]{cv::gpu::createGaussianFilter\_GPU}\r
+\r
+\r
+\cvfunc{cv::gpu::createFilter2D\_GPU}\label{cppfunc.gpu.createFilter2D}\r
+Creates non-separable filter engine with the specified filter.\r
\r
-\cvfunc{gpu::createFilter2D\_GPU}\label{cppfunc.gpu.createFilter2D}\r
-Create the non-separable filter engine with the specified filter.\r
\cvdefCpp{\r
Ptr<FilterEngine\_GPU> createFilter2D\_GPU(\par const Ptr<BaseFilter\_GPU>\& filter2D, \par int srcType, int dstType);\r
}\r
+\r
\begin{description}\r
-\cvarg{filter2D} {The non separable 2D filter.}\r
-\cvarg{srcType}{The input image type. It must be supported by \texttt{filter2D}.}\r
-\cvarg{dstType}{The output image type. It must be supported by \texttt{filter2D}.}\r
+\cvarg{filter2D} {Non-separable 2D filter.}\r
+\cvarg{srcType}{Input image type. It must be supported by \texttt{filter2D}.}\r
+\cvarg{dstType}{Output image type. It must be supported by \texttt{filter2D}.}\r
\end{description}\r
-Usually this function is used inside high-level functions, like \hyperref[cppfunc.gpu.createLinearFilter]{createLinearFilter\_GPU}, \hyperref[cppfunc.gpu.createBoxFilter]{createBoxFilter\_GPU}.\r
\r
-\cvfunc{gpu::createSeparableFilter\_GPU}\label{cppfunc.gpu.createSeparableFilter}\r
-Create the separable filter engine with the specified filters.\r
+Usually this function is used inside high-level functions, like \hyperref[cppfunc.gpu.createLinearFilter]{cv::gpu::createLinearFilter\_GPU}, \hyperref[cppfunc.gpu.createBoxFilter]{cv::gpu::createBoxFilter\_GPU}.\r
+\r
+\r
+\cvfunc{cv::gpu::createSeparableFilter\_GPU}\label{cppfunc.gpu.createSeparableFilter}\r
+Creates separable filter engine with the specified filters.\r
+\r
\cvdefCpp{\r
Ptr<FilterEngine\_GPU> createSeparableFilter\_GPU(\par const Ptr<BaseRowFilter\_GPU>\& rowFilter, \par const Ptr<BaseColumnFilter\_GPU>\& columnFilter, \par int srcType, int bufType, int dstType);\r
}\r
+\r
\begin{description}\r
-\cvarg{rowFilter} {The "horizontal" 1D filter.}\r
-\cvarg{columnFilter} {The "vertical" 1D filter.}\r
-\cvarg{srcType}{The input image type. It must be supported by \texttt{rowFilter}.}\r
-\cvarg{bufType}{The buffer image type. It must be supported by \texttt{rowFilter} and \texttt{columnFilter}.}\r
-\cvarg{dstType}{The output image type. It must be supported by \texttt{columnFilter}.}\r
+\cvarg{rowFilter} {"Horizontal" 1D filter.}\r
+\cvarg{columnFilter} {"Vertical" 1D filter.}\r
+\cvarg{srcType}{Input image type. It must be supported by \texttt{rowFilter}.}\r
+\cvarg{bufType}{Buffer image type. It must be supported by \texttt{rowFilter} and \texttt{columnFilter}.}\r
+\cvarg{dstType}{Output image type. It must be supported by \texttt{columnFilter}.}\r
\end{description}\r
-Usually this function is used inside high-level functions, like \hyperref[cppfunc.gpu.createSeparableLinearFilter]{createSeparableLinearFilter\_GPU}.\r
\r
-\cvfunc{gpu::getRowSumFilter\_GPU}\label{cppfunc.gpu.getRowSumFilter}\r
-Create horizontal 1D box filter.\r
+Usually this function is used inside high-level functions, like \hyperref[cppfunc.gpu.createSeparableLinearFilter]{cv::gpu::createSeparableLinearFilter\_GPU}.\r
+\r
+\r
+\cvfunc{cv::gpu::getRowSumFilter\_GPU}\label{cppfunc.gpu.getRowSumFilter}\r
+Creates horizontal 1D box filter.\r
+\r
\cvdefCpp{\r
Ptr<BaseRowFilter\_GPU> getRowSumFilter\_GPU(int srcType, int sumType, \par int ksize, int anchor = -1);\r
}\r
+\r
\begin{description}\r
-\cvarg{srcType}{The input image type. Now support only \texttt{CV\_8UC1}.}\r
-\cvarg{sumType}{The output image type. Now support only \texttt{CV\_32FC1}.}\r
-\cvarg{ksize}{The kernel size.}\r
-\cvarg{anchor}{The anchor point. The default value (-1) means that the anchor is at the kernel center.}\r
+\cvarg{srcType}{Input image type. Only \texttt{CV\_8UC1} type is supported for now.}\r
+\cvarg{sumType}{Output image type. Only \texttt{CV\_32FC1} type is supported for now.}\r
+\cvarg{ksize}{Kernel size.}\r
+\cvarg{anchor}{Anchor point. The default value (-1) means that the anchor is at the kernel center.}\r
\end{description}\r
+\r
This filter doesn't check indexes outside the image, so it can process only inner area. \r
\r
-\cvfunc{gpu::getColumnSumFilter\_GPU}\label{cppfunc.gpu.getColumnSumFilter}\r
-Create vertical 1D box filter.\r
+\r
+\cvfunc{cv::gpu::getColumnSumFilter\_GPU}\label{cppfunc.gpu.getColumnSumFilter}\r
+Creates vertical 1D box filter.\r
+\r
\cvdefCpp{\r
Ptr<BaseColumnFilter\_GPU> getColumnSumFilter\_GPU(int sumType, \par int dstType, int ksize, int anchor = -1);\r
}\r
+\r
\begin{description}\r
-\cvarg{sumType}{The input image type. Now support only \texttt{CV\_8UC1}.}\r
-\cvarg{dstType}{The output image type. Now support only \texttt{CV\_32FC1}.}\r
-\cvarg{ksize}{The kernel size.}\r
-\cvarg{anchor}{The anchor point. The default value (-1) means that the anchor is at the kernel center.}\r
+\cvarg{sumType}{Input image type. Only \texttt{CV\_8UC1} type is supported for now.}\r
+\cvarg{dstType}{Output image type. Only \texttt{CV\_32FC1} type is supported for now.}\r
+\cvarg{ksize}{Kernel size.}\r
+\cvarg{anchor}{Anchor point. The default value (-1) means that the anchor is at the kernel center.}\r
\end{description}\r
+\r
This filter doesn't check indexes outside the image, so it can process only inner area. \r
\r
-\cvfunc{gpu::createBoxFilter\_GPU}\label{cppfunc.gpu.createBoxFilter}\r
-Create normalized 2D box filter.\r
+\r
+\cvfunc{cv::gpu::createBoxFilter\_GPU}\label{cppfunc.gpu.createBoxFilter}\r
+Creates normalized 2D box filter.\r
+\r
\cvdefCpp{\r
Ptr<FilterEngine\_GPU> createBoxFilter\_GPU(int srcType, int dstType, \par const Size\& ksize, \par const Point\& anchor = Point(-1,-1));\r
}\r
\cvdefCpp{\r
Ptr<BaseFilter\_GPU> getBoxFilter\_GPU(int srcType, int dstType, \par const Size\& ksize, \par Point anchor = Point(-1, -1));\r
}\r
+\r
\begin{description}\r
-\cvarg{srcType}{The input image type. Now support \texttt{CV\_8UC1} and \texttt{CV\_8UC4}.}\r
-\cvarg{dstType}{The output image type. Now support only the same as source type.}\r
-\cvarg{ksize}{The kernel size.}\r
-\cvarg{anchor}{The anchor point. The default value Point(-1, -1) means that the anchor is at the kernel center.}\r
+\cvarg{srcType}{Input image type. Supports \texttt{CV\_8UC1} and \texttt{CV\_8UC4}.}\r
+\cvarg{dstType}{Output image type. Supports only the same as source type.}\r
+\cvarg{ksize}{Kernel size.}\r
+\cvarg{anchor}{Anchor point. The default value Point(-1, -1) means that the anchor is at the kernel center.}\r
\end{description}\r
-This filter doesn't check indexes outside the image, so it can process only inner area.\newline\r
+\r
+This filter doesn't check indexes outside the image, so it can process only inner area.\r
+\r
See also: \cvCppCross{boxFilter}.\r
\r
+\r
\cvCppFunc{gpu::boxFilter}\r
Smooths the image using the normalized box filter.\r
+\r
\cvdefCpp{\r
-void boxFilter(const GpuMat\& src, GpuMat\& dst, int ddepth, Size ksize, \par Point anchor = Point(-1,-1)); \r
+void boxFilter(const GpuMat\& src, GpuMat\& dst, int ddepth, Size ksize, \par Point anchor = Point(-1,-1));\r
}\r
+\r
\begin{description}\r
-\cvarg{src}{The input image. Now support \texttt{CV\_8UC1} and \texttt{CV\_8UC4} source type.}\r
-\cvarg{dst}{The output image type. Will have the same size and the same type as \texttt{src}.}\r
-\cvarg{ddepth}{The output image depth. Now support only the same as source depth (\texttt{CV\_8U}) or -1 what means use source depth.}\r
-\cvarg{ksize}{The kernel size.}\r
-\cvarg{anchor}{The anchor point. The default value Point(-1, -1) means that the anchor is at the kernel center.}\r
+\cvarg{src}{Input image. Supports \texttt{CV\_8UC1} and \texttt{CV\_8UC4} source types.}\r
+\cvarg{dst}{Output image type. Will have the same size and the same type as \texttt{src}.}\r
+\cvarg{ddepth}{Output image depth. Support only the same as source depth (\texttt{CV\_8U}) or -1 what means use source depth.}\r
+\cvarg{ksize}{Kernel size.}\r
+\cvarg{anchor}{Anchor point. The default value Point(-1, -1) means that the anchor is at the kernel center.}\r
\end{description}\r
-This filter doesn't check indexes outside the image, so it can process only inner area.\newline\r
-See also: \cvCppCross{boxFilter}, \hyperref[cppfunc.gpu.createBoxFilter]{createBoxFilter\_GPU}.\r
+\r
+This filter doesn't check indexes outside the image, so it can process only inner area.\r
+\r
+See also: \cvCppCross{boxFilter}, \hyperref[cppfunc.gpu.createBoxFilter]{cv::gpu::createBoxFilter\_GPU}.\r
+\r
\r
\cvCppFunc{gpu::blur}\r
A synonym for normalized box filter.\r
+\r
\cvdefCpp{\r
void blur(const GpuMat\& src, GpuMat\& dst, Size ksize, \par Point anchor = Point(-1,-1));\r
}\r
+\r
\begin{description}\r
-\cvarg{src}{The input image. Now support \texttt{CV\_8UC1} and \texttt{CV\_8UC4} source type.}\r
-\cvarg{dst}{The output image type. Will have the same size and the same type as \texttt{src}.}\r
-\cvarg{ksize}{The kernel size.}\r
-\cvarg{anchor}{The anchor point. The default value Point(-1, -1) means that the anchor is at the kernel center.}\r
+\cvarg{src}{Input image. Supports \texttt{CV\_8UC1} and \texttt{CV\_8UC4} source type.}\r
+\cvarg{dst}{Output image type. Will have the same size and the same type as \texttt{src}.}\r
+\cvarg{ksize}{Kernel size.}\r
+\cvarg{anchor}{Anchor point. The default value Point(-1, -1) means that the anchor is at the kernel center.}\r
\end{description}\r
-This filter doesn't check indexes outside the image, so it can process only inner area.\newline\r
+\r
+This filter doesn't check indexes outside the image, so it can process only inner area.\r
+\r
See also: \cvCppCross{blur}, \cvCppCross{gpu::boxFilter}.\r
\r
-\cvfunc{gpu::createMorphologyFilter\_GPU}\label{cppfunc.gpu.createMorphologyFilter}\r
-Create 2D morphological filter.\r
+\r
+\cvfunc{cv::gpu::createMorphologyFilter\_GPU}\label{cppfunc.gpu.createMorphologyFilter}\r
+Creates 2D morphological filter.\r
+\r
\cvdefCpp{\r
Ptr<FilterEngine\_GPU> createMorphologyFilter\_GPU(int op, int type, \par const Mat\& kernel, \par const Point\& anchor = Point(-1,-1), \par int iterations = 1);\r
}\r
\cvdefCpp{\r
Ptr<BaseFilter\_GPU> getMorphologyFilter\_GPU(int op, int type, \par const Mat\& kernel, const Size\& ksize, \par Point anchor=Point(-1,-1));\r
}\r
+\r
\begin{description}\r
-\cvarg{op} {The morphology operation id. Only \texttt{MORPH\_ERODE} and \texttt{MORPH\_DILATE} are supported.}\r
-\cvarg{type}{The input/output image type. Only \texttt{CV\_8UC1} and \texttt{CV\_8UC4} are supported.}\r
-\cvarg{kernel}{The 2D 8-bit structuring element for the morphological operation.}\r
-\cvarg{size}{The horizontal or vertical structuring element size for separable morphological operations}\r
-\cvarg{anchor}{The anchor position within the structuring element; negative values mean that the anchor is at the center}\r
+\cvarg{op} {Morphology operation id. Only \texttt{MORPH\_ERODE} and \texttt{MORPH\_DILATE} are supported.}\r
+\cvarg{type}{Input/output image type. Only \texttt{CV\_8UC1} and \texttt{CV\_8UC4} are supported.}\r
+\cvarg{kernel}{2D 8-bit structuring element for the morphological operation.}\r
+\cvarg{size}{Horizontal or vertical structuring element size for separable morphological operations.}\r
+\cvarg{anchor}{Anchor position within the structuring element; negative values mean that the anchor is at the center.}\r
\end{description}\r
-This filter doesn't check indexes outside the image, so it can process only inner area.\newline\r
+\r
+This filter doesn't check indexes outside the image, so it can process only inner area.\r
+\r
See also: \cvCppCross{createMorphologyFilter}.\r
\r
+\r
\cvCppFunc{gpu::erode}\r
Erodes an image by using a specific structuring element.\r
+\r
\cvdefCpp{\r
void erode(const GpuMat\& src, GpuMat\& dst, const Mat\& kernel, \par Point anchor = Point(-1, -1), \par int iterations = 1);\r
}\r
+\r
\begin{description}\r
-\cvarg{src}{The source image. Only \texttt{CV\_8UC1} and \texttt{CV\_8UC4} are supported.}\r
-\cvarg{dst}{The destination image. It will have the same size and the same type as \texttt{src}}\r
-\cvarg{kernel}{The structuring element used for dilation. If \texttt{kernel=Mat()}, a $3\times 3$ rectangular structuring element is used.}\r
+\cvarg{src}{Source image. Only \texttt{CV\_8UC1} and \texttt{CV\_8UC4} types are supported.}\r
+\cvarg{dst}{Destination image. It will have the same size and the same type as \texttt{src}.}\r
+\cvarg{kernel}{Structuring element used for dilation. If \texttt{kernel=Mat()}, a $3 \times 3$ rectangular structuring element is used.}\r
\cvarg{anchor}{Position of the anchor within the element. The default value $(-1, -1)$ means that the anchor is at the element center.}\r
-\cvarg{iterations}{The number of times erosion is applied.}\r
+\cvarg{iterations}{Number of times erosion to be applied.}\r
\end{description}\r
-This filter doesn't check indexes outside the image, so it can process only inner area.\newline\r
-See also: \cvCppCross{erode}, \hyperref[cppfunc.gpu.createMorphologyFilter]{createMorphologyFilter\_GPU}.\r
+\r
+This filter doesn't check indexes outside the image, so it can process only inner area.\r
+\r
+See also: \cvCppCross{erode}, \hyperref[cppfunc.gpu.createMorphologyFilter]{cv::gpu::createMorphologyFilter\_GPU}.\r
+\r
\r
\cvCppFunc{gpu::dilate}\r
Dilates an image by using a specific structuring element.\r
+\r
\cvdefCpp{\r
void dilate(const GpuMat\& src, GpuMat\& dst, const Mat\& kernel, \par Point anchor = Point(-1, -1), \par int iterations = 1);\r
}\r
+\r
\begin{description}\r
-\cvarg{src}{The source image. Supports \texttt{CV\_8UC1} and \texttt{CV\_8UC4} source type.}\r
-\cvarg{dst}{The destination image. It will have the same size and the same type as \texttt{src}}\r
-\cvarg{kernel}{The structuring element used for dilation. If \texttt{kernel=Mat()}, a $3\times 3$ rectangular structuring element is used.}\r
+\cvarg{src}{Source image. Supports \texttt{CV\_8UC1} and \texttt{CV\_8UC4} source types.}\r
+\cvarg{dst}{Destination image. It will have the same size and the same type as \texttt{src}.}\r
+\cvarg{kernel}{Structuring element used for dilation. If \texttt{kernel=Mat()}, a $3 \times 3$ rectangular structuring element is used.}\r
\cvarg{anchor}{Position of the anchor within the element. The default value $(-1, -1)$ means that the anchor is at the element center.}\r
-\cvarg{iterations}{The number of times dilation is applied.}\r
+\cvarg{iterations}{Number of times dilation to be applied.}\r
\end{description}\r
-This filter doesn't check indexes outside the image, so it can process only inner area.\newline\r
-See also: \cvCppCross{dilate}, \hyperref[cppfunc.gpu.createMorphologyFilter]{createMorphologyFilter\_GPU}.\r
+\r
+This filter doesn't check indexes outside the image, so it can process only inner area.\r
+\r
+See also: \cvCppCross{dilate}, \hyperref[cppfunc.gpu.createMorphologyFilter]{cv::gpu::createMorphologyFilter\_GPU}.\r
+\r
\r
\cvCppFunc{gpu::morphologyEx}\r
-Applies an advanced morphological operation to the image.\r
+Applies an advanced morphological operation to image.\r
+\r
\cvdefCpp{\r
void morphologyEx(const GpuMat\& src, GpuMat\& dst, int op, \par const Mat\& kernel, \par Point anchor = Point(-1, -1), \par int iterations = 1);\r
}\r
+\r
\begin{description}\r
\cvarg{src}{Source image. Supports \texttt{CV\_8UC1} and \texttt{CV\_8UC4} source type.}\r
\cvarg{dst}{Destination image. It will have the same size and the same type as \texttt{src}}\r
\end{description}}\r
\cvarg{kernel}{Structuring element.}\r
\cvarg{anchor}{Position of the anchor within the element. The default value Point(-1, -1) means that the anchor is at the element center.}\r
-\cvarg{iterations}{Number of times erosion and dilation are applied.}\r
+\cvarg{iterations}{Number of times erosion and dilation to be applied.}\r
\end{description}\r
-This filter doesn't check indexes outside the image, so it can process only inner area.\newline\r
+\r
+This filter doesn't check indexes outside the image, so it can process only inner area.\r
+\r
See also: \cvCppCross{morphologyEx}.\r
\r
-\cvfunc{gpu::createLinearFilter\_GPU}\label{cppfunc.gpu.createLinearFilter}\r
-Create the non-separable linear filter.\r
+\r
+\cvfunc{cv::gpu::createLinearFilter\_GPU}\label{cppfunc.gpu.createLinearFilter}\r
+Creates the non-separable linear filter.\r
+\r
\cvdefCpp{\r
Ptr<FilterEngine\_GPU> createLinearFilter\_GPU(int srcType, int dstType, \par const Mat\& kernel, \par const Point\& anchor = Point(-1,-1));\r
}\r
\cvdefCpp{\r
Ptr<BaseFilter\_GPU> getLinearFilter\_GPU(int srcType, int dstType, \par const Mat\& kernel, const Size\& ksize, \par Point anchor = Point(-1, -1));\r
}\r
+\r
\begin{description}\r
-\cvarg{srcType}{The input image type. Now support \texttt{CV\_8UC1} and \texttt{CV\_8UC4}.}\r
-\cvarg{dstType}{The output image type. Now support only the same as source type.}\r
-\cvarg{kernel}{The 2D array of filter coefficients. This filter works with integers kernels, if \texttt{kernel} has \texttt{float} or \texttt{double} type it will be used fixed point arithmetic.}\r
-\cvarg{ksize}{The kernel size.}\r
-\cvarg{anchor}{The anchor point. The default value Point(-1, -1) means that the anchor is at the kernel center.}\r
+\cvarg{srcType}{Input image type. Supports \texttt{CV\_8UC1} and \texttt{CV\_8UC4}.}\r
+\cvarg{dstType}{Output image type. Supports only the same as source type.}\r
+\cvarg{kernel}{2D array of filter coefficients. This filter works with integers kernels, if \texttt{kernel} has \texttt{float} or \texttt{double} type it will be used fixed point arithmetic.}\r
+\cvarg{ksize}{Kernel size.}\r
+\cvarg{anchor}{Anchor point. The default value Point(-1, -1) means that the anchor is at the kernel center.}\r
\end{description}\r
-This filter doesn't check indexes outside the image, so it can process only inner area.\newline\r
+\r
+This filter doesn't check indexes outside the image, so it can process only inner area.\r
+\r
See also: \cvCppCross{createLinearFilter}.\r
\r
+\r
\cvCppFunc{gpu::filter2D}\r
-Applies non-separable 2D linear filter to the image.\r
+Applies non-separable 2D linear filter to image.\r
+\r
\cvdefCpp{\r
void filter2D(const GpuMat\& src, GpuMat\& dst, int ddepth, \par const Mat\& kernel, \par Point anchor=Point(-1,-1));\r
}\r
+\r
\begin{description}\r
-\cvarg{src}{The source image. Supports \texttt{CV\_8UC1} and \texttt{CV\_8UC4} source type.}\r
-\cvarg{dst}{The destination image. It will have the same size and the same number of channels as \texttt{src}}\r
-\cvarg{ddepth}{The desired depth of the destination image. If it is negative, it will be the same as \texttt{src.depth()}. Now support only the same depth as source image.}\r
-\cvarg{kernel}{The 2D array of filter coefficients. This filter works with integers kernels, if \texttt{kernel} has \texttt{float} or \texttt{double} type it will use fixed point arithmetic.}\r
-\cvarg{anchor}{The anchor of the kernel that indicates the relative position of a filtered point within the kernel. The anchor should lie within the kernel. The special default value (-1,-1) means that the anchor is at the kernel center.}\r
+\cvarg{src}{Source image. Supports \texttt{CV\_8UC1} and \texttt{CV\_8UC4} source types.}\r
+\cvarg{dst}{Destination image. It will have the same size and the same number of channels as \texttt{src}.}\r
+\cvarg{ddepth}{The desired depth of the destination image. If it is negative, it will be the same as \texttt{src.depth()}. Supports only the same depth as source image.}\r
+\cvarg{kernel}{2D array of filter coefficients. This filter works with integers kernels, if \texttt{kernel} has \texttt{float} or \texttt{double} type it will use fixed point arithmetic.}\r
+\cvarg{anchor}{Anchor of the kernel that indicates the relative position of a filtered point within the kernel. The anchor should lie within the kernel. The special default value (-1,-1) means that the anchor is at the kernel center.}\r
\end{description}\r
-This filter doesn't check indexes outside the image, so it can process only inner area.\newline\r
-See also: \cvCppCross{filter2D}, \hyperref[cppfunc.gpu.createLinearFilter]{createLinearFilter\_GPU}.\r
+\r
+This filter doesn't check indexes outside the image, so it can process only inner area.\r
+\r
+See also: \cvCppCross{filter2D}, \hyperref[cppfunc.gpu.createLinearFilter]{cv::gpu::createLinearFilter\_GPU}.\r
+\r
\r
\cvCppFunc{gpu::Laplacian}\r
-Applies Laplacian operator to the image.\r
+Applies Laplacian operator to image.\r
+\r
\cvdefCpp{\r
void Laplacian(const GpuMat\& src, GpuMat\& dst, int ddepth, \par int ksize = 1, double scale = 1);\r
}\r
+\r
\begin{description}\r
-\cvarg{src}{Source image. Supports \texttt{CV\_8UC1} and \texttt{CV\_8UC4} source type.}\r
+\cvarg{src}{Source image. Supports \texttt{CV\_8UC1} and \texttt{CV\_8UC4} source types.}\r
\cvarg{dst}{Destination image; will have the same size and the same number of channels as \texttt{src}.}\r
-\cvarg{ddepth}{The desired depth of the destination image. Now support only tha same depth as source image.}\r
-\cvarg{ksize}{The aperture size used to compute the second-derivative filters, see \cvCppCross{getDerivKernels}. It must be positive and odd. Now supports only \texttt{ksize} = 1 and \texttt{ksize} = 3.}\r
-\cvarg{scale}{The optional scale factor for the computed Laplacian values (by default, no scaling is applied, see \cvCppCross{getDerivKernels}).}\r
+\cvarg{ddepth}{Desired depth of the destination image. Supports only tha same depth as source image depth.}\r
+\cvarg{ksize}{Aperture size used to compute the second-derivative filters, see \cvCppCross{getDerivKernels}. It must be positive and odd. Supports only \texttt{ksize} = 1 and \texttt{ksize} = 3.}\r
+\cvarg{scale}{Optional scale factor for the computed Laplacian values (by default, no scaling is applied, see \cvCppCross{getDerivKernels}).}\r
\end{description}\r
-This filter doesn't check indexes outside the image, so it can process only inner area.\newline\r
+\r
+This filter doesn't check indexes outside the image, so it can process only inner area.\r
+\r
See also: \cvCppCross{Laplacian}, \cvCppCross{gpu::filter2D}.\r
\r
-\cvfunc{gpu::getLinearRowFilter\_GPU}\label{cppfunc.gpu.getLinearRowFilter}\r
-Create the primitive row filter with the specified kernel.\r
+\r
+\cvfunc{cv::gpu::getLinearRowFilter\_GPU}\label{cppfunc.gpu.getLinearRowFilter}\r
+Creates primitive row filter with the specified kernel.\r
+\r
\cvdefCpp{\r
Ptr<BaseRowFilter\_GPU> getLinearRowFilter\_GPU(int srcType, \par int bufType, const Mat\& rowKernel, int anchor = -1, \par int borderType = BORDER\_CONSTANT);\r
}\r
+\r
\begin{description}\r
-\cvarg{srcType}{The source array type. Supports only \texttt{CV\_8UC1}, \texttt{CV\_8UC4}, \texttt{CV\_16SC1}, \texttt{CV\_16SC2}, \texttt{CV\_32SC1}, \texttt{CV\_32FC1} source type.}\r
-\cvarg{bufType}{The inermediate buffer type; must have as many channels as \texttt{srcType}.}\r
-\cvarg{rowKernel}{The coefficients for filtering each row.}\r
-\cvarg{anchor}{The anchor position within the kernel; negative values mean that anchor is positioned at the aperture center.}\r
-\cvarg{borderType}{The pixel extrapolation methods; see \cvCppCross{borderInterpolate}. About limitation see below.}\r
+\cvarg{srcType}{Source array type. Supports only \texttt{CV\_8UC1}, \texttt{CV\_8UC4}, \texttt{CV\_16SC1}, \texttt{CV\_16SC2}, \texttt{CV\_32SC1}, \texttt{CV\_32FC1} source types.}\r
+\cvarg{bufType}{Inermediate buffer type; must have as many channels as \texttt{srcType}.}\r
+\cvarg{rowKernel}{Filter coefficients.}\r
+\cvarg{anchor}{Anchor position within the kernel; negative values mean that anchor is positioned at the aperture center.}\r
+\cvarg{borderType}{Pixel extrapolation method; see \cvCppCross{borderInterpolate}. About limitation see below.}\r
\end{description}\r
-There are two version of algorithm: NPP and OpenCV. NPP calls when \texttt{srcType == CV\_8UC1} or \texttt{srcType == CV\_8UC4} and \texttt{bufType == srcType}, otherwise calls OpenCV version. NPP supports only \texttt{BORDER\_CONSTANT} border type and doesn't check indexes outside image. OpenCV version supports only \texttt{CV\_32F} as buffer depth and \texttt{BORDER\_REFLECT101}, \texttt{BORDER\_REPLICATE} and \texttt{BORDER\_CONSTANT} border types and checks indexes outside image.\newline\r
-See also: \hyperref[cppfunc.gpu.getLinearColumnFilter]{getLinearColumnFilter\_GPU}, \cvCppCross{createSeparableLinearFilter}.\r
\r
-\cvfunc{gpu::getLinearColumnFilter\_GPU}\label{cppfunc.gpu.getLinearColumnFilter}\r
-Create the primitive column filter with the specified kernel.\r
+There are two version of algorithm: NPP and OpenCV. NPP calls when \texttt{srcType == CV\_8UC1} or \texttt{srcType == CV\_8UC4} and \texttt{bufType == srcType}, otherwise calls OpenCV version. NPP supports only \texttt{BORDER\_CONSTANT} border type and doesn't check indexes outside image. OpenCV version supports only \texttt{CV\_32F} buffer depth and \texttt{BORDER\_REFLECT101}, \texttt{BORDER\_REPLICATE} and \texttt{BORDER\_CONSTANT} border types and checks indexes outside image.\r
+\r
+See also: \hyperref[cppfunc.gpu.getLinearColumnFilter]{cv::gpu::getLinearColumnFilter\_GPU}, \cvCppCross{createSeparableLinearFilter}.\r
+\r
+\r
+\cvfunc{cv::gpu::getLinearColumnFilter\_GPU}\label{cppfunc.gpu.getLinearColumnFilter}\r
+Creates the primitive column filter with the specified kernel.\r
+\r
\cvdefCpp{\r
Ptr<BaseColumnFilter\_GPU> getLinearColumnFilter\_GPU(int bufType, \par int dstType, const Mat\& columnKernel, int anchor = -1, \par int borderType = BORDER\_CONSTANT);\r
}\r
+\r
\begin{description}\r
-\cvarg{bufType}{The inermediate buffer type; must have as many channels as \texttt{dstType}.}\r
-\cvarg{dstType}{The destination array type. Supports only \texttt{CV\_8UC1}, \texttt{CV\_8UC4}, \texttt{CV\_16SC1}, \texttt{CV\_16SC2}, \texttt{CV\_32SC1}, \texttt{CV\_32FC1} source type.}\r
-\cvarg{columnKernel}{The coefficients for filtering each column.}\r
-\cvarg{anchor}{The anchor position within the kernel; negative values mean that anchor is positioned at the aperture center.}\r
-\cvarg{borderType}{The pixel extrapolation methods; see \cvCppCross{borderInterpolate}. About limitation see below.}\r
+\cvarg{bufType}{Inermediate buffer type; must have as many channels as \texttt{dstType}.}\r
+\cvarg{dstType}{Destination array type. Supports \texttt{CV\_8UC1}, \texttt{CV\_8UC4}, \texttt{CV\_16SC1}, \texttt{CV\_16SC2}, \texttt{CV\_32SC1}, \texttt{CV\_32FC1} destination types.}\r
+\cvarg{columnKernel}{Filter coefficients.}\r
+\cvarg{anchor}{Anchor position within the kernel; negative values mean that anchor is positioned at the aperture center.}\r
+\cvarg{borderType}{Pixel extrapolation method; see \cvCppCross{borderInterpolate}. About limitation see below.}\r
\end{description}\r
-There are two version of algorithm: NPP and OpenCV. NPP calls when \texttt{dstType == CV\_8UC1} or \texttt{dstType == CV\_8UC4} and \texttt{bufType == dstType}, otherwise calls OpenCV version. NPP supports only \texttt{BORDER\_CONSTANT} border type and doesn't check indexes outside image. OpenCV version supports only \texttt{CV\_32F} as buffer depth and \texttt{BORDER\_REFLECT101}, \texttt{BORDER\_REPLICATE} and \texttt{BORDER\_CONSTANT} border types and checks indexes outside image.\newline\r
-See also: \hyperref[cppfunc.gpu.getLinearRowFilter]{getLinearRowFilter\_GPU}, \cvCppCross{createSeparableLinearFilter}.\r
\r
-\cvfunc{gpu::createSeparableLinearFilter\_GPU}\label{cppfunc.gpu.createSeparableLinearFilter}\r
-Create the separable linear filter engine.\r
+There are two version of algorithm: NPP and OpenCV. NPP calls when \texttt{dstType == CV\_8UC1} or \texttt{dstType == CV\_8UC4} and \texttt{bufType == dstType}, otherwise calls OpenCV version. NPP supports only \texttt{BORDER\_CONSTANT} border type and doesn't check indexes outside image. OpenCV version supports only \texttt{CV\_32F} buffer depth and \texttt{BORDER\_REFLECT101}, \texttt{BORDER\_REPLICATE} and \texttt{BORDER\_CONSTANT} border types and checks indexes outside image.\newline\r
+\r
+See also: \hyperref[cppfunc.gpu.getLinearRowFilter]{cv::gpu::getLinearRowFilter\_GPU}, \cvCppCross{createSeparableLinearFilter}.\r
+\r
+\r
+\cvfunc{cv::gpu::createSeparableLinearFilter\_GPU}\label{cppfunc.gpu.createSeparableLinearFilter}\r
+Creates the separable linear filter engine.\r
+\r
\cvdefCpp{\r
Ptr<FilterEngine\_GPU> createSeparableLinearFilter\_GPU(int srcType, \par int dstType, const Mat\& rowKernel, const Mat\& columnKernel, \par const Point\& anchor = Point(-1,-1), \par int rowBorderType = BORDER\_DEFAULT, \par int columnBorderType = -1);\r
}\r
+\r
\begin{description}\r
-\cvarg{srcType}{The source array type. Supports \texttt{CV\_8UC1}, \texttt{CV\_8UC4}, \texttt{CV\_16SC1}, \texttt{CV\_16SC2}, \texttt{CV\_32SC1}, \texttt{CV\_32FC1} source type.}\r
-\cvarg{dstType}{The destination array type. Supports \texttt{CV\_8UC1}, \texttt{CV\_8UC4}, \texttt{CV\_16SC1}, \texttt{CV\_16SC2}, \texttt{CV\_32SC1}, \texttt{CV\_32FC1} source type.}\r
-\cvarg{rowKernel}{The coefficients for filtering each row.}\r
-\cvarg{columnKernel}{The coefficients for filtering each column.}\r
-\cvarg{anchor}{The anchor position within the kernel; negative values mean that anchor is positioned at the aperture center.}\r
-\cvarg{rowBorderType, columnBorderType}{The pixel extrapolation methods in the horizontal and the vertical directions; see \cvCppCross{borderInterpolate}. About limitation see \hyperref[cppfunc.gpu.getLinearRowFilter]{getLinearRowFilter\_GPU}, \hyperref[cppfunc.gpu.getLinearColumnFilter]{getLinearColumnFilter\_GPU}, \cvCppCross{createSeparableLinearFilter}.}\r
+\cvarg{srcType}{Source array type. Supports \texttt{CV\_8UC1}, \texttt{CV\_8UC4}, \texttt{CV\_16SC1}, \texttt{CV\_16SC2}, \texttt{CV\_32SC1}, \texttt{CV\_32FC1} source types.}\r
+\cvarg{dstType}{Destination array type. Supports \texttt{CV\_8UC1}, \texttt{CV\_8UC4}, \texttt{CV\_16SC1}, \texttt{CV\_16SC2}, \texttt{CV\_32SC1}, \texttt{CV\_32FC1} destination types.}\r
+\cvarg{rowKernel, columnKernel}{Filter coefficients.}\r
+\cvarg{anchor}{Anchor position within the kernel; negative values mean that anchor is positioned at the aperture center.}\r
+\cvarg{rowBorderType, columnBorderType}{Pixel extrapolation method in the horizontal and the vertical directions; see \cvCppCross{borderInterpolate}. About limitation see \hyperref[cppfunc.gpu.getLinearRowFilter]{cv::gpu::getLinearRowFilter\_GPU}, \hyperref[cppfunc.gpu.getLinearColumnFilter]{cv::gpu::getLinearColumnFilter\_GPU}.}\r
\end{description}\r
\r
+See also: \hyperref[cppfunc.gpu.getLinearRowFilter]{cv::gpu::getLinearRowFilter\_GPU}, \hyperref[cppfunc.gpu.getLinearColumnFilter]{cv::gpu::getLinearColumnFilter\_GPU}, \cvCppCross{createSeparableLinearFilter}.\r
+\r
+\r
\cvCppFunc{gpu::sepFilter2D}\r
Applies separable 2D linear filter to the image.\r
+\r
\cvdefCpp{\r
void sepFilter2D(const GpuMat\& src, GpuMat\& dst, int ddepth, \par const Mat\& kernelX, const Mat\& kernelY, \par Point anchor = Point(-1,-1), \par int rowBorderType = BORDER\_DEFAULT, \par int columnBorderType = -1);\r
}\r
+\r
\begin{description}\r
-\cvarg{src}{The source image.}\r
-\cvarg{dst}{The destination image; will have the same size and the same number of channels as \texttt{src}.}\r
-\cvarg{ddepth}{The destination image depth.}\r
-\cvarg{kernelX}{The coefficients for filtering each row.}\r
-\cvarg{kernelY}{The coefficients for filtering each column.}\r
-\cvarg{anchor}{The anchor position within the kernel; The default value $(-1, 1)$ means that the anchor is at the kernel center.}\r
-\cvarg{rowBorderType, columnBorderType}{The pixel extrapolation method; see \cvCppCross{borderInterpolate}.}\r
+\cvarg{src}{Source image. Supports \texttt{CV\_8UC1}, \texttt{CV\_8UC4}, \texttt{CV\_16SC1}, \texttt{CV\_16SC2}, \texttt{CV\_32SC1}, \texttt{CV\_32FC1} source types.}\r
+\cvarg{dst}{Destination image; will have the same size and the same number of channels as \texttt{src}.}\r
+\cvarg{ddepth}{Destination image depth. Supports \texttt{CV\_8U}, \texttt{CV\_16S}, \texttt{CV\_32S} and \texttt{CV\_32F}.}\r
+\cvarg{kernelX, kernelY}{Filter coefficients.}\r
+\cvarg{anchor}{Anchor position within the kernel; The default value $(-1, 1)$ means that the anchor is at the kernel center.}\r
+\cvarg{rowBorderType, columnBorderType}{Pixel extrapolation method; see \cvCppCross{borderInterpolate}.}\r
\end{description}\r
-See also: \hyperref[cppfunc.gpu.createSeparableLinearFilter]{createSeparableLinearFilter\_GPU}, \cvCppCross{sepFilter2D}.\r
\r
-\cvfunc{gpu::createDerivFilter\_GPU}\label{cppfunc.gpu.createDerivFilter}\r
-Create filter engine for the generalized Sobel operator.\r
+See also: \hyperref[cppfunc.gpu.createSeparableLinearFilter]{cv::gpu::createSeparableLinearFilter\_GPU}, \cvCppCross{sepFilter2D}.\r
+\r
+\r
+\cvfunc{cv::gpu::createDerivFilter\_GPU}\label{cppfunc.gpu.createDerivFilter}\r
+Creates filter engine for the generalized Sobel operator.\r
+\r
\cvdefCpp{\r
Ptr<FilterEngine\_GPU> createDerivFilter\_GPU(int srcType, int dstType, \par int dx, int dy, int ksize, \par int rowBorderType = BORDER\_DEFAULT, \par int columnBorderType = -1);\r
}\r
+\r
\begin{description}\r
-\cvarg{srcType}{The source image type.}\r
-\cvarg{dstType}{The destination image type; must have as many channels as \texttt{srcType}.}\r
-\cvarg{dx}{The derivative order in respect with x.}\r
-\cvarg{dy}{The derivative order in respect with y.}\r
-\cvarg{ksize}{The aperture size; see \cvCppCross{getDerivKernels}.}\r
-\cvarg{rowBorderType, columnBorderType}{Which border type to use; see \cvCppCross{borderInterpolate}.}\r
+\cvarg{srcType}{Source image type. Supports \texttt{CV\_8UC1}, \texttt{CV\_8UC4}, \texttt{CV\_16SC1}, \texttt{CV\_16SC2}, \texttt{CV\_32SC1}, \texttt{CV\_32FC1} source types.}\r
+\cvarg{dstType}{Destination image type; must have as many channels as \texttt{srcType}. Supports \texttt{CV\_8U}, \texttt{CV\_16S}, \texttt{CV\_32S} and \texttt{CV\_32F} depths.}\r
+\cvarg{dx}{Derivative order in respect with x.}\r
+\cvarg{dy}{Derivative order in respect with y.}\r
+\cvarg{ksize}{Aperture size; see \cvCppCross{getDerivKernels}.}\r
+\cvarg{rowBorderType, columnBorderType}{Pixel extrapolation method; see \cvCppCross{borderInterpolate}.}\r
\end{description}\r
-See also: \hyperref[cppfunc.gpu.createSeparableLinearFilter]{createSeparableLinearFilter\_GPU}, \cvCppCross{createDerivFilter}.\r
+\r
+See also: \hyperref[cppfunc.gpu.createSeparableLinearFilter]{cv::gpu::createSeparableLinearFilter\_GPU}, \cvCppCross{createDerivFilter}.\r
+\r
\r
\cvCppFunc{gpu::Sobel}\r
Applies generalized Sobel operator to the image.\r
+\r
\cvdefCpp{\r
void Sobel(const GpuMat\& src, GpuMat\& dst, int ddepth, int dx, int dy, \par int ksize = 3, double scale = 1, \par int rowBorderType = BORDER\_DEFAULT, \par int columnBorderType = -1);\r
}\r
+\r
\begin{description}\r
-\cvarg{srcType}{The source image.}\r
-\cvarg{dstType}{The destination image. Will have the same size and number of channels as source image.}\r
-\cvarg{ddepth}{The destination image depth.}\r
-\cvarg{dx}{The derivative order in respect with x.}\r
-\cvarg{dy}{The derivative order in respect with y.}\r
+\cvarg{src}{Source image. Supports \texttt{CV\_8UC1}, \texttt{CV\_8UC4}, \texttt{CV\_16SC1}, \texttt{CV\_16SC2}, \texttt{CV\_32SC1}, \texttt{CV\_32FC1} source types.}\r
+\cvarg{dst}{Destination image. Will have the same size and number of channels as source image.}\r
+\cvarg{ddepth}{Destination image depth. Supports \texttt{CV\_8U}, \texttt{CV\_16S}, \texttt{CV\_32S} and \texttt{CV\_32F}.}\r
+\cvarg{dx}{Derivative order in respect with x.}\r
+\cvarg{dy}{Derivative order in respect with y.}\r
\cvarg{ksize}{Size of the extended Sobel kernel, must be 1, 3, 5 or 7.}\r
-\cvarg{scale}{The optional scale factor for the computed derivative values (by default, no scaling is applied, see \cvCppCross{getDerivKernels}).}\r
-\cvarg{rowBorderType, columnBorderType}{Which border type to use; see \cvCppCross{borderInterpolate}.}\r
+\cvarg{scale}{Optional scale factor for the computed derivative values (by default, no scaling is applied, see \cvCppCross{getDerivKernels}).}\r
+\cvarg{rowBorderType, columnBorderType}{Pixel extrapolation method; see \cvCppCross{borderInterpolate}.}\r
\end{description}\r
-See also: \hyperref[cppfunc.gpu.createSeparableLinearFilter]{createSeparableLinearFilter\_GPU}, \cvCppCross{Sobel}.\r
+\r
+See also: \hyperref[cppfunc.gpu.createSeparableLinearFilter]{cv::gpu::createSeparableLinearFilter\_GPU}, \cvCppCross{Sobel}.\r
+\r
\r
\cvCppFunc{gpu::Scharr}\r
Calculates the first x- or y- image derivative using Scharr operator.\r
+\r
\cvdefCpp{\r
void Scharr(const GpuMat\& src, GpuMat\& dst, int ddepth, \par int dx, int dy, double scale = 1, \par int rowBorderType = BORDER\_DEFAULT, \par int columnBorderType = -1);\r
}\r
+\r
\begin{description}\r
-\cvarg{src}{The source image.}\r
-\cvarg{dst}{The destination image; will have the same size and the same number of channels as \texttt{src}.}\r
-\cvarg{ddepth}{The destination image depth.}\r
+\cvarg{src}{Source image. Supports \texttt{CV\_8UC1}, \texttt{CV\_8UC4}, \texttt{CV\_16SC1}, \texttt{CV\_16SC2}, \texttt{CV\_32SC1}, \texttt{CV\_32FC1} source types.}\r
+\cvarg{dst}{Destination image; will have the same size and the same number of channels as \texttt{src}.}\r
+\cvarg{ddepth}{Destination image depth. Supports \texttt{CV\_8U}, \texttt{CV\_16S}, \texttt{CV\_32S} and \texttt{CV\_32F}.}\r
\cvarg{xorder}{Order of the derivative x.}\r
\cvarg{yorder}{Order of the derivative y.}\r
-\cvarg{scale}{The optional scale factor for the computed derivative values (by default, no scaling is applied, see \cvCppCross{getDerivKernels}).}\r
-\cvarg{rowBorderType, columnBorderType}{The pixel extrapolation method, see \cvCppCross{borderInterpolate}}\r
+\cvarg{scale}{Optional scale factor for the computed derivative values (by default, no scaling is applied, see \cvCppCross{getDerivKernels}).}\r
+\cvarg{rowBorderType, columnBorderType}{Pixel extrapolation method, see \cvCppCross{borderInterpolate}}\r
\end{description}\r
-See also: \hyperref[cppfunc.gpu.createSeparableLinearFilter]{createSeparableLinearFilter\_GPU}, \cvCppCross{Scharr}.\r
\r
-\cvfunc{gpu::createGaussianFilter\_GPU}\label{cppfunc.gpu.createGaussianFilter}\r
-Create the Gaussian filter engine.\r
+See also: \hyperref[cppfunc.gpu.createSeparableLinearFilter]{cv::gpu::createSeparableLinearFilter\_GPU}, \cvCppCross{Scharr}.\r
+\r
+\r
+\cvfunc{cv::gpu::createGaussianFilter\_GPU}\label{cppfunc.gpu.createGaussianFilter}\r
+Creates Gaussian filter engine.\r
+\r
\cvdefCpp{\r
Ptr<FilterEngine\_GPU> createGaussianFilter\_GPU(int type, Size ksize, \par double sigmaX, double sigmaY = 0, \par int rowBorderType = BORDER\_DEFAULT, \par int columnBorderType = -1);\r
}\r
+\r
\begin{description}\r
-\cvarg{type}{The source and the destination image type.}\r
-\cvarg{ksize}{The aperture size; see \cvCppCross{getGaussianKernel}.}\r
-\cvarg{sigmaX}{The Gaussian sigma in the horizontal direction; see \cvCppCross{getGaussianKernel}.}\r
-\cvarg{sigmaY}{The Gaussian sigma in the vertical direction; if 0, then $\texttt{sigmaY}\leftarrow\texttt{sigmaX}$.}\r
-\cvarg{rowBorderType, columnBorderType}{Which border type to use; see \cvCppCross{borderInterpolate}}\r
+\cvarg{type}{Source and the destination image type. Supports \texttt{CV\_8UC1}, \texttt{CV\_8UC4}, \texttt{CV\_16SC1}, \texttt{CV\_16SC2}, \texttt{CV\_32SC1}, \texttt{CV\_32FC1}.}\r
+\cvarg{ksize}{Aperture size; see \cvCppCross{getGaussianKernel}.}\r
+\cvarg{sigmaX}{Gaussian sigma in the horizontal direction; see \cvCppCross{getGaussianKernel}.}\r
+\cvarg{sigmaY}{Gaussian sigma in the vertical direction; if 0, then $\texttt{sigmaY}\leftarrow\texttt{sigmaX}$.}\r
+\cvarg{rowBorderType, columnBorderType}{Which border type to use; see \cvCppCross{borderInterpolate}.}\r
\end{description}\r
-See also: \hyperref[cppfunc.gpu.createSeparableLinearFilter]{createSeparableLinearFilter\_GPU}, \cvCppCross{createGaussianFilter}.\r
+\r
+See also: \hyperref[cppfunc.gpu.createSeparableLinearFilter]{cv::gpu::createSeparableLinearFilter\_GPU}, \cvCppCross{createGaussianFilter}.\r
+\r
\r
\cvCppFunc{gpu::GaussianBlur}\r
Smooths the image using Gaussian filter.\r
+\r
\cvdefCpp{\r
void GaussianBlur(const GpuMat\& src, GpuMat\& dst, Size ksize, \par double sigmaX, double sigmaY = 0, \par int rowBorderType = BORDER\_DEFAULT, \par int columnBorderType = -1);\r
}\r
+\r
\begin{description}\r
-\cvarg{src}{The source image.}\r
-\cvarg{dst}{The destination image; will have the same size and the same type as \texttt{src}.}\r
-\cvarg{ksize}{The Gaussian kernel size; \texttt{ksize.width} and \texttt{ksize.height} can differ, but they both must be positive and odd. Or, they can be zero's, then they are computed from \texttt{sigma*}.}\r
-\cvarg{sigmaX, sigmaY}{The Gaussian kernel standard deviations in X and Y direction. If \texttt{sigmaY} is zero, it is set to be equal to \texttt{sigmaX}. If they are both zeros, they are computed from \texttt{ksize.width} and \texttt{ksize.height}, respectively, see \cvCppCross{getGaussianKernel}. To fully control the result regardless of possible future modification of all this semantics, it is recommended to specify all of \texttt{ksize}, \texttt{sigmaX} and \texttt{sigmaY}.}\r
-\cvarg{rowBorderType, columnBorderType}{The pixel extrapolation method; see \cvCppCross{borderInterpolate}.}\r
+\cvarg{src}{Source image. Supports \texttt{CV\_8UC1}, \texttt{CV\_8UC4}, \texttt{CV\_16SC1}, \texttt{CV\_16SC2}, \texttt{CV\_32SC1}, \texttt{CV\_32FC1} source types.}\r
+\cvarg{dst}{Destination image; will have the same size and the same type as \texttt{src}.}\r
+\cvarg{ksize}{Gaussian kernel size; \texttt{ksize.width} and \texttt{ksize.height} can differ, but they both must be positive and odd. Or, they can be zero's, then they are computed from \texttt{sigmaX} amd \texttt{sigmaY}.}\r
+\cvarg{sigmaX, sigmaY}{Gaussian kernel standard deviations in X and Y direction. If \texttt{sigmaY} is zero, it is set to be equal to \texttt{sigmaX}. If they are both zeros, they are computed from \texttt{ksize.width} and \texttt{ksize.height}, respectively, see \cvCppCross{getGaussianKernel}. To fully control the result regardless of possible future modification of all this semantics, it is recommended to specify all of \texttt{ksize}, \texttt{sigmaX} and \texttt{sigmaY}.}\r
+\cvarg{rowBorderType, columnBorderType}{Pixel extrapolation method; see \cvCppCross{borderInterpolate}.}\r
\end{description}\r
-See also: \hyperref[cppfunc.gpu.createGaussianFilter]{createGaussianFilter\_GPU}, \cvCppCross{GaussianBlur}.\r
\r
-\cvfunc{gpu::getMaxFilter\_GPU}\label{cppfunc.gpu.getMaxFilter}\r
-Create maximum filter.\r
+See also: \hyperref[cppfunc.gpu.createGaussianFilter]{cv::gpu::createGaussianFilter\_GPU}, \cvCppCross{GaussianBlur}.\r
+\r
+\r
+\cvfunc{cv::gpu::getMaxFilter\_GPU}\label{cppfunc.gpu.getMaxFilter}\r
+Creates maximum filter.\r
+\r
\cvdefCpp{\r
Ptr<BaseFilter\_GPU> getMaxFilter\_GPU(int srcType, int dstType, \par const Size\& ksize, Point anchor = Point(-1,-1));\r
}\r
+\r
\begin{description}\r
-\cvarg{srcType}{The input image type. Now support only \texttt{CV\_8UC1} and \texttt{CV\_8UC4}.}\r
-\cvarg{dstType}{The output image type. Now support only the same type as source.}\r
-\cvarg{ksize}{The kernel size.}\r
-\cvarg{anchor}{The anchor point. The default value (-1) means that the anchor is at the kernel center.}\r
+\cvarg{srcType}{Input image type. Supports only \texttt{CV\_8UC1} and \texttt{CV\_8UC4}.}\r
+\cvarg{dstType}{Output image type. Supports only the same type as source.}\r
+\cvarg{ksize}{Kernel size.}\r
+\cvarg{anchor}{Anchor point. The default value (-1) means that the anchor is at the kernel center.}\r
\end{description}\r
+\r
This filter doesn't check indexes outside the image, so it can process only inner area. \r
\r
-\cvfunc{gpu::getMinFilter\_GPU}\label{cppfunc.gpu.getMinFilter}\r
-Create minimum filter.\r
+\r
+\cvfunc{cv::gpu::getMinFilter\_GPU}\label{cppfunc.gpu.getMinFilter}\r
+Creates minimum filter.\r
+\r
\cvdefCpp{\r
Ptr<BaseFilter\_GPU> getMinFilter\_GPU(int srcType, int dstType, \par const Size\& ksize, Point anchor = Point(-1,-1));\r
}\r
+\r
\begin{description}\r
-\cvarg{srcType}{The input image type. Now support only \texttt{CV\_8UC1} and \texttt{CV\_8UC4}.}\r
-\cvarg{dstType}{The output image type. Now support only the same type as source.}\r
-\cvarg{ksize}{The kernel size.}\r
-\cvarg{anchor}{The anchor point. The default value (-1) means that the anchor is at the kernel center.}\r
+\cvarg{srcType}{Input image type. Supports only \texttt{CV\_8UC1} and \texttt{CV\_8UC4}.}\r
+\cvarg{dstType}{Output image type. Supports only the same type as source.}\r
+\cvarg{ksize}{Kernel size.}\r
+\cvarg{anchor}{Anchor point. The default value (-1) means that the anchor is at the kernel center.}\r
\end{description}\r
+\r
This filter doesn't check indexes outside the image, so it can process only inner area. \r
\r
See also: \cvCppCross{matchTemplate}. \r
\r
+\r
\cvCppFunc{gpu::remap}\r
Applies a generic geometrical transformation to an image.\r
+\r
\cvdefCpp{\r
void remap(const GpuMat\& src, GpuMat\& dst, \par const GpuMat\& xmap, const GpuMat\& ymap);\r
}\r
+\r
\begin{description}\r
\cvarg{src}{Source image. Only \texttt{CV\_8UC1} and \texttt{CV\_8UC3} source types are supported.}\r
\cvarg{dst}{Destination image. It will have the same size as \texttt{xmap} and the same type as \texttt{src}.}\r
-\cvarg{xmap}{The x values. Only \texttt{CV\_32FC1} type are supported.}\r
-\cvarg{ymap}{The y values. Only \texttt{CV\_32FC1} type are supported.}\r
+\cvarg{xmap}{X values. Only \texttt{CV\_32FC1} type is supported.}\r
+\cvarg{ymap}{Y values. Only \texttt{CV\_32FC1} type is supported.}\r
\end{description}\r
-The function remap transforms the source image using the specified map:\r
+\r
+The function transforms the source image using the specified map:\r
\[\r
\texttt{dst}(x,y) = \texttt{src}(xmap(x,y), ymap(x,y))\r
\]\r
-Where values of pixels with non-integer coordinates are computed using bilinear interpolation.\newline\r
-See also: \cvCppCross{remap}.\r
\r
-\cvCppFunc{gpu::drawColorDisp}\r
-Does coloring of disparity image.\r
-\cvdefCpp{\r
-void drawColorDisp(const GpuMat\& src\_disp, GpuMat\& dst\_disp, int ndisp);\r
-}\r
-\cvdefCpp{\r
-void drawColorDisp(const GpuMat\& src\_disp, GpuMat\& dst\_disp, int ndisp, \par const Stream\& stream);\r
-}\r
-\begin{description}\r
-\cvarg{src\_disp}{Source disparity image. Supports \texttt{CV\_8UC1} and \texttt{CV\_16SC1} types.}\r
-\cvarg{dst\_disp}{Output disparity image. Will have the same size as \texttt{src\_disp} and \texttt{CV\_8UC4} type in \texttt{BGRA} format (alpha = 255).}\r
-\cvarg{ndisp}{Number of disparities.}\r
-\cvarg{stream}{Stream fo async version.}\r
-\end{description}\r
-This function converts $[0..ndisp)$ interval to $[0..240, 1, 1]$ in \texttt{HSV} color space, than convert \texttt{HSV} color space to \texttt{RGB}.\r
+Values of pixels with non-integer coordinates are computed using bilinear interpolation.\r
+\r
+See also: \cvCppCross{remap}.\r
\r
-\cvCppFunc{gpu::reprojectImageTo3D}\r
-Reprojects disparity image to 3D space.\r
-\cvdefCpp{\r
-void reprojectImageTo3D(const GpuMat\& disp, GpuMat\& xyzw, \par const Mat\& Q);\r
-}\r
-\cvdefCpp{\r
-void reprojectImageTo3D(const GpuMat\& disp, GpuMat\& xyzw, \par const Mat\& Q, const Stream\& stream);\r
-}\r
-\begin{description}\r
-\cvarg{disp}{The input single-channel 8-bit unsigned ot 16-bit signed integer disparity image.}\r
-\cvarg{xyzw}{The output 4-channel floating-point image of the same size as \texttt{disp}. Each element of \texttt{xyzw(x,y)} will contain the 3D coordinates \texttt{(x,y,z,1)} of the point \texttt{(x,y)}, computed from the disparity map.}\r
-\cvarg{Q}{The $4 \times 4$ perspective transformation matrix that can be obtained with \cvCross{StereoRectify}{stereoRectify}.}\r
-\cvarg{stream}{Stream fo async version.}\r
-\end{description}\r
-See also: \cvCppCross{reprojectImageTo3D}.\r
\r
\cvCppFunc{gpu::cvtColor}\r
Converts image from one color space to another.\r
+\r
\cvdefCpp{\r
-void cvtColor(const GpuMat\& src, GpuMat\& dst, int code, int dcn = 0);\r
-}\r
-\cvdefCpp{\r
+void cvtColor(const GpuMat\& src, GpuMat\& dst, int code, int dcn = 0);\newline\r
void cvtColor(const GpuMat\& src, GpuMat\& dst, int code, int dcn, \par const Stream\& stream);\r
}\r
+\r
\begin{description}\r
-\cvarg{src}{The source image, 8-bit unsigned, 16-bit unsigned (\texttt{CV\_16UC...}) or single-precision floating-point.}\r
-\cvarg{dst}{The destination image; will have the same size and the same depth as \texttt{src}.}\r
-\cvarg{code}{The color space conversion code.}\r
-\cvarg{dcn}{The number of channels in the destination image; if the parameter is 0, the number of the channels will be derived automatically from \texttt{src} and the \texttt{code}.}\r
-\cvarg{stream}{Stream fo async version.}\r
+\cvarg{src}{Source image with \texttt{CV\_8U}, \texttt{CV\_16U} or \texttt{CV\_32F} depth and 1, 3 or 4 channels.}\r
+\cvarg{dst}{Destination image; will have the same size and the same depth as \texttt{src}.}\r
+\cvarg{code}{Color space conversion code. For details see \cvCppCross{cvtColor}. Conversion to/from Luv and Bayer color spaces doesn't supported.}\r
+\cvarg{dcn}{Number of channels in the destination image; if the parameter is 0, the number of the channels will be derived automatically from \texttt{src} and the \texttt{code}.}\r
+\cvarg{stream}{Stream for the asynchronous version.}\r
\end{description}\r
-3-channels color spaces (like \texttt{HSV}, \texttt{XYZ}, etc) can be stored to 4-channels image for better perfomance.\newline\r
+\r
+3-channel color spaces (like \texttt{HSV}, \texttt{XYZ}, etc) can be stored to 4-channel image for better perfomance.\r
+\r
See also: \cvCppCross{cvtColor}.\r
\r
+\r
\cvCppFunc{gpu::threshold}\r
Applies a fixed-level threshold to each array element.\r
+\r
\cvdefCpp{\r
double threshold(const GpuMat\& src, GpuMat\& dst, double thresh);\r
}\r
+\r
\begin{description}\r
\cvarg{src}{Source array. Supports only \texttt{CV\_32FC1} type.}\r
\cvarg{dst}{Destination array; will have the same size and the same type as \texttt{src}.}\r
\cvarg{thresh}{Threshold value.}\r
\end{description}\r
-Does only \texttt{THRESH\_TRUNC} threshold.\newline\r
+\r
See also: \cvCppCross{threshold}.\r
\r
+\r
\cvCppFunc{gpu::resize}\r
-Resizes the image.\r
+Resizes an image.\r
+\r
\cvdefCpp{\r
void resize(const GpuMat\& src, GpuMat\& dst, Size dsize, \par double fx=0, double fy=0, \par int interpolation = INTER\_LINEAR);\r
}\r
+\r
\begin{description}\r
-\cvarg{src}{Source image. Supports \texttt{CV\_8UC1}, \texttt{CV\_8UC4} types.}\r
+\cvarg{src}{Source image. Supports \texttt{CV\_8UC1} and \texttt{CV\_8UC4} types.}\r
\cvarg{dst}{Destination image. It will have size \texttt{dsize} (when it is non-zero) or the size computed from \texttt{src.size()} and \texttt{fx} and \texttt{fy}. The type of \texttt{dst} will be the same as of \texttt{src}.}\r
-\cvarg{dsize}{The destination image size. If it is zero, then it is computed as: \[\texttt{dsize = Size(round(fx*src.cols), round(fy*src.rows))}\] Either \texttt{dsize} or both \texttt{fx} or \texttt{fy} must be non-zero.}\r
-\cvarg{fx}{The scale factor along the horizontal axis. When 0, it is computed as \[\texttt{(double)dsize.width/src.cols}\]} \r
-\cvarg{fy}{The scale factor along the vertical axis. When 0, it is computed as \[\texttt{(double)dsize.height/src.rows}\]}\r
-\cvarg{interpolation}{The interpolation method. Supports only \texttt{INTER\_NEAREST} and \texttt{INTER\_LINEAR}.}\r
+\cvarg{dsize}{Destination image size. If it is zero, then it is computed as: \r
+\[\r
+\texttt{dsize = Size(round(fx*src.cols), round(fy*src.rows))}\r
+\]\r
+Either \texttt{dsize} or both \texttt{fx} or \texttt{fy} must be non-zero.}\r
+\cvarg{fx}{Scale factor along the horizontal axis. When 0, it is computed as \r
+\[\r
+\texttt{(double)dsize.width/src.cols}\r
+\]} \r
+\cvarg{fy}{Scale factor along the vertical axis. When 0, it is computed as \r
+\[\r
+\texttt{(double)dsize.height/src.rows}\r
+\]}\r
+\cvarg{interpolation}{Interpolation method. Supports only \texttt{INTER\_NEAREST} and \texttt{INTER\_LINEAR}.}\r
\end{description}\r
+\r
See also: \cvCppCross{resize}.\r
\r
+\r
\cvCppFunc{gpu::warpAffine}\r
Applies an affine transformation to an image.\r
+\r
\cvdefCpp{\r
void warpAffine(const GpuMat\& src, GpuMat\& dst, const Mat\& M, \par Size dsize, int flags = INTER\_LINEAR);\r
}\r
+\r
\begin{description}\r
-\cvarg{src}{Source image. Supports 8-bit unsigned, 16-bit unsigned, 32-bit signed amd 32-bit floating one, three and four channels images.}\r
+\cvarg{src}{Source image. Supports \texttt{CV\_8U}, \texttt{CV\_16U}, \texttt{CV\_32S} or \texttt{CV\_32F} depth and 1, 3 or 4 channels.}\r
\cvarg{dst}{Destination image; will have size \texttt{dsize} and the same type as \texttt{src}.}\r
\cvarg{M}{$2\times 3$ transformation matrix.}\r
\cvarg{dsize}{Size of the destination image.}\r
-\cvarg{flags}{A combination of interpolation methods, see \cvCppCross{resize}, and the optional flag \texttt{WARP\_INVERSE\_MAP} that means that \texttt{M} is the inverse transformation ($\texttt{dst}\rightarrow\texttt{src}$). Supports only \texttt{INTER\_NEAREST}, \texttt{INTER\_LINEAR} and \texttt{INTER\_CUBIC} interpolation methods.}\r
+\cvarg{flags}{Combination of interpolation methods, see \cvCppCross{resize}, and the optional flag \texttt{WARP\_INVERSE\_MAP} that means that \texttt{M} is the inverse transformation ($\texttt{dst}\rightarrow\texttt{src}$). Supports only \texttt{INTER\_NEAREST}, \texttt{INTER\_LINEAR} and \texttt{INTER\_CUBIC} interpolation methods.}\r
\end{description}\r
+\r
See also: \cvCppCross{warpAffine}.\r
\r
+\r
\cvCppFunc{gpu::warpPerspective}\r
Applies a perspective transformation to an image.\r
+\r
\cvdefCpp{\r
void warpPerspective(const GpuMat\& src, GpuMat\& dst, const Mat\& M, \par Size dsize, int flags = INTER\_LINEAR);\r
}\r
+\r
\begin{description}\r
-\cvarg{src}{Source image. Supports 8-bit unsigned, 16-bit unsigned, 32-bit signed amd 32-bit floating one, three and four channels images.}\r
+\cvarg{src}{Source image. Supports \texttt{CV\_8U}, \texttt{CV\_16U}, \texttt{CV\_32S} or \texttt{CV\_32F} depth and 1, 3 or 4 channels.}\r
\cvarg{dst}{Destination image; will have size \texttt{dsize} and the same type as \texttt{src}.}\r
-\cvarg{M}{$2\times 3$ transformation matrix.}\r
+\cvarg{M}{$2\r
+ 3$ transformation matrix.}\r
\cvarg{dsize}{Size of the destination image.}\r
-\cvarg{flags}{A combination of interpolation methods, see \cvCppCross{resize}, and the optional flag \texttt{WARP\_INVERSE\_MAP} that means that \texttt{M} is the inverse transformation ($\texttt{dst}\rightarrow\texttt{src}$). Supports only \texttt{INTER\_NEAREST}, \texttt{INTER\_LINEAR} and \texttt{INTER\_CUBIC} interpolation methods.}\r
+\cvarg{flags}{Combination of interpolation methods, see \cvCppCross{resize}, and the optional flag \texttt{WARP\_INVERSE\_MAP} that means that \texttt{M} is the inverse transformation ($\texttt{dst}\rightarrow\texttt{src}$). Supports only \texttt{INTER\_NEAREST}, \texttt{INTER\_LINEAR} and \texttt{INTER\_CUBIC} interpolation methods.}\r
\end{description}\r
+\r
See also: \cvCppCross{warpPerspective}.\r
\r
+\r
\cvCppFunc{gpu::rotate}\r
Rotates an image around the origin (0,0) and then shifts it.\r
+\r
\cvdefCpp{\r
void rotate(const GpuMat\& src, GpuMat\& dst, Size dsize, \par double angle, double xShift = 0, double yShift = 0, \par int interpolation = INTER\_LINEAR);\r
}\r
+\r
\begin{description}\r
-\cvarg{src}{Source image. Supports \texttt{CV\_8UC1}, \texttt{CV\_8UC4} types.}\r
+\cvarg{src}{Source image. Supports \texttt{CV\_8UC1} and \texttt{CV\_8UC4} types.}\r
\cvarg{dst}{Destination image; will have size \texttt{dsize} and the same type as \texttt{src}.}\r
\cvarg{dsize}{Size of the destination image.}\r
-\cvarg{angle}{The angle of rotation in degrees.}\r
+\cvarg{angle}{Angle of rotation in degrees.}\r
\cvarg{xShift}{Shift along horizontal axis.}\r
\cvarg{yShift}{Shift along vertical axis.}\r
-\cvarg{interpolation}{The interpolation method. Supports only \texttt{INTER\_NEAREST}, \texttt{INTER\_LINEAR} and \texttt{INTER\_CUBIC}.}\r
+\cvarg{interpolation}{Interpolation method. Supports only \texttt{INTER\_NEAREST}, \texttt{INTER\_LINEAR} and \texttt{INTER\_CUBIC}.}\r
\end{description}\r
+\r
See also: \cvCppCross{gpu::warpAffine}.\r
\r
+\r
\cvCppFunc{gpu::copyMakeBorder}\r
-Copies 2D array to a larger destination array and pads borders with user-specifiable constant.\r
+Copies 2D array to a larger destination array and pads borders with the given constant.\r
+\r
\cvdefCpp{\r
void copyMakeBorder(const GpuMat\& src, GpuMat\& dst, \par int top, int bottom, int left, int right, \par const Scalar\& value = Scalar());\r
}\r
+\r
\begin{description}\r
-\cvarg{src}{The source image. Supports \texttt{CV\_8UC1}, \texttt{CV\_8UC4}, \texttt{CV\_32SC1} and \texttt{CV\_32FC1} types.}\r
+\cvarg{src}{Source image. Supports \texttt{CV\_8UC1}, \texttt{CV\_8UC4}, \texttt{CV\_32SC1} and \texttt{CV\_32FC1} types.}\r
\cvarg{dst}{The destination image; will have the same type as \texttt{src} and the size \texttt{Size(src.cols+left+right, src.rows+top+bottom)}.}\r
\cvarg{top, bottom, left, right}{Specify how much pixels in each direction from the source image rectangle one needs to extrapolate, e.g. \texttt{top=1, bottom=1, left=1, right=1} mean that 1 pixel-wide border needs to be built.}\r
-\cvarg{value}{The border value.}\r
+\cvarg{value}{Border value.}\r
\end{description}\r
+\r
See also: \cvCppCross{copyMakeBorder}\r
\r
+\r
\cvCppFunc{gpu::rectStdDev}\r
-Computes the standard deviation of integral images. \r
+Computes standard deviation of integral images. \r
+\r
\cvdefCpp{\r
void rectStdDev(const GpuMat\& src, const GpuMat\& sqr, GpuMat\& dst, \par const Rect\& rect);\r
}\r
+\r
\begin{description}\r
-\cvarg{src}{The source image. Supports only \texttt{CV\_32SC1} type.}\r
-\cvarg{sqr}{The squared source image. Supports only \texttt{CV\_32FC1} type.}\r
-\cvarg{dst}{The destination image; will have the same type and the same size as \texttt{src}.}\r
+\cvarg{src}{Source image. Supports only \texttt{CV\_32SC1} type.}\r
+\cvarg{sqr}{Squared source image. Supports only \texttt{CV\_32FC1} type.}\r
+\cvarg{dst}{Destination image; will have the same type and the same size as \texttt{src}.}\r
\cvarg{rect}{Rectangular window.}\r
\end{description}\r
\r
+\r
\cvCppFunc{gpu::evenLevels}\r
-Compute levels with even distribution.\r
+Computes levels with even distribution.\r
+\r
\cvdefCpp{\r
void evenLevels(GpuMat\& levels, int nLevels, \par int lowerLevel, int upperLevel);\r
}\r
+\r
\begin{description}\r
-\cvarg{levels}{The destination array. \texttt{levels} will have 1 row and \texttt{nLevels} cols and \texttt{CV\_32SC1} type.}\r
-\cvarg{nLevels}{The number of levels being computed. \texttt{nLevels} must be at least 2}\r
+\cvarg{levels}{Destination array. \texttt{levels} will have 1 row and \texttt{nLevels} cols and \texttt{CV\_32SC1} type.}\r
+\cvarg{nLevels}{Number of levels being computed. \texttt{nLevels} must be at least 2.}\r
\cvarg{lowerLevel}{Lower boundary value of the lowest level.}\r
\cvarg{upperLevel}{Upper boundary value of the greatest level.}\r
\end{description}\r
\r
\cvCppFunc{gpu::histEven}\r
Calculates histogram with evenly distributed bins.\r
+\r
\cvdefCpp{\r
-void histEven(const GpuMat\& src, GpuMat\& hist, \par int histSize, int lowerLevel, int upperLevel);\r
-}\r
-\cvdefCpp{\r
+void histEven(const GpuMat\& src, GpuMat\& hist, \par int histSize, int lowerLevel, int upperLevel);\newline\r
void histEven(const GpuMat\& src, GpuMat hist[4], \par int histSize[4], int lowerLevel[4], int upperLevel[4]);\r
}\r
+\r
\begin{description}\r
-\cvarg{src}{The source image. Supports 8-bit unsigned, 16-bit unsigned and 16-bit one or four channel images. For four channels image all channels are processed separately.}\r
+\cvarg{src}{Source image. Supports \texttt{CV\_8U}, \texttt{CV\_16U} or \texttt{CV\_16S} depth and 1 or 4 channels. For four-channel image all channels are processed separately.}\r
\cvarg{hist}{Destination histogram. Will have one row, \texttt{histSize} cols and \texttt{CV\_32S} type.}\r
\cvarg{histSize}{Size of histogram.}\r
\cvarg{lowerLevel}{Lower boundary of lowest level bin.}\r
\r
\cvCppFunc{gpu::histRange}\r
Calculates histogram with bins determined by levels array.\r
+\r
\cvdefCpp{\r
-void histRange(const GpuMat\& src, GpuMat\& hist, const GpuMat\& levels);\r
-}\r
-\cvdefCpp{\r
+void histRange(const GpuMat\& src, GpuMat\& hist, const GpuMat\& levels);\newline\r
void histRange(const GpuMat\& src, GpuMat hist[4], \par const GpuMat levels[4]);\r
}\r
+\r
\begin{description}\r
-\cvarg{src}{The source image. Supports 8-bit unsigned, 16-bit unsigned and 16-bit one or four channel images. For four channels image all channels are processed separately.}\r
+\cvarg{src}{Source image. Supports \texttt{CV\_8U}, \texttt{CV\_16U} or \texttt{CV\_16S} depth and 1 or 4 channels. For four-channel image all channels are processed separately.}\r
\cvarg{hist}{Destination histogram. Will have one row, \texttt{(levels.cols-1)} cols and \texttt{CV\_32SC1} type.}\r
\cvarg{levels}{Number of levels in histogram.}\r
\end{description}\r
\cvarg{c}{Destination matrix. Will have the same size and type as \texttt{a}.}\r
\end{description}\r
\r
+This function in contrast to \cvCppCross{divide} uses round-down rounding mode.\r
+\r
See also: \cvCppCross{divide}.\r
\r
\r
pages = {331-340},
}
+@inproceedings{qx_csbp,
+ author = {Q. Yang and L. Wang and N. Ahuja},
+ title = {A Constant-Space Belief Propagation Algorithm for Stereo Matching},
+ booktitle = {CVPR},
+ year = {2010}
+}
+
+@article{felzenszwalb_bp,
+ author = {Pedro F. Felzenszwalb and Daniel P. Huttenlocher},
+ title = {Efficient Belief Propagation for Early Vision},
+ journal = {International Journal of Computer Vision},
+ volume = {70},
+ number = {1},
+ year = {2006},
+ month = {October}
+}
+
# '''[Bradski98]''' G.R. Bradski. Computer vision face tracking as a component of a perceptual user interface. In Workshop on Applications of Computer Vision, pages 214?219, Princeton, NJ, Oct. 1998.<<BR>> Updated version can be found at http://www.intel.com/technology/itj/q21998/articles/art\_2.htm.<<BR>> Also, it is included into OpenCV distribution ([[attachment:camshift.pdf]])
# '''[Burt81]''' P. J. Burt, T. H. Hong, A. Rosenfeld. Segmentation and Estimation of Image Region Properties Through Cooperative Hierarchical Computation. IEEE Tran. On SMC, Vol. 11, N.12, 1981, pp. 802-809.
# '''[Canny86]''' J. Canny. A Computational Approach to Edge Detection, IEEE Trans. on Pattern Analysis and Machine Intelligence, 8(6), pp. 679-698 (1986).
\input{gpu_object_detection}
\input{gpu_features2d}
\input{gpu_image_filtering}
+\input{gpu_calib3d}
\fi
projects / profile / ivi / opencv.git / commitdiff