1/*M///////////////////////////////////////////////////////////////////////////////////////
2//
3// IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
4//
5// By downloading, copying, installing or using the software you agree to this license.
6// If you do not agree to this license, do not download, install,
7// copy or use the software.
8//
9//
10// License Agreement
11// For Open Source Computer Vision Library
12//
13// Copyright (C) 2000-2008, Intel Corporation, all rights reserved.
14// Copyright (C) 2009, Willow Garage Inc., all rights reserved.
15// Third party copyrights are property of their respective owners.
16//
17// Redistribution and use in source and binary forms, with or without modification,
18// are permitted provided that the following conditions are met:
19//
20// * Redistribution's of source code must retain the above copyright notice,
21// this list of conditions and the following disclaimer.
22//
23// * Redistribution's in binary form must reproduce the above copyright notice,
24// this list of conditions and the following disclaimer in the documentation
25// and/or other materials provided with the distribution.
26//
27// * The name of the copyright holders may not be used to endorse or promote products
28// derived from this software without specific prior written permission.
29//
30// This software is provided by the copyright holders and contributors "as is" and
31// any express or implied warranties, including, but not limited to, the implied
32// warranties of merchantability and fitness for a particular purpose are disclaimed.
33// In no event shall the Intel Corporation or contributors be liable for any direct,
34// indirect, incidental, special, exemplary, or consequential damages
35// (including, but not limited to, procurement of substitute goods or services;
36// loss of use, data, or profits; or business interruption) however caused
37// and on any theory of liability, whether in contract, strict liability,
38// or tort (including negligence or otherwise) arising in any way out of
39// the use of this software, even if advised of the possibility of such damage.
40//
41//M*/
42
43#ifndef OPENCV_HIGHGUI_HPP
44#define OPENCV_HIGHGUI_HPP
45
46#include "opencv2/core.hpp"
47#ifdef HAVE_OPENCV_IMGCODECS
48#include "opencv2/imgcodecs.hpp"
49#endif
50#ifdef HAVE_OPENCV_VIDEOIO
51#include "opencv2/videoio.hpp"
52#endif
53
54/**
55@defgroup highgui High-level GUI
56
57While OpenCV was designed for use in full-scale applications and can be used within functionally
58rich UI frameworks (such as Qt\*, WinForms\*, or Cocoa\*) or without any UI at all, sometimes there
59it is required to try functionality quickly and visualize the results. This is what the HighGUI
60module has been designed for.
61
62It provides easy interface to:
63
64- Create and manipulate windows that can display images and "remember" their content (no need to
65 handle repaint events from OS).
66- Add trackbars to the windows, handle simple mouse events as well as keyboard commands.
67
68@{
69 @defgroup highgui_window_flags Flags related creating and manipulating HighGUI windows and mouse events
70 @defgroup highgui_opengl OpenGL support
71 @defgroup highgui_qt Qt New Functions
72
73 ![image](pics/qtgui.png)
74
75 This figure explains new functionality implemented with Qt\* GUI. The new GUI provides a statusbar,
76 a toolbar, and a control panel. The control panel can have trackbars and buttonbars attached to it.
77 If you cannot see the control panel, press Ctrl+P or right-click any Qt window and select **Display
78 properties window**.
79
80 - To attach a trackbar, the window name parameter must be NULL.
81
82 - To attach a buttonbar, a button must be created. If the last bar attached to the control panel
83 is a buttonbar, the new button is added to the right of the last button. If the last bar
84 attached to the control panel is a trackbar, or the control panel is empty, a new buttonbar is
85 created. Then, a new button is attached to it.
86
87 See below the example used to generate the figure:
88
89 @include highgui_qt.cpp
90
91 @defgroup highgui_winrt WinRT support
92
93 This figure explains new functionality implemented with WinRT GUI. The new GUI provides an Image control,
94 and a slider panel. Slider panel holds trackbars attached to it.
95
96 Sliders are attached below the image control. Every new slider is added below the previous one.
97
98 See below the example used to generate the figure:
99 @code
100 void sample_app::MainPage::ShowWindow()
101 {
102 static cv::String windowName("sample");
103 cv::winrt_initContainer(this->cvContainer);
104 cv::namedWindow(windowName); // not required
105
106 cv::Mat image = cv::imread("Assets/sample.jpg");
107 cv::Mat converted = cv::Mat(image.rows, image.cols, CV_8UC4);
108 cv::cvtColor(image, converted, COLOR_BGR2BGRA);
109 cv::imshow(windowName, converted); // this will create window if it hasn't been created before
110
111 int state = 42;
112 cv::TrackbarCallback callback = [](int pos, void* userdata)
113 {
114 if (pos == 0) {
115 cv::destroyWindow(windowName);
116 }
117 };
118 cv::TrackbarCallback callbackTwin = [](int pos, void* userdata)
119 {
120 if (pos >= 70) {
121 cv::destroyAllWindows();
122 }
123 };
124 cv::createTrackbar("Sample trackbar", windowName, &state, 100, callback);
125 cv::createTrackbar("Twin brother", windowName, &state, 100, callbackTwin);
126 }
127 @endcode
128@}
129*/
130
131///////////////////////// graphical user interface //////////////////////////
132namespace cv
133{
134
135//! @addtogroup highgui
136//! @{
137
138//! @addtogroup highgui_window_flags
139//! @{
140
141//! Flags for cv::namedWindow
142enum WindowFlags {
143 WINDOW_NORMAL = 0x00000000, //!< the user can resize the window (no constraint) / also use to switch a fullscreen window to a normal size.
144 WINDOW_AUTOSIZE = 0x00000001, //!< the user cannot resize the window, the size is constrainted by the image displayed.
145 WINDOW_OPENGL = 0x00001000, //!< window with opengl support.
146
147 WINDOW_FULLSCREEN = 1, //!< change the window to fullscreen.
148 WINDOW_FREERATIO = 0x00000100, //!< the image expends as much as it can (no ratio constraint).
149 WINDOW_KEEPRATIO = 0x00000000, //!< the ratio of the image is respected.
150 WINDOW_GUI_EXPANDED=0x00000000, //!< status bar and tool bar
151 WINDOW_GUI_NORMAL = 0x00000010, //!< old fashious way
152 };
153
154//! Flags for cv::setWindowProperty / cv::getWindowProperty
155enum WindowPropertyFlags {
156 WND_PROP_FULLSCREEN = 0, //!< fullscreen property (can be WINDOW_NORMAL or WINDOW_FULLSCREEN).
157 WND_PROP_AUTOSIZE = 1, //!< autosize property (can be WINDOW_NORMAL or WINDOW_AUTOSIZE).
158 WND_PROP_ASPECT_RATIO = 2, //!< window's aspect ration (can be set to WINDOW_FREERATIO or WINDOW_KEEPRATIO).
159 WND_PROP_OPENGL = 3, //!< opengl support.
160 WND_PROP_VISIBLE = 4, //!< checks whether the window exists and is visible
161 WND_PROP_TOPMOST = 5, //!< property to toggle normal window being topmost or not
162 WND_PROP_VSYNC = 6 //!< enable or disable VSYNC (in OpenGL mode)
163 };
164
165//! Mouse Events see cv::MouseCallback
166enum MouseEventTypes {
167 EVENT_MOUSEMOVE = 0, //!< indicates that the mouse pointer has moved over the window.
168 EVENT_LBUTTONDOWN = 1, //!< indicates that the left mouse button is pressed.
169 EVENT_RBUTTONDOWN = 2, //!< indicates that the right mouse button is pressed.
170 EVENT_MBUTTONDOWN = 3, //!< indicates that the middle mouse button is pressed.
171 EVENT_LBUTTONUP = 4, //!< indicates that left mouse button is released.
172 EVENT_RBUTTONUP = 5, //!< indicates that right mouse button is released.
173 EVENT_MBUTTONUP = 6, //!< indicates that middle mouse button is released.
174 EVENT_LBUTTONDBLCLK = 7, //!< indicates that left mouse button is double clicked.
175 EVENT_RBUTTONDBLCLK = 8, //!< indicates that right mouse button is double clicked.
176 EVENT_MBUTTONDBLCLK = 9, //!< indicates that middle mouse button is double clicked.
177 EVENT_MOUSEWHEEL = 10,//!< positive and negative values mean forward and backward scrolling, respectively.
178 EVENT_MOUSEHWHEEL = 11 //!< positive and negative values mean right and left scrolling, respectively.
179 };
180
181//! Mouse Event Flags see cv::MouseCallback
182enum MouseEventFlags {
183 EVENT_FLAG_LBUTTON = 1, //!< indicates that the left mouse button is down.
184 EVENT_FLAG_RBUTTON = 2, //!< indicates that the right mouse button is down.
185 EVENT_FLAG_MBUTTON = 4, //!< indicates that the middle mouse button is down.
186 EVENT_FLAG_CTRLKEY = 8, //!< indicates that CTRL Key is pressed.
187 EVENT_FLAG_SHIFTKEY = 16,//!< indicates that SHIFT Key is pressed.
188 EVENT_FLAG_ALTKEY = 32 //!< indicates that ALT Key is pressed.
189 };
190
191//! @} highgui_window_flags
192
193//! @addtogroup highgui_qt
194//! @{
195
196//! Qt font weight
197enum QtFontWeights {
198 QT_FONT_LIGHT = 25, //!< Weight of 25
199 QT_FONT_NORMAL = 50, //!< Weight of 50
200 QT_FONT_DEMIBOLD = 63, //!< Weight of 63
201 QT_FONT_BOLD = 75, //!< Weight of 75
202 QT_FONT_BLACK = 87 //!< Weight of 87
203 };
204
205//! Qt font style
206enum QtFontStyles {
207 QT_STYLE_NORMAL = 0, //!< Normal font.
208 QT_STYLE_ITALIC = 1, //!< Italic font.
209 QT_STYLE_OBLIQUE = 2 //!< Oblique font.
210 };
211
212//! Qt "button" type
213enum QtButtonTypes {
214 QT_PUSH_BUTTON = 0, //!< Push button.
215 QT_CHECKBOX = 1, //!< Checkbox button.
216 QT_RADIOBOX = 2, //!< Radiobox button.
217 QT_NEW_BUTTONBAR = 1024 //!< Button should create a new buttonbar
218 };
219
220//! @} highgui_qt
221
222/** @brief Callback function for mouse events. see cv::setMouseCallback
223@param event one of the cv::MouseEventTypes constants.
224@param x The x-coordinate of the mouse event.
225@param y The y-coordinate of the mouse event.
226@param flags one of the cv::MouseEventFlags constants.
227@param userdata The optional parameter.
228 */
229typedef void (*MouseCallback)(int event, int x, int y, int flags, void* userdata);
230
231/** @brief Callback function for Trackbar see cv::createTrackbar
232@param pos current position of the specified trackbar.
233@param userdata The optional parameter.
234 */
235typedef void (*TrackbarCallback)(int pos, void* userdata);
236
237/** @brief Callback function defined to be called every frame. See cv::setOpenGlDrawCallback
238@param userdata The optional parameter.
239 */
240typedef void (*OpenGlDrawCallback)(void* userdata);
241
242/** @brief Callback function for a button created by cv::createButton
243@param state current state of the button. It could be -1 for a push button, 0 or 1 for a check/radio box button.
244@param userdata The optional parameter.
245 */
246typedef void (*ButtonCallback)(int state, void* userdata);
247
248/** @brief Creates a window.
249
250The function namedWindow creates a window that can be used as a placeholder for images and
251trackbars. Created windows are referred to by their names.
252
253If a window with the same name already exists, the function does nothing.
254
255You can call cv::destroyWindow or cv::destroyAllWindows to close the window and de-allocate any associated
256memory usage. For a simple program, you do not really have to call these functions because all the
257resources and windows of the application are closed automatically by the operating system upon exit.
258
259@note Qt backend supports additional flags:
260 - **WINDOW_NORMAL or WINDOW_AUTOSIZE:** WINDOW_NORMAL enables you to resize the
261 window, whereas WINDOW_AUTOSIZE adjusts automatically the window size to fit the
262 displayed image (see imshow ), and you cannot change the window size manually.
263 - **WINDOW_FREERATIO or WINDOW_KEEPRATIO:** WINDOW_FREERATIO adjusts the image
264 with no respect to its ratio, whereas WINDOW_KEEPRATIO keeps the image ratio.
265 - **WINDOW_GUI_NORMAL or WINDOW_GUI_EXPANDED:** WINDOW_GUI_NORMAL is the old way to draw the window
266 without statusbar and toolbar, whereas WINDOW_GUI_EXPANDED is a new enhanced GUI.
267By default, flags == WINDOW_AUTOSIZE | WINDOW_KEEPRATIO | WINDOW_GUI_EXPANDED
268
269@param winname Name of the window in the window caption that may be used as a window identifier.
270@param flags Flags of the window. The supported flags are: (cv::WindowFlags)
271 */
272CV_EXPORTS_W void namedWindow(const String& winname, int flags = WINDOW_AUTOSIZE);
273
274/** @brief Destroys the specified window.
275
276The function destroyWindow destroys the window with the given name.
277
278@param winname Name of the window to be destroyed.
279 */
280CV_EXPORTS_W void destroyWindow(const String& winname);
281
282/** @brief Destroys all of the HighGUI windows.
283
284The function destroyAllWindows destroys all of the opened HighGUI windows.
285 */
286CV_EXPORTS_W void destroyAllWindows();
287
288
289/** @brief HighGUI backend used.
290
291The function returns HighGUI backend name used: could be COCOA, GTK2/3, QT, WAYLAND or WIN32.
292Returns empty string if there is no available UI backend.
293 */
294CV_EXPORTS_W const std::string currentUIFramework();
295
296
297CV_EXPORTS_W int startWindowThread();
298
299/** @brief Similar to #waitKey, but returns full key code.
300
301@note Key code is implementation specific and depends on used backend: QT/GTK/Win32/etc
302
303*/
304CV_EXPORTS_W int waitKeyEx(int delay = 0);
305
306/** @brief Waits for a pressed key.
307
308The function waitKey waits for a key event infinitely (when \f$\texttt{delay}\leq 0\f$ ) or for delay
309milliseconds, when it is positive. Since the OS has a minimum time between switching threads, the
310function will not wait exactly delay ms, it will wait at least delay ms, depending on what else is
311running on your computer at that time. It returns the code of the pressed key or -1 if no key was
312pressed before the specified time had elapsed. To check for a key press but not wait for it, use
313#pollKey.
314
315@note The functions #waitKey and #pollKey are the only methods in HighGUI that can fetch and handle
316GUI events, so one of them needs to be called periodically for normal event processing unless
317HighGUI is used within an environment that takes care of event processing.
318
319@note The function only works if there is at least one HighGUI window created and the window is
320active. If there are several HighGUI windows, any of them can be active.
321
322@param delay Delay in milliseconds. 0 is the special value that means "forever".
323 */
324CV_EXPORTS_W int waitKey(int delay = 0);
325
326/** @brief Polls for a pressed key.
327
328The function pollKey polls for a key event without waiting. It returns the code of the pressed key
329or -1 if no key was pressed since the last invocation. To wait until a key was pressed, use #waitKey.
330
331@note The functions #waitKey and #pollKey are the only methods in HighGUI that can fetch and handle
332GUI events, so one of them needs to be called periodically for normal event processing unless
333HighGUI is used within an environment that takes care of event processing.
334
335@note The function only works if there is at least one HighGUI window created and the window is
336active. If there are several HighGUI windows, any of them can be active.
337 */
338CV_EXPORTS_W int pollKey();
339
340/** @brief Displays an image in the specified window.
341
342The function imshow displays an image in the specified window. If the window was created with the
343cv::WINDOW_AUTOSIZE flag, the image is shown with its original size, however it is still limited by the screen resolution.
344Otherwise, the image is scaled to fit the window. The function may scale the image, depending on its depth:
345
346- If the image is 8-bit unsigned, it is displayed as is.
347- If the image is 16-bit unsigned, the pixels are divided by 256. That is, the
348 value range [0,255\*256] is mapped to [0,255].
349- If the image is 32-bit or 64-bit floating-point, the pixel values are multiplied by 255. That is, the
350 value range [0,1] is mapped to [0,255].
351- 32-bit integer images are not processed anymore due to ambiguouty of required transform.
352 Convert to 8-bit unsigned matrix using a custom preprocessing specific to image's context.
353
354If window was created with OpenGL support, cv::imshow also support ogl::Buffer , ogl::Texture2D and
355cuda::GpuMat as input.
356
357If the window was not created before this function, it is assumed creating a window with cv::WINDOW_AUTOSIZE.
358
359If you need to show an image that is bigger than the screen resolution, you will need to call namedWindow("", WINDOW_NORMAL) before the imshow.
360
361@note This function should be followed by a call to cv::waitKey or cv::pollKey to perform GUI
362housekeeping tasks that are necessary to actually show the given image and make the window respond
363to mouse and keyboard events. Otherwise, it won't display the image and the window might lock up.
364For example, **waitKey(0)** will display the window infinitely until any keypress (it is suitable
365for image display). **waitKey(25)** will display a frame and wait approximately 25 ms for a key
366press (suitable for displaying a video frame-by-frame). To remove the window, use cv::destroyWindow.
367
368@note [__Windows Backend Only__] Pressing Ctrl+C will copy the image to the clipboard. Pressing Ctrl+S will show a dialog to save the image.
369@note [__Wayland Backend Only__] Supoorting format is extended.
370- If the image is 8-bit signed, the pixels are biased by 128. That is, the
371 value range [-128,127] is mapped to [0,255].
372- If the image is 16-bit signed, the pixels are divided by 256 and biased by 128. That is, the
373 value range [-32768,32767] is mapped to [0,255].
374
375@param winname Name of the window.
376@param mat Image to be shown.
377 */
378CV_EXPORTS_W void imshow(const String& winname, InputArray mat);
379
380/** @brief Resizes the window to the specified size
381
382@note The specified window size is for the image area. Toolbars are not counted.
383Only windows created without cv::WINDOW_AUTOSIZE flag can be resized.
384
385@param winname Window name.
386@param width The new window width.
387@param height The new window height.
388 */
389CV_EXPORTS_W void resizeWindow(const String& winname, int width, int height);
390
391/** @overload
392@param winname Window name.
393@param size The new window size.
394*/
395CV_EXPORTS_W void resizeWindow(const String& winname, const cv::Size& size);
396
397/** @brief Moves the window to the specified position
398
399@param winname Name of the window.
400@param x The new x-coordinate of the window.
401@param y The new y-coordinate of the window.
402
403@note [__Wayland Backend Only__] This function is not supported by the Wayland protocol limitation.
404 */
405CV_EXPORTS_W void moveWindow(const String& winname, int x, int y);
406
407/** @brief Changes parameters of a window dynamically.
408
409The function setWindowProperty enables changing properties of a window.
410
411@param winname Name of the window.
412@param prop_id Window property to edit. The supported operation flags are: (cv::WindowPropertyFlags)
413@param prop_value New value of the window property. The supported flags are: (cv::WindowFlags)
414
415@note [__Wayland Backend Only__] This function is not supported.
416 */
417CV_EXPORTS_W void setWindowProperty(const String& winname, int prop_id, double prop_value);
418
419/** @brief Updates window title
420@param winname Name of the window.
421@param title New title.
422*/
423CV_EXPORTS_W void setWindowTitle(const String& winname, const String& title);
424
425/** @brief Provides parameters of a window.
426
427The function getWindowProperty returns properties of a window.
428
429@param winname Name of the window.
430@param prop_id Window property to retrieve. The following operation flags are available: (cv::WindowPropertyFlags)
431
432@sa setWindowProperty
433
434@note [__Wayland Backend Only__] This function is not supported.
435 */
436CV_EXPORTS_W double getWindowProperty(const String& winname, int prop_id);
437
438/** @brief Provides rectangle of image in the window.
439
440The function getWindowImageRect returns the client screen coordinates, width and height of the image rendering area.
441
442@param winname Name of the window.
443
444@sa resizeWindow moveWindow
445
446@note [__Wayland Backend Only__] This function is not supported by the Wayland protocol limitation.
447 */
448CV_EXPORTS_W Rect getWindowImageRect(const String& winname);
449
450/** @example samples/cpp/create_mask.cpp
451This program demonstrates using mouse events and how to make and use a mask image (black and white) .
452*/
453/** @brief Sets mouse handler for the specified window
454
455@param winname Name of the window.
456@param onMouse Callback function for mouse events. See OpenCV samples on how to specify and use the callback.
457@param userdata The optional parameter passed to the callback.
458 */
459CV_EXPORTS void setMouseCallback(const String& winname, MouseCallback onMouse, void* userdata = 0);
460
461/** @brief Gets the mouse-wheel motion delta, when handling mouse-wheel events cv::EVENT_MOUSEWHEEL and
462cv::EVENT_MOUSEHWHEEL.
463
464For regular mice with a scroll-wheel, delta will be a multiple of 120. The value 120 corresponds to
465a one notch rotation of the wheel or the threshold for action to be taken and one such action should
466occur for each delta. Some high-precision mice with higher-resolution freely-rotating wheels may
467generate smaller values.
468
469For cv::EVENT_MOUSEWHEEL positive and negative values mean forward and backward scrolling,
470respectively. For cv::EVENT_MOUSEHWHEEL, where available, positive and negative values mean right and
471left scrolling, respectively.
472
473@note Mouse-wheel events are currently supported only on Windows and Cocoa.
474
475@param flags The mouse callback flags parameter.
476 */
477CV_EXPORTS int getMouseWheelDelta(int flags);
478
479/** @brief Allows users to select a ROI on the given image.
480
481The function creates a window and allows users to select a ROI using the mouse.
482Controls: use `space` or `enter` to finish selection, use key `c` to cancel selection (function will return the zero cv::Rect).
483
484@param windowName name of the window where selection process will be shown.
485@param img image to select a ROI.
486@param showCrosshair if true crosshair of selection rectangle will be shown.
487@param fromCenter if true center of selection will match initial mouse position. In opposite case a corner of
488selection rectangle will correspont to the initial mouse position.
489@param printNotice if true a notice to select ROI or cancel selection will be printed in console.
490@return selected ROI or empty rect if selection canceled.
491
492@note The function sets it's own mouse callback for specified window using cv::setMouseCallback(windowName, ...).
493After finish of work an empty callback will be set for the used window.
494 */
495CV_EXPORTS_W Rect selectROI(const String& windowName, InputArray img, bool showCrosshair = true, bool fromCenter = false, bool printNotice = true);
496
497/** @overload
498 */
499CV_EXPORTS_W Rect selectROI(InputArray img, bool showCrosshair = true, bool fromCenter = false, bool printNotice = true);
500
501/** @brief Allows users to select multiple ROIs on the given image.
502
503The function creates a window and allows users to select multiple ROIs using the mouse.
504Controls: use `space` or `enter` to finish current selection and start a new one,
505use `esc` to terminate multiple ROI selection process.
506
507@param windowName name of the window where selection process will be shown.
508@param img image to select a ROI.
509@param boundingBoxes selected ROIs.
510@param showCrosshair if true crosshair of selection rectangle will be shown.
511@param fromCenter if true center of selection will match initial mouse position. In opposite case a corner of
512selection rectangle will correspont to the initial mouse position.
513@param printNotice if true a notice to select ROI or cancel selection will be printed in console.
514
515@note The function sets it's own mouse callback for specified window using cv::setMouseCallback(windowName, ...).
516After finish of work an empty callback will be set for the used window.
517 */
518CV_EXPORTS_W void selectROIs(const String& windowName, InputArray img,
519 CV_OUT std::vector<Rect>& boundingBoxes, bool showCrosshair = true, bool fromCenter = false, bool printNotice = true);
520
521/** @brief Creates a trackbar and attaches it to the specified window.
522
523The function createTrackbar creates a trackbar (a slider or range control) with the specified name
524and range, assigns a variable value to be a position synchronized with the trackbar and specifies
525the callback function onChange to be called on the trackbar position change. The created trackbar is
526displayed in the specified window winname.
527
528@note [__Qt Backend Only__] winname can be empty if the trackbar should be attached to the
529control panel.
530
531Clicking the label of each trackbar enables editing the trackbar values manually.
532
533@param trackbarname Name of the created trackbar.
534@param winname Name of the window that will contain the trackbar.
535@param value Pointer to the integer value that will be changed by the trackbar.
536Pass `nullptr` if the value pointer is not used. In this case, manually handle
537the trackbar position in the callback function.
538@param count Maximum position of the trackbar.
539@param onChange Pointer to the function to be called every time the slider changes position.
540This function should have the prototype void Foo(int, void\*);, where the first parameter is
541the trackbar position, and the second parameter is the user data (see the next parameter).
542If the callback is a nullptr, no callbacks are called, but the trackbar's value will still be
543updated automatically.
544@param userdata Optional user data that is passed to the callback.
545@note If the `value` pointer is `nullptr`, the trackbar position must be manually managed.
546Call the callback function manually with the desired initial value to avoid runtime warnings.
547@see \ref tutorial_trackbar
548 */
549CV_EXPORTS int createTrackbar(const String& trackbarname, const String& winname,
550 int* value, int count,
551 TrackbarCallback onChange = 0,
552 void* userdata = 0);
553
554/** @brief Returns the trackbar position.
555
556The function returns the current position of the specified trackbar.
557
558@note [__Qt Backend Only__] winname can be empty if the trackbar is attached to the control
559panel.
560
561@param trackbarname Name of the trackbar.
562@param winname Name of the window that is the parent of the trackbar.
563 */
564CV_EXPORTS_W int getTrackbarPos(const String& trackbarname, const String& winname);
565
566/** @brief Sets the trackbar position.
567
568The function sets the position of the specified trackbar in the specified window.
569
570@note [__Qt Backend Only__] winname can be empty if the trackbar is attached to the control
571panel.
572
573@param trackbarname Name of the trackbar.
574@param winname Name of the window that is the parent of trackbar.
575@param pos New position.
576 */
577CV_EXPORTS_W void setTrackbarPos(const String& trackbarname, const String& winname, int pos);
578
579/** @brief Sets the trackbar maximum position.
580
581The function sets the maximum position of the specified trackbar in the specified window.
582
583@note [__Qt Backend Only__] winname can be empty if the trackbar is attached to the control
584panel.
585
586@param trackbarname Name of the trackbar.
587@param winname Name of the window that is the parent of trackbar.
588@param maxval New maximum position.
589 */
590CV_EXPORTS_W void setTrackbarMax(const String& trackbarname, const String& winname, int maxval);
591
592/** @brief Sets the trackbar minimum position.
593
594The function sets the minimum position of the specified trackbar in the specified window.
595
596@note [__Qt Backend Only__] winname can be empty if the trackbar is attached to the control
597panel.
598
599@param trackbarname Name of the trackbar.
600@param winname Name of the window that is the parent of trackbar.
601@param minval New minimum position.
602 */
603CV_EXPORTS_W void setTrackbarMin(const String& trackbarname, const String& winname, int minval);
604
605//! @addtogroup highgui_opengl OpenGL support
606//! @{
607
608/** @brief Displays OpenGL 2D texture in the specified window.
609
610@param winname Name of the window.
611@param tex OpenGL 2D texture data.
612 */
613CV_EXPORTS void imshow(const String& winname, const ogl::Texture2D& tex);
614
615/** @brief Sets a callback function to be called to draw on top of displayed image.
616
617The function setOpenGlDrawCallback can be used to draw 3D data on the window. See the example of
618callback function below:
619@code
620 void on_opengl(void* param)
621 {
622 glLoadIdentity();
623
624 glTranslated(0.0, 0.0, -1.0);
625
626 glRotatef( 55, 1, 0, 0 );
627 glRotatef( 45, 0, 1, 0 );
628 glRotatef( 0, 0, 0, 1 );
629
630 static const int coords[6][4][3] = {
631 { { +1, -1, -1 }, { -1, -1, -1 }, { -1, +1, -1 }, { +1, +1, -1 } },
632 { { +1, +1, -1 }, { -1, +1, -1 }, { -1, +1, +1 }, { +1, +1, +1 } },
633 { { +1, -1, +1 }, { +1, -1, -1 }, { +1, +1, -1 }, { +1, +1, +1 } },
634 { { -1, -1, -1 }, { -1, -1, +1 }, { -1, +1, +1 }, { -1, +1, -1 } },
635 { { +1, -1, +1 }, { -1, -1, +1 }, { -1, -1, -1 }, { +1, -1, -1 } },
636 { { -1, -1, +1 }, { +1, -1, +1 }, { +1, +1, +1 }, { -1, +1, +1 } }
637 };
638
639 for (int i = 0; i < 6; ++i) {
640 glColor3ub( i*20, 100+i*10, i*42 );
641 glBegin(GL_QUADS);
642 for (int j = 0; j < 4; ++j) {
643 glVertex3d(0.2 * coords[i][j][0], 0.2 * coords[i][j][1], 0.2 * coords[i][j][2]);
644 }
645 glEnd();
646 }
647 }
648@endcode
649
650@param winname Name of the window.
651@param onOpenGlDraw Pointer to the function to be called every frame. This function should be
652prototyped as void Foo(void\*) .
653@param userdata Pointer passed to the callback function.(__Optional__)
654 */
655CV_EXPORTS void setOpenGlDrawCallback(const String& winname, OpenGlDrawCallback onOpenGlDraw, void* userdata = 0);
656
657/** @brief Sets the specified window as current OpenGL context.
658
659@param winname Name of the window.
660 */
661CV_EXPORTS void setOpenGlContext(const String& winname);
662
663/** @brief Force window to redraw its context and call draw callback ( See cv::setOpenGlDrawCallback ).
664
665@param winname Name of the window.
666 */
667CV_EXPORTS void updateWindow(const String& winname);
668
669//! @} highgui_opengl
670
671//! @addtogroup highgui_qt
672//! @{
673
674/** @brief QtFont available only for Qt. See cv::fontQt
675 */
676struct QtFont
677{
678 const char* nameFont; //!< Name of the font
679 Scalar color; //!< Color of the font. Scalar(blue_component, green_component, red_component[, alpha_component])
680 int font_face; //!< See cv::QtFontStyles
681 const int* ascii; //!< font data and metrics
682 const int* greek;
683 const int* cyrillic;
684 float hscale, vscale;
685 float shear; //!< slope coefficient: 0 - normal, >0 - italic
686 int thickness; //!< See cv::QtFontWeights
687 float dx; //!< horizontal interval between letters
688 int line_type; //!< PointSize
689};
690
691/** @brief Creates the font to draw a text on an image.
692
693The function fontQt creates a cv::QtFont object. This cv::QtFont is not compatible with putText .
694
695A basic usage of this function is the following: :
696@code
697 QtFont font = fontQt("Times");
698 addText( img1, "Hello World !", Point(50,50), font);
699@endcode
700
701@param nameFont Name of the font. The name should match the name of a system font (such as
702*Times*). If the font is not found, a default one is used.
703@param pointSize Size of the font. If not specified, equal zero or negative, the point size of the
704font is set to a system-dependent default value. Generally, this is 12 points.
705@param color Color of the font in BGRA where A = 255 is fully transparent. Use the macro CV_RGB
706for simplicity.
707@param weight Font weight. Available operation flags are : cv::QtFontWeights You can also specify a positive integer for better control.
708@param style Font style. Available operation flags are : cv::QtFontStyles
709@param spacing Spacing between characters. It can be negative or positive.
710 */
711CV_EXPORTS QtFont fontQt(const String& nameFont, int pointSize = -1,
712 Scalar color = Scalar::all(v0: 0), int weight = QT_FONT_NORMAL,
713 int style = QT_STYLE_NORMAL, int spacing = 0);
714
715/** @brief Draws a text on the image.
716
717The function addText draws *text* on the image *img* using a specific font *font* (see example cv::fontQt
718)
719
720@param img 8-bit 3-channel image where the text should be drawn.
721@param text Text to write on an image.
722@param org Point(x,y) where the text should start on an image.
723@param font Font to use to draw a text.
724 */
725CV_EXPORTS void addText( const Mat& img, const String& text, Point org, const QtFont& font);
726
727/** @brief Draws a text on the image.
728
729@param img 8-bit 3-channel image where the text should be drawn.
730@param text Text to write on an image.
731@param org Point(x,y) where the text should start on an image.
732@param nameFont Name of the font. The name should match the name of a system font (such as
733*Times*). If the font is not found, a default one is used.
734@param pointSize Size of the font. If not specified, equal zero or negative, the point size of the
735font is set to a system-dependent default value. Generally, this is 12 points.
736@param color Color of the font in BGRA where A = 255 is fully transparent.
737@param weight Font weight. Available operation flags are : cv::QtFontWeights You can also specify a positive integer for better control.
738@param style Font style. Available operation flags are : cv::QtFontStyles
739@param spacing Spacing between characters. It can be negative or positive.
740 */
741CV_EXPORTS_W void addText(const Mat& img, const String& text, Point org, const String& nameFont, int pointSize = -1, Scalar color = Scalar::all(v0: 0),
742 int weight = QT_FONT_NORMAL, int style = QT_STYLE_NORMAL, int spacing = 0);
743
744/** @brief Displays a text on a window image as an overlay for a specified duration.
745
746The function displayOverlay displays useful information/tips on top of the window for a certain
747amount of time *delayms*. The function does not modify the image, displayed in the window, that is,
748after the specified delay the original content of the window is restored.
749
750@param winname Name of the window.
751@param text Overlay text to write on a window image.
752@param delayms The period (in milliseconds), during which the overlay text is displayed. If this
753function is called before the previous overlay text timed out, the timer is restarted and the text
754is updated. If this value is zero, the text never disappears.
755 */
756CV_EXPORTS_W void displayOverlay(const String& winname, const String& text, int delayms = 0);
757
758/** @brief Displays a text on the window statusbar during the specified period of time.
759
760The function displayStatusBar displays useful information/tips on top of the window for a certain
761amount of time *delayms* . This information is displayed on the window statusbar (the window must be
762created with the CV_GUI_EXPANDED flags).
763
764@param winname Name of the window.
765@param text Text to write on the window statusbar.
766@param delayms Duration (in milliseconds) to display the text. If this function is called before
767the previous text timed out, the timer is restarted and the text is updated. If this value is
768zero, the text never disappears.
769 */
770CV_EXPORTS_W void displayStatusBar(const String& winname, const String& text, int delayms = 0);
771
772/** @brief Saves parameters of the specified window.
773
774The function saveWindowParameters saves size, location, flags, trackbars value, zoom and panning
775location of the window windowName.
776
777@param windowName Name of the window.
778 */
779CV_EXPORTS void saveWindowParameters(const String& windowName);
780
781/** @brief Loads parameters of the specified window.
782
783The function loadWindowParameters loads size, location, flags, trackbars value, zoom and panning
784location of the window windowName.
785
786@param windowName Name of the window.
787 */
788CV_EXPORTS void loadWindowParameters(const String& windowName);
789
790CV_EXPORTS int startLoop(int (*pt2Func)(int argc, char *argv[]), int argc, char* argv[]);
791
792CV_EXPORTS void stopLoop();
793
794/** @brief Attaches a button to the control panel.
795
796The function createButton attaches a button to the control panel. Each button is added to a
797buttonbar to the right of the last button. A new buttonbar is created if nothing was attached to the
798control panel before, or if the last element attached to the control panel was a trackbar or if the
799QT_NEW_BUTTONBAR flag is added to the type.
800
801See below various examples of the cv::createButton function call: :
802@code
803 createButton("",callbackButton);//create a push button "button 0", that will call callbackButton.
804 createButton("button2",callbackButton,NULL,QT_CHECKBOX,0);
805 createButton("button3",callbackButton,&value);
806 createButton("button5",callbackButton1,NULL,QT_RADIOBOX);
807 createButton("button6",callbackButton2,NULL,QT_PUSH_BUTTON,1);
808 createButton("button6",callbackButton2,NULL,QT_PUSH_BUTTON|QT_NEW_BUTTONBAR);// create a push button in a new row
809@endcode
810
811@param bar_name Name of the button.
812@param on_change Pointer to the function to be called every time the button changes its state.
813This function should be prototyped as void Foo(int state,\*void); . *state* is the current state
814of the button. It could be -1 for a push button, 0 or 1 for a check/radio box button.
815@param userdata Pointer passed to the callback function.
816@param type Optional type of the button. Available types are: (cv::QtButtonTypes)
817@param initial_button_state Default state of the button. Use for checkbox and radiobox. Its
818value could be 0 or 1. (__Optional__)
819*/
820CV_EXPORTS int createButton( const String& bar_name, ButtonCallback on_change,
821 void* userdata = 0, int type = QT_PUSH_BUTTON,
822 bool initial_button_state = false);
823
824//! @} highgui_qt
825
826//! @} highgui
827
828} // cv
829
830#endif
831

source code of opencv/modules/highgui/include/opencv2/highgui.hpp