vpDisplayGTK.cpp

/****************************************************************************
 *
 * This file is part of the ViSP software.
 * Copyright (C) 2005 - 2017 by Inria. All rights reserved.
 *
 * This software is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * ("GPL") version 2 as published by the Free Software Foundation.
 * See the file LICENSE.txt at the root directory of this source
 * distribution for additional information about the GNU GPL.
 *
 * For using ViSP with software that can not be combined with the GNU
 * GPL, please contact Inria about acquiring a ViSP Professional
 * Edition License.
 *
 * See http://visp.inria.fr for more information.
 *
 * This software was developed at:
 * Inria Rennes - Bretagne Atlantique
 * Campus Universitaire de Beaulieu
 * 35042 Rennes Cedex
 * France
 *
 * If you have questions regarding the use of this file, please contact
 * Inria at visp@inria.fr
 *
 * This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
 * WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
 *
 * Description:
 * Image display.
 *
 * Authors:
 * Christophe Collewet
 * Eric Marchand
 * Fabien Spindler
 *
 *****************************************************************************/


#include <visp3/core/vpConfig.h>

#if ( defined(VISP_HAVE_GTK) )

#include <stdio.h>
#include <stdlib.h>
#include <iostream>
#include <cmath>    // std::fabs
#include <limits>   // numeric_limits

// Display stuff
#include <visp3/core/vpDisplay.h>
#include <visp3/gui/vpDisplayGTK.h>

//debug / exception
#include <visp3/core/vpDebug.h>
#include <visp3/core/vpDisplayException.h>
#include <visp3/core/vpMath.h>
#include <visp3/core/vpImageTools.h>

vpDisplayGTK::vpDisplayGTK(vpImage<unsigned char> &I, vpScaleType scaleType)
  : widget(NULL), m_background(NULL), m_gc(NULL),
    blue(), red(), yellow(), green(), cyan(), orange(), white(), black(), gdkcolor(),
    lightBlue(), darkBlue(), lightRed(), darkRed(),lightGreen(), darkGreen(),
    purple(), lightGray(), gray(), darkGray(),
    colormap(NULL), font(NULL), vectgtk(NULL), col(NULL), ncol(0), nrow(0)
{
  setScale(scaleType, I.getWidth(), I.getHeight());
  init(I) ;
}

vpDisplayGTK::vpDisplayGTK(vpImage<unsigned char> &I,
                           int x,
                           int y,
                           const std::string &title, vpScaleType scaleType)
  : widget(NULL), m_background(NULL), m_gc(NULL),
    blue(), red(), yellow(), green(), cyan(), orange(), white(), black(), gdkcolor(),
    lightBlue(), darkBlue(), lightRed(), darkRed(),lightGreen(), darkGreen(),
    purple(), lightGray(), gray(), darkGray(),
    colormap(NULL), font(NULL), vectgtk(NULL), col(NULL), ncol(0), nrow(0)
{
  setScale(scaleType, I.getWidth(), I.getHeight());
  init(I, x, y, title) ;
}

vpDisplayGTK::vpDisplayGTK(vpImage<vpRGBa> &I, vpScaleType scaleType)
  : widget(NULL), m_background(NULL), m_gc(NULL),
    blue(), red(), yellow(), green(), cyan(), orange(), white(), black(), gdkcolor(),
    lightBlue(), darkBlue(), lightRed(), darkRed(),lightGreen(), darkGreen(),
    purple(), lightGray(), gray(), darkGray(),
    colormap(NULL), font(NULL), vectgtk(NULL), col(NULL), ncol(0), nrow(0)
{
  setScale(scaleType, I.getWidth(), I.getHeight());
  init(I) ;
}

vpDisplayGTK::vpDisplayGTK(vpImage<vpRGBa> &I,
                           int x,
                           int y,
                           const std::string &title, vpScaleType scaleType)
  : widget(NULL), m_background(NULL), m_gc(NULL),
    blue(), red(), yellow(), green(), cyan(), orange(), white(), black(), gdkcolor(),
    lightBlue(), darkBlue(), lightRed(), darkRed(),lightGreen(), darkGreen(),
    purple(), lightGray(), gray(), darkGray(),
    colormap(NULL), font(NULL), vectgtk(NULL), col(NULL), ncol(0), nrow(0)
{
  setScale(scaleType, I.getWidth(), I.getHeight());
  init(I, x, y, title) ;
}

vpDisplayGTK::vpDisplayGTK(int x, int y, const std::string &title)
  : widget(NULL), m_background(NULL), m_gc(NULL),
    blue(), red(), yellow(), green(), cyan(), orange(), white(), black(), gdkcolor(),
    lightBlue(), darkBlue(), lightRed(), darkRed(),lightGreen(), darkGreen(),
    purple(), lightGray(), gray(), darkGray(),
    colormap(NULL), font(NULL), vectgtk(NULL), col(NULL), ncol(0), nrow(0)
{
  m_windowXPosition = x ;
  m_windowYPosition = y ;
  m_title = title;
}

vpDisplayGTK::vpDisplayGTK()
  : vpDisplay(), widget(NULL), m_background(NULL), m_gc(NULL),
    blue(), red(), yellow(), green(), cyan(), orange(), white(), black(), gdkcolor(),
    lightBlue(), darkBlue(), lightRed(), darkRed(),lightGreen(), darkGreen(),
    purple(), lightGray(), gray(), darkGray(),
    colormap(NULL), font(NULL), vectgtk(NULL), col(NULL), ncol(0), nrow(0)

{
}

vpDisplayGTK::~vpDisplayGTK()
{
  closeDisplay() ;
}

void
vpDisplayGTK::init(vpImage<unsigned char> &I,
                   int x,
                   int y,
                   const std::string &title)
{  
  if ((I.getHeight() == 0) || (I.getWidth()==0))
  {
    throw(vpDisplayException(vpDisplayException::notInitializedError,
                             "Image not initialized")) ;
  }

  if (x != -1)
    m_windowXPosition = x ;
  if (y != -1)
    m_windowYPosition = y ;

  if (! title.empty())
    m_title = title;

  setScale(m_scaleType, I.getWidth(), I.getHeight());
  init (I.getWidth(), I.getHeight(), m_windowXPosition, m_windowYPosition, m_title) ;

  I.display = this ;
  m_displayHasBeenInitialized = true ;
}

void
vpDisplayGTK::init(vpImage<vpRGBa> &I,
                   int x,
                   int y,
                   const std::string &title)
{
  if ((I.getHeight() == 0) || (I.getWidth()==0))
  {
    throw(vpDisplayException(vpDisplayException::notInitializedError,
                             "Image not initialized")) ;
  }

  if (x != -1)
    m_windowXPosition = x ;
  if (y != -1)
    m_windowYPosition = y ;

  if (! title.empty())
    m_title = title;

  setScale(m_scaleType, I.getWidth(), I.getHeight());
  init (I.getWidth(), I.getHeight(), m_windowXPosition, m_windowYPosition, m_title) ;

  I.display = this ;
  m_displayHasBeenInitialized = true ;
}
void
vpDisplayGTK::init(unsigned int w, unsigned int h,
                   int x, int y,
                   const std::string &title)
{
  /* Initialisation of thegdk et gdk_rgb library */
  int *argc=NULL ;
  char **argv ;

  gtk_init(argc, &argv);

  setScale(m_scaleType, w, h);

  m_width  = w/m_scale;
  m_height = h/m_scale;

  /* Create the window*/
  widget = gtk_window_new(GTK_WINDOW_TOPLEVEL);

  gtk_widget_add_events(widget, GDK_BUTTON_PRESS_MASK | GDK_BUTTON_RELEASE_MASK
                        | GDK_POINTER_MOTION_MASK);

  gtk_window_set_default_size(GTK_WINDOW(widget), (gint)m_width, (gint)m_height);

  if (x != -1)
    m_windowXPosition = x ;
  if (y != -1)
    m_windowYPosition = y ;

  gtk_window_move(GTK_WINDOW(widget), m_windowXPosition, m_windowYPosition);

  gtk_widget_show(widget);

  gdk_rgb_init();

  /* Create background pixmap */
  m_background = gdk_pixmap_new(widget->window, (gint)m_width, (gint)m_height, -1);

  /* Create graphic context */
  m_gc = gdk_gc_new(widget->window);

  /* get the colormap  */
  colormap = gdk_window_get_colormap(widget->window);

  col = new GdkColor *[vpColor::id_unknown] ; // id_unknown = number of predefined colors

  /* Create color */
  gdk_color_parse("light blue",&lightBlue);
  gdk_colormap_alloc_color(colormap,&lightBlue,FALSE,TRUE);
  col[vpColor::id_lightBlue] = &lightBlue ;
  
  gdk_color_parse("blue",&blue);
  gdk_colormap_alloc_color(colormap,&blue,FALSE,TRUE);
  col[vpColor::id_blue] = &blue ;
  
  gdk_color_parse("dark blue",&darkBlue);
  gdk_colormap_alloc_color(colormap,&darkBlue,FALSE,TRUE);
  col[vpColor::id_darkBlue] = &darkBlue ;
  
  gdk_color_parse("#FF8C8C",&lightRed);
  gdk_colormap_alloc_color(colormap,&lightRed,FALSE,TRUE);
  col[vpColor::id_lightRed] = &lightRed ;

  gdk_color_parse("red",&red);
  gdk_colormap_alloc_color(colormap,&red,FALSE,TRUE);
  col[vpColor::id_red] = &red ;
  
  gdk_color_parse("dark red",&darkRed);
  gdk_colormap_alloc_color(colormap,&darkRed,FALSE,TRUE);
  col[vpColor::id_darkRed] = &darkRed ;
  
  gdk_color_parse("light green",&lightGreen);
  gdk_colormap_alloc_color(colormap,&lightGreen,FALSE,TRUE);
  col[vpColor::id_lightGreen] = &lightGreen ;

  gdk_color_parse("green",&green);
  gdk_colormap_alloc_color(colormap,&green,FALSE,TRUE);
  col[vpColor::id_green] = &green ;
  
  gdk_color_parse("dark green",&darkGreen);
  gdk_colormap_alloc_color(colormap,&darkGreen,FALSE,TRUE);
  col[vpColor::id_darkGreen] = &darkGreen ;

  gdk_color_parse("yellow",&yellow);
  gdk_colormap_alloc_color(colormap,&yellow,FALSE,TRUE);
  col[vpColor::id_yellow] = &yellow ;

  gdk_color_parse("cyan",&cyan);
  gdk_colormap_alloc_color(colormap,&cyan,FALSE,TRUE);
  col[vpColor::id_cyan] = &cyan ;

  gdk_color_parse("orange",&orange);
  gdk_colormap_alloc_color(colormap,&orange,FALSE,TRUE);
  col[vpColor::id_orange] = &orange ;
  
  gdk_color_parse("purple",&purple);
  gdk_colormap_alloc_color(colormap,&purple,FALSE,TRUE);
  col[vpColor::id_purple] = &purple ;

  gdk_color_parse("white",&white);
  gdk_colormap_alloc_color(colormap,&white,FALSE,TRUE);
  col[vpColor::id_white] = &white ;

  gdk_color_parse("black",&black);
  gdk_colormap_alloc_color(colormap,&black,FALSE,TRUE);
  col[vpColor::id_black] = &black ;
  
  gdk_color_parse("#C0C0C0",&lightGray);
  gdk_colormap_alloc_color(colormap,&lightGray,FALSE,TRUE);
  col[vpColor::id_lightGray] = &lightGray ;
  
  gdk_color_parse("#808080",&gray);
  gdk_colormap_alloc_color(colormap,&gray,FALSE,TRUE);
  col[vpColor::id_gray] = &gray ;
  
  gdk_color_parse("#404040",&darkGray);
  gdk_colormap_alloc_color(colormap,&darkGray,FALSE,TRUE);
  col[vpColor::id_darkGray] = &darkGray ;

  // Try to load a default font
  font = gdk_font_load("-*-times-medium-r-normal-*-16-*-*-*-*-*-*-*");
  if (font == NULL)
    font = gdk_font_load("-*-courier-bold-r-normal-*-*-140-*-*-*-*-*-*");
  if (font == NULL)
    font = gdk_font_load("-*-courier 10 pitch-medium-r-normal-*-16-*-*-*-*-*-*-*");

  m_title = title;
  if(!title.empty())
    gdk_window_set_title(widget->window, m_title.c_str());

  m_displayHasBeenInitialized = true ;
}


void
vpDisplayGTK::setFont(const std::string &fontname)
{
  font = gdk_font_load((const gchar*)fontname.c_str());
}

void
vpDisplayGTK::setTitle(const std::string &title)
{
  if (m_displayHasBeenInitialized)
  {
    m_title = title;
    if(!title.empty())
      gdk_window_set_title(widget->window, m_title.c_str());
  }
  else
  {
    throw(vpDisplayException(vpDisplayException::notInitializedError,
                             "GTK not initialized")) ;
  }
}

void vpDisplayGTK::setWindowPosition(int winx, int winy)
{

  if (m_displayHasBeenInitialized)  {
    gtk_window_move(GTK_WINDOW(widget), winx, winy);
  }
  else
  {
    throw(vpDisplayException(vpDisplayException::notInitializedError,
                             "GTK not initialized")) ;
  }
}


void vpDisplayGTK::displayImage(const vpImage<unsigned char> &I)
{

  if (m_displayHasBeenInitialized)
  {
    if(m_scale == 1) {
      /* Copie de l'image dans le pixmap fond */
      gdk_draw_gray_image(m_background,
                          m_gc, 0, 0, (gint)m_width, (gint)m_height,
                          GDK_RGB_DITHER_NONE,
                          I.bitmap,
                          (gint)m_width);
    }
    else{
      vpImage<unsigned char> sampled;
      I.subsample(m_scale, m_scale, sampled);
      gdk_draw_gray_image(m_background,
                          m_gc, 0, 0, (gint)m_width, (gint)m_height,
                          GDK_RGB_DITHER_NONE,
                          sampled.bitmap,
                          (gint)m_width);
    }

    /* Le pixmap background devient le fond de la zone de dessin */
    gdk_window_set_back_pixmap(widget->window, m_background, FALSE);
  }
  else
  {
    throw(vpDisplayException(vpDisplayException::notInitializedError,
                             "GTK not initialized")) ;
  }
}


void vpDisplayGTK::displayImageROI ( const vpImage<unsigned char> &I,const vpImagePoint &iP, const unsigned int w, const unsigned int h )
{
  if (m_displayHasBeenInitialized)
  {
    vpImage<unsigned char> Itemp;
    vpImageTools::crop(I, iP.get_i(), iP.get_j(), h, w, Itemp, m_scale, m_scale);

    /* Copie de l'image dans le pixmap fond */
    int i_min = std::max((int)ceil(iP.get_i()/m_scale), 0);
    int j_min = std::max((int)ceil(iP.get_j()/m_scale), 0);

    gdk_draw_gray_image(m_background,
                        m_gc, (gint)j_min, (gint)i_min, (gint)Itemp.getWidth(), (gint)Itemp.getHeight(),
                        GDK_RGB_DITHER_NONE,
                        Itemp.bitmap,
                        (gint)Itemp.getWidth());

    /* Le pixmap background devient le fond de la zone de dessin */
    gdk_window_set_back_pixmap(widget->window, m_background, FALSE);
  }
  else
  {
    throw(vpDisplayException(vpDisplayException::notInitializedError,
                             "GTK not initialized")) ;
  }
}


void vpDisplayGTK::displayImage(const vpImage<vpRGBa> &I)
{

  if (m_displayHasBeenInitialized)
  {
    if (m_scale == 1) {
      /* Copie de l'image dans le pixmap fond */
      gdk_draw_rgb_32_image(m_background,
                            m_gc, 0, 0,  (gint)m_width, (gint)m_height,
                            GDK_RGB_DITHER_NONE,
                            (unsigned char *)I.bitmap,
                            (gint)(4*m_width));
    }
    else {
      vpImage<vpRGBa> sampled;
      I.subsample(m_scale, m_scale, sampled);
      gdk_draw_rgb_32_image(m_background,
                            m_gc, 0, 0, (gint)m_width, (gint)m_height,
                            GDK_RGB_DITHER_NONE,
                            (unsigned char *)sampled.bitmap,
                            (gint)(4*m_width));
    }
    /* Permet de fermer la fenetre si besoin (cas des sequences d'images) */
    //while (g_main_iteration(FALSE));

    /* Le pixmap background devient le fond de la zone de dessin */
    gdk_window_set_back_pixmap(widget->window, m_background, FALSE);
  }
  else
  {
    throw(vpDisplayException(vpDisplayException::notInitializedError,
                             "GTK not initialized")) ;
  }
}

void vpDisplayGTK::displayImageROI ( const vpImage<vpRGBa> &I,const vpImagePoint &iP, const unsigned int w, const unsigned int h )
{
  if (m_displayHasBeenInitialized)
  {
    vpImage<vpRGBa> Itemp;
    vpImageTools::crop(I, iP.get_i(), iP.get_j(), h, w, Itemp, m_scale, m_scale);

    /* Copie de l'image dans le pixmap fond */
    int i_min = std::max((int)ceil(iP.get_i()/m_scale), 0);
    int j_min = std::max((int)ceil(iP.get_j()/m_scale), 0);

    gdk_draw_rgb_32_image(m_background,
                          m_gc, (gint)j_min, (gint)i_min, (gint)Itemp.getWidth(), (gint)Itemp.getHeight(),
                          GDK_RGB_DITHER_NONE,
                          (unsigned char *)Itemp.bitmap,
                          (gint)Itemp.getWidth()*4);

    /* Le pixmap background devient le fond de la zone de dessin */
    gdk_window_set_back_pixmap(widget->window, m_background, FALSE);
  }
  else
  {
    throw(vpDisplayException(vpDisplayException::notInitializedError,
                             "GTK not initialized")) ;
  }
}

void vpDisplayGTK::displayImage(const unsigned char * /* I */)
{
  vpTRACE(" not implemented ") ;
}

void vpDisplayGTK::closeDisplay()
{
  if (col != NULL)
  {
    delete [] col ; col = NULL ;
  }

  if (widget != NULL)
  {
    gdk_window_hide (widget->window);
    gdk_window_destroy(widget->window);
    gtk_widget_destroy(widget);
    widget = NULL;
  }
  m_displayHasBeenInitialized = false;
}


void vpDisplayGTK::flushDisplay()
{
  if (m_displayHasBeenInitialized)
  {
    gdk_window_clear(widget->window);
    gdk_flush();
  }
  else
  {
    throw(vpDisplayException(vpDisplayException::notInitializedError,
                             "GTK not initialized")) ;
  }
}


void vpDisplayGTK::flushDisplayROI(const vpImagePoint &/*iP*/, const unsigned int /*width*/, const unsigned int /*height*/)
{
  if (m_displayHasBeenInitialized)
  {
    gdk_window_clear(widget->window);
    gdk_flush();
  }
  else
  {
    throw(vpDisplayException(vpDisplayException::notInitializedError,
                             "GTK not initialized")) ;
  }
}


void vpDisplayGTK::clearDisplay(const vpColor & /* color */)
{
  vpTRACE("Not implemented") ;
}

void vpDisplayGTK::displayArrow ( const vpImagePoint &ip1, 
                                  const vpImagePoint &ip2,
                                  const vpColor &color,
                                  unsigned int w, unsigned int h,
                                  unsigned int thickness)
{
  if (m_displayHasBeenInitialized)
  {
    double a = ip2.get_i() - ip1.get_i() ;
    double b = ip2.get_j() - ip1.get_j() ;
    double lg = sqrt(vpMath::sqr(a)+vpMath::sqr(b)) ;

    //if ((a==0)&&(b==0))
    if ((std::fabs(a) <= std::numeric_limits<double>::epsilon() )&&(std::fabs(b) <= std::numeric_limits<double>::epsilon()) )
    {
      // DisplayCrossLarge(i1,j1,3,col) ;
    }
    else
    {
      a /= lg ;
      b /= lg ;

      vpImagePoint ip3;
      ip3.set_i(ip2.get_i() - w*a);
      ip3.set_j(ip2.get_j() - w*b);

      vpImagePoint ip4;
      ip4.set_i( ip3.get_i() - b*h );
      ip4.set_j( ip3.get_j() + a*h );

      if (lg > 2*vpImagePoint::distance(ip2, ip4) )
        displayLine ( ip2, ip4, color, thickness ) ;

      ip4.set_i( ip3.get_i() + b*h );
      ip4.set_j( ip3.get_j() - a*h );

      if (lg > 2*vpImagePoint::distance(ip2, ip4) )
        displayLine ( ip2, ip4, color, thickness ) ;

      displayLine ( ip1, ip2, color, thickness ) ;
    }
  }
  else
  {
    throw(vpDisplayException(vpDisplayException::notInitializedError,
                             "GTK not initialized")) ;
  }
}


void vpDisplayGTK::displayCharString ( const vpImagePoint &ip,
                                       const char *text,
                                       const vpColor &color )
{
  if (m_displayHasBeenInitialized)
  {
    if (color.id < vpColor::id_unknown)
      gdk_gc_set_foreground(m_gc, col[color.id]);
    else {
      gdkcolor.red   = 256 * color.R;
      gdkcolor.green = 256 * color.G;
      gdkcolor.blue  = 256 * color.B;
      gdk_colormap_alloc_color(colormap,&gdkcolor,FALSE,TRUE);
      gdk_gc_set_foreground(m_gc, &gdkcolor);
    }
    if (font != NULL)
      gdk_draw_string(m_background, font, m_gc,
                      vpMath::round( ip.get_u()/m_scale ),
                      vpMath::round( ip.get_v()/m_scale ),
                      (const gchar *)text);
    else
      std::cout << "Cannot draw string: no font is selected" << std::endl;
  }
  else
  {
    throw(vpDisplayException(vpDisplayException::notInitializedError,
                             "GTK not initialized")) ;
  }
}
void vpDisplayGTK::displayCircle ( const vpImagePoint &center,
                                   unsigned int radius,
                                   const vpColor &color,
                                   bool fill,
                                   unsigned int thickness )
{
  if (m_displayHasBeenInitialized)
  {
    if ( thickness == 1 ) thickness = 0;

    if (color.id < vpColor::id_unknown)
      gdk_gc_set_foreground(m_gc, col[color.id]);
    else {
      gdkcolor.red   = 256 * color.R;
      gdkcolor.green = 256 * color.G;
      gdkcolor.blue  = 256 * color.B;
      gdk_colormap_alloc_color(colormap,&gdkcolor,FALSE,TRUE);
      gdk_gc_set_foreground(m_gc, &gdkcolor);
    }

    gdk_gc_set_line_attributes(m_gc, (gint)thickness,
                               GDK_LINE_SOLID, GDK_CAP_BUTT,
                               GDK_JOIN_BEVEL) ;

    if (fill == false)
      gdk_draw_arc(m_background, m_gc, FALSE,
                   vpMath::round( (center.get_u()-radius)/m_scale ),
                   vpMath::round( (center.get_v()-radius)/m_scale ),
                   (gint)(2.*radius/m_scale), (gint)(2.*radius/m_scale), 23040, 23040) ; /* 23040 = 360*64 */
    else
      gdk_draw_arc(m_background, m_gc, TRUE,
                   vpMath::round( (center.get_u()-radius)/m_scale ),
                   vpMath::round( (center.get_v()-radius)/m_scale ),
                   (gint)(2.*radius/m_scale), (gint)(2.*radius/m_scale), 23040, 23040) ; /* 23040 = 360*64 */
  }
  else
  {
    throw(vpDisplayException(vpDisplayException::notInitializedError,
                             "GTK not initialized")) ;
  }
}
void vpDisplayGTK::displayCross ( const vpImagePoint &ip, 
                                  unsigned int size,
                                  const vpColor &color,
                                  unsigned int thickness)
{
  if (m_displayHasBeenInitialized)
  {
    double i = ip.get_i();
    double j = ip.get_j();
    vpImagePoint ip1, ip2;

    ip1.set_i( i-size/2 );
    ip1.set_j( j );
    ip2.set_i( i+size/2 );
    ip2.set_j( j );
    displayLine ( ip1, ip2, color, thickness ) ;

    ip1.set_i( i );
    ip1.set_j( j-size/2 );
    ip2.set_i( i );
    ip2.set_j( j+size/2 );

    displayLine ( ip1, ip2, color, thickness ) ;
  }

  else
  {
    throw(vpDisplayException(vpDisplayException::notInitializedError,
                             "GTK not initialized")) ;
  }
}
void vpDisplayGTK::displayDotLine ( const vpImagePoint &ip1, 
                                    const vpImagePoint &ip2,
                                    const vpColor &color,
                                    unsigned int thickness )
{

  if (m_displayHasBeenInitialized)
  {
    if ( thickness == 1 ) thickness = 0;

    if (color.id < vpColor::id_unknown)
      gdk_gc_set_foreground(m_gc, col[color.id]);
    else {
      gdkcolor.red   = 256 * color.R;
      gdkcolor.green = 256 * color.G;
      gdkcolor.blue  = 256 * color.B;
      gdk_colormap_alloc_color(colormap,&gdkcolor,FALSE,TRUE);
      gdk_gc_set_foreground(m_gc, &gdkcolor);
    }

    gdk_gc_set_line_attributes(m_gc, (gint)thickness,
                               GDK_LINE_ON_OFF_DASH, GDK_CAP_BUTT,
                               GDK_JOIN_BEVEL) ;
    gdk_draw_line(m_background, m_gc,
                  vpMath::round( ip1.get_u()/m_scale ),
                  vpMath::round( ip1.get_v()/m_scale ),
                  vpMath::round( ip2.get_u()/m_scale ),
                  vpMath::round( ip2.get_v()/m_scale ) );
    gdk_gc_set_line_attributes(m_gc, 0,
                               GDK_LINE_SOLID, GDK_CAP_BUTT,
                               GDK_JOIN_BEVEL) ;
  }
  else
  {
    throw(vpDisplayException(vpDisplayException::notInitializedError,
                             "GTK not initialized")) ;
  }
}

void vpDisplayGTK::displayLine ( const vpImagePoint &ip1, 
                                 const vpImagePoint &ip2,
                                 const vpColor &color,
                                 unsigned int thickness )
{
  if (m_displayHasBeenInitialized)
  {
    if ( thickness == 1 ) thickness = 0;

    if (color.id < vpColor::id_unknown)
      gdk_gc_set_foreground(m_gc, col[color.id]);
    else {
      gdkcolor.red   = 256 * color.R;
      gdkcolor.green = 256 * color.G;
      gdkcolor.blue  = 256 * color.B;
      gdk_colormap_alloc_color(colormap,&gdkcolor,FALSE,TRUE);
      gdk_gc_set_foreground(m_gc, &gdkcolor);
    }

    gdk_gc_set_line_attributes(m_gc, (gint)thickness,
                               GDK_LINE_SOLID, GDK_CAP_BUTT,
                               GDK_JOIN_BEVEL) ;
    gdk_draw_line(m_background, m_gc,
                  vpMath::round( ip1.get_u()/m_scale ),
                  vpMath::round( ip1.get_v()/m_scale ),
                  vpMath::round( ip2.get_u()/m_scale ),
                  vpMath::round( ip2.get_v()/m_scale ) );
  }
  else
  {
    throw(vpDisplayException(vpDisplayException::notInitializedError,
                             "GTK not initialized")) ;
  }
}

void vpDisplayGTK::displayPoint ( const vpImagePoint &ip, const vpColor &color, unsigned int thickness )
{
  if (m_displayHasBeenInitialized)
  {
    if (color.id < vpColor::id_unknown)
      gdk_gc_set_foreground(m_gc, col[color.id]);
    else {
      gdkcolor.red   = 256 * color.R;
      gdkcolor.green = 256 * color.G;
      gdkcolor.blue  = 256 * color.B;
      gdk_colormap_alloc_color(colormap,&gdkcolor,FALSE,TRUE);
      gdk_gc_set_foreground(m_gc, &gdkcolor);
    }

    if (thickness == 1) {
      gdk_draw_point(m_background, m_gc,
                     vpMath::round( ip.get_u()/m_scale ),
                     vpMath::round( ip.get_v()/m_scale ) );
    }
    else {
      gdk_draw_rectangle( m_background, m_gc, TRUE,
                          vpMath::round( ip.get_u()/m_scale ),
                          vpMath::round( ip.get_v()/m_scale ),
                          thickness, thickness );
    }
  }
  else
  {
    throw(vpDisplayException(vpDisplayException::notInitializedError,
                             "GTK not initialized")) ;
  }
}


void
vpDisplayGTK::displayRectangle ( const vpImagePoint &topLeft,
                                 unsigned int w, unsigned int h,
                                 const vpColor &color, bool fill,
                                 unsigned int thickness )
{
  if (m_displayHasBeenInitialized)
  {
    if ( thickness == 1 ) thickness = 0;

    if (color.id < vpColor::id_unknown)
      gdk_gc_set_foreground(m_gc, col[color.id]);
    else {
      gdkcolor.red   = 256 * color.R;
      gdkcolor.green = 256 * color.G;
      gdkcolor.blue  = 256 * color.B;
      gdk_colormap_alloc_color(colormap,&gdkcolor,FALSE,TRUE);
      gdk_gc_set_foreground(m_gc, &gdkcolor);
    }
    gdk_gc_set_line_attributes(m_gc, (gint)thickness,
                               GDK_LINE_SOLID, GDK_CAP_BUTT,
                               GDK_JOIN_BEVEL) ;

    if (fill == false)
      gdk_draw_rectangle(m_background, m_gc, FALSE,
                         vpMath::round( topLeft.get_u()/m_scale ),
                         vpMath::round( topLeft.get_v()/m_scale ),
                         (gint)w/m_scale, (gint)h/m_scale);
    else
      gdk_draw_rectangle(m_background, m_gc, TRUE,
                         vpMath::round( topLeft.get_u()/m_scale ),
                         vpMath::round( topLeft.get_v()/m_scale ),
                         (gint)w/m_scale, (gint)h/m_scale);

    if (thickness > 1)
      gdk_gc_set_line_attributes(m_gc, 0, GDK_LINE_SOLID, GDK_CAP_BUTT,
                                 GDK_JOIN_BEVEL) ;
  }
  else
  {
    throw(vpDisplayException(vpDisplayException::notInitializedError,
                             "GTK not initialized")) ;
  }
}

void
vpDisplayGTK::displayRectangle ( const vpImagePoint &topLeft,
                                 const vpImagePoint &bottomRight,
                                 const vpColor &color, bool fill,
                                 unsigned int thickness )
{
  if (m_displayHasBeenInitialized)
  {
    if ( thickness == 1 ) thickness = 0;

    if (color.id < vpColor::id_unknown)
      gdk_gc_set_foreground(m_gc, col[color.id]);
    else {
      gdkcolor.red   = 256 * color.R;
      gdkcolor.green = 256 * color.G;
      gdkcolor.blue  = 256 * color.B;
      gdk_colormap_alloc_color(colormap,&gdkcolor,FALSE,TRUE);
      gdk_gc_set_foreground(m_gc, &gdkcolor);
    }

    gdk_gc_set_line_attributes(m_gc, (gint)thickness,
                               GDK_LINE_SOLID, GDK_CAP_BUTT,
                               GDK_JOIN_BEVEL) ;

    int w  = vpMath::round( bottomRight.get_u() - topLeft.get_u() );
    int h = vpMath::round( bottomRight.get_v() - topLeft.get_v() );

    if (fill == false)
      gdk_draw_rectangle(m_background, m_gc, FALSE,
                         vpMath::round( topLeft.get_u()/m_scale ),
                         vpMath::round( topLeft.get_v()/m_scale ),
                         w/m_scale,h/m_scale);
    else
      gdk_draw_rectangle(m_background, m_gc, TRUE,
                         vpMath::round( topLeft.get_u()/m_scale ),
                         vpMath::round( topLeft.get_v()/m_scale ),
                         w/m_scale, h/m_scale);

    if (thickness > 1)
      gdk_gc_set_line_attributes(m_gc, 0, GDK_LINE_SOLID, GDK_CAP_BUTT,
                                 GDK_JOIN_BEVEL) ;
  }
  else
  {
    throw(vpDisplayException(vpDisplayException::notInitializedError,
                             "GTK not initialized")) ;
  }
}

void
vpDisplayGTK::displayRectangle ( const vpRect &rectangle,
                                 const vpColor &color, bool fill,
                                 unsigned int thickness )
{
  if (m_displayHasBeenInitialized)
  {
    if (color.id < vpColor::id_unknown)
      gdk_gc_set_foreground(m_gc, col[color.id]);
    else {
      gdkcolor.red   = 256 * color.R;
      gdkcolor.green = 256 * color.G;
      gdkcolor.blue  = 256 * color.B;
      gdk_colormap_alloc_color(colormap,&gdkcolor,FALSE,TRUE);
      gdk_gc_set_foreground(m_gc, &gdkcolor);
    }

    if ( thickness == 1 ) thickness = 0;

    gdk_gc_set_line_attributes(m_gc, (gint)thickness, GDK_LINE_SOLID, GDK_CAP_BUTT,
                               GDK_JOIN_BEVEL) ;

    if (fill == false)
      gdk_draw_rectangle(m_background, m_gc, FALSE,
                         vpMath::round( rectangle.getLeft()/m_scale ),
                         vpMath::round( rectangle.getTop()/m_scale ),
                         vpMath::round( rectangle.getWidth()/m_scale ),
                         vpMath::round( rectangle.getHeight()/m_scale ) );

    else
      gdk_draw_rectangle(m_background, m_gc, TRUE,
                         vpMath::round( rectangle.getLeft()/m_scale ),
                         vpMath::round( rectangle.getTop()/m_scale ),
                         vpMath::round( rectangle.getWidth()/m_scale ),
                         vpMath::round( rectangle.getHeight()/m_scale ) );

    if (thickness > 1)
      gdk_gc_set_line_attributes(m_gc, 0, GDK_LINE_SOLID, GDK_CAP_BUTT,
                                 GDK_JOIN_BEVEL) ;
  }
  else
  {
    throw(vpDisplayException(vpDisplayException::notInitializedError,
                             "GTK not initialized")) ;
  }
}


bool
vpDisplayGTK::getClick(bool blocking)
{
  bool ret = false;

  if (m_displayHasBeenInitialized) {

    //    flushDisplay() ;
    //int cpt =0;
    do {
      GdkEvent *ev = NULL;
      while ((ev = gdk_event_get())!=NULL){
        //cpt++;
        //  printf("event %d type %d on window %p My window %p\n",
        //cpt, ev->type, ev->any.window, widget->window);

        if (ev->any.window == widget->window && ev->type == GDK_BUTTON_PRESS){
          ret = true ;
          //printf("Click detection\n");
        }
        gdk_event_free(ev) ;
      }
      if (blocking){
        flushDisplay();
        vpTime::wait(100);
      }
    } while ( ret == false && blocking == true);
  }
  else {
    throw(vpDisplayException(vpDisplayException::notInitializedError,
                             "GTK not initialized")) ;
  }
  return ret;
}

bool
vpDisplayGTK::getClick(vpImagePoint &ip, bool blocking)
{
  bool ret = false;

  if (m_displayHasBeenInitialized) {

    double u, v ;
    do {
      GdkEvent *ev = NULL;
      while ((ev = gdk_event_get())!=NULL){
        if (ev->any.window == widget->window && ev->type == GDK_BUTTON_PRESS) {
          u = ((GdkEventButton *)ev)->x ;
          v = ((GdkEventButton *)ev)->y ;
          ip.set_u( u*m_scale );
          ip.set_v( v*m_scale );
          ret = true ;
        }
        gdk_event_free(ev) ;
      }
      if (blocking){
        flushDisplay();
        vpTime::wait(100);
      }
    } while ( ret == false && blocking == true);
  }
  else {
    throw(vpDisplayException(vpDisplayException::notInitializedError,
                             "GTK not initialized")) ;
  }
  return ret ;
}


bool
vpDisplayGTK::getClick(vpImagePoint &ip,
                       vpMouseButton::vpMouseButtonType& button,
                       bool blocking)
{
  bool ret = false;

  if (m_displayHasBeenInitialized) {
    double u, v ;
    do {
      GdkEvent *ev = NULL;
      while ((ev = gdk_event_get())){
        if (ev->any.window == widget->window && ev->type == GDK_BUTTON_PRESS){
          u = ((GdkEventButton *)ev)->x ;
          v = ((GdkEventButton *)ev)->y ;
          ip.set_u( u*m_scale );
          ip.set_v( v*m_scale );

          switch ((int)((GdkEventButton *)ev)->button) {
          case 1:
            button = vpMouseButton::button1; break;
          case 2:
            button = vpMouseButton::button2; break;
          case 3:
            button = vpMouseButton::button3; break;
          }
          ret = true ;
        }
        gdk_event_free(ev) ;
      }
      if (blocking){
        flushDisplay();
        vpTime::wait(100);
      }

    } while ( ret == false && blocking == true);
  }
  else {
    throw(vpDisplayException(vpDisplayException::notInitializedError,
                             "GTK not initialized")) ;
  }
  return ret;
}

bool
vpDisplayGTK::getClickUp(vpImagePoint &ip,
                         vpMouseButton::vpMouseButtonType& button,
                         bool blocking)
{
  bool ret = false;

  if ( m_displayHasBeenInitialized ) {

    //flushDisplay() ;
    double u, v ;
    do {
      GdkEvent *ev = NULL;
      while ((ev = gdk_event_get())!=NULL){
        if ( ev->any.window == widget->window
             && ev->type == GDK_BUTTON_RELEASE) {
          u = ((GdkEventButton *)ev)->x ;
          v = ((GdkEventButton *)ev)->y ;
          ip.set_u( u*m_scale );
          ip.set_v( v*m_scale );

          switch ( ( int ) ( ( GdkEventButton * ) ev )->button ) {
          case 1:
            button = vpMouseButton::button1; break;
          case 2:
            button = vpMouseButton::button2; break;
          case 3:
            button = vpMouseButton::button3; break;
          }
          ret = true ;
        }
        gdk_event_free(ev) ;
      }
      if (blocking){
        flushDisplay();
        vpTime::wait(100);
      }

    } while ( ret == false && blocking == true);
  }
  else {
    throw ( vpDisplayException ( vpDisplayException::notInitializedError,
                                 "GTK not initialized" ) ) ;
  }
  return ret;
}

/*
  \brief gets the displayed image (including the overlay plane)
  and returns an RGBa image
*/
void vpDisplayGTK::getImage(vpImage<vpRGBa> &I)
{
  // should certainly be optimized.
  if (m_displayHasBeenInitialized)
  {

    GdkImage *ImageGtk;
    /*
     */

    ImageGtk = gdk_image_get(m_background, 0, 0, (gint)m_width, (gint)m_height);

    I.resize(m_height, m_width) ;
    guint32 pixel;
    gint x,y;
    guchar OctetRouge,OctetVert,OctetBleu,mask;
    mask = 0x000000FF;

    for (y=0;y<(gint)m_height;y++)
    {
      for (x=0;x<(gint)m_width;x++)
      {
        pixel = gdk_image_get_pixel(ImageGtk,x,y);
        OctetBleu  = (guchar)pixel & mask;
        OctetVert  = (guchar)(pixel>>8) & mask;
        OctetRouge = (guchar)(pixel>>16) & mask;
        I[y][x].R = OctetRouge;
        I[y][x].G = OctetVert;
        I[y][x].B = OctetBleu;
        I[y][x].A = vpRGBa::alpha_default; // default opacity
      }
    }
  }
  else
  {
    throw(vpDisplayException(vpDisplayException::notInitializedError,
                             "GTK not initialized")) ;
  }

}

unsigned int vpDisplayGTK::getScreenDepth()
{

  unsigned int depth;

  depth = (unsigned int)gdk_window_get_visual(widget->window)->depth ;

  return (depth);
}

bool
vpDisplayGTK::getKeyboardEvent(bool blocking)
{
  bool ret = false;

  if (m_displayHasBeenInitialized) {

    int cpt =0;
    do {
      GdkEvent *ev = NULL;
      while ((ev = gdk_event_get())!=NULL){
        cpt++;
        //  printf("event %d type %d on window %p My window %p\n",
        //cpt, ev->type, ev->any.window, widget->window);

        if (ev->any.window == widget->window && ev->type == GDK_KEY_PRESS){
          ret = true ;
          //printf("Key press detection\n");
        }
        gdk_event_free(ev) ;
      }
      if (blocking){
        flushDisplay();
        vpTime::wait(100);
      }
    } while ( ret == false && blocking == true);
  }
  else {
    throw(vpDisplayException(vpDisplayException::notInitializedError,
                             "GTK not initialized")) ;
  }
  return ret;
}

bool
vpDisplayGTK::getKeyboardEvent(std::string &key, bool blocking)
{
  bool ret = false;

  if (m_displayHasBeenInitialized) {

    int cpt =0;
    do {
      GdkEvent *ev = NULL;
      while ((ev = gdk_event_get())!=NULL){
        cpt++;
        //  printf("event %d type %d on window %p My window %p\n",
        //cpt, ev->type, ev->any.window, widget->window);

        if (ev->any.window == widget->window && ev->type == GDK_KEY_PRESS){
          //std::cout << "Key val: \"" << gdk_keyval_name (ev->key.keyval) /*ev->key.string*/ << "\"" << std::endl;
          key = gdk_keyval_name (ev->key.keyval);
          ret = true ;
          //printf("Key press detection\n");
        }
        gdk_event_free(ev) ;
      }
      if (blocking){
        flushDisplay();
        vpTime::wait(100);
      }
    } while ( ret == false && blocking == true);
  }
  else {
    throw(vpDisplayException(vpDisplayException::notInitializedError,
                             "GTK not initialized")) ;
  }
  return ret;
}

bool
vpDisplayGTK::getPointerMotionEvent ( vpImagePoint &ip)
{
  bool ret = false;

  if (m_displayHasBeenInitialized) {
    GdkEvent *ev = NULL;
    if ((ev = gdk_event_get())){
      if (ev->any.window == widget->window && ev->type == GDK_MOTION_NOTIFY){
        double u = ((GdkEventMotion *)ev)->x ;
        double v = ((GdkEventMotion *)ev)->y ;
        ip.set_u( u*m_scale );
        ip.set_v( v*m_scale );

        ret = true ;
      }
      gdk_event_free(ev) ;
    }
  }
  else {
    throw(vpDisplayException(vpDisplayException::notInitializedError,
                             "GTK not initialized")) ;
  }
  return ret;
}

bool
vpDisplayGTK::getPointerPosition ( vpImagePoint &ip)
{
  if (m_displayHasBeenInitialized)
  {
    int u,v;
    gdk_window_get_pointer(widget->window, &u, &v, NULL);
    ip.set_u( u*m_scale );
    ip.set_v( v*m_scale );
  }
  else {
    throw(vpDisplayException(vpDisplayException::notInitializedError,
                             "GTK not initialized")) ;
  }
  
  return true;
}

void vpDisplayGTK::getScreenSize ( unsigned int &w, unsigned int &h )
{
  w = h = 0;

  if (! m_displayHasBeenInitialized) {
    int *argc=NULL ;
    char **argv ;

    gtk_init(argc, &argv);

    GtkWidget *widget_ = gtk_window_new(GTK_WINDOW_TOPLEVEL);
    gtk_window_set_default_size(GTK_WINDOW(widget_), 100, 100);
    gtk_widget_show(widget_);

    GdkScreen *screen_ =    gdk_window_get_screen(widget_->window);
    w = (unsigned int)gdk_screen_get_width(screen_);
    h = (unsigned int)gdk_screen_get_height(screen_);
    gtk_widget_destroy(widget_);
  }
  else {
    GdkScreen *screen_ =    gdk_window_get_screen(widget->window);
    w = (unsigned int)gdk_screen_get_width(screen_);
    h = (unsigned int)gdk_screen_get_height(screen_);
  }

}

unsigned int vpDisplayGTK::getScreenWidth()
{
  unsigned int width, height;
  getScreenSize(width, height);
  return width;
}

unsigned int vpDisplayGTK::getScreenHeight()
{
  unsigned int width, height;
  getScreenSize(width, height);
  return height;
}

#elif !defined(VISP_BUILD_SHARED_LIBS)
// Work arround to avoid warning: libvisp_core.a(vpDisplayGTK.cpp.o) has no symbols
void dummy_vpDisplayGTK() {};
#endif