git.maemo.org Git - mardrone/blob - mardrone/ARDrone_SDK_Version_1_8_20110726/Examples/Linux/Navigation/Sources/ihm/ihm_vision.c

   1 /*
   2  * @ihm_vision.c
   3  * @author marc-olivier.dzeukou@parrot.com
   4  * @date 2007/07/27
   5  *
   6  * @author stephane.piskorski@parrot.com
   7  * @date 2010/10/18
   8  * ihm vision source file
   9  *
  10  */
  11
  12 #include   <pthread.h>
  13 #include   <gtk/gtk.h>
  14
  15 #include <ardrone_api.h>
  16 #ifdef PC_USE_VISION
  17 #    include <Vision/vision_tracker_engine.h>
  18 #endif
  19 #include "UI/ui.h"
  20 #include "ihm/ihm_vision.h"
  21 #include "ihm/ihm.h"
  22 #include "common/mobile_config.h"
  23 #include "ihm/ihm_stages_o_gtk.h"
  24
  25 #include <ardrone_tool/ardrone_tool_configuration.h>
  26
  27 #include <VP_Os/vp_os_print.h>
  28 #include <VP_Os/vp_os_malloc.h>
  29 #include <VP_Api/vp_api_supervisor.h>
  30 #include <ardrone_tool/Video/video_stage_recorder.h>
  31 #include <VLIB/video_codec.h>
  32
  33 enum {
  34   STATE_FRAME=0,
  35   TRACKING_PARAMETERS_FRAME,
  36   TRACKING_OPTION_FRAME,
  37   COMPUTING_OPTION_FRAME,
  38   VIDEO_STREAM_FRAME,
  39   VIDEO_DISPLAY_FRAME,
  40   NB_IMAGES_FRAMES
  41 };
  42
  43 enum {
  44   TRACKING_PARAM_HBOX1=0,
  45   TRACKING_PARAM_HBOX2,
  46   TRACKING_PARAMS_HBOX,
  47   TRACKING_OPTION_HBOX,
  48   COMPUTING_OPTION_HBOX,
  49   VIDEO_STREAM_HBOX,
  50   VIDEO_DISPLAY_HBOX,
  51   NB_IMAGES_H_BOXES
  52 };
  53
  54 enum {
  55   CS_ENTRY=0,
  56   NB_P_ENTRY,
  57   LOSS_ENTRY,
  58   NB_TLG_ENTRY,
  59   NB_TH_ENTRY,
  60   SCALE_ENTRY,
  61   DIST_MAX_ENTRY,
  62   MAX_DIST_ENTRY,
  63   NOISE_ENTRY,
  64   FAKE_ENTRY,
  65   NB_IMAGES_ENTRIES
  66 };
  67
  68 enum {
  69   UPDATE_VISION_PARAMS_BUTTON = 0,
  70   TZ_KNOWN_BUTTON,
  71   NO_SE_BUTTON,
  72   SE2_BUTTON,
  73   SE3_BUTTON,
  74   PROJ_OVERSCENE_BUTTON,
  75   LS_BUTTON,
  76   FRONTAL_SCENE_BUTTON,
  77   FLAT_GROUND_BUTTON,
  78   RAW_CAPTURE_BUTTON,
  79   ZAPPER_BUTTON,
  80   FULLSCREEN_BUTTON,
  81   NB_IMAGES_BUTTONS
  82 };
  83
  84 enum {
  85   CODEC_TYPE_LIST=0,
  86   BITRATE_MODE_LIST,
  87   MANUAL_BITRATE_ENTRY,
  88   NB_VIDEO_STREAM_WIDGET
  89 };
  90
  91 char  ihm_ImageTitle[128] = "VISION : Image" ;
  92 char *ihm_ImageFrameCaption[NB_IMAGES_FRAMES]  = {"Vision states","Tracking parameters","Tracking options","Computing options","Video Stream","Video Display"};
  93 char *ihm_ImageEntryCaption[NB_IMAGES_ENTRIES]  = {  "      CS ",
  94                                      "           NB_P ",
  95                                      "       Loss% ",
  96                                      "     NB_TLg ",
  97                                      "   NB_TH ",
  98                                      " Scale ",
  99                                      "    Dist_Max ",
 100                                      "   Max_Dist ",
 101                                      "        Noise ",
 102                                      ""};
 103 char *ihm_ImageButtonCaption[NB_IMAGES_BUTTONS] = { "Update\nvision\nparams",
 104                                      " TZ_Known  ",
 105                                      "   No_SE    ",
 106                                      "   SE2      ",
 107                                      "     SE3     ",
 108                                      "Proj_OverScene",
 109                                      "    LS   ",
 110                                      " Frontal_Scene  ",
 111                                      " Flat_ground ",
 112                                      "Record Video\non local disk",
 113                                      " Change camera",
 114                                      " GTK Full Screen "};
 115 char *ihm_ImageVideoStreamCaption[NB_VIDEO_STREAM_WIDGET] = {" Codec type "," Bitrate control mode ", " Manual target bitrate "};
 116
 117
 118 GtkWidget *ihm_ImageVBox, *ihm_ImageVBoxPT, *ihm_ImageHBox[NB_IMAGES_H_BOXES], *displayvbox,*ihm_ImageButton[NB_IMAGES_BUTTONS], *ihm_ImageLabel[NB_IMAGES_ENTRIES],  *ihm_ImageFrames[NB_IMAGES_FRAMES], *ihm_VideoStreamLabel[NB_VIDEO_STREAM_WIDGET];
 119
 120 extern GtkWidget *button_show_image,*button_show_image2;
 121 extern mobile_config_t *pcfg;
 122 extern PIPELINE_HANDLE pipeline_handle;
 123 /* Vision image var */
 124 GtkLabel *label_vision_values=NULL;
 125 GtkWidget *ihm_ImageWin=NULL, *ihm_ImageEntry[NB_IMAGES_ENTRIES], *ihm_VideoStream_VBox=NULL;
 126
 127 /* For fullscreen video display */
 128 GtkWidget *fullscreen_window = NULL;
 129 GtkWidget *fullscreen_eventbox = NULL;
 130 GtkImage *fullscreen_image = NULL;
 131 GdkScreen *fullscreen = NULL;
 132 GtkWidget *ihm_fullScreenButton[4], *ihm_fullScreenHBox;
 133 GtkWidget *ihm_fullScreenFixedContainer;
 134 GtkWidget *align;
 135 int flag_timer_is_active = 0;
 136 int timer_counter = 0;
 137
 138 GtkWidget* video_bitrateEntry;
 139 GtkWidget*  video_bitrateModeList;
 140 GtkWidget * video_codecList;
 141 GtkWidget *video_bitrateButton;
 142 int tab_vision_config_params[10];
 143 int vision_config_options;
 144 int image_vision_window_status, image_vision_window_view;
 145 char label_vision_state_value[32];
 146 extern GtkImage *image;
 147
 148 static void ihm_sendVisionConfigParams(GtkWidget *widget, gpointer data) {
 149   api_vision_tracker_params_t params;
 150
 151   params.coarse_scale       = tab_vision_config_params[0]; // scale of current picture with respect to original picture
 152   params.nb_pair            = tab_vision_config_params[1]; // number of searched pairs in each direction
 153   params.loss_per           = tab_vision_config_params[2]; // authorized lost pairs percentage for tracking
 154   params.nb_tracker_width   = tab_vision_config_params[3]; // number of trackers in width of current picture
 155   params.nb_tracker_height  = tab_vision_config_params[4]; // number of trackers in height of current picture
 156   params.scale              = tab_vision_config_params[5]; // distance between two pixels in a pair
 157   params.trans_max          = tab_vision_config_params[6]; // largest value of trackers translation between two adjacent pictures
 158   params.max_pair_dist      = tab_vision_config_params[7]; // largest distance of pairs research from tracker location
 159   params.noise              = tab_vision_config_params[8]; // threshold of significative contrast
 160
 161   ardrone_at_set_vision_track_params( &params );
 162
 163   DEBUG_PRINT_SDK("CS %04d NB_P %04d Lossp %04d NB_Tlg %04d NB_TH %04d Scale %04d Dist_Max %04d Max_Dist %04d Noise %04d\n",
 164           tab_vision_config_params[0],
 165           tab_vision_config_params[1],
 166           tab_vision_config_params[2],
 167           tab_vision_config_params[3],
 168           tab_vision_config_params[4],
 169           tab_vision_config_params[5],
 170           tab_vision_config_params[6],
 171           tab_vision_config_params[7],
 172           tab_vision_config_params[8] );
 173 }
 174
 175
 176 void ihm_video_recording_callback(video_stage_recorder_config_t * cfg) {
 177   printf("Started recording %s\n", cfg->video_filename);
 178 }
 179
 180 static void ihm_RAWCapture(GtkWidget *widget, gpointer data) {
 181   static int is_recording = 0;
 182
 183   DEBUG_PRINT_SDK("   RAW video capture\n");
 184   DEST_HANDLE dest;
 185
 186   is_recording ^= 1;
 187
 188   // Sending AT command to drone.
 189   ardrone_at_start_raw_capture();
 190
 191   /*
 192    * Tells the Raw capture stage to start dumping YUV frames from
 193    *  the pipeline to a disk file.
 194    */
 195   dest.stage = 2;
 196   dest.pipeline = pipeline_handle;
 197   vp_api_post_message(dest, PIPELINE_MSG_START, ihm_video_recording_callback, NULL);
 198
 199   /* Tells the FFMPEG recorder stage to start dumping the video in a
 200    * MPEG4 video file.
 201    */
 202   dest.stage = 3;
 203   vp_api_post_message(dest, PIPELINE_MSG_START, NULL, NULL);
 204
 205   if (is_recording) {
 206     gtk_button_set_label((GtkButton*) ihm_ImageButton[RAW_CAPTURE_BUTTON], (const gchar*) "Recording...\n(click again to stop)");
 207     gtk_button_set_label((GtkButton*) ihm_fullScreenButton[0], (const gchar*) "Recording...\n(click again to stop)");
 208   }
 209   else {
 210     gtk_button_set_label((GtkButton*) ihm_ImageButton[RAW_CAPTURE_BUTTON], (const gchar*) "Recording stopped.\nClick again to start a new video");
 211     gtk_button_set_label((GtkButton*) ihm_fullScreenButton[0], (const gchar*) "Recording stopped.\nClick again to start a new video");
 212   }
 213
 214 }
 215
 216 static void ihm_Zapper(GtkWidget *widget, gpointer data) {
 217   int32_t channel = ZAP_CHANNEL_NEXT;
 218   printf("   Zap\n");
 219   ARDRONE_TOOL_CONFIGURATION_ADDEVENT(video_channel, &channel, NULL);
 220 }
 221
 222 static void ihm_VideoFullScreenStop(GtkWidget *widget, gpointer data) {
 223   printf("Quitting fullscreen.\n");
 224   fullscreen = NULL;
 225   fullscreen_image = NULL;
 226   fullscreen_window = NULL;
 227 }
 228
 229 gboolean hide_fullscreen_buttons(gpointer pData) {
 230   timer_counter--;
 231   if (timer_counter <= 0) {
 232     if (GTK_IS_WIDGET(ihm_fullScreenHBox))
 233       gtk_widget_hide(ihm_fullScreenHBox);
 234     timer_counter = 0;
 235   }
 236   return TRUE;
 237 }
 238
 239 void ihm_VideoFullScreenMouseMove(GtkWidget *widget, gpointer data) {
 240   timer_counter = 2;
 241   if (GTK_IS_WIDGET(ihm_fullScreenHBox)) {
 242     gtk_widget_show(ihm_fullScreenHBox);
 243   }
 244 }
 245
 246 static void ihm_QuitFullscreenRequest(GtkWidget *widget, gpointer data) {
 247   gtk_widget_destroy(fullscreen_window);
 248 }
 249
 250 static void ihm_VideoFullScreen(GtkWidget *widget, gpointer data) {
 251   int w, h;
 252
 253   if (fullscreen != NULL) {
 254     printf("   Already fullscreen\n");
 255     return;
 256   }
 257   printf("   Go Fullscreen\n");
 258
 259   /* Builds the image */
 260   fullscreen_image = (GtkImage*) gtk_image_new();
 261   fullscreen_eventbox = gtk_event_box_new();
 262   //align = gtk_alignment_new(0.5f,0.5f,0.0f,0.0f);
 263
 264
 265   /* Add three buttons on the fullscreen window */
 266   ihm_fullScreenHBox = gtk_hbox_new(FALSE, 0);
 267
 268   ihm_fullScreenButton[0] = gtk_button_new_with_label(ihm_ImageButtonCaption[RAW_CAPTURE_BUTTON]);
 269   g_signal_connect(G_OBJECT(ihm_fullScreenButton[0]), "clicked", (GCallback) ihm_RAWCapture, NULL);
 270   gtk_container_add(GTK_CONTAINER(ihm_fullScreenHBox), ihm_fullScreenButton[0]);
 271
 272   ihm_fullScreenButton[1] = gtk_button_new_with_label(ihm_ImageButtonCaption[ZAPPER_BUTTON]);
 273   g_signal_connect(G_OBJECT(ihm_fullScreenButton[1]), "clicked", (GCallback) ihm_Zapper, NULL);
 274   gtk_container_add(GTK_CONTAINER(ihm_fullScreenHBox), ihm_fullScreenButton[1]);
 275
 276   ihm_fullScreenButton[2] = gtk_button_new_with_label("Quit Fullscreen");
 277   g_signal_connect(G_OBJECT(ihm_fullScreenButton[2]), "clicked", (GCallback) ihm_QuitFullscreenRequest, NULL);
 278   gtk_container_add(GTK_CONTAINER(ihm_fullScreenHBox), ihm_fullScreenButton[2]);
 279
 280   //ihm_fullScreenButton[3] = gtk_button_new(); // Fake button
 281
 282   //gtk_container_add(GTK_CONTAINER (align),ihm_fullScreenHBox);
 283
 284   /* Create window (full screen) */
 285   fullscreen_window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
 286
 287   /* the screen */
 288   fullscreen = gtk_window_get_screen(GTK_WINDOW(fullscreen_window));
 289   w = gdk_screen_get_width(fullscreen);
 290   h = gdk_screen_get_height(fullscreen);
 291   gtk_widget_set_size_request(GTK_WIDGET(fullscreen_window), w, h);
 292
 293   /* The fixed container */
 294   ihm_fullScreenFixedContainer = gtk_fixed_new();
 295   gtk_fixed_put((GtkFixed*) (ihm_fullScreenFixedContainer), GTK_WIDGET(fullscreen_image), 0, 0);
 296   gtk_fixed_put((GtkFixed*) (ihm_fullScreenFixedContainer), GTK_WIDGET(ihm_fullScreenHBox), 0, 0);
 297
 298   /* Build the fullscreen window with the fixed container */
 299   gtk_container_add(GTK_CONTAINER(fullscreen_eventbox), ihm_fullScreenFixedContainer);
 300   gtk_container_add(GTK_CONTAINER(fullscreen_window), fullscreen_eventbox);
 301
 302   gtk_window_set_decorated(GTK_WINDOW(fullscreen_window), FALSE);
 303   gtk_window_set_resizable(GTK_WINDOW(fullscreen_window), FALSE);
 304
 305   printf("Fullscreen size : %ix%i\n", w, h);
 306
 307   g_signal_connect(G_OBJECT(fullscreen_window), "destroy", (GCallback) ihm_VideoFullScreenStop, NULL);
 308   g_signal_connect(fullscreen_eventbox, "motion_notify_event", (GCallback) ihm_VideoFullScreenMouseMove, NULL);
 309   gtk_widget_add_events(fullscreen_eventbox, GDK_POINTER_MOTION_MASK);
 310
 311   gtk_window_fullscreen(GTK_WINDOW(fullscreen_window));
 312   gtk_widget_show_all(GTK_WIDGET(fullscreen_window));
 313   gtk_widget_hide(ihm_fullScreenHBox);
 314   //gtk_widget_get_size_request(ihm_fullScreenHBox,&w2,&h2);
 315   //printf("Fullscreen size2 : %ix%i    %ix%i\n",w,h,w2,h2);
 316
 317   //gtk_fixed_put(ihm_fullScreenFixedContainer,ihm_fullScreenHBox,0,h-30);
 318
 319   if (!flag_timer_is_active) {
 320     g_timeout_add(1000, (GtkFunction) hide_fullscreen_buttons, NULL);
 321     flag_timer_is_active = 1;
 322   }
 323
 324 }
 325
 326
 327 static void ihm_ImageButtonCB(GtkWidget *widget, gpointer data) {
 328   int button = (int) data;
 329
 330   printf("   Button clicked No: %d\n", button);
 331
 332   ardrone_at_set_vision_update_options(button);
 333 }
 334
 335 // void ihm_ImageWinDestroy ( void )
 336 void ihm_ImageWinDestroy(GtkWidget *widget, gpointer data) {
 337   image_vision_window_status = WINDOW_CLOSED;
 338   printf("Destroying the Video window.\n");
 339   if (fullscreen != NULL) {
 340     ihm_VideoFullScreenStop(NULL, NULL);
 341   }
 342   ihm_VideoStream_VBox = NULL; /* this var. is tested by stage Gtk */
 343   ihm_ImageWin = NULL;
 344 }
 345
 346 gint ihm_ImageWinDelete(GtkWidget *widget, GdkEvent *event, gpointer data) {
 347   image_vision_window_status = WINDOW_CLOSED;
 348   printf("Deleting the Video window.\n");
 349   gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(button_show_image), FALSE);
 350   return FALSE;
 351 }
 352
 353 static void ihm_showImage(gpointer pData) {
 354   GtkWidget* widget = (GtkWidget*) pData;
 355
 356   if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(widget))) {
 357     if (!GTK_IS_WIDGET(ihm_ImageWin)) {
 358       create_image_window(); // Recreate window if it has been killed
 359     }
 360     gtk_widget_show_all(ihm_ImageWin);
 361     image_vision_window_view = WINDOW_VISIBLE;
 362   }
 363   else {
 364     if (GTK_IS_WIDGET(ihm_ImageWin)) {
 365       gtk_widget_hide_all(ihm_ImageWin);
 366       image_vision_window_view = WINDOW_HIDE;
 367     }
 368   }
 369 }
 370
 371 static void ihm_send_VideoBitrate(GtkWidget *widget, gpointer data) {
 372   int32_t bitrateValue = atoi(gtk_entry_get_text(GTK_ENTRY(video_bitrateEntry)));
 373   ARDRONE_TOOL_CONFIGURATION_ADDEVENT(bitrate, &bitrateValue, NULL);
 374 }
 375
 376 static void ihm_send_VideoCodec(GtkComboBox *widget, gpointer data) {
 377   gint pos;
 378   int32_t codec;
 379   pos = gtk_combo_box_get_active( widget );
 380   codec = (pos == 0) ? UVLC_CODEC : P264_CODEC;
 381   ARDRONE_TOOL_CONFIGURATION_ADDEVENT(video_codec, &codec, NULL);
 382 }
 383
 384 static void ihm_send_VideoBitrateMode(GtkComboBox *widget, gpointer data) {
 385   int32_t pos;
 386   pos = (int32_t)gtk_combo_box_get_active( widget );
 387   ARDRONE_TOOL_CONFIGURATION_ADDEVENT(bitrate_ctrl_mode, &pos, NULL);
 388 }
 389
 390 void update_vision( void )
 391 {
 392   if (ihm_ImageWin != NULL && GTK_IS_WIDGET(ihm_ImageWin)) {
 393     if (image_vision_window_view == WINDOW_VISIBLE) {
 394
 395       // Vision state refresh
 396       if (label_vision_values != NULL && GTK_IS_LABEL(label_vision_values))
 397         gtk_label_set_label(label_vision_values, label_vision_state_value);
 398       if (ihm_ImageWin != NULL && GTK_IS_WIDGET(ihm_ImageWin))
 399         gtk_widget_show_all(ihm_ImageWin);
 400     }
 401   }
 402 }
 403
 404 void create_image_window( void )
 405 {
 406   /* Image display main window */
 407   /* ------------------------- */
 408   int k;
 409
 410   printf("Creating the Video window.\n");
 411
 412   // Image main window
 413   ihm_ImageWin = gtk_window_new( GTK_WINDOW_TOPLEVEL);
 414   gtk_container_set_border_width(GTK_CONTAINER(ihm_ImageWin), 10);
 415   gtk_window_set_title(GTK_WINDOW(ihm_ImageWin), ihm_ImageTitle);
 416   gtk_signal_connect(GTK_OBJECT(ihm_ImageWin), "destroy", G_CALLBACK(ihm_ImageWinDestroy), NULL );
 417
 418   // Boxes
 419   ihm_ImageVBox = gtk_vbox_new(FALSE, 0);
 420   ihm_VideoStream_VBox = gtk_vbox_new(FALSE, 0);
 421   ihm_ImageVBoxPT = gtk_vbox_new(FALSE, 0);
 422
 423   //hBox_vision_state = gtk_hbox_new(FALSE, 0);
 424   for (k=0; k<NB_IMAGES_H_BOXES; k++)  ihm_ImageHBox[k] = gtk_hbox_new(FALSE, 0);
 425   // Frames
 426   for (k=0; k<NB_IMAGES_FRAMES; k++)  ihm_ImageFrames[k] = gtk_frame_new( ihm_ImageFrameCaption[k] );
 427   // Entries
 428   for (k=0; k<NB_IMAGES_ENTRIES; k++) {
 429     ihm_ImageEntry[k] = gtk_entry_new();
 430     gtk_widget_set_size_request(ihm_ImageEntry[k], 80, 20);
 431   }
 432   // Video Stream
 433
 434   for (k=0; k<NB_VIDEO_STREAM_WIDGET; k++)  ihm_VideoStreamLabel[k] = gtk_label_new( ihm_ImageVideoStreamCaption[k] );
 435
 436   video_bitrateEntry =   gtk_entry_new();
 437   gtk_widget_set_size_request(video_bitrateEntry, 150, 20);
 438
 439   video_codecList = gtk_combo_box_new_text();
 440   gtk_combo_box_insert_text( (GtkComboBox*)video_codecList, 0, (const gchar*)"UVLC");
 441   gtk_combo_box_insert_text( (GtkComboBox*)video_codecList, 1, (const gchar*)"P264");
 442   gtk_widget_set_size_request(video_codecList, 150, 20);
 443
 444   video_bitrateModeList = gtk_combo_box_new_text();
 445   gtk_combo_box_insert_text( (GtkComboBox*)video_bitrateModeList, 0, (const gchar*)"None");
 446   gtk_combo_box_insert_text( (GtkComboBox*)video_bitrateModeList, 1, (const gchar*)"Adaptative");
 447   gtk_combo_box_insert_text( (GtkComboBox*)video_bitrateModeList, 2, (const gchar*)"Manual");
 448   gtk_widget_set_size_request(video_codecList, 150, 20);
 449
 450   for (k=0; k<NB_IMAGES_ENTRIES; k++)  ihm_ImageLabel[k] = gtk_label_new( ihm_ImageEntryCaption[k] );
 451
 452   /* Creates buttons and links them to callbacks */
 453   for (k=0; k<NB_IMAGES_BUTTONS; k++)
 454   {
 455     ihm_ImageButton[k] = gtk_button_new();// ihm_ImageButtonCaption[k] );
 456     gtk_button_set_label((GtkButton*)ihm_ImageButton[k] ,ihm_ImageButtonCaption[k]);
 457
 458     switch (k)
 459     {
 460       case UPDATE_VISION_PARAMS_BUTTON:
 461         g_signal_connect( G_OBJECT(ihm_ImageButton[k]), "clicked", G_CALLBACK(ihm_sendVisionConfigParams), (gpointer)k );
 462         break;
 463       case RAW_CAPTURE_BUTTON:
 464         g_signal_connect( G_OBJECT(ihm_ImageButton[k]), "clicked", G_CALLBACK(ihm_RAWCapture), (gpointer)k );
 465         break;
 466       case ZAPPER_BUTTON:
 467         g_signal_connect( G_OBJECT(ihm_ImageButton[k]), "clicked", G_CALLBACK(ihm_Zapper), (gpointer)k );
 468         break;
 469       case FULLSCREEN_BUTTON:
 470         g_signal_connect( G_OBJECT(ihm_ImageButton[k]), "clicked", G_CALLBACK(ihm_VideoFullScreen), (gpointer)k );
 471         break;
 472       default:
 473         g_signal_connect( G_OBJECT(ihm_ImageButton[k]), "clicked", G_CALLBACK(ihm_ImageButtonCB), (gpointer)k );
 474       }
 475   }
 476
 477   GdkColor color;
 478   gdk_color_parse ("red", &color);
 479   gtk_widget_modify_text (ihm_ImageLabel[RAW_CAPTURE_BUTTON], GTK_STATE_NORMAL, &color);
 480
 481   video_bitrateButton = gtk_button_new_with_label( "Send" );
 482   g_signal_connect(G_OBJECT(video_bitrateButton), "clicked", G_CALLBACK(ihm_send_VideoBitrate), 0 );
 483   g_signal_connect(G_OBJECT(video_codecList), "changed", G_CALLBACK(ihm_send_VideoCodec), 0 );
 484   g_signal_connect(G_OBJECT(video_bitrateModeList), "changed", G_CALLBACK(ihm_send_VideoBitrateMode), 0 );
 485
 486   /* Creates input boxes (aka. entries) */
 487   char label_vision_default_val[NB_IMAGES_ENTRIES] ;
 488   tab_vision_config_params[0] = DEFAULT_CS;
 489   tab_vision_config_params[1] = DEFAULT_NB_PAIRS;
 490   tab_vision_config_params[2] = DEFAULT_LOSS_PER;
 491   tab_vision_config_params[3] = DEFAULT_NB_TRACKERS_WIDTH;
 492   tab_vision_config_params[4] = DEFAULT_NB_TRACKERS_HEIGHT;
 493   tab_vision_config_params[5] = DEFAULT_SCALE;
 494   tab_vision_config_params[6] = DEFAULT_TRANSLATION_MAX;
 495   tab_vision_config_params[7] = DEFAULT_MAX_PAIR_DIST;
 496   tab_vision_config_params[8] = DEFAULT_NOISE;
 497
 498   for (k=0; k<NB_IMAGES_ENTRIES; k++)  {
 499     if (k==FAKE_ENTRY) continue;
 500     sprintf(label_vision_default_val, "%d", tab_vision_config_params[k]);
 501     gtk_entry_set_text( GTK_ENTRY(ihm_ImageEntry[k]), label_vision_default_val);
 502   }
 503   gtk_entry_set_text( GTK_ENTRY(video_bitrateEntry), "frame size (bytes)");
 504
 505   /* Builds the vision state frame */
 506   vp_os_memset(label_vision_state_value, 0, sizeof(label_vision_state_value));
 507   strcat(label_vision_state_value, "Not Connected");
 508   label_vision_values = (GtkLabel*) gtk_label_new(label_vision_state_value);
 509
 510   gtk_container_add( GTK_CONTAINER(ihm_ImageFrames[STATE_FRAME]), (GtkWidget*) label_vision_values );
 511
 512   /* Builds the vision parameters frame */
 513
 514   /* First line of parameters */
 515   for (k=CS_ENTRY; k<NB_TH_ENTRY; k++)  {
 516     gtk_box_pack_start(GTK_BOX(ihm_ImageHBox[TRACKING_PARAM_HBOX1]), ihm_ImageLabel[k], FALSE , FALSE, 0);
 517     gtk_box_pack_start(GTK_BOX(ihm_ImageHBox[TRACKING_PARAM_HBOX1]), ihm_ImageEntry[k], FALSE , FALSE, 0);
 518   }
 519   /* Second line of parameters */
 520   for (k=NB_TH_ENTRY; k<NB_IMAGES_ENTRIES; k++)  {
 521     if (k==FAKE_ENTRY) continue;
 522     gtk_box_pack_start(GTK_BOX(ihm_ImageHBox[TRACKING_PARAM_HBOX2]), ihm_ImageLabel[k], FALSE , FALSE, 0);
 523     gtk_box_pack_start(GTK_BOX(ihm_ImageHBox[TRACKING_PARAM_HBOX2]), ihm_ImageEntry[k], FALSE , FALSE, 0);
 524   }
 525
 526   gtk_box_pack_start(GTK_BOX(ihm_ImageHBox[TRACKING_PARAM_HBOX2]), ihm_ImageLabel[FAKE_ENTRY], FALSE , FALSE, 0); // To fill space
 527   /* Fuses the two line in a single VBox */
 528   gtk_box_pack_start(GTK_BOX(ihm_ImageVBoxPT), ihm_ImageHBox[TRACKING_PARAM_HBOX1], FALSE , FALSE, 0);
 529   gtk_box_pack_start(GTK_BOX(ihm_ImageVBoxPT), ihm_ImageHBox[TRACKING_PARAM_HBOX2], FALSE , FALSE, 0);
 530
 531   /* Builds the whole parameter block */
 532   gtk_container_add(GTK_CONTAINER(ihm_ImageFrames[TRACKING_PARAMETERS_FRAME]), ihm_ImageVBoxPT );
 533   gtk_box_pack_start(GTK_BOX(ihm_ImageHBox[TRACKING_PARAMS_HBOX]), ihm_ImageFrames[TRACKING_PARAMETERS_FRAME], FALSE , FALSE, 0);
 534   gtk_box_pack_start(GTK_BOX(ihm_ImageHBox[TRACKING_PARAMS_HBOX]), ihm_ImageButton[UPDATE_VISION_PARAMS_BUTTON], TRUE  , FALSE, 5);
 535
 536   for (k=TZ_KNOWN_BUTTON; k<=SE3_BUTTON; k++)
 537     gtk_box_pack_start(GTK_BOX( ihm_ImageHBox[TRACKING_OPTION_HBOX]), ihm_ImageButton[k], TRUE , FALSE, 0);
 538   for (k=PROJ_OVERSCENE_BUTTON; k<=FLAT_GROUND_BUTTON; k++)
 539     gtk_box_pack_start(GTK_BOX( ihm_ImageHBox[COMPUTING_OPTION_HBOX]), ihm_ImageButton[k], TRUE , FALSE, 0);
 540
 541
 542   gtk_box_pack_start(GTK_BOX( ihm_ImageHBox[VIDEO_STREAM_HBOX]), ihm_VideoStreamLabel[CODEC_TYPE_LIST], FALSE , FALSE, 0);
 543   gtk_box_pack_start(GTK_BOX( ihm_ImageHBox[VIDEO_STREAM_HBOX]), video_codecList, TRUE , FALSE, 0);
 544   gtk_box_pack_start(GTK_BOX( ihm_ImageHBox[VIDEO_STREAM_HBOX]), ihm_VideoStreamLabel[BITRATE_MODE_LIST], FALSE , FALSE, 0);
 545   gtk_box_pack_start(GTK_BOX( ihm_ImageHBox[VIDEO_STREAM_HBOX]), video_bitrateModeList, TRUE , FALSE, 0);
 546   gtk_box_pack_start(GTK_BOX( ihm_ImageHBox[VIDEO_STREAM_HBOX]), ihm_VideoStreamLabel[MANUAL_BITRATE_ENTRY], FALSE , FALSE, 0);
 547   gtk_box_pack_start(GTK_BOX( ihm_ImageHBox[VIDEO_STREAM_HBOX]), video_bitrateEntry, TRUE , FALSE, 0);
 548   gtk_box_pack_start(GTK_BOX( ihm_ImageHBox[VIDEO_STREAM_HBOX]), video_bitrateButton, TRUE , FALSE, 0);
 549
 550   /* */
 551   gtk_container_add(GTK_CONTAINER( ihm_ImageFrames[TRACKING_OPTION_FRAME]) , ihm_ImageHBox[TRACKING_OPTION_HBOX] );
 552   gtk_container_add(GTK_CONTAINER( ihm_ImageFrames[COMPUTING_OPTION_FRAME]), ihm_ImageHBox[COMPUTING_OPTION_HBOX] );
 553   gtk_container_add(GTK_CONTAINER( ihm_ImageFrames[VIDEO_STREAM_FRAME])    , ihm_ImageHBox[VIDEO_STREAM_HBOX] );
 554
 555   /* Frame where to show buttons controlling how the drone video is displayed */
 556   displayvbox = gtk_vbox_new(FALSE,0);
 557
 558   gtk_box_pack_start(GTK_BOX(displayvbox), ihm_ImageButton[RAW_CAPTURE_BUTTON], FALSE  , FALSE, 5);
 559   gtk_box_pack_start(GTK_BOX(displayvbox), ihm_ImageButton[ZAPPER_BUTTON], FALSE  , FALSE, 5);
 560   gtk_box_pack_start(GTK_BOX(displayvbox), ihm_ImageButton[FULLSCREEN_BUTTON], FALSE  , FALSE, 5);
 561
 562   gtk_box_pack_start(GTK_BOX(ihm_ImageHBox[VIDEO_DISPLAY_HBOX]),ihm_VideoStream_VBox,FALSE,FALSE,5);
 563   gtk_box_pack_start(GTK_BOX(ihm_ImageHBox[VIDEO_DISPLAY_HBOX]),displayvbox,FALSE,FALSE,5);
 564
 565   gtk_container_add(GTK_CONTAINER( ihm_ImageFrames[VIDEO_DISPLAY_FRAME])    , ihm_ImageHBox[VIDEO_DISPLAY_HBOX] );
 566
 567   /* Builds the final window */
 568   gtk_box_pack_start(GTK_BOX(ihm_ImageVBox), ihm_ImageFrames[VIDEO_DISPLAY_FRAME], FALSE, FALSE, 5);
 569   gtk_box_pack_start(GTK_BOX(ihm_ImageVBox), ihm_ImageFrames[STATE_FRAME], FALSE, FALSE, 5);
 570   gtk_box_pack_start(GTK_BOX(ihm_ImageVBox), ihm_ImageHBox[TRACKING_PARAMS_HBOX], FALSE, FALSE, 5);
 571   gtk_box_pack_start(GTK_BOX(ihm_ImageVBox), ihm_ImageFrames[TRACKING_OPTION_FRAME], FALSE, FALSE, 5);
 572   gtk_box_pack_start(GTK_BOX(ihm_ImageVBox), ihm_ImageFrames[COMPUTING_OPTION_FRAME], FALSE, FALSE, 5);
 573   gtk_box_pack_start(GTK_BOX(ihm_ImageVBox), ihm_ImageFrames[VIDEO_STREAM_FRAME], FALSE, FALSE, 5);
 574
 575   gtk_container_add(GTK_CONTAINER(ihm_ImageWin), ihm_ImageVBox);
 576   image_vision_window_view = WINDOW_HIDE;
 577   image_vision_window_status = WINDOW_OPENED;
 578
 579   /* Set the callback for the checkbox inside the main application window */
 580   g_signal_connect(G_OBJECT(button_show_image), "clicked", G_CALLBACK(ihm_showImage), (gpointer) ihm_ImageWin);
 581   g_signal_connect(G_OBJECT(button_show_image2), "clicked", G_CALLBACK(ihm_showImage), (gpointer) ihm_ImageWin);
 582 }