Fawkes API Fawkes Development Version
bb2calib.cpp
1
2/***************************************************************************
3 * bb2calib.cpp - Bumblebee2 calibration GUI
4 *
5 * Created: Thu Jul 18 20:59:47 2013
6 * Copyright 2008-2013 Tim Niemueller [www.niemueller.de]
7 *
8 ****************************************************************************/
9
10/* This program is free software; you can redistribute it and/or modify
11 * it under the terms of the GNU General Public License as published by
12 * the Free Software Foundation; either version 2 of the License, or
13 * (at your option) any later version.
14 *
15 * This program is distributed in the hope that it will be useful,
16 * but WITHOUT ANY WARRANTY; without even the implied warranty of
17 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 * GNU Library General Public License for more details.
19 *
20 * Read the full text in the LICENSE.GPL file in the doc directory.
21 */
22
23#include "bb2calib.h"
24
25#include <blackboard/remote.h>
26#include <fvcams/net.h>
27#include <fvutils/color/conversions.h>
28#include <gui_utils/interface_dispatcher.h>
29#include <gui_utils/service_chooser_dialog.h>
30#include <interfaces/OpenCVStereoParamsInterface.h>
31#include <netcomm/fawkes/client.h>
32
33#include <cstring>
34#include <iomanip>
35#include <sstream>
36#include <string>
37
38using namespace firevision;
39using namespace fawkes;
40
41#define FIREVISION_PORT 2208
42#define BB2_IMG_RECT_LEFT "bumblebee2-rgb-rectified-left"
43#define BB2_IMG_DISPARITY "bumblebee2-disparity"
44#define IMG_UPDATE_INTERVAL 200
45
46/** @class Bumblebee2CalibGtkWindow "naogui.h"
47 * Bumblebee2 calibration GUI main window.
48 * @author Tim Niemueller
49 */
50
51/** Constructor.
52 * @param cobject C base object
53 * @param builder Gtk builder to get widgets from
54 */
56 const Glib::RefPtr<Gtk::Builder> &builder)
57: Gtk::Window(cobject)
58{
59 bb_ = NULL;
60 params_if_ = NULL;
61 cam_left_rectified_ = cam_disparity_ = NULL;
62 buffer_rgb_disparity_ = buffer_rgb_rect_left_ = NULL;
63
64 builder->get_widget("cmb_pre_filter_type", cmb_pre_filter_type);
65 builder->get_widget("lab_pre_filter_type", lab_pre_filter_type);
66 builder->get_widget("lab_pre_filter_size", lab_pre_filter_size);
67 builder->get_widget("lab_pre_filter_cap", lab_pre_filter_cap);
68 builder->get_widget("lab_sad_window_size", lab_sad_window_size);
69 builder->get_widget("lab_min_disparity", lab_min_disparity);
70 builder->get_widget("lab_num_disparities", lab_num_disparities);
71 builder->get_widget("lab_texture_threshold", lab_texture_threshold);
72 builder->get_widget("lab_uniqueness_ratio", lab_uniqueness_ratio);
73 builder->get_widget("lab_speckle_window_size", lab_speckle_window_size);
74 builder->get_widget("lab_speckle_range", lab_speckle_range);
75 builder->get_widget("lab_try_smaller_windows", lab_try_smaller_windows);
76 builder->get_widget("hsc_pre_filter_size", hsc_pre_filter_size);
77 builder->get_widget("hsc_pre_filter_cap", hsc_pre_filter_cap);
78 builder->get_widget("hsc_sad_window_size", hsc_sad_window_size);
79 builder->get_widget("hsc_min_disparity", hsc_min_disparity);
80 builder->get_widget("hsc_num_disparities", hsc_num_disparities);
81 builder->get_widget("hsc_texture_threshold", hsc_texture_threshold);
82 builder->get_widget("hsc_uniqueness_ratio", hsc_uniqueness_ratio);
83 builder->get_widget("hsc_speckle_window_size", hsc_speckle_window_size);
84 builder->get_widget("cb_try_smaller_windows", cb_try_smaller_windows);
85 builder->get_widget("hsc_speckle_range", hsc_speckle_range);
86 builder->get_widget("tb_connection", tb_connection);
87 builder->get_widget("tb_exit", tb_exit);
88 builder->get_widget("img_left_rectified", img_left_rectified);
89 builder->get_widget("img_disparity", img_disparity);
90 builder->get_widget("img_writer", img_writer);
91
92 cmb_pre_filter_type->signal_changed().connect(
93 sigc::mem_fun(*this, &Bumblebee2CalibGtkWindow::on_pre_filter_type_changed));
94 hsc_pre_filter_size->signal_value_changed().connect(
95 sigc::mem_fun(*this, &Bumblebee2CalibGtkWindow::on_pre_filter_size_changed));
96 hsc_pre_filter_cap->signal_value_changed().connect(
97 sigc::mem_fun(*this, &Bumblebee2CalibGtkWindow::on_pre_filter_cap_changed));
98 hsc_sad_window_size->signal_value_changed().connect(
99 sigc::mem_fun(*this, &Bumblebee2CalibGtkWindow::on_sad_window_size_changed));
100 hsc_min_disparity->signal_value_changed().connect(
101 sigc::mem_fun(*this, &Bumblebee2CalibGtkWindow::on_min_disparity_changed));
102 hsc_num_disparities->signal_value_changed().connect(
103 sigc::mem_fun(*this, &Bumblebee2CalibGtkWindow::on_num_disparities_changed));
104 hsc_texture_threshold->signal_value_changed().connect(
105 sigc::mem_fun(*this, &Bumblebee2CalibGtkWindow::on_texture_threshold_changed));
106 hsc_uniqueness_ratio->signal_value_changed().connect(
107 sigc::mem_fun(*this, &Bumblebee2CalibGtkWindow::on_uniqueness_ratio_changed));
108 hsc_speckle_window_size->signal_value_changed().connect(
109 sigc::mem_fun(*this, &Bumblebee2CalibGtkWindow::on_speckle_window_size_changed));
110 hsc_speckle_range->signal_value_changed().connect(
111 sigc::mem_fun(*this, &Bumblebee2CalibGtkWindow::on_speckle_range_changed));
112 cb_try_smaller_windows->signal_toggled().connect(
113 sigc::mem_fun(*this, &Bumblebee2CalibGtkWindow::on_try_smaller_windows_toggled));
114
115 tb_connection->signal_clicked().connect(
116 sigc::mem_fun(*this, &Bumblebee2CalibGtkWindow::on_connection_clicked));
117 tb_exit->signal_clicked().connect(
118 sigc::mem_fun(*this, &Bumblebee2CalibGtkWindow::on_exit_clicked));
119 ;
120 connection_dispatcher.signal_connected().connect(
121 sigc::mem_fun(*this, &Bumblebee2CalibGtkWindow::on_connect));
122 connection_dispatcher.signal_disconnected().connect(
123 sigc::mem_fun(*this, &Bumblebee2CalibGtkWindow::on_disconnect));
124
125 init();
126}
127
128/** Destructor. */
130{
131 on_disconnect();
132}
133
134/**
135 * Sets the default values (locale dependent)
136 */
137void
138Bumblebee2CalibGtkWindow::init()
139{
140}
141
142/** Event handler for combo box changes. */
143void
144Bumblebee2CalibGtkWindow::on_pre_filter_type_changed()
145{
147 if (cmb_pre_filter_type->get_active_row_number() == 1) {
148 new_type = OpenCVStereoParamsInterface::PFT_NORMALIZED_RESPONSE;
149 } else {
150 new_type = OpenCVStereoParamsInterface::PFT_XSOBEL;
151 }
152
153 if (params_if_ && params_if_->has_writer() && (params_if_->pre_filter_type() != new_type)) {
154 printf("Setting pre filter type %s\n", params_if_->tostring_PreFilterType(new_type));
157 params_if_->msgq_enqueue(msg);
158 }
159}
160
161/** Event handler for slider changes. */
162void
163Bumblebee2CalibGtkWindow::on_pre_filter_size_changed()
164{
165 unsigned new_value = (unsigned int)hsc_pre_filter_size->get_value() * 2 + 1;
166
167 if (params_if_ && params_if_->has_writer() && (params_if_->pre_filter_size() != new_value)) {
168 printf("Setting pre filter size %u\n", new_value);
171 params_if_->msgq_enqueue(msg);
172 }
173}
174
175/** Event handler for slider changes. */
176void
177Bumblebee2CalibGtkWindow::on_pre_filter_cap_changed()
178{
179 unsigned int new_value = (unsigned int)hsc_pre_filter_cap->get_value();
180 if (params_if_ && params_if_->has_writer() && (params_if_->pre_filter_cap() != new_value)) {
181 printf("Setting pre filter cap %u\n", new_value);
184 params_if_->msgq_enqueue(msg);
185 }
186}
187
188/** Event handler for slider changes. */
189void
190Bumblebee2CalibGtkWindow::on_sad_window_size_changed()
191{
192 unsigned int new_value = (unsigned int)hsc_sad_window_size->get_value() * 2 + 1;
193
194 if (params_if_ && params_if_->has_writer() && (params_if_->sad_window_size() != new_value)) {
195 printf("Setting SAD window size %u\n", new_value);
198 params_if_->msgq_enqueue(msg);
199 }
200}
201
202/** Event handler for slider changes. */
203void
204Bumblebee2CalibGtkWindow::on_min_disparity_changed()
205{
206 int new_value = (int)hsc_min_disparity->get_value();
207 if (params_if_ && params_if_->has_writer() && (params_if_->min_disparity() != new_value)) {
208 printf("Setting min disparity %i\n", new_value);
211 params_if_->msgq_enqueue(msg);
212 }
213}
214
215/** Event handler for slider changes. */
216void
217Bumblebee2CalibGtkWindow::on_num_disparities_changed()
218{
219 unsigned int new_value = (unsigned int)hsc_num_disparities->get_value() * 16;
220 if (params_if_ && params_if_->has_writer() && (params_if_->num_disparities() != new_value)) {
221 printf("Setting num disparities %u\n", new_value);
224 params_if_->msgq_enqueue(msg);
225 }
226}
227
228/** Event handler for slider changes. */
229void
230Bumblebee2CalibGtkWindow::on_texture_threshold_changed()
231{
232 unsigned int new_value = (unsigned int)hsc_texture_threshold->get_value();
233 if (params_if_ && params_if_->has_writer() && (params_if_->texture_threshold() != new_value)) {
234 printf("Setting texture threshold %u\n", new_value);
237 params_if_->msgq_enqueue(msg);
238 }
239}
240
241/** Event handler for slider changes. */
242void
243Bumblebee2CalibGtkWindow::on_uniqueness_ratio_changed()
244{
245 unsigned int new_value = (unsigned int)hsc_uniqueness_ratio->get_value();
246 if (params_if_ && params_if_->has_writer() && (params_if_->uniqueness_ratio() != new_value)) {
247 printf("Setting uniqueness ratio %u\n", new_value);
250 params_if_->msgq_enqueue(msg);
251 }
252}
253
254/** Event handler for slider changes. */
255void
256Bumblebee2CalibGtkWindow::on_speckle_window_size_changed()
257{
258 unsigned int new_value = (unsigned int)hsc_speckle_window_size->get_value();
259 if (params_if_ && params_if_->has_writer() && (params_if_->speckle_window_size() != new_value)) {
260 printf("Setting speckle window size %u\n", new_value);
263 params_if_->msgq_enqueue(msg);
264 }
265}
266
267/** Event handler for slider changes. */
268void
269Bumblebee2CalibGtkWindow::on_speckle_range_changed()
270{
271 unsigned int new_value = (unsigned int)hsc_speckle_range->get_value();
272 if (params_if_ && params_if_->has_writer() && (params_if_->speckle_range() != new_value)) {
273 printf("Setting speckle range %u\n", new_value);
276 params_if_->msgq_enqueue(msg);
277 }
278}
279
280/** Event handler for connection button. */
281void
282Bumblebee2CalibGtkWindow::on_connection_clicked()
283{
284 if (!connection_dispatcher.get_client()->connected()) {
285 ServiceChooserDialog ssd(*this, connection_dispatcher.get_client());
286 ssd.run_and_connect();
287 } else {
288 connection_dispatcher.get_client()->disconnect();
289 }
290}
291
292/** Event handler for combo box changes. */
293void
294Bumblebee2CalibGtkWindow::on_try_smaller_windows_toggled()
295{
296 bool new_value = cb_try_smaller_windows->get_active();
297
298 if (params_if_ && params_if_->has_writer()
299 && (params_if_->is_try_smaller_windows() != new_value)) {
300 printf("%sabling smaller windows\n", new_value ? "En" : "Dis");
303 params_if_->msgq_enqueue(msg);
304 }
305}
306
307/** Event handler for connected event. */
308void
309Bumblebee2CalibGtkWindow::on_connect()
310{
311 try {
312 bb_ = new RemoteBlackBoard(connection_dispatcher.get_client());
313 params_if_ = bb_->open_for_reading<OpenCVStereoParamsInterface>("bumblebee2");
314
315 if (!params_if_->has_writer()) {
316 throw Exception("No writer for parameter blackboard interface");
317 }
318
319 ifd_params_ = new InterfaceDispatcher("Bumblebee2OpenCVParamsIfaceDisp", params_if_);
320 ifd_params_->signal_data_changed().connect(
321 sigc::hide(sigc::mem_fun(*this, &Bumblebee2CalibGtkWindow::update_param_values)));
322
323 bb_->register_listener(ifd_params_, BlackBoard::BBIL_FLAG_DATA);
324
325 tb_connection->set_stock_id(Gtk::Stock::DISCONNECT);
326
327 update_param_values();
328
329 switch (params_if_->pre_filter_type()) {
330 case OpenCVStereoParamsInterface::PFT_XSOBEL: cmb_pre_filter_type->set_active(0); break;
331 default: cmb_pre_filter_type->set_active(1); break;
332 }
333 hsc_pre_filter_size->set_value(params_if_->pre_filter_size() / 2);
334 hsc_pre_filter_cap->set_value(params_if_->pre_filter_cap());
335 hsc_sad_window_size->set_value(params_if_->sad_window_size() / 2);
336 hsc_min_disparity->set_value(params_if_->min_disparity());
337 hsc_num_disparities->set_value(params_if_->num_disparities() / 16);
338 hsc_texture_threshold->set_value(params_if_->texture_threshold());
339 hsc_uniqueness_ratio->set_value(params_if_->uniqueness_ratio());
340 hsc_speckle_window_size->set_value(params_if_->speckle_window_size());
341 hsc_speckle_range->set_value(params_if_->speckle_range());
342 cb_try_smaller_windows->set_active(params_if_->is_try_smaller_windows());
343
344 cmb_pre_filter_type->set_sensitive(true);
345 hsc_pre_filter_size->set_sensitive(true);
346 hsc_pre_filter_cap->set_sensitive(true);
347 hsc_sad_window_size->set_sensitive(true);
348 hsc_min_disparity->set_sensitive(true);
349 hsc_num_disparities->set_sensitive(true);
350 hsc_texture_threshold->set_sensitive(true);
351 hsc_uniqueness_ratio->set_sensitive(true);
352 hsc_speckle_window_size->set_sensitive(true);
353 hsc_speckle_range->set_sensitive(true);
354 cb_try_smaller_windows->set_sensitive(true);
355
356 cam_left_rectified_ = new NetworkCamera(connection_dispatcher.get_client()->get_hostname(),
357 FIREVISION_PORT,
358 BB2_IMG_RECT_LEFT,
359 false);
360 cam_left_rectified_->open();
361 cam_left_rectified_->start();
362 printf("Colorspace: %s\n", colorspace_to_string(cam_left_rectified_->colorspace()));
363
364 cam_disparity_ = new NetworkCamera(connection_dispatcher.get_client()->get_hostname(),
365 FIREVISION_PORT,
366 BB2_IMG_DISPARITY,
367 false);
368 cam_disparity_->open();
369 cam_disparity_->start();
370 buffer_rgb_disparity_ =
371 malloc_buffer(RGB, cam_disparity_->pixel_width(), cam_disparity_->pixel_height());
372 buffer_rgb_rect_left_ =
373 malloc_buffer(RGB, cam_left_rectified_->pixel_width(), cam_left_rectified_->pixel_height());
374
375 sconn_update_images_ =
376 Glib::signal_timeout().connect(sigc::mem_fun(*this, &Bumblebee2CalibGtkWindow::update_images),
377 IMG_UPDATE_INTERVAL);
378
379 this->set_title(std::string("Bumblebee2 Calibration @ ")
380 + connection_dispatcher.get_client()->get_hostname());
381
382 } catch (Exception &e) {
383 Glib::ustring message = *(e.begin());
384 Gtk::MessageDialog md(*this,
385 message,
386 /* markup */ false,
387 Gtk::MESSAGE_ERROR,
388 Gtk::BUTTONS_OK,
389 /* modal */ true);
390 md.set_title("Connection failed");
391 md.run();
392 if (bb_) {
393 bb_->unregister_listener(ifd_params_);
394 bb_->close(params_if_);
395 delete ifd_params_;
396 delete bb_;
397 params_if_ = NULL;
398 bb_ = NULL;
399 ifd_params_ = NULL;
400 }
401 delete cam_left_rectified_;
402 delete cam_disparity_;
403 if (buffer_rgb_disparity_)
404 free(buffer_rgb_disparity_);
405 if (buffer_rgb_rect_left_)
406 free(buffer_rgb_rect_left_);
407 cam_left_rectified_ = cam_disparity_ = NULL;
408 buffer_rgb_disparity_ = buffer_rgb_rect_left_ = NULL;
409
410 connection_dispatcher.get_client()->disconnect();
411 }
412}
413
414/** Event handler for disconnected event. */
415void
416Bumblebee2CalibGtkWindow::on_disconnect()
417{
418 sconn_update_images_.disconnect();
419
420 img_writer->set_from_icon_name(Gtk::Stock::NO.id, Gtk::IconSize(Gtk::ICON_SIZE_SMALL_TOOLBAR));
421 img_writer->set_tooltip_text("Not connected and thus no writer");
422
423 img_disparity->clear();
424 img_disparity->set("gtk-missing-image");
425
426 img_left_rectified->clear();
427 img_left_rectified->set("gtk-missing-image");
428
429 lab_pre_filter_size->set_text("");
430 lab_pre_filter_cap->set_text("");
431 lab_sad_window_size->set_text("");
432 lab_min_disparity->set_text("");
433 lab_num_disparities->set_text("");
434 lab_texture_threshold->set_text("");
435 lab_uniqueness_ratio->set_text("");
436 lab_speckle_window_size->set_text("");
437 lab_speckle_range->set_text("");
438 lab_try_smaller_windows->set_text("");
439
440 cmb_pre_filter_type->set_sensitive(false);
441 hsc_pre_filter_size->set_sensitive(false);
442 hsc_pre_filter_cap->set_sensitive(false);
443 hsc_sad_window_size->set_sensitive(false);
444 hsc_min_disparity->set_sensitive(false);
445 hsc_num_disparities->set_sensitive(false);
446 hsc_texture_threshold->set_sensitive(false);
447 hsc_uniqueness_ratio->set_sensitive(false);
448 hsc_speckle_window_size->set_sensitive(false);
449 hsc_speckle_range->set_sensitive(false);
450 cb_try_smaller_windows->set_sensitive(false);
451
452 if (bb_) {
453 bb_->unregister_listener(ifd_params_);
454 bb_->close(params_if_);
455
456 delete ifd_params_;
457 delete bb_;
458 params_if_ = NULL;
459 bb_ = NULL;
460 ifd_params_ = NULL;
461 }
462 if (cam_disparity_) {
463 cam_disparity_->stop();
464 cam_disparity_->close();
465 delete cam_disparity_;
466 cam_disparity_ = NULL;
467 }
468 if (buffer_rgb_disparity_)
469 free(buffer_rgb_disparity_);
470 buffer_rgb_disparity_ = NULL;
471
472 if (buffer_rgb_rect_left_)
473 free(buffer_rgb_rect_left_);
474 buffer_rgb_rect_left_ = NULL;
475
476 if (cam_left_rectified_) {
477 cam_left_rectified_->stop();
478 cam_left_rectified_->close();
479 delete cam_left_rectified_;
480 cam_left_rectified_ = NULL;
481 }
482
483 tb_connection->set_stock_id(Gtk::Stock::CONNECT);
484
485 //img_writer->set_stock_id(Gtk::Stock::NO);
486 this->set_title("Bumblebee2 Calibration");
487}
488
489void
490Bumblebee2CalibGtkWindow::update_param_values()
491{
492 params_if_->read();
493
494 switch (params_if_->pre_filter_type()) {
495 case OpenCVStereoParamsInterface::PFT_XSOBEL: lab_pre_filter_type->set_text("XSOBEL"); break;
496 default: lab_pre_filter_type->set_text("NORM RESP"); break;
497 }
498 lab_pre_filter_size->set_text(convert_float2str(params_if_->pre_filter_size(), 0));
499 lab_pre_filter_cap->set_text(convert_float2str(params_if_->pre_filter_cap(), 0));
500 lab_sad_window_size->set_text(convert_float2str(params_if_->sad_window_size(), 0));
501 lab_min_disparity->set_text(convert_float2str(params_if_->min_disparity(), 0));
502 lab_num_disparities->set_text(convert_float2str(params_if_->num_disparities(), 0));
503 lab_texture_threshold->set_text(convert_float2str(params_if_->texture_threshold(), 0));
504 lab_uniqueness_ratio->set_text(convert_float2str(params_if_->uniqueness_ratio(), 0));
505 lab_speckle_window_size->set_text(convert_float2str(params_if_->speckle_window_size(), 0));
506 lab_speckle_range->set_text(convert_float2str(params_if_->speckle_range(), 0));
507 lab_try_smaller_windows->set_text(params_if_->is_try_smaller_windows() ? "true" : "false");
508}
509
510void
511Bumblebee2CalibGtkWindow::dont_destroy(const guint8 *data)
512{
513}
514
515bool
516Bumblebee2CalibGtkWindow::update_images()
517{
518 if (bb_ && params_if_ && params_if_->has_writer()) {
519 if (img_writer->get_icon_name() != Gtk::Stock::YES.id) {
520 img_writer->set_from_icon_name(Gtk::Stock::YES.id,
521 Gtk::IconSize(Gtk::ICON_SIZE_SMALL_TOOLBAR));
522 img_writer->set_tooltip_text("Writer for blackboard interface exists");
523 }
524
525 cam_left_rectified_->capture();
526 unsigned int rlwidth = cam_left_rectified_->pixel_width();
527 unsigned int rlheight = cam_left_rectified_->pixel_height();
528 convert(cam_left_rectified_->colorspace(),
529 RGB,
530 cam_left_rectified_->buffer(),
531 buffer_rgb_rect_left_,
532 rlwidth,
533 rlheight);
534 cam_left_rectified_->dispose_buffer();
535
536 Glib::RefPtr<Gdk::Pixbuf> image =
537 Gdk::Pixbuf::create_from_data(buffer_rgb_rect_left_,
538 Gdk::COLORSPACE_RGB,
539 /* has alpha */ false,
540 /* bits per color */ 8,
541 rlwidth,
542 rlheight,
543 /* row stride */ 3 * rlwidth,
544 sigc::mem_fun(*this, &Bumblebee2CalibGtkWindow::dont_destroy));
545
546 image = image->scale_simple(320, 240, Gdk::INTERP_BILINEAR);
547
548 img_left_rectified->set(image);
549
550 // size must be the same as the rectified image
551 cam_disparity_->capture();
552 convert(cam_disparity_->colorspace(),
553 RGB,
554 cam_disparity_->buffer(),
555 buffer_rgb_disparity_,
556 rlwidth,
557 rlheight);
558 cam_disparity_->dispose_buffer();
559
560 Glib::RefPtr<Gdk::Pixbuf> dimage =
561 Gdk::Pixbuf::create_from_data(buffer_rgb_disparity_,
562 Gdk::COLORSPACE_RGB,
563 /* has alpha */ false,
564 /* bits per color */ 8,
565 rlwidth,
566 rlheight,
567 /* row stride */ 3 * rlwidth,
568 sigc::mem_fun(*this, &Bumblebee2CalibGtkWindow::dont_destroy));
569 img_disparity->set(dimage);
570 } else {
571 if (img_writer->get_icon_name() != Gtk::Stock::NO.id) {
572 img_writer->set_from_icon_name(Gtk::Stock::NO.id,
573 Gtk::IconSize(Gtk::ICON_SIZE_SMALL_TOOLBAR));
574 img_writer->set_tooltip_text("There is no blackboard writer for the interface");
575 }
576 }
577
578 return true;
579}
580
581void
582Bumblebee2CalibGtkWindow::on_exit_clicked()
583{
584 Gtk::Main::quit();
585}
586
587/**
588 * Converts a float value to a Glib::ustring (locale dependent)
589 * @param f The float value
590 * @param width The precision width
591 * @return the formatted string
592 */
593Glib::ustring
594Bumblebee2CalibGtkWindow::convert_float2str(float f, unsigned int width)
595{
596#if GLIBMM_MAJOR_VERSION > 2 || (GLIBMM_MAJOR_VERSION == 2 && GLIBMM_MINOR_VERSION >= 16)
597 return Glib::ustring::format(std::fixed, std::setprecision(width), f);
598#else
599 std::ostringstream ss;
600 ss << std::fixed << std::setprecision(width);
601 ss << f;
602
603 return Glib::locale_to_utf8(ss.str());
604#endif
605}
606
607bool
608Bumblebee2CalibGtkWindow::convert_str2float(Glib::ustring sn, float *f)
609{
610 char *endptr = NULL;
611 *f = strtof(sn.c_str(), &endptr);
612 if (endptr[0] != 0) {
613 Glib::ustring s("Could not convert string to valid number: ");
614 s.append(sn, 0, sn.length() - strlen(endptr));
615 s += " &gt;&gt;&gt;<b>";
616 s += endptr[0];
617 s += "</b>&lt;&lt;&lt; ";
618 s.append(endptr + 1, strlen(endptr) - 1);
619
620 Gtk::MessageDialog md(*this,
621 s,
622 /* use markup */ true,
623 Gtk::MESSAGE_ERROR);
624 md.set_title("Invalid value");
625 md.run();
626 md.hide();
627 return false;
628 } else {
629 return true;
630 }
631}
Bumblebee2CalibGtkWindow(BaseObjectType *cobject, const Glib::RefPtr< Gtk::Builder > &builder)
Constructor.
Definition: bb2calib.cpp:55
~Bumblebee2CalibGtkWindow()
Destructor.
Definition: bb2calib.cpp:129
virtual Interface * open_for_reading(const char *interface_type, const char *identifier, const char *owner=NULL)=0
Open interface for reading.
virtual void unregister_listener(BlackBoardInterfaceListener *listener)
Unregister BB interface listener.
Definition: blackboard.cpp:212
virtual void register_listener(BlackBoardInterfaceListener *listener, ListenerRegisterFlag flag=BBIL_FLAG_ALL)
Register BB event listener.
Definition: blackboard.cpp:185
virtual void close(Interface *interface)=0
Close interface.
sigc::signal< void > signal_connected()
Get "connected" signal.
FawkesNetworkClient * get_client()
Get client.
sigc::signal< void > signal_disconnected()
Get "disconnected" signal.
Base class for exceptions in Fawkes.
Definition: exception.h:36
iterator begin() noexcept
Get iterator for messages.
Definition: exception.cpp:676
const char * get_hostname() const
Get the client's hostname.
Definition: client.cpp:859
void disconnect()
Disconnect socket.
Definition: client.cpp:539
bool connected() const noexcept
Check if connection is alive.
Definition: client.cpp:828
Interface listener with dispatcher.
sigc::signal< void, Interface * > signal_data_changed()
Get "data changed" signal.
unsigned int msgq_enqueue(Message *message, bool proxy=false)
Enqueue message at end of queue.
Definition: interface.cpp:915
void read()
Read from BlackBoard into local copy.
Definition: interface.cpp:479
bool has_writer() const
Check if there is a writer for the interface.
Definition: interface.cpp:848
SetMinDisparityMessage Fawkes BlackBoard Interface Message.
SetNumDisparitiesMessage Fawkes BlackBoard Interface Message.
SetPreFilterCapMessage Fawkes BlackBoard Interface Message.
SetPreFilterSizeMessage Fawkes BlackBoard Interface Message.
SetPreFilterTypeMessage Fawkes BlackBoard Interface Message.
SetSADWindowSizeMessage Fawkes BlackBoard Interface Message.
SetSpeckleRangeMessage Fawkes BlackBoard Interface Message.
SetSpeckleWindowSizeMessage Fawkes BlackBoard Interface Message.
SetTextureThresholdMessage Fawkes BlackBoard Interface Message.
SetTrySmallerWindowsMessage Fawkes BlackBoard Interface Message.
SetUniquenessRatioMessage Fawkes BlackBoard Interface Message.
OpenCVStereoParamsInterface Fawkes BlackBoard Interface.
bool is_try_smaller_windows() const
Get try_smaller_windows value.
uint32_t speckle_window_size() const
Get speckle_window_size value.
uint32_t pre_filter_size() const
Get pre_filter_size value.
uint32_t texture_threshold() const
Get texture_threshold value.
PreFilterType
The type used for the pre-filter to come up with the features for the correspondence matching.
int32_t min_disparity() const
Get min_disparity value.
uint32_t pre_filter_cap() const
Get pre_filter_cap value.
const char * tostring_PreFilterType(PreFilterType value) const
Convert PreFilterType constant to string.
PreFilterType pre_filter_type() const
Get pre_filter_type value.
uint32_t num_disparities() const
Get num_disparities value.
uint32_t speckle_range() const
Get speckle_range value.
uint32_t sad_window_size() const
Get sad_window_size value.
uint32_t uniqueness_ratio() const
Get uniqueness_ratio value.
Remote BlackBoard.
Definition: remote.h:50
Network camera.
Definition: net.h:41
virtual void open()
Open the camera.
Definition: net.cpp:188
virtual unsigned int pixel_height()
Height of image in pixels.
Definition: net.cpp:342
virtual void stop()
Stop image transfer from the camera.
Definition: net.cpp:218
virtual colorspace_t colorspace()
Colorspace of returned image.
Definition: net.cpp:400
virtual unsigned char * buffer()
Get access to current image buffer.
Definition: net.cpp:272
virtual void start()
Start image transfer from the camera.
Definition: net.cpp:212
virtual void close()
Close camera.
Definition: net.cpp:302
virtual unsigned int pixel_width()
Width of image in pixels.
Definition: net.cpp:332
virtual void dispose_buffer()
Dispose current buffer.
Definition: net.cpp:321
virtual void capture()
Capture an image.
Definition: net.cpp:229
Fawkes library namespace.