1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
|
//! \example tutorial-grabber-opencv-threaded.cpp
//! [capture-multi-threaded declaration]
#include <iostream>
#include <visp3/core/vpConfig.h>
#if defined(VISP_HAVE_OPENCV) && defined(VISP_HAVE_THREADS) && \
(((VISP_HAVE_OPENCV_VERSION < 0x030000) && defined(HAVE_OPENCV_HIGHGUI)) || ((VISP_HAVE_OPENCV_VERSION >= 0x030000) && defined(HAVE_OPENCV_VIDEOIO)))
#include <thread>
#include <mutex>
#if (VISP_HAVE_OPENCV_VERSION < 0x030000) && defined(HAVE_OPENCV_HIGHGUI)
#include <opencv2/highgui/highgui.hpp> // for cv::VideoCapture
#elif (VISP_HAVE_OPENCV_VERSION >= 0x030000) && defined(HAVE_OPENCV_VIDEOIO)
#include <opencv2/videoio/videoio.hpp> // for cv::VideoCapture
#endif
#include <visp3/core/vpImageConvert.h>
#include <visp3/core/vpTime.h>
#include <visp3/gui/vpDisplayFactory.h>
#ifdef ENABLE_VISP_NAMESPACE
using namespace VISP_NAMESPACE_NAME;
#endif
// Possible capture states
typedef enum { capture_waiting, capture_started, capture_stopped } t_CaptureState;
//! [capture-multi-threaded declaration]
//! [capture-multi-threaded captureFunction]
void captureFunction(cv::VideoCapture &cap, std::mutex &mutex_capture, cv::Mat &frame, t_CaptureState &capture_state)
{
if (!cap.isOpened()) { // check if we succeeded
std::cout << "Unable to start capture" << std::endl;
return;
}
cv::Mat frame_;
int i = 0;
while ((i++ < 100) && !cap.read(frame_)) {
}; // warm up camera by skipping unread frames
bool stop_capture_ = false;
double start_time = vpTime::measureTimeSecond();
while ((vpTime::measureTimeSecond() - start_time) < 30 && !stop_capture_) {
// Capture in progress
cap >> frame_; // get a new frame from camera
// Update shared data
{
std::lock_guard<std::mutex> lock(mutex_capture);
if (capture_state == capture_stopped)
stop_capture_ = true;
else
capture_state = capture_started;
frame = frame_;
}
}
{
std::lock_guard<std::mutex> lock(mutex_capture);
capture_state = capture_stopped;
}
std::cout << "End of capture thread" << std::endl;
}
//! [capture-multi-threaded captureFunction]
//! [capture-multi-threaded displayFunction]
void displayFunction(std::mutex &mutex_capture, cv::Mat &frame, t_CaptureState &capture_state)
{
vpImage<unsigned char> I_;
t_CaptureState capture_state_;
bool display_initialized_ = false;
#if (VISP_CXX_STANDARD >= VISP_CXX_STANDARD_11)
std::shared_ptr<vpDisplay> display;
#else
vpDisplay *display = nullptr;
#endif
do {
mutex_capture.lock();
capture_state_ = capture_state;
mutex_capture.unlock();
// Check if a frame is available
if (capture_state_ == capture_started) {
// Get the frame and convert it to a ViSP image used by the display
// class
{
std::lock_guard<std::mutex> lock(mutex_capture);
vpImageConvert::convert(frame, I_);
}
// Check if we need to initialize the display with the first frame
if (!display_initialized_) {
// Initialize the display
#if (VISP_CXX_STANDARD >= VISP_CXX_STANDARD_11)
display = vpDisplayFactory::createDisplay(I_);
display_initialized_ = true;
#else
display = vpDisplayFactory::allocateDisplay(I_);
display_initialized_ = true;
#endif
}
// Display the image
vpDisplay::display(I_);
// Trigger end of acquisition with a mouse click
vpDisplay::displayText(I_, 10, 10, "Click to exit...", vpColor::red);
if (vpDisplay::getClick(I_, false)) {
std::lock_guard<std::mutex> lock(mutex_capture);
capture_state = capture_stopped;
}
// Update the display
vpDisplay::flush(I_);
}
else {
vpTime::wait(2); // Sleep 2ms
}
} while (capture_state_ != capture_stopped);
#if (VISP_CXX_STANDARD < VISP_CXX_STANDARD_11)
if (display != nullptr) {
delete display;
}
#endif
std::cout << "End of display thread" << std::endl;
}
//! [capture-multi-threaded displayFunction]
//! [capture-multi-threaded mainFunction]
int main(int argc, const char *argv[])
{
int opt_device = 0;
// Command line options
for (int i = 1; i < argc; i++) {
if (std::string(argv[i]) == "--camera-device" && i + 1 < argc) {
opt_device = atoi(argv[++i]);
}
else if (std::string(argv[i]) == "--help") {
std::cout << "Usage: " << argv[0] << " [--camera-device <camera device (default: 0)>] [--help]" << std::endl;
return EXIT_SUCCESS;
}
}
// Instantiate the capture
cv::VideoCapture cap;
cap.open(opt_device);
cv::Mat frame;
t_CaptureState capture_state = capture_waiting;
// Create a mutex for capture
std::mutex mutex_capture;
// Start the threads
std::thread thread_capture(&captureFunction, std::ref(cap), std::ref(mutex_capture), std::ref(frame), std::ref(capture_state));
std::thread thread_display(&displayFunction, std::ref(mutex_capture), std::ref(frame), std::ref(capture_state));
// Wait until thread ends up
thread_capture.join();
thread_display.join();
return EXIT_SUCCESS;
}
//! [capture-multi-threaded mainFunction]
#else
int main()
{
#if defined(VISP_HAVE_OPENCV) && (VISP_HAVE_OPENCV_VERSION < 0x030000) && !defined(HAVE_OPENCV_HIGHGUI)
std::cout << "Install OpenCV highgui module, configure and build ViSP again to use this tutorial." << std::endl;
#endif
#if defined(VISP_HAVE_OPENCV) && (VISP_HAVE_OPENCV_VERSION >= 0x030000) && !defined(HAVE_OPENCV_VIDEOIO)
std::cout << "Install OpenCV videoio module, configure and build ViSP again to use this tutorial." << std::endl;
#endif
#if !defined(HAVE_OPENCV_HIGHGUI)
std::cout << "Install OpenCV highgui module, configure and build ViSP again to use this tutorial." << std::endl;
#endif
#if !defined(VISP_HAVE_THREADS) // UNIX
std::cout << "This tutorial cannot run without std::thread usage." << std::endl;
std::cout << "Multi-threading seems not supported on this platform" << std::endl;
#endif
return EXIT_SUCCESS;
}
#endif
|
