22 #include "firestation.h" 23 #include "color_train_widget.h" 24 #include "fuse_transfer_widget.h" 26 #include <utils/math/angle.h> 28 #include <fvwidgets/fuse_image_list_widget.h> 29 #include <gui_utils/avahi_dispatcher.h> 31 #include <fvcams/fileloader.h> 32 #include <fvcams/shmem.h> 33 #include <fvcams/net.h> 35 #ifdef HAVE_MIRROR_CALIB 36 #include <fvmodels/mirror/mirror_calib.h> 39 #include <fvutils/ipc/shm_image.h> 40 #include <fvutils/color/conversions.h> 41 #include <fvutils/color/yuv.h> 42 #include <fvutils/colormap/yuvcm.h> 43 #include <fvutils/scalers/lossy.h> 44 #include <fvutils/system/camargp.h> 45 #include <fvutils/writers/jpeg.h> 46 #include <fvutils/writers/fvraw.h> 47 #include <fvutils/draw/drawer.h> 49 #include <core/exception.h> 51 #include <gdkmm/pixbuf.h> 53 #include <arpa/inet.h> 72 builder->get_widget(
"wndMain", m_wnd_main);
73 builder->get_widget(
"imgImage", m_img_image);
74 builder->get_widget(
"evtImageEventBox", m_evt_image);
75 builder->get_widget(
"trvShmImageIds", m_trv_shm_image_ids);
76 builder->get_widget(
"stbStatus", m_stb_status);
77 builder->get_widget(
"ckbContTrans", m_ckb_cont_trans);
78 builder->get_widget(
"spbUpdateTime", m_spb_update_time);
80 m_img_image->signal_size_allocate().connect( sigc::mem_fun(*
this, &Firestation::resize_image) );
81 m_evt_image->signal_button_press_event().connect( sigc::mem_fun(*
this, &Firestation::image_click) );
82 m_ckb_cont_trans->signal_toggled().connect( sigc::mem_fun(*
this, &Firestation::enable_cont_img_trans) );
88 builder->get_widget(
"tbtnExit", m_tbtn_exit);
89 builder->get_widget(
"tbtnCloseCamera", m_tbtn_close_camera);
90 builder->get_widget(
"tbtnUpdate", m_tbtn_update);
91 builder->get_widget(
"tbtnSave", m_tbtn_save);
92 builder->get_widget(
"tbtnOpenFile", m_tbtn_open_file);
93 builder->get_widget(
"tbtnOpenFolder", m_tbtn_open_folder);
94 builder->get_widget(
"tbtnOpenShm", m_tbtn_open_shm);
95 builder->get_widget(
"tbtnOpenFuse", m_tbtn_open_fuse);
97 m_tbtn_exit->signal_clicked().connect( sigc::mem_fun(*
this, &Firestation::exit) );
98 m_tbtn_close_camera->signal_clicked().connect( sigc::mem_fun(*
this, &Firestation::close_camera) );
99 m_tbtn_update->signal_clicked().connect( sigc::mem_fun(*
this, &Firestation::update_image) );
100 m_tbtn_save->signal_clicked().connect( sigc::mem_fun(*
this, &Firestation::save_image) );
101 m_tbtn_open_file->signal_clicked().connect( sigc::mem_fun(*
this, &Firestation::open_file) );
102 m_tbtn_open_folder->signal_clicked().connect( sigc::mem_fun(*
this, &Firestation::open_folder) );
103 m_tbtn_open_shm->signal_clicked().connect( sigc::mem_fun(*
this, &Firestation::open_shm) );
104 m_tbtn_open_fuse->signal_clicked().connect( sigc::mem_fun(*
this, &Firestation::open_fuse) );
109 builder->get_widget(
"fcdOpenImage", m_fcd_open_image);
110 builder->get_widget(
"fcdSaveImage", m_fcd_save_image);
111 builder->get_widget(
"dlgOpenShm", m_dlg_open_shm);
112 builder->get_widget(
"trvShmImageIds", m_trv_shm_image_ids);
113 builder->get_widget(
"dlgOpenFuse", m_dlg_open_fuse);
114 builder->get_widget(
"ckbFuseJpeg", m_ckb_fuse_jpeg);
115 builder->get_widget(
"trvFuseServices", m_trv_fuse_services);
117 #if GTK_VERSION_GE(3,0) 118 Glib::RefPtr<Gtk::FileFilter> filter_jpg = Gtk::FileFilter::create();
120 Gtk::FileFilter *filter_jpg = Gtk::manage(
new Gtk::FileFilter());
122 filter_jpg->set_name(
"JPEG");
123 filter_jpg->add_pattern(
"*.jpg");
124 filter_jpg->add_pattern(
"*.jpeg");
126 #if GTK_VERSION_GE(3,0) 127 Glib::RefPtr<Gtk::FileFilter> filter_fvraw = Gtk::FileFilter::create();
129 Gtk::FileFilter *filter_fvraw = Gtk::manage(
new Gtk::FileFilter());
131 filter_fvraw->set_name(
"FVRaw");
132 filter_fvraw->add_pattern(
"*.raw");
133 filter_fvraw->add_pattern(
"*.fvraw");
135 #if GTK_VERSION_GE(3,0) 136 m_fcd_open_image->add_filter(filter_jpg);
137 m_fcd_open_image->add_filter(filter_fvraw);
139 m_fcd_save_image->add_filter(filter_jpg);
140 m_fcd_save_image->add_filter(filter_fvraw);
143 m_fcd_open_image->add_filter(*filter_jpg);
144 m_fcd_open_image->add_filter(*filter_fvraw);
146 m_fcd_save_image->add_filter(*filter_jpg);
147 m_fcd_save_image->add_filter(*filter_fvraw);
150 m_shm_list_store = Gtk::ListStore::create(m_shm_columns);
151 m_trv_shm_image_ids->set_model(m_shm_list_store);
152 m_trv_shm_image_ids->append_column(
"#", m_shm_columns.m_id);
153 m_trv_shm_image_ids->append_column(
"Name", m_shm_columns.m_name);
155 m_fuse_tree_store = Gtk::TreeStore::create(m_fuse_columns);
156 m_trv_fuse_services->set_model(m_fuse_tree_store);
158 m_trv_fuse_services->append_column(
"Name", m_fuse_columns.m_name);
164 builder->get_widget(
"cmbCtObjectType", m_cmb_ct_type);
165 builder->get_widget(
"btnCtStart", m_btn_ct_start);
166 builder->get_widget(
"btnCtSeg", m_btn_ct_seg);
167 builder->get_widget(
"spbtnCtCmDepth", m_spbtn_depth);
168 builder->get_widget(
"spbtnCtCmWidth", m_spbtn_width);
169 builder->get_widget(
"spbtnCtCmHeight", m_spbtn_height);
171 m_cmb_ct_type->signal_changed().connect(sigc::mem_fun(*
this, &Firestation::ct_object_changed));
172 m_cmb_ct_type->set_active(0);
174 m_btn_ct_start->signal_clicked().connect( sigc::mem_fun(*
this, &Firestation::ct_start) );
176 m_ctw->update_image().connect( sigc::mem_fun(*
this, &Firestation::draw_image) );
177 m_ctw->colormap_updated().connect( sigc::mem_fun(*
this, &Firestation::on_colormap_updated) );
180 builder->get_widget(
"btnCtUnselect", btn);
181 m_ctw->set_reset_selection_btn(btn);
183 builder->get_widget(
"btnCtAdd", btn);
184 m_ctw->set_add_to_colormap_btn(btn);
186 builder->get_widget(
"btnCtReset", btn);
187 m_ctw->set_reset_colormap_btn(btn);
189 builder->get_widget(
"btnCtSaveHistos", btn);
190 m_ctw->set_save_histos_btn(btn);
192 builder->get_widget(
"btnCtLoadHistos", btn);
193 m_ctw->set_load_histos_btn(btn);
195 builder->get_widget(
"btnCtSaveColormap", btn);
196 m_ctw->set_save_colormap_btn(btn);
198 builder->get_widget(
"btnCtLoadColormap", btn);
199 m_ctw->set_load_colormap_btn(btn);
202 builder->get_widget(
"sclCtThreshold", scl);
203 m_ctw->set_threshold_scl(scl);
205 builder->get_widget(
"sclCtMinProb", scl);
206 m_ctw->set_min_prob_scl(scl);
208 builder->get_widget(
"sclCtLayerSelector", scl);
209 m_ctw->set_cm_layer_selector(scl);
212 builder->get_widget(
"imgCtSegmentation", img);
213 m_ctw->set_segmentation_img(img);
215 builder->get_widget(
"imgCtColormap", img);
216 m_ctw->set_colormap_img(img);
218 Gtk::FileChooserDialog* fcd;
219 builder->get_widget(
"fcdFilechooser", fcd);
220 m_ctw->set_filechooser_dlg(fcd);
223 m_btn_ct_seg->signal_toggled().connect( sigc::mem_fun(*
this, &Firestation::draw_image) );
224 m_ctw->set_cm_selector(m_spbtn_depth, m_spbtn_width, m_spbtn_height);
229 #ifdef HAVE_MIRROR_CALIB 233 #ifndef HAVE_MIRROR_CALIB 236 builder->get_widget(
"ntbOptions", nb);
237 builder->get_widget(
"boxMirrorCalib", box);
238 nb->get_tab_label(*box)->set_sensitive(
false);
239 box->set_sensitive(
false);
242 builder->get_widget(
"sclMcLine", m_scl_mc_line);
243 m_scl_mc_line->signal_change_value().connect( sigc::mem_fun(*
this, &Firestation::mc_on_line_angle_changed) );
245 builder->get_widget(
"btnMcLoadMask", m_btn_mc_load_mask);
246 m_btn_mc_load_mask->signal_clicked().connect( sigc::mem_fun(*
this, &Firestation::mc_load_mask) );
249 builder->get_widget(
"btnCalibLoad", m_btn_mc_load);
250 builder->get_widget(
"btnCalibSave", m_btn_mc_save);
251 builder->get_widget(
"entCalibDist", m_ent_mc_dist);
252 builder->get_widget(
"entCalibOri", m_ent_mc_ori);
253 builder->get_widget(
"fcdCalibSave", m_fcd_mc_save);
254 builder->get_widget(
"fcdCalibLoad", m_fcd_mc_load);
257 m_btn_mc_load->signal_clicked().connect( sigc::mem_fun(*
this, &Firestation::mc_load) );
258 m_btn_mc_save->signal_clicked().connect( sigc::mem_fun(*
this, &Firestation::mc_save) );
260 builder->get_widget(
"btnMcSetCenter", m_btn_mc_set_center);
261 m_btn_mc_set_center->signal_clicked().connect( sigc::mem_fun(*
this, &Firestation::mc_set_center) );
263 builder->get_widget(
"btnMcMemorize", m_btn_mc_memorize);
264 m_btn_mc_memorize->signal_clicked().connect( sigc::mem_fun(*
this, &Firestation::mc_memorize) );
266 builder->get_widget(
"btnMcSimulateClicks", m_btn_mc_simulate_clicks);
267 m_btn_mc_simulate_clicks->signal_clicked().connect( sigc::mem_fun(*
this, &Firestation::mc_simulate_clicks) );
269 builder->get_widget(
"entCalibDist", m_ent_mc_dist);
270 builder->get_widget(
"entCalibOri", m_ent_mc_ori);
273 builder->get_widget(
"fcdMcLoadMask", m_fcd_mc_load_mask);
274 builder->get_widget(
"fcdCalibSave", m_fcd_mc_save);
275 builder->get_widget(
"fcdCalibLoad", m_fcd_mc_load);
283 builder->get_widget(
"trvFuseRemoteLuts", trv);
284 m_ftw->set_remote_lut_list_trv(trv);
285 builder->get_widget(
"trvFuseLocalLuts", trv);
286 m_ftw->set_local_lut_list_trv(trv);
287 builder->get_widget(
"imgFuseLocal", img);
288 m_ftw->set_local_img(img);
289 builder->get_widget(
"imgFuseRemote", img);
290 m_ftw->set_remote_img(img);
291 builder->get_widget(
"btnFuseUpload", btn);
292 m_ftw->set_upload_btn(btn);
293 builder->get_widget(
"sclLocalLayerSelector", scl);
294 m_ftw->set_local_layer_selector(scl);
295 builder->get_widget(
"sclRemoteLayerSelector", scl);
296 m_ftw->set_remote_layer_selector(scl);
302 builder->get_widget(
"trvFuseImageList", trv);
303 m_filw->set_image_list_trv(trv);
304 Gtk::CheckButton* chk;
305 builder->get_widget(
"chkFuseImageListUpdate", chk);
306 m_filw->set_auto_update_chk(chk);
307 builder->get_widget(
"chkFuseCompression", chk);
308 m_filw->set_toggle_compression_chk(chk);
309 m_filw->image_selected().connect( sigc::mem_fun(*
this, &Firestation::on_fuse_image_selected) );
312 m_yuv_orig_buffer = 0;
313 m_yuv_draw_buffer = 0;
314 m_yuv_scaled_buffer = 0;
315 m_rgb_scaled_buffer = 0;
320 m_img_cs = CS_UNKNOWN;
326 m_img_src = SRC_NONE;
327 m_op_mode = MODE_VIEWER;
329 m_cont_img_trans =
false;
331 mc_line_angle_deg = 0.0;
333 m_max_img_width = m_evt_image->get_width();
334 m_max_img_height = m_evt_image->get_height();
335 m_scaled_img_width = m_evt_image->get_width();
336 m_scaled_img_height = m_evt_image->get_height();
337 m_scale_factor = 1.0;
342 m_avahi_dispatcher->
signal_service_added().connect( sigc::mem_fun( *
this, &Firestation::on_service_added ) );
343 m_avahi_dispatcher->signal_service_removed().connect( sigc::mem_fun( *
this, &Firestation::on_service_removed ) );
345 m_avahi_thread->watch_service(
"_fountain._tcp", m_avahi_dispatcher);
346 m_avahi_thread->start();
352 if (m_yuv_orig_buffer) free(m_yuv_orig_buffer);
353 if (m_yuv_draw_buffer) free(m_yuv_draw_buffer);
354 if (m_yuv_scaled_buffer) free(m_yuv_scaled_buffer);
355 if (m_rgb_scaled_buffer) free(m_rgb_scaled_buffer);
360 #ifdef HAVE_MIRROR_CALIB 367 m_avahi_thread->cancel();
368 m_avahi_thread->join();
369 delete m_avahi_thread;
370 delete m_avahi_dispatcher;
373 delete m_fcd_open_image;
374 delete m_fcd_save_image;
375 delete m_dlg_open_shm;
376 delete m_dlg_open_fuse;
392 if (SRC_NONE != m_img_src)
393 { m_camera->close(); }
399 Firestation::close_camera()
401 if (SRC_NONE == m_img_src)
404 m_img_src = SRC_NONE;
412 m_img_cs = CS_UNKNOWN;
416 m_img_image->clear();
417 m_img_image->set(
"gtk-missing-image");
419 m_ctw->set_src_buffer(NULL, 0, 0);
420 m_ctw->set_draw_buffer(NULL);
425 Firestation::save_image()
427 if (m_img_src == SRC_NONE)
430 m_fcd_save_image->set_transient_for(*
this);
432 int result = m_fcd_save_image->run();
436 case(Gtk::RESPONSE_OK):
440 Glib::ustring filter_name = m_fcd_save_image->get_filter()->get_name();
441 if ( Glib::ustring(
"JPEG") == filter_name )
445 else if( Glib::ustring(
"FVRaw") == filter_name )
451 cout <<
"save_file(): unknown file format" << endl;
455 std::string filename = m_fcd_save_image->get_filename();
456 m_img_writer->set_filename( filename.c_str() );
457 m_img_writer->set_dimensions(m_img_width, m_img_height);
458 m_img_writer->set_buffer(m_img_cs, m_yuv_orig_buffer);
459 m_img_writer->write();
461 std::cout <<
"Save file: " << filename << std::endl;
465 case(Gtk::RESPONSE_CANCEL):
472 m_fcd_save_image->hide();
477 Firestation::update_image()
479 if (m_img_src == SRC_NONE)
485 convert(m_img_cs, YUV422_PLANAR,
486 m_camera->buffer(), m_yuv_orig_buffer,
487 m_img_width, m_img_height);
488 memcpy(m_yuv_draw_buffer, m_yuv_orig_buffer,
489 colorspace_buffer_size(YUV422_PLANAR, m_img_width, m_img_height));
490 m_camera->dispose_buffer();
494 m_ctw->draw_segmentation_result();
503 Firestation::call_update_image()
505 if ( !m_cont_img_trans )
514 Firestation::enable_cont_img_trans()
516 if (m_cont_img_trans)
518 m_cont_img_trans =
false;
522 int timeout = (int) rint( m_spb_update_time->get_value() );
523 sigc::connection conn = Glib::signal_timeout().connect( sigc::mem_fun(*
this, &Firestation::call_update_image), timeout);
524 m_cont_img_trans =
true;
529 Firestation::open_file()
531 m_fcd_open_image->set_action(Gtk::FILE_CHOOSER_ACTION_OPEN);
532 m_fcd_open_image->set_transient_for(*
this);
534 int result = m_fcd_open_image->run();
538 case Gtk::RESPONSE_OK:
542 std::string filename = m_fcd_open_image->get_filename();
544 m_camera =
new FileLoader( filename.c_str() );
545 m_img_src = SRC_FILE;
550 case Gtk::RESPONSE_CANCEL:
561 m_fcd_open_image->hide();
566 Firestation::open_folder()
568 m_fcd_open_image->set_action(Gtk::FILE_CHOOSER_ACTION_SELECT_FOLDER);
569 m_fcd_open_image->set_transient_for(*
this);
571 int result = m_fcd_open_image->run();
575 case Gtk::RESPONSE_OK:
579 std::string extension;
580 Glib::ustring filter_name = m_fcd_save_image->get_filter()->get_name();
581 if ( Glib::ustring(
"JPEG") == filter_name )
582 { extension =
"jpg"; }
583 else if ( Glib::ustring(
"FVRaw") == filter_name )
584 { extension =
"raw"; }
586 std::string folder = m_fcd_open_image->get_current_folder();
588 if (asprintf(&as,
"file:file:dir=%s:ext=%s", folder.c_str(), extension.c_str()) != -1) {
591 m_img_src = SRC_FILE;
595 printf(
"Cannot open folder, asprintf() ran out of memory");
601 case Gtk::RESPONSE_CANCEL:
612 m_fcd_open_image->hide();
617 Firestation::open_shm()
619 unsigned int num_buffers = 0;
622 shmit = SharedMemory::find(FIREVISION_SHM_IMAGE_MAGIC_TOKEN, h);
624 if (shmit == SharedMemory::end())
626 m_stb_status->push(
"No SHM images found");
631 m_shm_list_store->clear();
633 while ( shmit != SharedMemory::end() )
636 Gtk::TreeModel::Row row = *(m_shm_list_store->append());
637 row[m_shm_columns.m_id] = num_buffers;
639 row[m_shm_columns.m_name] = h->
image_id();
644 m_dlg_open_shm->set_transient_for(*
this);
646 int result = m_dlg_open_shm->run();
650 case Gtk::RESPONSE_OK:
654 Gtk::TreeModel::Path path;
655 Gtk::TreeViewColumn* column;
656 m_trv_shm_image_ids->get_cursor(path, column);
658 Gtk::TreeModel::iterator iter = m_shm_list_store->get_iter(path);
662 Gtk::TreeModel::Row row = *iter;
665 Glib::ustring name = row[m_shm_columns.m_name];
684 std::cout <<
"invalid iter" << std::endl;
690 case Gtk::RESPONSE_CANCEL:
697 m_dlg_open_shm->hide();
702 Firestation::open_fuse()
704 Gtk::TreeModel::Children children = m_fuse_tree_store->children();
705 if ( 0 == children.size() )
707 m_stb_status->push(
"No FUSE services found");
711 m_trv_fuse_services->expand_all();
712 m_dlg_open_fuse->set_transient_for(*
this);
714 int result = m_dlg_open_fuse->run();
718 case Gtk::RESPONSE_OK:
720 Gtk::TreeModel::Path path;
721 Gtk::TreeViewColumn* column;
722 m_trv_fuse_services->get_cursor(path, column);
724 Gtk::TreeModel::iterator iter = m_fuse_tree_store->get_iter(path);
728 Gtk::TreeModel::Row row = *iter;
731 Glib::ustring hostname = row[m_fuse_columns.m_service_hostname];
732 unsigned short int port = row[m_fuse_columns.m_service_port];
733 Glib::ustring image_id = row[m_fuse_columns.m_image_id];
734 bool jpeg = m_ckb_fuse_jpeg->get_active();
740 m_camera =
new NetworkCamera(hostname.c_str(), port, image_id.c_str(), jpeg);
741 m_img_src = SRC_FUSE;
746 m_img_src = SRC_NONE;
753 std::cout <<
"invalid iter" << std::endl;
759 case Gtk::RESPONSE_CANCEL:
766 m_dlg_open_fuse->hide();
770 Firestation::pre_open_img_src()
772 if (SRC_NONE != m_img_src)
780 m_img_src = SRC_NONE;
786 Firestation::post_open_img_src()
788 if (m_img_src == SRC_NONE) {
return; }
795 m_img_width = m_camera->pixel_width();
796 m_img_height = m_camera->pixel_height();
797 m_img_cs = m_camera->colorspace();
799 m_img_size = colorspace_buffer_size( m_img_cs,
803 m_yuv_orig_buffer = malloc_buffer(YUV422_PLANAR, m_img_width, m_img_height);
804 m_yuv_draw_buffer = malloc_buffer(YUV422_PLANAR, m_img_width, m_img_height);
806 convert(m_img_cs, YUV422_PLANAR,
807 m_camera->buffer(), m_yuv_orig_buffer,
808 m_img_width, m_img_height);
809 memcpy(m_yuv_draw_buffer, m_yuv_orig_buffer,
810 colorspace_buffer_size(YUV422_PLANAR, m_img_width, m_img_height));
812 m_camera->dispose_buffer();
814 m_tbtn_update->set_sensitive(
true);
815 m_tbtn_save->set_sensitive(
true);
819 m_ctw->set_src_buffer(m_yuv_orig_buffer, m_img_width, m_img_height);
820 m_ctw->set_draw_buffer(m_yuv_draw_buffer);
821 m_ctw->draw_segmentation_result();
828 printf(
"Opening camera failed.\n");
834 Firestation::on_fuse_image_selected()
841 m_filw->get_selected_image(host_name, port, image_id, compression);
847 m_camera =
new NetworkCamera( host_name.c_str(), port, image_id.c_str(), compression );
848 m_img_src = SRC_FUSE;
852 m_img_src = SRC_NONE;
860 Firestation::on_colormap_updated()
862 m_ftw->set_current_colormap( m_ctw->get_colormap() );
867 Firestation::draw_image()
869 if ( m_img_src == SRC_NONE ) {
return; }
879 if (scaled_width != m_scaled_img_width || scaled_height != m_scaled_img_height)
881 m_scaled_img_width = scaled_width;
882 m_scaled_img_height = scaled_height;
886 if (m_rgb_scaled_buffer) free(m_rgb_scaled_buffer);
887 if (m_yuv_scaled_buffer) free(m_yuv_scaled_buffer);
888 m_yuv_scaled_buffer = malloc_buffer(YUV422_PLANAR, m_scaled_img_width,
889 m_scaled_img_height);
893 if (m_btn_ct_seg->get_active()) {
894 unsigned int sld_img_size = m_scaled_img_width * m_scaled_img_height;
895 unsigned char u_seg = 255 / (
unsigned int)pow(2, m_spbtn_width->get_value());
896 unsigned char v_seg = 255 / (
unsigned int)pow(2, m_spbtn_height->get_value());
898 for (u = sld_img_size; u < sld_img_size + sld_img_size / 2; ++u) {
899 m_yuv_scaled_buffer[u] = (m_yuv_scaled_buffer[u] / u_seg) * u_seg;
902 for (; u < 2 * sld_img_size; ++u) {
903 m_yuv_scaled_buffer[u] = (m_yuv_scaled_buffer[u] / v_seg) * v_seg;
907 if ( m_img_src == SRC_SHM )
913 drawer.
set_buffer(m_yuv_scaled_buffer, m_scaled_img_width, m_scaled_img_height);
923 m_rgb_scaled_buffer = (
unsigned char*) malloc( colorspace_buffer_size( RGB,
925 m_scaled_img_height ) );
927 convert( YUV422_PLANAR, RGB,
928 m_yuv_scaled_buffer, m_rgb_scaled_buffer,
929 m_scaled_img_width, m_scaled_img_height );
931 Glib::RefPtr<Gdk::Pixbuf> image = Gdk::Pixbuf::create_from_data( m_rgb_scaled_buffer,
937 3 * m_scaled_img_width );
939 m_img_image->set(image);
946 Firestation::resize_image(Gtk::Allocation& allocation)
948 unsigned int new_width = (
unsigned int) allocation.get_width();
949 unsigned int new_height = (
unsigned int) allocation.get_height();
951 if (new_width != m_max_img_width || new_height != m_max_img_height)
953 m_max_img_width = new_width;
954 m_max_img_height = new_height;
964 Firestation::image_click(GdkEventButton* event)
966 unsigned int offset_x;
967 unsigned int offset_y;
969 offset_x = (m_max_img_width - m_scaled_img_width) / 2;
970 offset_y = (m_max_img_height - m_scaled_img_height) / 2;
972 offset_x = offset_x > m_max_img_width ? 0 : offset_x;
973 offset_y = offset_y > m_max_img_height ? 0 : offset_y;
975 unsigned int image_x;
976 unsigned int image_y;
979 image_x = (
unsigned int)rint( (event->x - offset_x) / m_scale_factor);
980 image_y = (
unsigned int)rint( (event->y - offset_y) / m_scale_factor);
986 if ( image_x > m_img_width || image_y > m_img_height )
992 if (m_img_src != SRC_NONE)
994 register unsigned char y;
995 register unsigned char u;
996 register unsigned char v;
997 YUV422_PLANAR_YUV( m_yuv_orig_buffer,
1003 printf(
"Y=%d U=%d Y=%d @ (%d, %d)\n",
1004 (
unsigned int) y, (
unsigned int) u, (
unsigned int) v,
1009 case MODE_COLOR_TRAIN:
1010 m_ctw->click(image_x, image_y, event->button);
1014 case MODE_MIRROR_CALIB:
1016 #ifdef HAVE_MIRROR_CALIB 1017 if (m_btn_mc_set_center->get_active()) {
1018 m_calib_tool->set_center(image_x, image_y);
1019 m_btn_mc_set_center->set_active(
false);
1021 printf(
"Setting center to %d, %d\n", image_x, image_y);
1023 printf(
"Using center to %d, %d\n", m_calib_tool->center_x(), m_calib_tool->center_y());
1024 m_calib_tool->next_step();
1025 const unsigned char* last_yuv = m_calib_tool->get_last_yuv_buffer();
1026 memcpy(m_yuv_draw_buffer, last_yuv, m_img_size);
1027 memcpy(m_yuv_orig_buffer, last_yuv, m_img_size);
1028 m_calib_tool->draw_mark_lines(m_yuv_draw_buffer);
1030 m_stb_status->push(m_calib_tool->get_state_description());
1033 printf(
"IPP and OpenCV not installed; mirror calibration does not work.\n");
1038 case MODE_MIRROR_CALIB_EVAL:
1040 #ifdef HAVE_MIRROR_CALIB 1043 m_calib_tool->eval(image_x, image_y, &dist, &phi);
1045 printf(
"(%d, %d) = POLAR(%.2f deg, %.2f meters)\n",
1050 printf(
"IPP and OpenCV not installed; mirror calibration does not work.\n");
1064 Firestation::ct_start()
1066 if (m_op_mode == MODE_COLOR_TRAIN)
1068 m_op_mode = MODE_VIEWER;
1069 m_stb_status->push(
"Leaving color training mode");
1073 if (m_img_src != SRC_NONE)
1075 m_ctw->set_fg_object( ct_get_fg_object() );
1077 m_op_mode = MODE_COLOR_TRAIN;
1079 m_stb_status->push(
"Entering color training mode");
1085 Firestation::ct_get_fg_object()
1087 int active = m_cmb_ct_type->get_active_row_number();
1106 return H_GOAL_YELLOW;
1115 printf(
"ct_get_fg_object(): UNKNOWN\n");
1121 Firestation::ct_object_changed()
1123 hint_t
object = ct_get_fg_object();
1124 m_ctw->set_fg_object(
object);
1128 Firestation::mc_draw_line()
1130 if (m_img_src != SRC_NONE) {
1131 #ifdef HAVE_MIRROR_CALIB 1132 memcpy(m_yuv_draw_buffer, m_yuv_orig_buffer, m_img_size);
1133 MirrorCalibTool::draw_line(m_yuv_draw_buffer,
1135 m_calib_tool->center_x(),
1136 m_calib_tool->center_y(),
1141 printf(
"IPP and OpenCV not installed; mirror calibration does not work.\n");
1147 Firestation::mc_on_line_angle_changed(Gtk::ScrollType scroll,
double value)
1149 mc_line_angle_deg = -1.0f * value;
1163 Firestation::mc_load_mask()
1165 m_fcd_mc_load_mask->set_transient_for(*
this);
1167 #if GTK_VERSION_GE(3,0) 1168 Glib::RefPtr<Gtk::FileFilter> filter_mirror = Gtk::FileFilter::create();
1170 Gtk::FileFilter *filter_mirror = Gtk::manage(
new Gtk::FileFilter());
1172 filter_mirror->set_name(
"Robot Mask");
1173 filter_mirror->add_pattern(
"*.pnm");
1174 #if GTK_VERSION_GE(3,0) 1175 m_fcd_mc_load_mask->add_filter(filter_mirror);
1177 m_fcd_mc_load_mask->add_filter(*filter_mirror);
1180 int result = m_fcd_mc_load_mask->run();
1184 case Gtk::RESPONSE_OK:
1186 #ifdef HAVE_MIRROR_CALIB 1187 std::string filename = m_fcd_mc_load_mask->get_filename();
1188 m_calib_tool->load_mask( filename.c_str() );
1191 printf(
"IPP and OpenCV not installed; mirror calibration does not work.\n");
1195 case Gtk::RESPONSE_CANCEL:
1201 m_fcd_mc_load_mask->hide();
1207 Firestation::mc_set_center()
1209 m_op_mode = MODE_MIRROR_CALIB;
1214 Firestation::mc_memorize()
1221 if (m_img_src != SRC_NONE)
1223 #ifdef HAVE_MIRROR_CALIB 1224 double ori = mc_line_angle_deg;
1225 std::cout <<
"Starting calibration for ori = " << ori << std::endl;
1226 m_calib_tool->push_back(m_yuv_orig_buffer, m_img_size,
1227 m_img_width, m_img_height,
deg2rad(ori));
1228 m_op_mode = MODE_MIRROR_CALIB;
1229 std::cout <<
"Initialization for ori = " << ori <<
" completed" << std::endl;
1231 mc_line_angle_deg -= 120.0;
1234 m_scl_mc_line->set_value(-1.0f * mc_line_angle_deg);
1243 printf(
"IPP and OpenCV not installed; mirror calibration does not work.\n");
1250 Firestation::mc_simulate_clicks()
1252 for (
int i = 1; i <= 3; ++i) {
1254 for (
int j = 1; j <= 8; ++j) { image_click(NULL); }
1255 for (
int j = 1; j <= 2*8; ++j) { image_click(NULL); }
1263 Firestation::mc_load()
1265 m_fcd_mc_load->set_transient_for(*
this);
1267 #if GTK_VERSION_GE(3,0) 1268 Glib::RefPtr<Gtk::FileFilter> filter_mirror = Gtk::FileFilter::create();
1270 Gtk::FileFilter *filter_mirror = Gtk::manage(
new Gtk::FileFilter());
1272 filter_mirror->set_name(
"Mirror Calibration");
1273 filter_mirror->add_pattern(
"*.mirror");
1274 filter_mirror->add_pattern(
"*.bulb");
1275 #if GTK_VERSION_GE(3,0) 1276 m_fcd_mc_load->add_filter(filter_mirror);
1278 m_fcd_mc_load->add_filter(*filter_mirror);
1281 int result = m_fcd_mc_load->run();
1285 case Gtk::RESPONSE_OK:
1287 #ifdef HAVE_MIRROR_CALIB 1288 std::string filename = m_fcd_mc_load->get_filename();
1289 m_calib_tool->load( filename.c_str() );
1290 m_op_mode = MODE_MIRROR_CALIB_EVAL;
1292 printf(
"IPP and OpenCV not installed; mirror calibration does not work.\n");
1296 case Gtk::RESPONSE_CANCEL:
1302 m_fcd_mc_load->hide();
1307 Firestation::mc_save()
1309 m_fcd_mc_save->set_transient_for(*
this);
1311 int result = m_fcd_mc_save->run();
1315 case(Gtk::RESPONSE_OK):
1317 #ifdef HAVE_MIRROR_CALIB 1318 std::string filename = m_fcd_mc_save->get_filename();
1320 m_calib_tool->save( filename.c_str() );
1322 printf(
"IPP and OpenCV not installed; mirror calibration does not work.\n");
1327 case(Gtk::RESPONSE_CANCEL):
1334 m_fcd_mc_save->hide();
1341 const char* host = service->
host();
1342 const char* name = service->
name();
1343 const char* type = service->
type();
1344 const char* domain = service->
domain();
1345 unsigned short int port = service->
port();
1347 std::vector<FUSE_imageinfo_t> image_list;
1357 e.
append(
"Could not open camera on %s:%d", host, port);
1364 printf(
"%zu images available on host %s.\n", image_list.size(), host);
1367 std::vector<FUSE_imageinfo_t>::iterator fit;
1369 Gtk::TreeModel::Children children = m_fuse_tree_store->children();
1370 Gtk::TreeModel::Row row = *(m_fuse_tree_store->append());
1371 row[m_fuse_columns.m_id] = children.size();
1372 row[m_fuse_columns.m_name] = Glib::ustring(name);
1373 row[m_fuse_columns.m_service_name] = Glib::ustring(name);
1374 row[m_fuse_columns.m_service_type] = Glib::ustring(type);
1375 row[m_fuse_columns.m_service_domain] = Glib::ustring(domain);
1376 row[m_fuse_columns.m_service_hostname] = Glib::ustring(host);
1377 row[m_fuse_columns.m_service_port] = port;
1379 for (fit = image_list.begin(); fit != image_list.end(); ++fit)
1381 Gtk::TreeModel::Row childrow = *(m_fuse_tree_store->append(row.children()));
1382 childrow[m_fuse_columns.m_name] = Glib::ustring(fit->image_id);
1383 childrow[m_fuse_columns.m_service_name] = Glib::ustring(name);
1384 childrow[m_fuse_columns.m_service_type] = Glib::ustring(type);
1385 childrow[m_fuse_columns.m_service_domain] = Glib::ustring(domain);
1386 childrow[m_fuse_columns.m_service_hostname] = Glib::ustring(host);
1387 childrow[m_fuse_columns.m_service_port] = port;
1388 childrow[m_fuse_columns.m_image_id] = Glib::ustring(fit->image_id);
1389 childrow[m_fuse_columns.m_image_width] = fit->width;
1390 childrow[m_fuse_columns.m_image_height] = fit->height;
1391 childrow[m_fuse_columns.m_image_colorspace] = Glib::ustring( colorspace_to_string((colorspace_t) fit->colorspace) );
1394 m_ftw->add_fountain_service(name, host, port);
1395 m_filw->add_fountain_service(name, host, port);
1401 const char* name = service->
name();
1402 const char* type = service->
type();
1403 const char* domain = service->
domain();
1405 Gtk::TreeModel::Children children = m_fuse_tree_store->children();
1406 Gtk::TreeModel::iterator rit;
1407 for (rit = children.begin(); rit != children.end(); ++rit)
1409 Glib::ustring n = (*rit)[m_fuse_columns.m_service_name];
1410 Glib::ustring t = (*rit)[m_fuse_columns.m_service_type];
1411 Glib::ustring d = (*rit)[m_fuse_columns.m_service_domain];
1413 if ( strcmp( n.c_str(), name) == 0 &&
1414 strcmp( t.c_str(), type) == 0 &&
1415 strcmp( d.c_str(), domain) == 0 )
1417 m_fuse_tree_store->erase(rit);
1421 m_ftw->remove_fountain_service(name);
1422 m_filw->remove_fountain_service(name);
virtual float get_scale_factor()
Returns the scale factor.
virtual unsigned int needed_scaled_height()
Minimum needed height of scaled image depending on factor and original image height.
virtual std::vector< FUSE_imageinfo_t > & image_list()
List the available images.
virtual void set_scaled_buffer(unsigned char *buffer)
Set scaled image buffer.
virtual ~Firestation()
Destructor.
unsigned int roi_y() const
Get ROI Y.
virtual void set_original_buffer(unsigned char *buffer)
Set original image buffer.
Fawkes library namespace.
const char * host() const
Get host of service.
virtual void open()
Open the camera.
unsigned short int port() const
Get port of service.
float normalize_mirror_rad(float angle_rad)
Normalize angle in radian between -PI (inclusive) and PI (exclusive).
bool circle_found() const
Check if circle was found .
unsigned int roi_width() const
Get ROI width.
FvRaw Writer implementation.
Base class for exceptions in Fawkes.
void set_buffer(unsigned char *buffer, unsigned int width, unsigned int height)
Set the buffer to draw to.
virtual void start()
Start image transfer from the camera.
Gtk::Window & get_window() const
Returns reference to main window.
void draw_rectangle(unsigned int x, unsigned int y, unsigned int w, unsigned int h)
Draw rectangle.
virtual void set_original_dimensions(unsigned int width, unsigned int height)
Set original image dimensions.
virtual void set_scaled_dimensions(unsigned int width, unsigned int height)
Set dimenins of scaled image buffer.
Representation of a service announced or found via service discovery (i.e.
float rad2deg(float rad)
Convert an angle given in radians to degrees.
virtual void close()
Close camera.
void print_trace()
Prints trace to stderr.
SharedMemoryImageBuffer * shared_memory_image_buffer()
Get the shared memory image buffer.
unsigned int roi_x() const
Get ROI X.
const char * domain() const
Get domain of service.
virtual unsigned int needed_scaled_width()
Minimum needed width of scaled image depending on factor and original image width.
float deg2rad(float deg)
Convert an angle given in degrees to radians.
virtual void scale()
Scale image.
sigc::signal< void, NetworkService * > signal_service_added()
Get "service added" signal.
const char * type() const
Get type of service.
unsigned int roi_height() const
Get ROI height.
void append(const char *format,...)
Append messages to the message list.
void set_color(unsigned char y, unsigned char u, unsigned char v)
Set drawing color.
const char * name() const
Get name of service.
Firestation(Glib::RefPtr< Gtk::Builder > builder)
Constructor.