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 
38 using namespace firevision;
39 using 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  */
137 void
138 Bumblebee2CalibGtkWindow::init()
139 {
140 }
141 
142 /** Event handler for combo box changes. */
143 void
144 Bumblebee2CalibGtkWindow::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. */
162 void
163 Bumblebee2CalibGtkWindow::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. */
176 void
177 Bumblebee2CalibGtkWindow::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. */
189 void
190 Bumblebee2CalibGtkWindow::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. */
203 void
204 Bumblebee2CalibGtkWindow::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. */
216 void
217 Bumblebee2CalibGtkWindow::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. */
229 void
230 Bumblebee2CalibGtkWindow::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. */
242 void
243 Bumblebee2CalibGtkWindow::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. */
255 void
256 Bumblebee2CalibGtkWindow::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. */
268 void
269 Bumblebee2CalibGtkWindow::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. */
281 void
282 Bumblebee2CalibGtkWindow::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. */
293 void
294 Bumblebee2CalibGtkWindow::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. */
308 void
309 Bumblebee2CalibGtkWindow::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. */
415 void
416 Bumblebee2CalibGtkWindow::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 
489 void
490 Bumblebee2CalibGtkWindow::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 
510 void
511 Bumblebee2CalibGtkWindow::dont_destroy(const guint8 *data)
512 {
513 }
514 
515 bool
516 Bumblebee2CalibGtkWindow::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 
581 void
582 Bumblebee2CalibGtkWindow::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  */
593 Glib::ustring
594 Bumblebee2CalibGtkWindow::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 
607 bool
608 Bumblebee2CalibGtkWindow::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.