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 }
fawkes::OpenCVStereoParamsInterface::SetNumDisparitiesMessage
Definition: OpenCVStereoParamsInterface.h:244
fawkes::BlackBoard::register_listener
virtual void register_listener(BlackBoardInterfaceListener *listener, ListenerRegisterFlag flag=BBIL_FLAG_ALL)
Register BB event listener.
Definition: blackboard.cpp:190
fawkes::OpenCVStereoParamsInterface::texture_threshold
uint32_t texture_threshold() const
Get texture_threshold value.
Definition: OpenCVStereoParamsInterface.cpp:317
firevision::NetworkCamera::stop
virtual void stop()
Definition: net.cpp:218
firevision::NetworkCamera
Definition: net.h:46
firevision::NetworkCamera::pixel_width
virtual unsigned int pixel_width()
Definition: net.cpp:332
fawkes::Interface::read
void read()
Read from BlackBoard into local copy.
Definition: interface.cpp:477
fawkes::OpenCVStereoParamsInterface::speckle_window_size
uint32_t speckle_window_size() const
Get speckle_window_size value.
Definition: OpenCVStereoParamsInterface.cpp:392
fawkes::BlackBoard::unregister_listener
virtual void unregister_listener(BlackBoardInterfaceListener *listener)
Unregister BB interface listener.
Definition: blackboard.cpp:217
Bumblebee2CalibGtkWindow::~Bumblebee2CalibGtkWindow
~Bumblebee2CalibGtkWindow()
Destructor.
Definition: bb2calib.cpp:129
fawkes::OpenCVStereoParamsInterface::SetSpeckleRangeMessage
Definition: OpenCVStereoParamsInterface.h:359
fawkes::RemoteBlackBoard
Definition: remote.h:53
firevision::NetworkCamera::buffer
virtual unsigned char * buffer()
Definition: net.cpp:272
firevision::NetworkCamera::close
virtual void close()
Definition: net.cpp:302
fawkes::OpenCVStereoParamsInterface::pre_filter_size
uint32_t pre_filter_size() const
Get pre_filter_size value.
Definition: OpenCVStereoParamsInterface.cpp:145
fawkes::FawkesNetworkClient::disconnect
void disconnect()
Disconnect socket.
Definition: client.cpp:545
fawkes::OpenCVStereoParamsInterface::tostring_PreFilterType
const char * tostring_PreFilterType(PreFilterType value) const
Convert PreFilterType constant to string.
Definition: OpenCVStereoParamsInterface.cpp:98
fawkes::OpenCVStereoParamsInterface::SetSADWindowSizeMessage
Definition: OpenCVStereoParamsInterface.h:190
fawkes::ConnectionDispatcher::signal_connected
sigc::signal< void > signal_connected()
Get "connected" signal.
Definition: connection_dispatcher.cpp:222
fawkes::FawkesNetworkClient::get_hostname
const char * get_hostname() const
Get the client's hostname.
Definition: client.cpp:865
firevision::NetworkCamera::dispose_buffer
virtual void dispose_buffer()
Definition: net.cpp:321
fawkes::OpenCVStereoParamsInterface::speckle_range
uint32_t speckle_range() const
Get speckle_range value.
Definition: OpenCVStereoParamsInterface.cpp:427
Bumblebee2CalibGtkWindow::Bumblebee2CalibGtkWindow
Bumblebee2CalibGtkWindow(BaseObjectType *cobject, const Glib::RefPtr< Gtk::Builder > &builder)
Constructor.
Definition: bb2calib.cpp:55
fawkes::BlackBoard::close
virtual void close(Interface *interface)=0
fawkes::OpenCVStereoParamsInterface::is_try_smaller_windows
bool is_try_smaller_windows() const
Get try_smaller_windows value.
Definition: OpenCVStereoParamsInterface.cpp:463
firevision::NetworkCamera::colorspace
virtual colorspace_t colorspace()
Definition: net.cpp:400
fawkes::OpenCVStereoParamsInterface::pre_filter_cap
uint32_t pre_filter_cap() const
Get pre_filter_cap value.
Definition: OpenCVStereoParamsInterface.cpp:180
fawkes::OpenCVStereoParamsInterface
Definition: OpenCVStereoParamsInterface.h:39
fawkes
fawkes::ServiceChooserDialog
Definition: service_chooser_dialog.h:51
fawkes::Interface::has_writer
bool has_writer() const
Check if there is a writer for the interface.
Definition: interface.cpp:819
fawkes::OpenCVStereoParamsInterface::SetSpeckleWindowSizeMessage
Definition: OpenCVStereoParamsInterface.h:331
fawkes::OpenCVStereoParamsInterface::SetUniquenessRatioMessage
Definition: OpenCVStereoParamsInterface.h:301
fawkes::OpenCVStereoParamsInterface::pre_filter_type
PreFilterType pre_filter_type() const
Get pre_filter_type value.
Definition: OpenCVStereoParamsInterface.cpp:112
fawkes::ConnectionDispatcher::signal_disconnected
sigc::signal< void > signal_disconnected()
Get "disconnected" signal.
Definition: connection_dispatcher.cpp:233
fawkes::InterfaceDispatcher
Definition: interface_dispatcher.h:42
fawkes::Exception::begin
iterator begin()
Get iterator for messages.
Definition: exception.cpp:676
fawkes::OpenCVStereoParamsInterface::SetTrySmallerWindowsMessage
Definition: OpenCVStereoParamsInterface.h:387
fawkes::OpenCVStereoParamsInterface::SetPreFilterTypeMessage
Definition: OpenCVStereoParamsInterface.h:108
firevision::NetworkCamera::start
virtual void start()
Definition: net.cpp:212
fawkes::OpenCVStereoParamsInterface::PreFilterType
PreFilterType
The type used for the pre-filter to come up with the features for the correspondence matching.
Definition: OpenCVStereoParamsInterface.h:57
fawkes::OpenCVStereoParamsInterface::num_disparities
uint32_t num_disparities() const
Get num_disparities value.
Definition: OpenCVStereoParamsInterface.cpp:281
fawkes::OpenCVStereoParamsInterface::SetMinDisparityMessage
Definition: OpenCVStereoParamsInterface.h:218
fawkes::BlackBoard::open_for_reading
virtual Interface * open_for_reading(const char *interface_type, const char *identifier, const char *owner=NULL)=0
fawkes::OpenCVStereoParamsInterface::SetPreFilterCapMessage
Definition: OpenCVStereoParamsInterface.h:162
fawkes::InterfaceDispatcher::signal_data_changed
sigc::signal< void, Interface * > signal_data_changed()
Get "data changed" signal.
Definition: interface_dispatcher.cpp:265
firevision::NetworkCamera::open
virtual void open()
Definition: net.cpp:188
fawkes::Interface::msgq_enqueue
unsigned int msgq_enqueue(Message *message)
Enqueue message at end of queue.
Definition: interface.cpp:884
fawkes::FawkesNetworkClient::connected
bool connected() const
Check if connection is alive.
Definition: client.cpp:834
fawkes::OpenCVStereoParamsInterface::min_disparity
int32_t min_disparity() const
Get min_disparity value.
Definition: OpenCVStereoParamsInterface.cpp:248
fawkes::ConnectionDispatcher::get_client
FawkesNetworkClient * get_client()
Get client.
Definition: connection_dispatcher.cpp:132
fawkes::OpenCVStereoParamsInterface::SetTextureThresholdMessage
Definition: OpenCVStereoParamsInterface.h:272
fawkes::OpenCVStereoParamsInterface::SetPreFilterSizeMessage
Definition: OpenCVStereoParamsInterface.h:134
fawkes::OpenCVStereoParamsInterface::sad_window_size
uint32_t sad_window_size() const
Get sad_window_size value.
Definition: OpenCVStereoParamsInterface.cpp:215
firevision::NetworkCamera::pixel_height
virtual unsigned int pixel_height()
Definition: net.cpp:342
fawkes::OpenCVStereoParamsInterface::uniqueness_ratio
uint32_t uniqueness_ratio() const
Get uniqueness_ratio value.
Definition: OpenCVStereoParamsInterface.cpp:355
firevision::NetworkCamera::capture
virtual void capture()
Definition: net.cpp:229
fawkes::Exception
Definition: exception.h:41