wuffur: переводы

→The input and output images are being displayed on the two highgui windows that we
defined.

→You can now compile and run this program and your 2-button GUI will allow you to select an
image and process it.

→You then create a new slot by right-clicking on the second button. This second slot will perform
some processing on the selected input image. The following code will simply flip the image:

→OpenCV code can then be added. The first button opens the source image. This is done by
adding the following code to the corresponding slot method:

→Note that we have also included the core.hpp and the highgui.hpp header files. As we
learned in a preceding recipe, we must not forget to edit the project file in order to append the
OpenCV library information.

→In order to be able to display and then process the image, we need to define a cv::Mat class
member variable. This is done in the header file of the MainWindow class. This header now
reads as follows:

→Simply select the clicked() signal. This is the one that handles the button pushed events.
By doing this, you will be brought to the mainwindow.cpp file. You will see that a new
method has been added. This is the slot method that is called when the click() signal is
received:

→Note that we also have unchecked the Precompiled header option which is an MS Visual
Studio-specific feature to make the compilation process faster. Since we want to stay within
the ANSI C++ standard, we will not use this option. If you click on Finish, your project will be
created. It is empty for now, but we will add a main file to it soon.

→Let's now add a signal method in order to handle the click button event. Right-click on the
first button and select Go to slot... in the contextual menu. The list of possible signals is then
displayed as seen in the following screenshot:

→You can drag-and-drop different widgets on it. Drop two Push Buttons as we did in the
preceding example. You can resize them and resize the window to make it nice. You should
also rename the button labels. Just click on the text and insert the name of your choice.

→Give a name and a location to your project. If you then click on Next, you will see that the
QtGUI Module is checked. Since we do not need other modules, you can click on Finish at
this point. This will create your new project. In addition to the usual project file ( .pro) and
the main.cpp file, you see two mainwindow files defining the class that contains your GUI
window. You will also find a file having the extension .ui, which is the one that describes the
UI layout. In fact, if you double-click on it, you will see the current user interface as seen here:

→Select Create New Project… and choose Qt GUI Application as seen in the following
screenshot:

→Start Qt Creator which we will use to create our GUI application. It is also possible to create a
GUI without this tool, but the use of a visual IDE in which the widgets can simply be dragged
and dropped is the easiest way to build a nice looking GUI.

→Qt offers a rich library to build a sophisticated GUI with a professional look. Using Qt Creator,
the process of GUI creation is made easy. This recipe will show you how to build an OpenCV
application with Qt that a user can control using a GUI.

→Creating a GUI application using Qt

→Remember, you should avoid using this deprecate data structure. Instead, always use
cv::Mat.

→Otherwise, if you need to deallocate the memory pointed by your IplImage structure, you
need to do it explicitly:

→The function cvLoadImage is the C-interface function to load images. The second parameter
in the constructor of the cv::Mat object indicates that the data will not be copied (set it to
true if you want a new copy, while false is the default value so it could have been omitted),
that is both IplImage and image4 will share the same image data. You need to be careful
here to not create dangling pointers. For this reason, it is safer to encapsulate the IplImage
pointer into the reference-counting pointer class provided by OpenCV 2:

→With version 2 of the OpenCV, a new C++ interface has been introduced. Previously, C-like
functions and structures were used (and can still be used). In particular, images were
manipulated using the IplImage structure. This structure was inherited from the IPL library
(that is the Intel Image Processing Library) now integrated with the IPP library (the Intel
Integrated Performance Primitive library). If you use code and libraries that were created with
the old C interface, you might need to manipulate those IplImage structures. Fortunately,
there is a convenient way to convert an IplImage into a cv::Mat object.

→Here, if a function calls the method of this class, it obtains a shallow copy of the image
attributes. If later, this copy is modified, the class attribute will also be modified which can
affect the subsequent behavior of the class (and vice versa). To avoid these kinds of errors,
you should instead return a copy of the attribute.