}
tt {
- color: {{ theme_headtext_color }}
+ color: {{ theme_headtextcolor }};
background-color: #ecf0f3;
padding: 0 1px 0 1px;
font-size: 1.2em;
}
tt.descname {
- color: {{ theme_headtext_color }}
+ color: {{ theme_headtextcolor }};
background-color: #ecf0f3;
padding: 0 1px 0 1px;
font-size: 1.4em;
margin-bottom: 7px;
}
-dl.cfunction > dt:first-child {
+dl.c\:function > dt:first-child {
margin-bottom: 7px;
color: #8080B0;
}
ul.simple {
list-style: none;
}
+
+.enumeratevisibleitems .simple {
+list-style: square;
+}
\ No newline at end of file
[options]
rightsidebar = false
stickysidebar = false
-
footerbgcolor = #004068
footertextcolor = #ffffff
sidebarbgcolor = #006090
feedbackbgcolor = #004068
feedbacktextcolor = #ffffff
feedbacklinkcolor = #ffffff
-
bodyfont = sans-serif
headfont = 'Trebuchet MS', sans-serif
-lang = none
+lang = none
\ No newline at end of file
# Add any Sphinx extension module names here, as strings. They can be extensions
# coming with Sphinx (named 'sphinx.ext.*') or your custom ones.
-extensions = ['sphinx.ext.pngmath', 'sphinx.ext.ifconfig', 'sphinx.ext.todo', 'sphinx.ext.extlinks', 'ocv']
+extensions = ['sphinx.ext.pngmath', 'sphinx.ext.ifconfig', 'sphinx.ext.todo', 'sphinx.ext.extlinks', 'ocv', 'sphinx.ext.doctest']
doctest_test_doctest_blocks = 'block'
# Add any paths that contain templates here, relative to this directory.
# OpenCV docs use some custom LaTeX macros in the formulae. Make sure we include the definitions
pngmath_latex_preamble = r"""
-\usepackage{euler}\usepackage{amssymb}\usepackage{amsmath}\usepackage{bbm}
+\usepackage[usenames,dvipsnames]{color}\usepackage{amssymb}\usepackage{amsmath}\usepackage{bbm}
\newcommand{\matTT}[9]{
\[
\left|\begin{array}{ccc}
+Include in this directory only defintion files. None of the reST files entered here will be parsed by the Sphinx Builder.
\ No newline at end of file
.. math::
K = \dfrac{1}{159}\begin{bmatrix}
- 2 & 4 & 5 & 4 & 2 \\
- 4 & 9 & 12 & 9 & 4 \\
- 5 & 12 & 15 & 12 & 5 \\
- 4 & 9 & 12 & 9 & 4 \\
- 2 & 4 & 5 & 4 & 2
- \end{bmatrix}
+ 2 & 4 & 5 & 4 & 2 \\
+ 4 & 9 & 12 & 9 & 4 \\
+ 5 & 12 & 15 & 12 & 5 \\
+ 4 & 9 & 12 & 9 & 4 \\
+ 2 & 4 & 5 & 4 & 2
+ \end{bmatrix}
#. Find the intensity gradient of the image. For this, we follow a procedure analogous to Sobel:
#. Create a window to display the results
.. code-block:: cpp
- namedWindow( window_name, CV_WINDOW_AUTOSIZE );
+
+ namedWindow( window_name, CV_WINDOW_AUTOSIZE );
#. Create a Trackbar for the user to enter the lower threshold for our Canny detector:
-.. _copyMakeBorder:
+.. _copyMakeBorderTutorial:
Adding borders to your images
******************************
return 0;
}
+
Explanation
=============
b. In the **Polar coordinate system:** Parameters: :math:`(r,\theta)`
.. image:: images/Hough_Lines_Tutorial_Theory_0.jpg
- :alt: Line variables
- :height: 200pt
- :align: center
+ :alt: Line variables
+ :height: 200pt
+ :align: center
For Hough Transforms, we will express lines in the *Polar system*. Hence, a line equation can be written as:
#. If for a given :math:`(x_{0}, y_{0})` we plot the family of lines that goes through it, we get a sinusoid. For instance, for :math:`x_{0} = 8` and :math:`y_{0} = 6` we get the following plot (in a plane :math:`\theta` - :math:`r`):
.. image:: images/Hough_Lines_Tutorial_Theory_1.jpg
- :alt: Polar plot of a the family of lines of a point
- :height: 200pt
- :align: center
+ :alt: Polar plot of a the family of lines of a point
+ :height: 200pt
+ :align: center
We consider only points such that :math:`r > 0` and :math:`0< \theta < 2 \pi`.
#. We can do the same operation above for all the points in an image. If the curves of two different points intersect in the plane :math:`\theta` - :math:`r`, that means that both points belong to a same line. For instance, following with the example above and drawing the plot for two more points: :math:`x_{1} = 9`, :math:`y_{1} = 4` and :math:`x_{2} = 12`, :math:`y_{2} = 3`, we get:
.. image:: images/Hough_Lines_Tutorial_Theory_2.jpg
- :alt: Polar plot of the family of lines for three points
- :height: 200pt
- :align: center
+ :alt: Polar plot of the family of lines for three points
+ :height: 200pt
+ :align: center
+
The three plots intersect in one single point :math:`(0.925, 9.6)`, these coordinates are the parameters (:math:`\theta, r`) or the line in which :math:`(x_{0}, y_{0})`, :math:`(x_{1}, y_{1})` and :math:`(x_{2}, y_{2})` lay.
#. What does all the stuff above mean? It means that in general, a line can be *detected* by finding the number of intersections between curves.The more curves intersecting means that the line represented by that intersection have more points. In general, we can define a *threshold* of the minimum number of intersections needed to *detect* a line.
Using an input image such as:
.. image:: images/Hough_Lines_Tutorial_Original_Image.jpg
- :alt: Result of detecting lines with Hough Transform
- :align: center
+ :alt: Result of detecting lines with Hough Transform
+ :align: center
We get the following result by using the Probabilistic Hough Line Transform:
.. image:: images/Hough_Lines_Tutorial_Result.jpg
- :alt: Result of detecting lines with Hough Transform
- :align: center
+ :alt: Result of detecting lines with Hough Transform
+ :align: center
You may observe that the number of lines detected vary while you change the *threshold*. The explanation is sort of evident: If you establish a higher threshold, fewer lines will be detected (since you will need more points to declare a line detected).
Sobel( src_gray, grad_x, ddepth, 1, 0, 3, scale, delta, BORDER_DEFAULT );
/// Gradient Y
Sobel( src_gray, grad_y, ddepth, 0, 1, 3, scale, delta, BORDER_DEFAULT );
+
The function takes the following arguments:
* *src_gray*: In our example, the input image. Here it is *CV_8U*
../opening_closing_hats/opening_closing_hats\r
../pyramids/pyramids\r
../threshold/threshold\r
+ ../imgtrans/filter_2d/filter_2d\r
+ ../imgtrans/copyMakeBorder/copyMakeBorder\r
+ ../imgtrans/sobel_derivatives/sobel_derivatives\r
+ ../imgtrans/laplace_operator/laplace_operator\r
+ ../imgtrans/canny_detector/canny_detector\r
+ ../imgtrans/hough_lines/hough_lines\r
+ ../imgtrans/hough_circle/hough_circle\r
\r
.. |Author_AnaH| unicode:: Ana U+0020 Huam U+00E1 n\r
\r
:width: 100pt\r
\r
\r
-* :ref:`copyMakeBorder`\r
+* :ref:`copyMakeBorderTutorial`\r
\r
===================== ==============================================\r
|CopyMakeBorder| *Title:* **Adding borders to your images**\r
Prerequisites
===============
-#. Having installed `Eclipse <http://www.eclipse.org/>`_ in your workstation (only the CDT plugin for C/C++ is needed). You can follow the following steps:
+1. Having installed `Eclipse <http://www.eclipse.org/>`_ in your workstation (only the CDT plugin for C/C++ is needed). You can follow the following steps:
* Go to the Eclipse site
* Download `Eclipse IDE for C/C++ Developers <http://www.eclipse.org/downloads/packages/eclipse-ide-cc-developers/heliossr2>`_ . Choose the link according to your workstation.
-#. Having installed OpenCV. If not yet, go :ref:`here <Linux_Installation>`
+#. Having installed OpenCV. If not yet, go :ref:`here <Linux-Installation>`.
Making a project
=================
-#. Start Eclipse. Just run the executable that comes in the folder.
+1. Start Eclipse. Just run the executable that comes in the folder.
#. Go to **File -> New -> C/C++ Project**
- .. image:: images/Eclipse_Tutorial_Screenshot-0.png
+ .. image:: images/a0.png
:height: 400px
:alt: Eclipse Tutorial Screenshot 0
:align: center
#. Choose a name for your project (i.e. DisplayImage). An **Empty Project** should be okay for this example.
- .. image:: images/Eclipse_Tutorial_Screenshot-1.png
+ .. image:: images/a1.png
:height: 400px
:alt: Eclipse Tutorial Screenshot 1
:align: center
#. Leave everything else by default. Press **Finish**.
- .. image:: images/Eclipse_Tutorial_Screenshot-2.png
+ .. image:: images/a2.png
:height: 400px
:alt: Eclipse Tutorial Screenshot 2
:align: center
#. Your project (in this case DisplayImage) should appear in the **Project Navigator** (usually at the left side of your window).
- .. image:: images/Eclipse_Tutorial_Screenshot-3.png
+ .. image:: images/a3.png
:height: 400px
:alt: Eclipse Tutorial Screenshot 3
:align: center
* Right click on **DisplayImage** (in the Navigator). **New -> Folder** .
- .. image:: images/Eclipse_Tutorial_Screenshot-4.png
+ .. image:: images/a4.png
:height: 400px
:alt: Eclipse Tutorial Screenshot 4
:align: center
* Name your folder **src** and then hit **Finish**
- .. image:: images/Eclipse_Tutorial_Screenshot-5.png
+ .. image:: images/a5.png
:height: 400px
:alt: Eclipse Tutorial Screenshot 5
:align: center
* Right click on your newly created **src** folder. Choose **New source file**:
- .. image:: images/Eclipse_Tutorial_Screenshot-6.png
+ .. image:: images/a6.png
:height: 400px
:alt: Eclipse Tutorial Screenshot 6
:align: center
* Call it **DisplayImage.cpp**. Hit **Finish**
- .. image:: images/Eclipse_Tutorial_Screenshot-7.png
+ .. image:: images/a7.png
:height: 400px
:alt: Eclipse Tutorial Screenshot 7
:align: center
*
Go to **Project-->Properties**
- .. image:: images/Eclipse_Tutorial_Screenshot-8.png
- :height: 400px
- :alt: Eclipse Tutorial Screenshot 8
- :align: center
+ .. image:: images/a8.png
+ :height: 400px
+ :alt: Eclipse Tutorial Screenshot 8
+ :align: center
*
In **C/C++ Build**, click on **Settings**. At the right, choose the **Tool Settings** Tab. Here we will enter the headers and libraries info:
a.
In **GCC C++ Compiler**, go to **Includes**. In **Include paths(-l)** you should include the path of the folder where opencv was installed. In our example, this is ``/usr/local/include/opencv``.
- .. image:: images/Eclipse_Tutorial_Screenshot-9.png
+ .. image:: images/a9.png
:height: 400px
:alt: Eclipse Tutorial Screenshot 9
:align: center
If you do not know where your opencv files are, open the **Terminal** and type:
.. code-block:: bash
-
+
pkg-config --cflags opencv
For instance, that command gave me this output:
-I/usr/local/include/opencv -I/usr/local/include
-
+
b.
Now go to **GCC C++ Linker**,there you have to fill two spaces:
- * In **Library search path (-L)** you have to write the path to where the opencv libraries reside, in my case the path is:
- ::
+ First in **Library search path (-L)** you have to write the path to where the opencv libraries reside, in my case the path is:
- /usr/local/lib
-
- ..
-
- *
- In **Libraries(-l)** add the OpenCV libraries that you may need. Usually just the 3 first on the list below are enough (for simple applications) . In my case, I am putting all of them since I plan to use the whole bunch:
-
-
- * opencv_core
- * opencv_imgproc
- * opencv_highgui
- * opencv_ml
- * opencv_video
- * opencv_features2d
- * opencv_calib3d
- * opencv_objdetect
- * opencv_contrib
- * opencv_legacy
- * opencv_flann
+ ::
- .. image:: images/Eclipse_Tutorial_Screenshot-10.png
- :height: 400px
- :alt: Eclipse Tutorial Screenshot 10
- :align: center
-
- .. note::
-
- If you don't know where your libraries are (or you are just psychotic and want to make sure the path is fine), type in **Terminal**:
-
- .. code-block:: bash
+ /usr/local/lib
+
+ Then in **Libraries(-l)** add the OpenCV libraries that you may need. Usually just the 3 first on the list below are enough (for simple applications) . In my case, I am putting all of them since I plan to use the whole bunch:
+
+ * In **Libraries(-l)** add the OpenCV libraries that you may need. Usually just the 3 first on the list below are enough (for simple applications) . In my case, I am putting all of them since I plan to use the whole bunch:
+
+ opencv_core
+ opencv_imgproc
+ opencv_highgui
+ opencv_ml
+ opencv_video
+ opencv_features2d
+ opencv_calib3d
+ opencv_objdetect
+ opencv_contrib
+ opencv_legacy
+ opencv_flann
+
+
+ * opencv_core
+ * opencv_imgproc
+ * opencv_highgui
+ * opencv_ml
+ * opencv_video
+ * opencv_features2d
+ * opencv_calib3d
+ * opencv_objdetect
+ * opencv_contrib
+ * opencv_legacy
+ * opencv_flann
+
+ .. image:: images/Eclipse_Tutorial_Screenshot-10.png
+ :height: 400px
+ :alt: Eclipse Tutorial Screenshot 10
+ :align: center
+ .. image:: images/a10.png
+ :height: 400px
+ :alt: Eclipse Tutorial Screenshot 10
+ :align: center
+
+ .. note::
+ If you don't know where your libraries are (or you are just psychotic and want to make sure the path is fine), type in **Terminal**:
+
+ If you don't know where your libraries are (or you are just psychotic and want to make sure the path is fine), type in **Terminal**:
+ .. code-block:: bash
+
+ .. code-block:: bash
- pkg-config --libs opencv
+ pkg-config --libs opencv
+ pkg-config --libs opencv
+
+ My output (in case you want to check) was:
+ My output (in case you want to check) was:
- My output (in case you want to check) was:
+ .. code-block:: bash
+ .. code-block:: bash
- .. code-block:: bash
+ -L/usr/local/lib -lopencv_core -lopencv_imgproc -lopencv_highgui -lopencv_ml -lopencv_video -lopencv_features2d -lopencv_calib3d -lopencv_objdetect -lopencv_contrib -lopencv_legacy -lopencv_flann
+ -L/usr/local/lib -lopencv_core -lopencv_imgproc -lopencv_highgui -lopencv_ml -lopencv_video -lopencv_features2d -lopencv_calib3d -lopencv_objdetect -lopencv_contrib -lopencv_legacy -lopencv_flann
- -L/usr/local/lib -lopencv_core -lopencv_imgproc -lopencv_highgui -lopencv_ml -lopencv_video -lopencv_features2d -lopencv_calib3d -lopencv_objdetect -lopencv_contrib -lopencv_legacy -lopencv_flann
+ Now you are done. Click **OK**
- Now you are done. Click **OK**
* Your project should be ready to be built. For this, go to **Project->Build all**
.. image:: images/Eclipse_Tutorial_Screenshot-11.png
+
+ .. image:: images/a11.png
:height: 400px
:alt: Eclipse Tutorial Screenshot 11
:align: center
In the Console you should get something like
.. image:: images/Eclipse_Tutorial_Screenshot-12.png
+ .. image:: images/a12.png
:height: 200px
:alt: Eclipse Tutorial Screenshot 12
:align: center
cd src
./DisplayImage ../images/HappyLittleFish.jpg
+
Assuming that the image to use as the argument would be located in <DisplayImage_directory>/images/HappyLittleFish.jpg. We can still do this, but let's do it from Eclipse:
#. Go to **Run->Run Configurations**
.. image:: images/Eclipse_Tutorial_Screenshot-13.png
+ .. image:: images/a13.png
:height: 300px
:alt: Eclipse Tutorial Screenshot 13
:align: center
#. Now, in the right side of the window, choose the **Arguments** Tab. Write the path of the image file we want to open (path relative to the workspace/DisplayImage folder). Let's use **HappyLittleFish.jpg**:
.. image:: images/Eclipse_Tutorial_Screenshot-14.png
+ .. image:: images/a14.png
:height: 300px
:alt: Eclipse Tutorial Screenshot 14
:align: center
#. Click on the **Apply** button and then in Run. An OpenCV window should pop up with the fish image (or whatever you used).
.. image:: images/Eclipse_Tutorial_Screenshot-15.png
+ .. image:: images/a15.png
:alt: Eclipse Tutorial Screenshot 15
:align: center
#. Congratulations! You are ready to have fun with OpenCV using Eclipse.
+#. Congratulations! You are ready to have fun with OpenCV using Eclipse.
.. image:: images/GCC_CMake_Example_Tutorial.png
:alt: Display Image - Lena
:align: center
-
In this tutorial you will learn how to:
-* Load an image using :imread:`imread <> `
+* Load an image using :imread:`imread <>`
* Transform an image from RGB to Grayscale format by using :cvt_color:`cvtColor <>`
* Save your transformed image in a file on disk (using :imwrite:`imwrite <>`)
-.. _Windows_Installation:
-
-Installation in Windows
-***********************
-For now this is just a stub article. It will be updated with valuable content as soon as possible. Make sure to check back for it!
+.. _Windows_Installation:\r
+\r
+Installation in Windows\r
+***********************\r
+\r
+The description here was tested by the author using the Windows 7 SP1 **o**\ perating **s**\ ystem (OS). Nevertheless, it should also work on any other Windows OS too. If you encounter errors after following the steps described here feel free to contact us via our :opencv_group:`user group <>` and we will try to fix your problem.\r
+\r
+.. note:: To use the OpenCV library you have two options:\r
+ \r
+ .. container:: enumeratevisibleitems\r
+ \r
+ - download and install our pre-built libraries\r
+ - make your own ones from the source files.\r
+\r
+ While the first one is easier to complete, it only works if you are coding inside the latest Microsoft Visual Studio integrated development environments and doesn't takes advantage of the most novel technologies we integrate into our library. \r
+\r
+Installation by using the pre-built libraries\r
+=============================================\r
+\r
+1. Open up a web browser and go to: http://sourceforge.net/projects/opencvlibrary/files/opencv-win/\r
+\r
+#. Open the folder for the latest version (currently this is 2.3).\r
+\r
+#. Choose a build you want to use and download it. The naming conventions used will show what kind of support they offer. For example:\r
+ \r
+ .. container:: enumeratevisibleitems\r
+ \r
+ * *vs2010* means the Visual Studio \r
+ * *win32* means that it is for 32 bit applications in the OS\r
+ * *gpu* means that it includes the support for using your GPU in order to further increase the performance of the library).\r
+ \r
+ If you downloaded the source files present here see :ref:`CppTutWindowsMakeOwn`.\r
+\r
+#. Make sure you have admin rights. Start the setup and follow the wizard. Agree to the \" License Agreement \" . \r
+\r
+#. Adding the OpenCV library to the system path is a good decision unless you want to play around with multiple flavors of the same OpenCV version. You will use the OpenCV library in form of *\"Dynamic-link library\"* (also known as **DLL**). Inside these are stored all the algorithms and information the OpenCV library contains. The operating system will load them only on demand during runtime. However, to do this he needs to know where they are. The systems **PATH** contains a list of folders where DLLs can be found. Add the OpenCV library path to this and the OS will know of the existence of the OpenCV binaries. Otherwise you will need to copy the used DLLs right beside the applications executable file (*exe*) for the OS to find it. \r
+\r
+ .. note:: \r
+ A good way to check your systems path folders is by using the \"*Path Editor*\" application. You can download it `from here <http://www.redfernplace.com/software-projects/patheditor/>`_. Use this if you are not sure the systems path was updated with the OpenCV entry. You can also add manually new folders to the system path by using this application. \r
+\r
+#. Most of the time it is a good idea to install the source files as this will allow for you to debug into the OpenCV library, if it is necessary. Therefore, just follow the default settings of the wizard and finish the installation. \r
+\r
+#. In the end you can check the installation at the chosen path. If you added the OpenCV Path to the system PATH inside the *Path Editor* you should see an entry with the *bin* folder of the OpenCV directory. \r
+\r
+.. image:: images/OpenCV_Install_Directory.png\r
+ :alt: An example of how the installation directory should look in case of success.\r
+ :align: center\r
+\r
+Szia.\r
+\r
+.. _CppTutWindowsMakeOwn: \r
+\r
+Installation by making your own libraries\r
+=========================================\r
+\r
+If you are building your own libraries you can either take the source files from our latest:\r
+\r
+ .. container:: enumeratevisibleitems\r
+\r
+ + stable/tested build - https://code.ros.org/svn/opencv/branches/\r
+ + development build - https://code.ros.org/svn/opencv/trunk/\r
+\r
+While the later one may contain a couple of new and experimental algorithms, performance increases and interface improvements be aware that it may also contain many-many bugs. Using the first one is recommended in most of the cases, unless you are extending the OpenCV library itself or really need to most up to date version of it. \r
-############
Tutorials
###########
==================
The code
--------
+--------
We will start with a short sample ``opencv/samples/cpp/matcher_simple.cpp``: ::
Mat img1 = imread(argv[1], CV_LOAD_IMAGE_GRAYSCALE);
:maxdepth: 2
modules/refman.rst
- doc/opencv2/py/py_index.rst
- doc/opencv1/c/c_index.rst
- doc/opencv1/py/py_index.rst
doc/user_guide/user_guide.rst
doc/tutorials/tutorials.rst
* :math:`A` is a camera matrix, or a matrix of intrinsic parameters
* :math:`(cx, cy)` is a principal point that is usually at the image center
* :math:`fx, fy` are the focal lengths expressed in pixel-related units
+
Thus, if an image from the camera is
scaled by a factor, all of these parameters should
be scaled (multiplied/divided, respectively) by the same factor. The
:param imagePoints: Array of corresponding image points, 2xN/Nx2 1-channel or 1xN/Nx1 2-channel, where N is the number of points. ``vector<Point2f>`` can be also passed here.
:param cameraMatrix: Input camera matrix :math:`A = \vecthreethree{fx}{0}{cx}{0}{fy}{cy}{0}{0}{1}` .
-
+
:param distCoeffs: Input vector of distortion coefficients :math:`(k_1, k_2, p_1, p_2[, k_3[, k_4, k_5, k_6]])` of 4, 5, or 8 elements. If the vector is NULL/empty, the zero distortion coefficients are assumed.
:param rvec: Output rotation vector (see :ocv:func:`Rodrigues` ) that, together with ``tvec`` , brings points from the model coordinate system to the camera coordinate system.
:param points1: Array of ``N`` points from the first image. The point coordinates should be floating-point (single or double precision).
:param points2: Array of the second image points of the same size and format as ``points1`` .
-
+
:param method: Method for computing a fundamental matrix.
* **CV_FM_7POINT** for a 7-point algorithm. :math:`N = 7`
* **CV_FM_RANSAC** for the RANSAC algorithm. :math:`N \ge 8`
* **CV_FM_LMEDS** for the LMedS algorithm. :math:`N \ge 8`
- :param param1: Parameter used for RANSAC. It is the maximum distance from a point to an epipolar line in pixels, beyond which the point is considered an outlier and is not used for computing the final fundamental matrix. It can be set to something like 1-3, depending on the accuracy of the point localization, image resolution, and the image noise.
+ :param param1: Parameter used for RANSAC. It is the maximum distance from a point to an epipolar line in pixels, beyond which the point is considered an outlier and is not used for computing the final fundamental matrix. It can be set to something like 1-3, depending on the accuracy of the point localization, image resolution, and the image noise.
:param param2: Parameter used for the RANSAC or LMedS methods only. It specifies a desirable level of confidence (probability) that the estimated matrix is correct.
:param imageSize: Original image size.
:param alpha: Free scaling parameter between 0 (when all the pixels in the undistorted image are valid) and 1 (when all the source image pixels are retained in the undistorted image). See :ref:`StereoRectify` for details.
-
+
:param newCameraMatrix: Output new camera matrix.
:param newImageSize: Image size after rectification. By default,it is set to ``imageSize`` .
:param imagePoints2: Vector of vectors of the projections of the calibration pattern points, observed by the second camera.
- :param cameraMatrix1: Input/output first camera matrix: :math:`\vecthreethree{f_x^{(j)}}{0}{c_x^{(j)}}{0}{f_y^{(j)}}{c_y^{(j)}}{0}{0}{1}` ,
- :math:`j = 0,\, 1` . If any of ``CV_CALIB_USE_INTRINSIC_GUESS`` , ``CV_CALIB_FIX_ASPECT_RATIO`` , ``CV_CALIB_FIX_INTRINSIC`` , or ``CV_CALIB_FIX_FOCAL_LENGTH`` are specified, some or all of the matrix components must be initialized. See the flags description for details.
+ :param cameraMatrix1: Input/output first camera matrix: :math:`\vecthreethree{f_x^{(j)}}{0}{c_x^{(j)}}{0}{f_y^{(j)}}{c_y^{(j)}}{0}{0}{1}` , :math:`j = 0,\, 1` . If any of ``CV_CALIB_USE_INTRINSIC_GUESS`` , ``CV_CALIB_FIX_ASPECT_RATIO`` , ``CV_CALIB_FIX_INTRINSIC`` , or ``CV_CALIB_FIX_FOCAL_LENGTH`` are specified, some or all of the matrix components must be initialized. See the flags description for details.
:param distCoeffs1: Input/output vector of distortion coefficients :math:`(k_1, k_2, p_1, p_2[, k_3[, k_4, k_5, k_6]])` of 4, 5, or 8 elements. The output vector length depends on the flags.
* **CV_CALIB_FIX_ASPECT_RATIO** Optimize :math:`f^{(j)}_y` . Fix the ratio :math:`f^{(j)}_x/f^{(j)}_y` .
* **CV_CALIB_SAME_FOCAL_LENGTH** Enforce :math:`f^{(0)}_x=f^{(1)}_x` and :math:`f^{(0)}_y=f^{(1)}_y` .
-
+
* **CV_CALIB_ZERO_TANGENT_DIST** Set tangential distortion coefficients for each camera to zeros and fix there.
* **CV_CALIB_FIX_K1,...,CV_CALIB_FIX_K6** Do not change the corresponding radial distortion coefficient during the optimization. If ``CV_CALIB_USE_INTRINSIC_GUESS`` is set, the coefficient from the supplied ``distCoeffs`` matrix is used. Otherwise, it is set to 0.
.. [BouguetMCT] J.Y.Bouguet. MATLAB calibration tool. http://www.vision.caltech.edu/bouguetj/calib_doc/
-.. [Hartley99] Hartley, R.I., “Theory and Practice of Projective Rectification”. IJCV 35 2, pp 115-127 (1999)
+.. [Hartley99] Hartley, R.I., \93Theory and Practice of Projective Rectification\94. IJCV 35 2, pp 115-127 (1999)
-.. [Zhang2000] Z. Zhang. A Flexible New Technique for Camera Calibration. IEEE Transactions on Pattern Analysis and Machine Intelligence, 22(11):1330-1334, 2000.
\ No newline at end of file
+.. [Zhang2000] Z. Zhang. A Flexible New Technique for Camera Calibration. IEEE Transactions on Pattern Analysis and Machine Intelligence, 22(11):1330-1334, 2000.
7, 8, 9);
cout << sum(Mat(m*m.t())) << endl;
-
+
Vec
---
.. ocv:class:: Vec
}
+.. _Ptr:
+
Ptr
---
.. ocv:class:: Ptr
.. note::
- In the current implementation, the following code does not work as expected: ::
+ In the current implementation, the following code does not work as expected: ::
- Mat A;
- ...
- A.row(i) = A.row(j); // will not work
+ Mat A;
+ ...
+ A.row(i) = A.row(j); // will not work
- This happens because ``A.row(i)`` forms a temporary header that is further assigned to another header. Remember that each of these operations is O(1), that is, no data is copied. Thus, the above assignment is not true if you may have expected the j-th row to be copied to the i-th row. To achieve that, you should either turn this simple assignment into an expression or use the
- :ocv:func:`Mat::copyTo` method: ::
+ This happens because ``A.row(i)`` forms a temporary header that is further assigned to another header. Remember that each of these operations is O(1), that is, no data is copied. Thus, the above assignment is not true if you may have expected the j-th row to be copied to the i-th row. To achieve that, you should either turn this simple assignment into an expression or use the
+ :ocv:func:`Mat::copyTo` method: ::
- Mat A;
- ...
- // works, but looks a bit obscure.
- A.row(i) = A.row(j) + 0;
+ Mat A;
+ ...
+ // works, but looks a bit obscure.
+ A.row(i) = A.row(j) + 0;
- // this is a bit longe, but the recommended method.
- Mat Ai = A.row(i); M.row(j).copyTo(Ai);
+ // this is a bit longe, but the recommended method.
+ Mat Ai = A.row(i); M.row(j).copyTo(Ai);
Mat::col
------------
When the operation mask is specified, and the ``Mat::create`` call shown above reallocated the matrix, the newly allocated matrix is initialized with all zeros before copying the data.
+.. _Mat::convertTo:
+
Mat::convertTo
------------------
.. ocv:function:: void Mat::convertTo( OutputArray m, int rtype, double alpha=1, double beta=0 ) const
:param cols: Number of columns.
:param size: Alternative to the matrix size specification ``Size(cols, rows)`` .
-
+
:param sizes: Array of integers specifying the array shape.
:param type: Created matrix type.
:param cols: Number of columns.
:param size: Alternative to the matrix size specification ``Size(cols, rows)`` .
-
- :param sizes: Array of integers specifying the array shape.
+
+ :param sizes: Array of integers specifying the array shape.
:param type: Created matrix type.
:param cols: Number of columns.
:param size: Alternative matrix size specification as ``Size(cols, rows)`` .
-
+
:param type: Created matrix type.
The method returns a Matlab-style identity matrix initializer, similarly to
:param cols: New number of columns.
:param size: Alternative new matrix size specification: ``Size(cols, rows)``
-
+
:param sizes: Array of integers specifying a new array shape.
:param type: New matrix type.
#.
If the current array shape and the type match the new ones, return immediately. Otherwise, de-reference the previous data by calling
:ocv:func:`Mat::release`.
-
+
#.
Initialize the new header.
Extracts a rectangular submatrix.
:param rowRange: Start and end row of the extracted submatrix. The upper boundary is not included. To select all the rows, use ``Range::all()``.
-
+
:param colRange: Start and end column of the extracted submatrix. The upper boundary is not included. To select all the columns, use ``Range::all()``.
-
+
:param roi: Extracted submatrix specified as a rectangle.
:param ranges: Array of selected ranges along each array dimension.
:param i, j, k: Indices along the dimensions 0, 1, and 2, respectively.
:param pt: Element position specified as ``Point(j,i)`` .
-
+
:param idx: Array of ``Mat::dims`` indices.
The template methods return a reference to the specified array element. For the sake of higher performance, the index range checks are only performed in the Debug configuration.
NAryMatIterator
---------------
+---------------
.. ocv:class:: NAryMatIterator
n-ary multi-dimensional array iterator. ::
:param vec: Set of elements stored as a vector.
:param labels: Output vector of labels. It contains as many elements as ``vec``. Each label ``labels[i]`` is a 0-based cluster index of ``vec[i]`` .
-
+
:param predicate: Equivalence predicate (pointer to a boolean function of two arguments or an instance of the class that has the method ``bool operator()(const _Tp& a, const _Tp& b)`` ). The predicate returns ``true`` when the elements are certainly in the same class, and returns ``false`` if they may or may not be in the same class.
The generic function ``partition`` implements an
. The function
returns the number of equivalency classes.
-.. [Arthur2007] Arthur and S. Vassilvitskii “k-means++: the advantages of careful seeding”, Proceedings of the eighteenth annual ACM-SIAM symposium on Discrete algorithms, 2007
+.. [Arthur2007] Arthur and S. Vassilvitskii \93k-means++: the advantages of careful seeding\94, Proceedings of the eighteenth annual ACM-SIAM symposium on Discrete algorithms, 2007
.. ocv:pyfunction:: cv2.circle(img, center, radius, color[, thickness[, lineType[, shift]]]) -> None
-.. ocv:cfunction:: void cvCircle( CvArr* img, CvPoint center, int radius, CvScalar color, int thickness=1, int lineType=8, int shift=0 )
+.. ocv:function:: void cvCircle( CvArr* img, CvPoint center, int radius, CvScalar color, int thickness=1, int lineType=8, int shift=0 )
.. ocv:pyoldfunction:: cv.Circle(img, center, radius, color, thickness=1, lineType=8, shift=0)-> None
:param img: Image where the circle is drawn.
.. ocv:pyfunction:: cv2.clipLine(imgRect, pt1, pt2) -> retval, pt1, pt2
-.. ocv:cfunction:: int cvClipLine( CvSize imgSize, CvPoint* pt1, CvPoint* pt2 )
+.. ocv:function:: int cvClipLine( CvSize imgSize, CvPoint* pt1, CvPoint* pt2 )
.. ocv:pyoldfunction:: cv.ClipLine(imgSize, pt1, pt2) -> (clippedPt1, clippedPt2)
:param imgSize: Image size. The image rectangle is ``Rect(0, 0, imgSize.width, imgSize.height)`` .
.. ocv:pyfunction:: cv2.ellipse(img, center, axes, angle, startAngle, endAngle, color[, thickness[, lineType[, shift]]]) -> None
.. ocv:pyfunction:: cv2.ellipse(img, box, color[, thickness[, lineType]]) -> None
-.. ocv:cfunction:: void cvEllipse( CvArr* img, CvPoint center, CvSize axes, double angle, double startAngle, double endAngle, CvScalar color, int thickness=1, int lineType=8, int shift=0 )
+.. ocv:function:: void cvEllipse( CvArr* img, CvPoint center, CvSize axes, double angle, double startAngle, double endAngle, CvScalar color, int thickness=1, int lineType=8, int shift=0 )
.. ocv:pyoldfunction:: cv.Ellipse(img, center, axes, angle, startAngle, endAngle, color, thickness=1, lineType=8, shift=0)-> None
-.. ocv:cfunction:: void cvEllipseBox( CvArr* img, CvBox2D box, CvScalar color, int thickness=1, int lineType=8, int shift=0 )
+.. ocv:function:: void cvEllipseBox( CvArr* img, CvBox2D box, CvScalar color, int thickness=1, int lineType=8, int shift=0 )
.. ocv:pyoldfunction:: cv.EllipseBox(img, box, color, thickness=1, lineType=8, shift=0)-> None
:param img: Image.
:param center: Center of the arc.
:param axes: Half-sizes of the arc. See the :ocv:func:`ellipse` for details.
-
+
:param angle: Rotation angle of the ellipse in degrees. See the :ocv:func:`ellipse` for details.
-
+
:param startAngle: Starting angle of the elliptic arc in degrees.
:param endAngle: Ending angle of the elliptic arc in degrees.
.. ocv:pyfunction:: cv2.fillConvexPoly(img, points, color[, lineType[, shift]]) -> None
-.. ocv:cfunction:: void cvFillConvexPoly( CvArr* img, CvPoint* pts, int npts, CvScalar color, int lineType=8, int shift=0 )
+.. ocv:function:: void cvFillConvexPoly( CvArr* img, CvPoint* pts, int npts, CvScalar color, int lineType=8, int shift=0 )
.. ocv:pyoldfunction:: cv.FillConvexPoly(img, pn, color, lineType=8, shift=0)-> None
:param img: Image.
.. ocv:pyfunction:: cv2.fillPoly(img, pts, color[, lineType[, shift[, offset]]]) -> None
-.. ocv:cfunction:: void cvFillPoly( CvArr* img, CvPoint** pts, int* npts, int contours, CvScalar color, int lineType=8, int shift=0 )
+.. ocv:function:: void cvFillPoly( CvArr* img, CvPoint** pts, int* npts, int contours, CvScalar color, int lineType=8, int shift=0 )
.. ocv:pyoldfunction:: cv.FillPoly(img, polys, color, lineType=8, shift=0)-> None
:param img: Image.
.. ocv:pyfunction:: cv2.getTextSize(text, fontFace, fontScale, thickness) -> retval, baseLine
-.. ocv:cfunction:: void cvGetTextSize( const char* textString, const CvFont* font, CvSize* textSize, int* baseline )
+.. ocv:function:: void cvGetTextSize( const char* textString, const CvFont* font, CvSize* textSize, int* baseline )
.. ocv:pyoldfunction:: cv.GetTextSize(textString, font)-> (textSize, baseline)
:param text: Input text string.
--------
Initializes font structure (OpenCV 1.x API).
-.. cfunction:: void cvInitFont( CvFont* font, int fontFace, double hscale, double vscale, double shear=0, int thickness=1, int lineType=8 )
+.. c:function:: void cvInitFont( CvFont* font, int fontFace, double hscale, double vscale, double shear=0, int thickness=1, int lineType=8 )
:param font: Pointer to the font structure initialized by the function
.. seealso:: :ocv:cfunc:`PutText`
+.. _Line:
line
--------
.. ocv:pyfunction:: cv2.line(img, pt1, pt2, color[, thickness[, lineType[, shift]]]) -> None
-.. ocv:cfunction:: void cvLine( CvArr* img, CvPoint pt1, CvPoint pt2, CvScalar color, int thickness=1, int lineType=8, int shift=0 )
+.. ocv:function:: void cvLine( CvArr* img, CvPoint pt1, CvPoint pt2, CvScalar color, int thickness=1, int lineType=8, int shift=0 )
.. ocv:pyoldfunction:: cv.Line(img, pt1, pt2, color, thickness=1, lineType=8, shift=0)-> None
:param img: Image.
.. ocv:pyfunction:: cv2.rectangle(img, pt1, pt2, color[, thickness[, lineType[, shift]]]) -> None
-.. ocv:cfunction:: void cvRectangle( CvArr* img, CvPoint pt1, CvPoint pt2, CvScalar color, int thickness=1, int lineType=8, int shift=0 )
+.. ocv:function:: void cvRectangle( CvArr* img, CvPoint pt1, CvPoint pt2, CvScalar color, int thickness=1, int lineType=8, int shift=0 )
.. ocv:pyoldfunction:: cv.Rectangle(img, pt1, pt2, color, thickness=1, lineType=8, shift=0)-> None
:param img: Image.
.. ocv:pyfunction:: cv2.polylines(img, pts, isClosed, color[, thickness[, lineType[, shift]]]) -> None
-.. ocv:cfunction:: void cvPolyLine( CvArr* img, CvPoint** pts, int* npts, int contours, int isClosed, CvScalar color, int thickness=1, int lineType=8, int shift=0 )
+.. ocv:function:: void cvPolyLine( CvArr* img, CvPoint** pts, int* npts, int contours, int isClosed, CvScalar color, int thickness=1, int lineType=8, int shift=0 )
.. ocv:pyoldfunction:: cv.PolyLine(img, polys, isClosed, color, thickness=1, lineType=8, shift=0)-> None
.. ocv:pyfunction:: cv2.putText(img, text, org, fontFace, fontScale, color[, thickness[, linetype[, bottomLeftOrigin]]]) -> None
-.. ocv:cfunction:: void cvPutText( CvArr* img, const char* text, CvPoint org, const CvFont* font, CvScalar color )
+.. ocv:function:: void cvPutText( CvArr* img, const char* text, CvPoint org, const CvFont* font, CvScalar color )
.. ocv:pyoldfunction:: cv.PutText(img, text, org, font, color)-> None
:param img: Image.
* ``CV_8UC(n)`` ... ``CV_64FC(n)`` or ``CV_MAKETYPE(CV_8U, n)`` ... ``CV_MAKETYPE(CV_64F, n)`` macros when the number of channels is more than 4 or unknown at the compilation time.
.. note:: ``CV_32FC1 == CV_32F``, ``CV_32FC2 == CV_32FC(2) == CV_MAKETYPE(CV_32F, 2)``, and ``CV_MAKETYPE(depth, n) == ((x&7)<<3) + (n-1)``. This means that the constant type is formed from the ``depth``, taking the lowest 3 bits, and the number of channels minus 1, taking the next ``log2(CV_CN_MAX)`` bits.
+
Examples::
Mat mtx(3, 3, CV_32F); // make a 3x3 floating-point matrix
:param exc: Exception to throw.
:param code: Error code. Normally, it is a negative value. The list of pre-defined error codes can be found in ``cxerror.h`` .
-
+
:param msg: Text of the error message.
:param args: ``printf`` -like formatted error message in parentheses.
format
-----------
+------
Returns a text string formatted using the ``printf`` -like expression.
.. ocv:function:: string format( const char* fmt, ... )
The function returns the number of threads that is used by OpenCV.
.. seealso::
-:ocv:func:`setNumThreads`,
-:ocv:func:`getThreadNum`
+ :ocv:func:`setNumThreads`,
+ :ocv:func:`getThreadNum`
The function returns a 0-based index of the currently executed thread. The function is only valid inside a parallel OpenMP region. When OpenCV is built without OpenMP support, the function always returns 0.
.. seealso::
-:ocv:func:`setNumThreads`,
-:ocv:func:`getNumThreads` .
+ :ocv:func:`setNumThreads`,
+ :ocv:func:`getNumThreads` .
The function sets the number of threads used by OpenCV in parallel OpenMP regions. If ``nthreads=0`` , the function uses the default number of threads that is usually equal to the number of the processing cores.
.. seealso::
-:ocv:func:`getNumThreads`,
-:ocv:func:`getThreadNum`
+ :ocv:func:`getNumThreads`,
+ :ocv:func:`getThreadNum`
BOWKMeansTrainer::BOWKMeansTrainer
----------------------------------
+
The constructor.
.. ocv:function:: BOWKMeansTrainer::BOWKMeansTrainer( int clusterCount, const TermCriteria& termcrit=TermCriteria(), int attempts=3, int flags=KMEANS_PP_CENTERS );
BOWImgDescriptorExtractor::descriptorType
---------------------------------------------
+
Returns an image descriptor type.
.. ocv:function:: int BOWImgDescriptorExtractor::descriptorType() const
typedef DevMem2D_<unsigned char> DevMem2D;
typedef DevMem2D_<float> DevMem2Df;
typedef DevMem2D_<int> DevMem2Di;
+
..
Beware that the latter limitation may lead to overloaded matrix operators that cause memory allocations. The ``GpuMat`` class is convertible to :ocv:class:`gpu::DevMem2D_` and :ocv:class:`gpu::PtrStep_` so it can be passed directly to the kernel.
.. note:: In contrast with :ocv:class:`Mat`, in most cases ``GpuMat::isContinuous() == false`` . This means that rows are aligned to a size depending on the hardware. Single-row ``GpuMat`` is always a continuous matrix.
+
::
class CV_EXPORTS GpuMat
.. note::
- You are not recommended to leave static or global ``GpuMat`` variables allocated, that is, to rely on its destructor. The destruction order of such variables and CUDA context is undefined. GPU memory release function returns error if the CUDA context has been destroyed before.
+ You are not recommended to leave static or global ``GpuMat`` variables allocated, that is, to rely on its destructor. The destruction order of such variables and CUDA context is undefined. GPU memory release function returns error if the CUDA context has been destroyed before.
.. seealso::
-:ocv:class:`Mat`
+ :ocv:class:`Mat`
.. index:: gpu::CudaMem
``ALLOC_WRITE_COMBINED`` sets the write combined buffer that is not cached by CPU. Such buffers are used to supply GPU with data when GPU only reads it. The advantage is a better CPU cache utilization.
.. note::
+ Allocation size of such memory types is usually limited. For more details, see *CUDA 2.2 Pinned Memory APIs* document or *CUDA C Programming Guide*.
- Allocation size of such memory types is usually limited. For more details, see *CUDA 2.2 Pinned Memory APIs* document or *CUDA C Programming Guide*.
::
class CV_EXPORTS CudaMem
This class encapsulates a queue of asynchronous calls. Some functions have overloads with the additional ``gpu::Stream`` parameter. The overloads do initialization work (allocate output buffers, upload constants, and so on), start the GPU kernel, and return before results are ready. You can check whether all operations are complete via :ocv:func:`gpu::Stream::queryIfComplete`. You can asynchronously upload/download data from/to page-locked buffers, using the :ocv:class:`gpu::CudaMem` or :ocv:class:`Mat` header that points to a region of :ocv:class:`gpu::CudaMem`.
.. note::
-
- Currently, you may face problems if an operation is enqueued twice with different data. Some functions use the constant GPU memory, and next call may update the memory before the previous one has been finished. But calling different operations asynchronously is safe because each operation has its own constant buffer. Memory copy/upload/download/set operations to the buffers you hold are also safe.
+ Currently, you may face problems if an operation is enqueued twice with different data. Some functions use the constant GPU memory, and next call may update the memory before the previous one has been finished. But calling different operations asynchronously is safe because each operation has its own constant buffer. Memory copy/upload/download/set operations to the buffers you hold are also safe.
+
::
class CV_EXPORTS Stream
The following wrappers are also available:
- * .. ocv:function:: GpuMat gpu::createContinuous(int rows, int cols, int type)
+ * .. ocv:function:: GpuMat gpu::createContinuous(int rows, int cols, int type)
- * .. ocv:function:: void gpu::createContinuous(Size size, int type, GpuMat& m)
+ * .. ocv:function:: void gpu::createContinuous(Size size, int type, GpuMat& m)
- * .. ocv:function:: GpuMat gpu::createContinuous(Size size, int type)
+ * .. ocv:function:: GpuMat gpu::createContinuous(Size size, int type)
Matrix is called continuous if its elements are stored continuously, that is, without gaps at the end of each row.
The class ``SURF_GPU`` uses some buffers and provides access to it. All buffers can be safely released between function calls.
.. seealso::
-:ocv:class:`SURF`
+ :ocv:class:`SURF`
.. index:: gpu::BruteForceMatcher_GPU
The class ``BruteForceMatcher_GPU`` has an interface similar to the class :ocv:class:`DescriptorMatcher`. It has two groups of ``match`` methods: for matching descriptors of one image with another image or with an image set. Also, all functions have an alternative to save results either to the GPU memory or to the CPU memory. The ``Distance`` template parameter is kept for CPU/GPU interfaces similarity. ``BruteForceMatcher_GPU`` supports only the ``L1<float>``, ``L2<float>``, and ``Hamming`` distance types.
.. seealso::
-:ocv:class:`DescriptorMatcher`,
-:ocv:class:`BruteForceMatcher`
+ :ocv:class:`DescriptorMatcher`,
+ :ocv:class:`BruteForceMatcher`
.. index:: gpu::BruteForceMatcher_GPU::match
Finds the best match for each descriptor from a query set with train descriptors.
.. seealso::
-:ocv:func:`DescriptorMatcher::match`
+ :ocv:func:`DescriptorMatcher::match`
.. index:: gpu::BruteForceMatcher_GPU::matchSingle
-----------------------------------------------
.. ocv:function:: void gpu::BruteForceMatcher_GPU::matchCollection(const GpuMat& queryDescs, const GpuMat& trainCollection, GpuMat& trainIdx, GpuMat& imgIdx, GpuMat& distance, const GpuMat& maskCollection)
- Finds the best match for each query descriptor from train collection. Results are stored in the GPU memory.
+ Finds the best match for each query descriptor from train collection. Results are stored in the GPU memory.
:param queryDescs: Query set of descriptors.
-------------------------------------------------
.. ocv:function:: void gpu::BruteForceMatcher_GPU::makeGpuCollection(GpuMat& trainCollection, GpuMat& maskCollection, const vector<GpuMat>&masks = std::vector<GpuMat>())
- Performs a GPU collection of train descriptors and masks in a suitable format for the
- :ocv:func:`gpu::BruteForceMatcher_GPU::matchCollection` function.
+ Performs a GPU collection of train descriptors and masks in a suitable format for the
+ :ocv:func:`gpu::BruteForceMatcher_GPU::matchCollection` function.
.. index:: gpu::BruteForceMatcher_GPU::matchDownload
.. ocv:function:: void gpu::BruteForceMatcher_GPU::matchDownload(const GpuMat& trainIdx, GpuMat& imgIdx, const GpuMat& distance, std::vector<DMatch>&matches)
- Downloads ``trainIdx``, ``imgIdx``, and ``distance`` matrices obtained via
- :ocv:func:`gpu::BruteForceMatcher_GPU::matchSingle` or
- :ocv:func:`gpu::BruteForceMatcher_GPU::matchCollection` to CPU vector with :ocv:class:`DMatch`.
+ Downloads ``trainIdx``, ``imgIdx``, and ``distance`` matrices obtained via
+ :ocv:func:`gpu::BruteForceMatcher_GPU::matchSingle` or
+ :ocv:func:`gpu::BruteForceMatcher_GPU::matchCollection` to CPU vector with :ocv:class:`DMatch`.
.. index:: gpu::BruteForceMatcher_GPU::knnMatch
.. ocv:function:: void knnMatch(const GpuMat& queryDescs, std::vector< std::vector<DMatch> >&matches, int k, const std::vector<GpuMat>&masks = std::vector<GpuMat>(), bool compactResult = false )
.. seealso::
-:ocv:func:`DescriptorMatcher::knnMatch`
+ :ocv:func:`DescriptorMatcher::knnMatch`
.. index:: gpu::BruteForceMatcher_GPU::knnMatch
This function works only on devices with the compute capability :math:`>=` 1.1.
.. seealso::
-:ocv:func:`DescriptorMatcher::radiusMatch`
+ :ocv:func:`DescriptorMatcher::radiusMatch`
.. index:: gpu::BruteForceMatcher_GPU::radiusMatch
---------------------------------------------------
.. ocv:function:: void gpu::BruteForceMatcher_GPU::radiusMatchDownload(const GpuMat& trainIdx, const GpuMat& nMatches, const GpuMat& distance, std::vector< std::vector<DMatch> >&matches, bool compactResult = false)
- Downloads ``trainIdx``, ``nMatches`` and ``distance`` matrices obtained via :ocv:func:`gpu::BruteForceMatcher_GPU::radiusMatch` to CPU vector with :ocv:class:`DMatch`. If ``compactResult`` is true, the ``matches`` vector does not contain matches for fully masked-out query descriptors.
+ Downloads ``trainIdx``, ``nMatches`` and ``distance`` matrices obtained via :ocv:func:`gpu::BruteForceMatcher_GPU::radiusMatch` to CPU vector with :ocv:class:`DMatch`. If ``compactResult`` is true, the ``matches`` vector does not contain matches for fully masked-out query descriptors.
.. note:: The GPU filters do not support the in-place mode.
.. seealso::
-:ocv:class:`gpu::BaseRowFilter_GPU`,
-:ocv:class:`gpu::BaseColumnFilter_GPU`,
-:ocv:class:`gpu::BaseFilter_GPU`,
-:ocv:func:`gpu::createFilter2D_GPU`,
-:ocv:func:`gpu::createSeparableFilter_GPU`,
-:ocv:func:`gpu::createBoxFilter_GPU`,
-:ocv:func:`gpu::createMorphologyFilter_GPU`,
-:ocv:func:`gpu::createLinearFilter_GPU`,
-:ocv:func:`gpu::createSeparableLinearFilter_GPU`,
-:ocv:func:`gpu::createDerivFilter_GPU`,
-:ocv:func:`gpu::createGaussianFilter_GPU`
+ :ocv:class:`gpu::BaseRowFilter_GPU`,
+ :ocv:class:`gpu::BaseColumnFilter_GPU`,
+ :ocv:class:`gpu::BaseFilter_GPU`,
+ :ocv:func:`gpu::createFilter2D_GPU`,
+ :ocv:func:`gpu::createSeparableFilter_GPU`,
+ :ocv:func:`gpu::createBoxFilter_GPU`,
+ :ocv:func:`gpu::createMorphologyFilter_GPU`,
+ :ocv:func:`gpu::createLinearFilter_GPU`,
+ :ocv:func:`gpu::createSeparableLinearFilter_GPU`,
+ :ocv:func:`gpu::createDerivFilter_GPU`,
+ :ocv:func:`gpu::createGaussianFilter_GPU`
.. index:: gpu::createFilter2D_GPU
:param iterations: Number of times erosion to be applied.
.. note::
-
- This filter does not check out-of-border accesses, so only a proper sub-matrix of a bigger matrix has to be passed to it.
+
+ This filter does not check out-of-border accesses, so only a proper sub-matrix of a bigger matrix has to be passed to it.
.. seealso:: :ocv:func:`erode`
:param kernel: 2D array of filter coefficients. This filter works with integers kernels. If ``kernel`` has a ``float`` or ``double`` type, it uses fixed-point arithmetic.
:param anchor: Anchor of the kernel that indicates the relative position of a filtered point within the kernel. The anchor resides within the kernel. The special default value (-1,-1) means that the anchor is at the kernel cente
-
- This filter does not check out-of-border accesses, so only a proper sub-matrix of a bigger matrix has to be passed to it.
+
+ This filter does not check out-of-border accesses, so only a proper sub-matrix of a bigger matrix has to be passed to it.
.. seealso:: :ocv:func:`filter2D`
:param borderType: Pixel extrapolation method. For details, see :ocv:func:`borderInterpolate`. For details on limitations, see below.
- There are two versions of the algorithm: NPP and OpenCV.
- * NPP version is called when ``srcType == CV_8UC1`` or ``srcType == CV_8UC4`` and ``bufType == srcType`` . Otherwise, the OpenCV version is called. NPP supports only ``BORDER_CONSTANT`` border type and does not check indices outside the image.
- * OpenCV version supports only ``CV_32F`` buffer depth and ``BORDER_REFLECT101``,``BORDER_REPLICATE``, and ``BORDER_CONSTANT`` border types. It checks indices outside the image.
+ There are two versions of the algorithm: NPP and OpenCV.
+ * NPP version is called when ``srcType == CV_8UC1`` or ``srcType == CV_8UC4`` and ``bufType == srcType`` . Otherwise, the OpenCV version is called. NPP supports only ``BORDER_CONSTANT`` border type and does not check indices outside the image.
+ * OpenCV version supports only ``CV_32F`` buffer depth and ``BORDER_REFLECT101``,``BORDER_REPLICATE``, and ``BORDER_CONSTANT`` border types. It checks indices outside the image.
See Also:,:ocv:func:`createSeparableLinearFilter` .
:param borderType: Pixel extrapolation method. For details, see :ocv:func:`borderInterpolate` . For details on limitations, see below.
- There are two versions of the algorithm: NPP and OpenCV.
- * NPP version is called when ``dstType == CV_8UC1`` or ``dstType == CV_8UC4`` and ``bufType == dstType`` . Otherwise, the OpenCV version is called. NPP supports only ``BORDER_CONSTANT`` border type and does not check indices outside the image.
- * OpenCV version supports only ``CV_32F`` buffer depth and ``BORDER_REFLECT101``, ``BORDER_REPLICATE``, and ``BORDER_CONSTANT`` border types. It checks indices outside image.
-
+ There are two versions of the algorithm: NPP and OpenCV.
+ * NPP version is called when ``dstType == CV_8UC1`` or ``dstType == CV_8UC4`` and ``bufType == dstType`` . Otherwise, the OpenCV version is called. NPP supports only ``BORDER_CONSTANT`` border type and does not check indices outside the image.
+ * OpenCV version supports only ``CV_32F`` buffer depth and ``BORDER_REFLECT101``, ``BORDER_REPLICATE``, and ``BORDER_CONSTANT`` border types. It checks indices outside image.
+
.. seealso:: :ocv:func:`gpu::getLinearRowFilter_GPU`, :ocv:func:`createSeparableLinearFilter`
.. index:: gpu::createSeparableLinearFilter_GPU
:param anchor: Anchor point. The default value (-1) means that the anchor is at the kernel center.
- .. note:: This filter does not check out-of-border accesses, so only a proper sub-matrix of a bigger matrix has to be passed to it.
+ .. note:: This filter does not check out-of-border accesses, so only a proper sub-matrix of a bigger matrix has to be passed to it.
:param criteria: Termination criteria. See :ocv:class:`TermCriteria`.
.. seealso::
-:ocv:func:`gpu::meanShiftFiltering`
+ :ocv:func:`gpu::meanShiftFiltering`
.. index:: gpu::meanShiftSegmentation
:param sqsum: Squared integral image of the ``CV_32FC1`` type.
.. seealso::
-:ocv:func:`integral`
+ :ocv:func:`integral`
.. index:: gpu::sqrIntegral
:param borderType: Pixel extrapolation method. Only ``BORDER_REFLECT101`` and ``BORDER_REPLICATE`` are supported for now.
.. seealso::
-:ocv:func:`cornerHarris`
+ :ocv:func:`cornerHarris`
.. index:: gpu::cornerMinEigenVal
Only full (not packed) ``CV_32FC2`` complex spectrums in the interleaved format are supported for now.
.. seealso::
-:ocv:func:`mulSpectrums`
+ :ocv:func:`mulSpectrums`
.. index:: gpu::mulAndScaleSpectrums
Only full (not packed) ``CV_32FC2`` complex spectrums in the interleaved format are supported for now.
.. seealso::
-:ocv:func:`mulSpectrums`
+ :ocv:func:`mulSpectrums`
.. index:: gpu::dft
If the source matrix is real (its type is ``CV_32FC1`` ), forward DFT is performed. The result of the DFT is packed into complex ( ``CV_32FC2`` ) matrix. So, the width of the destination matrix is ``dft_size.width / 2 + 1`` . But if the source is a single column, the height is reduced instead of the width.
.. seealso::
-:ocv:func:`dft`
+ :ocv:func:`dft`
.. index:: gpu::convolve
* ``CV_TM_CCORR``
.. seealso::
-:ocv:func:`matchTemplate`
+ :ocv:func:`matchTemplate`
.. index:: gpu::remap
Values of pixels with non-integer coordinates are computed using the bilinear interpolation.
.. seealso::
-:ocv:func:`remap`
+ :ocv:func:`remap`
.. index:: gpu::cvtColor
3-channel color spaces (like ``HSV``, ``XYZ``, and so on) can be stored in a 4-channel image for better perfomance.
.. seealso::
-:ocv:func:`cvtColor`
+ :ocv:func:`cvtColor`
.. index:: gpu::threshold
:param stream: Stream for the asynchronous version.
.. seealso::
-:ocv:func:`threshold`
+ :ocv:func:`threshold`
.. index:: gpu::resize
:param flags: Combination of interpolation methods (see :ocv:func:`resize`) and the optional flag ``WARP_INVERSE_MAP`` specifying that ``M`` is an inverse transformation (``dst=>src``). Only ``INTER_NEAREST``, ``INTER_LINEAR``, and ``INTER_CUBIC`` interpolation methods are supported.
.. seealso::
-:ocv:func:`warpAffine`
+ :ocv:func:`warpAffine`
.. index:: gpu::warpPerspective
:param flags: Combination of interpolation methods (see :ocv:func:`resize` ) and the optional flag ``WARP_INVERSE_MAP`` specifying that ``M`` is the inverse transformation (``dst => src``). Only ``INTER_NEAREST``, ``INTER_LINEAR``, and ``INTER_CUBIC`` interpolation methods are supported.
.. seealso::
-:ocv:func:`warpPerspective`
+ :ocv:func:`warpPerspective`
.. index:: gpu::rotate
:param interpolation: Interpolation method. Only ``INTER_NEAREST``, ``INTER_LINEAR``, and ``INTER_CUBIC`` are supported.
.. seealso::
-:ocv:func:`gpu::warpAffine`
+ :ocv:func:`gpu::warpAffine`
.. index:: gpu::copyMakeBorder
:param value: Border value.
.. seealso::
-:ocv:func:`copyMakeBorder`
+ :ocv:func:`copyMakeBorder`
.. index:: gpu::rectStdDev
It is also possible to create the context explicitly using the CUDA Driver API, attach, and set the "current" context for all necessary threads. The CUDA Runtime API (and OpenCV functions, respectively) picks it up.
Utilizing Multiple GPUs
----------
+-----------------------
In the current version, each of the OpenCV GPU algorithms can use only a single GPU. So, to utilize multiple GPUs, you have to manually distribute the work between GPUs. Consider the following ways of utilizing multiple GPUs:
:param stddev: Standard deviation value.
.. seealso::
-:ocv:func:`meanStdDev`
+ :ocv:func:`meanStdDev`
.. index:: gpu::norm
:param buf: Optional buffer to avoid extra memory allocations. It is resized automatically.
.. seealso::
-:ocv:func:`norm`
+ :ocv:func:`norm`
.. index:: gpu::sum
:param buf: Optional buffer to avoid extra memory allocations. It is resized automatically.
.. seealso::
-:ocv:func:`sum`
+ :ocv:func:`sum`
.. index:: gpu::absSum
:param buf: Optional buffer to avoid extra memory allocations. It is resized automatically.
The function does not work with ``CV_64F`` images on GPUs with the compute capability < 1.3.
-
+
.. seealso::
-:ocv:func:`minMaxLoc`
+ :ocv:func:`minMaxLoc`
.. index:: gpu::minMaxLoc
:param locbuf: Optional locations buffer to avoid extra memory allocations. It is resized automatically.
- The function does not work with ``CV_64F`` images on GPU with the compute capability < 1.3.
+ The function does not work with ``CV_64F`` images on GPU with the compute capability < 1.3.
.. seealso::
-:ocv:func:`minMaxLoc`
+ :ocv:func:`minMaxLoc`
.. index:: gpu::countNonZero
:param buf: Optional buffer to avoid extra memory allocations. It is resized automatically.
The function does not work with ``CV_64F`` images on GPUs with the compute capability < 1.3.
-
+
.. seealso::
-:ocv:func:`countNonZero`
+ :ocv:func:`countNonZero`
double threshold_L2hys=0.2, bool gamma_correction=true,
int nlevels=DEFAULT_NLEVELS)??check the output??
- Creates the ``HOG`` descriptor and detector.
+ Creates the ``HOG`` descriptor and detector.
:param win_size: Detection window size. Align to block size and block stride.
vector<Point>\& found_locations, double hit_threshold=0,
Size win_stride=Size(), Size padding=Size())??see output??
- Performs object detection without a multi-scale window.
+ Performs object detection without a multi-scale window.
:param img: Source image. ``CV_8UC1`` and ``CV_8UC4`` types are supported for now.
Size win_stride=Size(), Size padding=Size(),
double scale0=1.05, int group_threshold=2)??the same??
- Performs object detection with a multi-scale window.
+ Performs object detection with a multi-scale window.
:param img: Source image. See :ocv:func:`gpu::HOGDescriptor::detect` for type limitations.
Size win_stride, GpuMat\& descriptors,
int descr_format=DESCR_FORMAT_COL_BY_COL)?? the same??
- Returns block descriptors computed for the whole image. The function is mainly used to learn the classifier.
+ Returns block descriptors computed for the whole image. The function is mainly used to learn the classifier.
:param img: Source image. See :ocv:func:`gpu::HOGDescriptor::detect` for type limitations.
:param minSize: Minimum possible object size. Objects smaller than that are ignored.
The function returns the number of detected objects, so you can retrieve them as in the following example:
+
::
gpu::CascadeClassifier_GPU cascade_gpu(...);
:param dst: Destination matrix.
.. seealso::
-:ocv:func:`transpose`
+ :ocv:func:`transpose`
.. index:: gpu::flip
.. seealso::
-:ocv:func:`flip`
+ :ocv:func:`flip`
.. index:: gpu::LUT
.. seealso::
-:ocv:func:`LUT`
+ :ocv:func:`LUT`
.. index:: gpu::merge
:param stream: Stream for the asynchronous version.
.. seealso::
-:ocv:func:`merge`
+ :ocv:func:`merge`
.. index:: gpu::split
:param stream: Stream for the asynchronous version.
.. seealso::
-:ocv:func:`split`
+ :ocv:func:`split`
.. index:: gpu::magnitude
:param stream: Stream for the asynchronous version.
.. seealso::
-:ocv:func:`magnitude`
+ :ocv:func:`magnitude`
.. index:: gpu::magnitudeSqr
:param stream: Stream for the asynchronous version.
.. seealso::
-:ocv:func:`phase`
+ :ocv:func:`phase`
.. index:: gpu::cartToPolar
:param stream: Stream for the asynchronous version.
.. seealso::
-:ocv:func:`cartToPolar`
+ :ocv:func:`cartToPolar`
.. index:: gpu::polarToCart
:param stream: Stream for the asynchronous version.
.. seealso::
-:ocv:func:`polarToCart`
+ :ocv:func:`polarToCart`
:param dst: Destination matrix with the same size and type as ``src1``.
.. seealso::
-:ocv:func:`add`
+ :ocv:func:`add`
.. index:: gpu::subtract
:param dst: Destination matrix with the same size and type as ``src1``.
.. seealso::
-:ocv:func:`subtract`
+ :ocv:func:`subtract`
:param dst: Destination matrix with the same size and type as ``src1``.
.. seealso::
-:ocv:func:`multiply`
+ :ocv:func:`multiply`
.. index:: gpu::divide
This function, in contrast to :ocv:func:`divide`, uses a round-down rounding mode.
.. seealso::
-:ocv:func:`divide`
+ :ocv:func:`divide`
:param dst: Destination matrix with the same size and type as ``src``.
.. seealso::
-:ocv:func:`exp`
+ :ocv:func:`exp`
:param dst: Destination matrix with the same size and type as ``src1``.
.. seealso::
-:ocv:func:`absdiff`
+ :ocv:func:`absdiff`
.. index:: gpu::compare
* **CMP_NE:** ``src1(.) != src2(.)``
.. seealso::
-:ocv:func:`compare`
+ :ocv:func:`compare`
.. index:: gpu::bitwise_not
:param stream: Stream for the asynchronous version.
.. seealso::
-:ocv:func:`min`
+ :ocv:func:`min`
:param stream: Stream for the asynchronous version.
.. seealso::
-:ocv:func:`max`
+ :ocv:func:`max`
ResizeWindow
-----------
+------------
Resizes window to the specified size
.. ocv:cfunction:: void cvResizeWindow( const char* name, int width, int height )
:ocv:func:`FilterEngine` constructor. While the filtering operation interface uses the ``uchar`` type, a particular implementation is not limited to 8-bit data.
.. seealso::
-:ocv:func:`BaseRowFilter`,
-:ocv:func:`BaseFilter`,
-:ocv:func:`FilterEngine`,
-:ocv:func:`getColumnSumFilter`,
-:ocv:func:`getLinearColumnFilter`,
-:ocv:func:`getMorphologyColumnFilter`
+ :ocv:func:`BaseRowFilter`,
+ :ocv:func:`BaseFilter`,
+ :ocv:func:`FilterEngine`,
+ :ocv:func:`getColumnSumFilter`,
+ :ocv:func:`getLinearColumnFilter`,
+ :ocv:func:`getMorphologyColumnFilter`
:ocv:func:`FilterEngine` constructor. While the filtering operation interface uses the ``uchar`` type, a particular implementation is not limited to 8-bit data.
.. seealso::
-:ocv:func:`BaseColumnFilter`,
-:ocv:func:`BaseRowFilter`,
-:ocv:func:`FilterEngine`,
-:ocv:func:`getLinearFilter`,
-:ocv:func:`getMorphologyFilter`
+ :ocv:func:`BaseColumnFilter`,
+ :ocv:func:`BaseRowFilter`,
+ :ocv:func:`FilterEngine`,
+ :ocv:func:`getLinearFilter`,
+ :ocv:func:`getMorphologyFilter`
:ocv:func:`FilterEngine` constructor. While the filtering operation interface uses the ``uchar`` type, a particular implementation is not limited to 8-bit data.
.. seealso::
-:ocv:func:`BaseColumnFilter`,
-:ocv:func:`Filter`,
-:ocv:func:`FilterEngine`,
-:ocv:func:`getLinearRowFilter`,
-:ocv:func:`getMorphologyRowFilter`,
-:ocv:func:`getRowSumFilter`
+ :ocv:func:`BaseColumnFilter`,
+ :ocv:func:`Filter`,
+ :ocv:func:`FilterEngine`,
+ :ocv:func:`getLinearRowFilter`,
+ :ocv:func:`getMorphologyRowFilter`,
+ :ocv:func:`getRowSumFilter`
In case of non-separable filtering, ``bufType`` must be the same as ``srcType`` . The source data is copied to the temporary buffer, if needed, and then just passed to ``FilterEngine::filter2D`` . That is, the input type for ``filter2D`` is ``srcType`` (= ``bufType`` ) and the output type is ``dstType`` .
.. seealso::
-:ocv:func:`BaseColumnFilter`,
-:ocv:func:`BaseFilter`,
-:ocv:func:`BaseRowFilter`,
-:ocv:func:`createBoxFilter`,
-:ocv:func:`createDerivFilter`,
-:ocv:func:`createGaussianFilter`,
-:ocv:func:`createLinearFilter`,
-:ocv:func:`createMorphologyFilter`,
-:ocv:func:`createSeparableLinearFilter`
+ :ocv:func:`BaseColumnFilter`,
+ :ocv:func:`BaseFilter`,
+ :ocv:func:`BaseRowFilter`,
+ :ocv:func:`createBoxFilter`,
+ :ocv:func:`createDerivFilter`,
+ :ocv:func:`createGaussianFilter`,
+ :ocv:func:`createLinearFilter`,
+ :ocv:func:`createMorphologyFilter`,
+ :ocv:func:`createSeparableLinearFilter`
The call ``blur(src, dst, ksize, anchor, borderType)`` is equivalent to ``boxFilter(src, dst, src.type(), anchor, true, borderType)`` .
.. seealso::
-:ocv:func:`boxFilter`,
-:ocv:func:`bilateralFilter`,
-:ocv:func:`GaussianBlur`,
-:ocv:func:`medianBlur`
+ :ocv:func:`boxFilter`,
+ :ocv:func:`bilateralFilter`,
+ :ocv:func:`GaussianBlur`,
+ :ocv:func:`medianBlur`
:ocv:func:`copyMakeBorder` to compute tables for quick extrapolation.
.. seealso::
-:ocv:func:`FilterEngine`,
-:ocv:func:`copyMakeBorder`
+ :ocv:func:`FilterEngine`,
+ :ocv:func:`copyMakeBorder`
:ocv:func:`integral` .
.. seealso::
-:ocv:func:`boxFilter`,
-:ocv:func:`bilateralFilter`,
-:ocv:func:`GaussianBlur`,
-:ocv:func:`medianBlur`,
-:ocv:func:`integral`
+ :ocv:func:`boxFilter`,
+ :ocv:func:`bilateralFilter`,
+ :ocv:func:`GaussianBlur`,
+ :ocv:func:`medianBlur`,
+ :ocv:func:`integral`
.. seealso::
-:ocv:func:`borderInterpolate`
+ :ocv:func:`borderInterpolate`
createBoxFilter
:ocv:func:`boxFilter` .
.. seealso::
-:ocv:func:`FilterEngine`,
-:ocv:func:`blur`,
-:ocv:func:`boxFilter`
+ :ocv:func:`FilterEngine`,
+ :ocv:func:`blur`,
+ :ocv:func:`boxFilter`
:ocv:func:`Scharr` .
.. seealso::
-:ocv:func:`createSeparableLinearFilter`,
-:ocv:func:`getDerivKernels`,
-:ocv:func:`Scharr`,
-:ocv:func:`Sobel`
+ :ocv:func:`createSeparableLinearFilter`,
+ :ocv:func:`getDerivKernels`,
+ :ocv:func:`Scharr`,
+ :ocv:func:`Sobel`
:ocv:func:`createSeparableFilter` directly.
.. seealso::
-:ocv:func:`createSeparableLinearFilter`,
-:ocv:func:`getGaussianKernel`,
-:ocv:func:`GaussianBlur`
+ :ocv:func:`createSeparableLinearFilter`,
+ :ocv:func:`getGaussianKernel`,
+ :ocv:func:`GaussianBlur`
:ocv:func:`FilterEngine` constructor.
.. seealso::
-:ocv:func:`createSeparableLinearFilter`,
-:ocv:func:`FilterEngine`,
-:ocv:func:`filter2D`
+ :ocv:func:`createSeparableLinearFilter`,
+ :ocv:func:`FilterEngine`,
+ :ocv:func:`filter2D`
createMorphologyFilter
:ocv:func:`createMorphologyFilter` analyzes the structuring element shape and builds a separable morphological filter engine when the structuring element is square.
.. seealso::
-:ocv:func:`erode`,
-:ocv:func:`dilate`,
-:ocv:func:`morphologyEx`,
-:ocv:func:`FilterEngine`
+ :ocv:func:`erode`,
+ :ocv:func:`dilate`,
+ :ocv:func:`morphologyEx`,
+ :ocv:func:`FilterEngine`
createSeparableLinearFilter
:ocv:func:`FilterEngine` constructor.
.. seealso::
-:ocv:func:`sepFilter2D`,
-:ocv:func:`createLinearFilter`,
-:ocv:func:`FilterEngine`,
-:ocv:func:`getKernelType`
+ :ocv:func:`sepFilter2D`,
+ :ocv:func:`createLinearFilter`,
+ :ocv:func:`FilterEngine`,
+ :ocv:func:`getKernelType`
dilate
The function supports the in-place mode. Dilation can be applied several ( ``iterations`` ) times. In case of multi-channel images, each channel is processed independently.
.. seealso::
-:ocv:func:`erode`,
-:ocv:func:`morphologyEx`,
-:ocv:func:`createMorphologyFilter`
+ :ocv:func:`erode`,
+ :ocv:func:`morphologyEx`,
+ :ocv:func:`createMorphologyFilter`
erode
The function supports the in-place mode. Erosion can be applied several ( ``iterations`` ) times. In case of multi-channel images, each channel is processed independently.
.. seealso::
-:ocv:func:`dilate`,
-:ocv:func:`morphologyEx`,
-:ocv:func:`createMorphologyFilter`
+ :ocv:func:`dilate`,
+ :ocv:func:`morphologyEx`,
+ :ocv:func:`createMorphologyFilter`
The function uses the DFT-based algorithm in case of sufficiently large kernels (~``11 x 11`` or larger) and the direct algorithm (that uses the engine retrieved by :ocv:func:`createLinearFilter` ) for small kernels.
.. seealso::
-:ocv:func:`sepFilter2D`,
-:ocv:func:`createLinearFilter`,
-:ocv:func:`dft`,
-:ocv:func:`matchTemplate`
+ :ocv:func:`sepFilter2D`,
+ :ocv:func:`createLinearFilter`,
+ :ocv:func:`dft`,
+ :ocv:func:`matchTemplate`
The function convolves the source image with the specified Gaussian kernel. In-place filtering is supported.
.. seealso::
-:ocv:func:`sepFilter2D`,
-:ocv:func:`filter2D`,
-:ocv:func:`blur`,
-:ocv:func:`boxFilter`,
-:ocv:func:`bilateralFilter`,
-:ocv:func:`medianBlur`
+ :ocv:func:`sepFilter2D`,
+ :ocv:func:`filter2D`,
+ :ocv:func:`blur`,
+ :ocv:func:`boxFilter`,
+ :ocv:func:`bilateralFilter`,
+ :ocv:func:`medianBlur`
getDerivKernels
:ocv:func:`GaussianBlur`.
.. seealso::
-:ocv:func:`sepFilter2D`,
-:ocv:func:`createSeparableLinearFilter`,
-:ocv:func:`getDerivKernels`,
-:ocv:func:`getStructuringElement`,
-:ocv:func:`GaussianBlur`
+ :ocv:func:`sepFilter2D`,
+ :ocv:func:`createSeparableLinearFilter`,
+ :ocv:func:`getDerivKernels`,
+ :ocv:func:`getStructuringElement`,
+ :ocv:func:`GaussianBlur`
:math:`\texttt{ksize} \times \texttt{ksize}` aperture. Each channel of a multi-channel image is processed independently. In-place operation is supported.
.. seealso::
-:ocv:func:`bilateralFilter`,
-:ocv:func:`blur`,
-:ocv:func:`boxFilter`,
-:ocv:func:`GaussianBlur`
+ :ocv:func:`bilateralFilter`,
+ :ocv:func:`blur`,
+ :ocv:func:`boxFilter`,
+ :ocv:func:`GaussianBlur`
Any of the operations can be done in-place.
.. seealso::
-:ocv:func:`dilate`,
-:ocv:func:`erode`,
-:ocv:func:`createMorphologyFilter`
+ :ocv:func:`dilate`,
+ :ocv:func:`erode`,
+ :ocv:func:`createMorphologyFilter`
\vecthreethree {0}{1}{0}{1}{-4}{1}{0}{1}{0}
.. seealso::
-:ocv:func:`Sobel`,
-:ocv:func:`Scharr`
+ :ocv:func:`Sobel`,
+ :ocv:func:`Scharr`
The function applies a separable linear filter to the image. That is, first, every row of ``src`` is filtered with the 1D kernel ``rowKernel`` . Then, every column of the result is filtered with the 1D kernel ``columnKernel`` . The final result shifted by ``delta`` is stored in ``dst`` .
.. seealso::
-:ocv:func:`createSeparableLinearFilter`,
-:ocv:func:`filter2D`,
-:ocv:func:`Sobel`,
-:ocv:func:`GaussianBlur`,
-:ocv:func:`boxFilter`,
-:ocv:func:`blur`
+ :ocv:func:`createSeparableLinearFilter`,
+ :ocv:func:`filter2D`,
+ :ocv:func:`Sobel`,
+ :ocv:func:`GaussianBlur`,
+ :ocv:func:`boxFilter`,
+ :ocv:func:`blur`
Smooth
\vecthreethree{-1}{-2}{-1}{0}{0}{0}{1}{2}{1}
.. seealso::
-:ocv:func:`Scharr`,
-:ocv:func:`Lapacian`,
-:ocv:func:`sepFilter2D`,
-:ocv:func:`filter2D`,
-:ocv:func:`GaussianBlur`
+ :ocv:func:`Scharr`,
+ :ocv:func:`Lapacian`,
+ :ocv:func:`sepFilter2D`,
+ :ocv:func:`filter2D`,
+ :ocv:func:`GaussianBlur`
The functions in this section perform various geometrical transformations of 2D images. They do not change the image content but deform the pixel grid and map this deformed grid to the destination image. In fact, to avoid sampling artifacts, the mapping is done in the reverse order, from destination to the source. That is, for each pixel
:math:`(x, y)` of the destination image, the functions compute coordinates of the corresponding "donor" pixel in the source image and copy the pixel value:
+The functions in this section perform various geometrical transformations of 2D images. They do not change the image content but deform the pixel grid and map this deformed grid to the destination image. In fact, to avoid sampling artifacts, the mapping is done in the reverse order, from destination to the source. That is, for each pixel :math:`(x, y)` of the destination image, the functions compute coordinates of the corresponding "donor" pixel in the source image and copy the pixel value:
.. math::
\texttt{dst} (x,y)= \texttt{src} (f_x(x,y), f_y(x,y))
See Also:
:ocv:func:`calcHist`
-
+.. _compareHist:
compareHist
-----------
The function makes a copy of the histogram. If the second histogram pointer ``*dst`` is NULL, a new histogram of the same size as ``src`` is created. Otherwise, both histograms must have equal types and sizes. Then the function copies the source histogram's bin values to the destination histogram and sets the same bin value ranges as in ``src``.
+.. _createhist:
CreateHist
----------
Moments( const CvMoments& moments );
operator CvMoments() const;
- // spatial moments
- double m00, m10, m01, m20, m11, m02, m30, m21, m12, m03;
- // central moments
- double mu20, mu11, mu02, mu30, mu21, mu12, mu03;
- // central normalized moments
- double nu20, nu11, nu02, nu30, nu21, nu12, nu03;
- };
+ ..
In case of a raster image, the spatial moments :math:`\texttt{Moments::m}_{ji}` are computed as:
:param contourIdx: Parameter indicating a contour to draw. If it is negative, all the contours are drawn.
:param color: Color of the contours.
-
+
:param thickness: Thickness of lines the contours are drawn with. If it is negative (for example, ``thickness=CV_FILLED`` ), the contour interiors are
drawn.
.. image:: pics/pointpolygon.png
-.. [Fitzgibbon95] Andrew W. Fitzgibbon, R.B.Fisher. A Buyer’s Guide to Conic Fitting. Proc.5th British Machine Vision Conference, Birmingham, pp. 513-522, 1995.
+.. [Fitzgibbon95] Andrew W. Fitzgibbon, R.B.Fisher. A Buyer\92s Guide to Conic Fitting. Proc.5th British Machine Vision Conference, Birmingham, pp. 513-522, 1995.
.. [Hu62] M. Hu. Visual Pattern Recognition by Moment Invariants, IRE Transactions on Information Theory, 8:2, pp. 179-187, 1962.
-.. [Sklansky82] Sklansky, J., “Finding the Convex Hull of a Simple Polygon”. PRL 1 $number, pp 79-83 (1982)
+.. [Sklansky82] Sklansky, J., \93Finding the Convex Hull of a Simple Polygon\94. PRL 1 $number, pp 79-83 (1982)
-.. [Suzuki85] Suzuki, S. and Abe, K., “Topological Structural Analysis of Digitized Binary Images by Border Following”. CVGIP 30 1, pp 32-46 (1985)
+.. [Suzuki85] Suzuki, S. and Abe, K., \93Topological Structural Analysis of Digitized Binary Images by Border Following\94. CVGIP 30 1, pp 32-46 (1985)
-.. [TehChin89] Teh, C.H. and Chin, R.T., “On the Detection of Dominant Points on Digital Curve”. PAMI 11 8, pp 859-872 (1989)
+.. [TehChin89] Teh, C.H. and Chin, R.T., \93On the Detection of Dominant Points on Digital Curve\94. PAMI 11 8, pp 859-872 (1989)
**all**
training examples are recomputed at each training iteration. Examples deleted at a particular iteration may be used again for learning some of the weak classifiers further [FHT98]_.
-.. [HTF01] Hastie, T., Tibshirani, R., Friedman, J. H. *The Elements of Statistical Learning: Data Mining, Inference, and Prediction*. Springer Series in Statistics. 2001.
+.. _HTF01: [HTF01] Hastie, T., Tibshirani, R., Friedman, J. H. *The Elements of Statistical Learning: Data Mining, Inference, and Prediction. Springer Series in Statistics*. 2001.
-.. [FHT98] Friedman, J. H., Hastie, T. and Tibshirani, R. *Additive Logistic Regression: a Statistical View of Boosting*. Technical Report, Dept. of Statistics, Stanford University, 1998.
+.. _FHT98: [FHT98] Friedman, J. H., Hastie, T. and Tibshirani, R. Additive Logistic Regression: a Statistical View of Boosting. Technical Report, Dept. of Statistics*, Stanford University, 1998.
CvBoostParams
-------------
\r
.. math:: f(x) = f_0 + \nu\cdot\sum^M_{i=1}T_i(x) ,\r
\r
-where :math:`f_0` is an initial guess (the best constant model) and :math:`\nu`\r
+where :math:`f_0` is the initial guess (the best constant model) and :math:`\nu`\r
is a regularization parameter from the interval :math:`(0,1]`, futher called\r
*shrinkage*.\r
\r
:param maxLevel: 0-based maximal pyramid level number. If set to 0, pyramids are not used (single level). If set to 1, two levels are used, and so on.
:param criteria: Parameter specifying the termination criteria of the iterative search algorithm (after the specified maximum number of iterations ``criteria.maxCount`` or when the search window moves by less than ``criteria.epsilon`` .
-
+
:param derivLambda: Relative weight of the spatial image derivatives impact to the optical flow estimation. If ``derivLambda=0`` , only the image intensity is used. If ``derivLambda=1`` , only derivatives are used. Any other values between 0 and 1 mean that both derivatives and the image intensity are used (in the corresponding proportions).
:param flags: Operation flags:
:param polyN: Size of the pixel neighborhood used to find polynomial expansion in each pixel. Larger values mean that the image will be approximated with smoother surfaces, yielding more robust algorithm and more blurred motion field. Typically, ``polyN`` =5 or 7.
:param polySigma: Standard deviation of the Gaussian that is used to smooth derivatives used as a basis for the polynomial expansion. For ``polyN=5`` , you can set ``polySigma=1.1`` . For ``polyN=7`` , a good value would be ``polySigma=1.5`` .
-
+
:param flags: Operation flags that can be a combination of the following:
* **OPTFLOW_USE_INITIAL_FLOW** Use the input ``flow`` as an initial flow approximation.
when ``fullAffine=false`` .
.. seealso::
-:ocv:func:`getAffineTransform`,
-:ocv:func:`getPerspectiveTransform`,
-:ocv:func:`findHomography`
+ :ocv:func:`getAffineTransform`,
+ :ocv:func:`getPerspectiveTransform`,
+ :ocv:func:`findHomography`
.. ocv:pyoldfunction:: cv.MeanShift(probImage, window, criteria)-> comp
:param probImage: Back projection of the object histogram. See :ocv:func:`calcBackProject` for details.
-
+
:param window: Initial search window.
:param criteria: Stop criteria for the iterative search algorithm.
BackgroundSubtractor::operator()
--------------------------------
+--------------------------------
Computes a foreground mask.
.. ocv:function:: virtual void BackgroundSubtractor::operator()(InputArray image, OutputArray fgmask, double learningRate=0)
BackgroundSubtractorMOG2::operator()
------------------------------------
+------------------------------------
Updates the background model and computes the foreground mask
.. ocv:function:: virtual void BackgroundSubtractorMOG2::operator()(InputArray image, OutputArray fgmask, double learningRate=-1)
projects / profile / ivi / opencv.git / commitdiff
