oneassasin: переводы

→When the cv::Mat object goes out of scope, the memory allocated is automatically released.
This is very convenient because you avoid having problems with memory leaks. Moreover, the
cv::Mat class implements reference counting and shallow copy such that when an image
is assigned to another one, the image data (that is the pixels) is not copied, and both images
will point to the same memory block. This also applies to images passed by value or returned
by value. A reference count is kept such that the memory will be released only when all of the
references to the image will be destructed. If you wish to create an image that will contain a new
copy of the original image, you will use the method copyTo(). You can test this behavior by
declaring a few extra images in the example of this project, as follows:

→In this case, you also need to specify the type of each matrix element, here CV_8U which
corresponds to 1-byte pixel images. Letter U means unsigned. You can also declare
signed numbers by using the letter S. For a color image, you would specify three channels
(CV_8UC3). You can also declare integers (signed or unsigned) of size 16 and 32 (for example,
CV_16SC3). You also have access to 32-bit and 64-bit floating point numbers (for example,
CV_32F).

→The class cv::Mat is the data structure used to hold your images (and obviously other matrix
data). By default, they have a zero size but you can also specify an initial size:

→Alternatively, prefix all OpenCV class and function names by the namespace specification that
is cv::, as we did in this recipe.

→All classes and functions defined in the C++ API of OpenCV are defined within the name space
cv. You have two options to access them. First, precede the main function definition by the
following declaration:

→The file extension determines which codec will be used to save the image.

→You can then see both the input and output images displayed on two distinct windows. Finally,
you will probably want to save the processed image on your disk. This is done using the
following highgui function:

→Since it is a console window that will terminate at the end of the main function, we add an
extra highgui method to wait for a user key before ending the program:

→And the result is displayed on another window:

→Now, you would normally apply some processing to the image. OpenCV offers a wide selection
of processing functions, and several of them are explored in this book. Let's start with a
very simple one that will simply flip the image horizontally. Several image transformations in
OpenCV can be performed in-place, meaning that the transformation is applied directly on the
input image (no new image being created). This is the case of the flipping method. However,
we can always create another matrix to hold the output result and that is what we will do:

→The member variable data is in fact a pointer to the allocated memory block that will contain
the image data. It is simply set to 0 when no image has been read. The first thing you might
want to do with this image is to display it. You do it using the highgui module provided by
OpenCV. You start by declaring the window on which you want to display images, and then you
specify the image to be shown on this special window:

→You are now ready to use this image. However, you should first check if the image has been
correctly read (an error will occur if the file is not found or if the file is corrupted, or is not a
recognizable format). The validity of the image is tested by:

→Next a simple call to the reading function will read an image from file, decode it, and allocate
the memory:

→This definition creates an image of size 0 by 0. This can be confirmed by calling the cv::Mat
method size() that allows you to read the current size of this image. It returns a structure
containing the height and width of the image:

→The first thing to do is to declare a variable that will hold the image. Under OpenCV 2, you
define an object of class cv::Mat.

→Using either MS Visual Studio or Qt, create a new console application with a main function
ready to be filled. See the first two recipes on how to proceed.

→The new property sheet is then added once we click on Add. We now need to edit it. Simply
double-click on the property sheet's name and select VC++ Directories, as seen here:

→In Visual C++ 2010, a property sheet is an XML file that describes your project settings. We
will now create a new one by right-clicking on the Debug | Win32 node of the project, and by
selecting the Add New Project Property Sheet option (as seen in the following screenshot):

→But first, to be able to compile and run your future OpenCV application, you need to tell Visual
C++ where to find the OpenCV libraries and include files. Since you will probably create several
OpenCV projects in the future, the best option is to create a Property Sheet that you will be
able to reuse from project to project. This is done through the Property Manager. If it is not
already visible in your current IDE, you can access it from the View menu.

→You need to specify where your want to create your project, and what name you want to give to
your project. There is also an option for creating or not creating a directory for the solution (the
bottom-right checkbox). If you check this option, an additional directory will be created (with
the name you specify) that will contain your solution directory. If you simply leave this option
unchecked, a solution file (extension .sln) will still be created, but this one will be contained
within the same (single) project directory. Click on OK and then Next to go to the Application
Settings window of the Win32 Application Wizard. As seen in the following screenshot, a
number of options are offered there. We will simply create an empty project.