GuiBase.cpp

/*
This file is part of the BIAS library (Basic ImageAlgorithmS).

Copyright (C) 2003-2009    (see file CONTACT for details)
  Multimediale Systeme der Informationsverarbeitung
  Institut fuer Informatik
  Christian-Albrechts-Universitaet Kiel


BIAS is free software; you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as published by
the Free Software Foundation; either version 2.1 of the License, or
(at your option) any later version.

BIAS is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU Lesser General Public License for more details.

You should have received a copy of the GNU Lesser General Public License
along with BIAS; if not, write to the Free Software
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
*/

#include "GuiBase.hh"

#ifndef  WIN32
//no unistd in WIN32 by default
#  include <unistd.h>
//#  include <pthread.h>
#endif //WIN32

#include <Base/Image/ImageConvert.hh>

#include <Base/Common/BIASpragma.hh>

using namespace BIAS;
using namespace std;



// instantiations for ConvertToUC_
template int GuiBase::ConvertToUC_<float>(Image<float>& image, float, float);
#ifdef BUILD_IMAGE_CHAR
template int GuiBase::ConvertToUC_<char>(Image<char>& image, float, float);
#endif

#ifdef BUILD_IMAGE_DOUBLE
template int GuiBase::ConvertToUC_<double>(Image<double>& image, float, float);
#endif

#ifdef BUILD_IMAGE_UINT
template int GuiBase::ConvertToUC_<unsigned int>(Image<unsigned int>& image,
                         float, float);
#endif

#ifdef BUILD_IMAGE_INT
template int GuiBase::ConvertToUC_<int>(Image<int>& image, float, float);
#endif

#ifdef BUILD_IMAGE_SHORT
template int GuiBase::ConvertToUC_<short int>(Image<short int>& image,
                          float, float);
#endif

#ifdef BUILD_IMAGE_USHORT
template int GuiBase::ConvertToUC_<unsigned short>(Image<unsigned short>& image
                           , float, float);
#endif



// instantiate static stuff
  pthread_mutex_t GuiBase::MouseButtonMutex_;

bool GuiBase::BaseInitialized_=false;

GuiBase::GuiBase(bool ShowMousePos) : Debug()
{
  Init_(ShowMousePos);
}

GuiBase::GuiBase(const string& Title,bool ShowMousePos) : Debug()
{
  Init_(ShowMousePos);
  Title_ = Title;
}

GuiBase::GuiBase(const GuiBase& gui) :Debug()
{
  Init_(gui.ShowMouse_);
  Title_ = gui.Title_;
}


GuiBase::~GuiBase()
{}



void GuiBase::Init_(bool ShowMousePos)
{
  WindowCreated_=false;
  Width_=0;
  Height_=0;
  nChannels_=0;
  Title_="Window";
  KeyBuffer_=-1;
  ShowMouse_ = ShowMousePos;
  MouseButtonPressed_ = MouseButtonReleased_ = -1;
  MouseButtonPressX_ = MouseButtonPressY_ = -1;
  MouseButtonReleaseX_ = MouseButtonReleaseY_ = -1;
  Factor_ = 1;
  XOffset_ = YOffset_ = 0;
  if (!BaseInitialized_){
    pthread_mutex_init(&MouseButtonMutex_, NULL);
    BaseInitialized_ = true;
  }
  IsPyramid_=false;
  Pyramid0Width_=Pyramid0Height_=PyramidLevels_=0;
}

void GuiBase::SetFactorOffset(int xoffset, int yoffset, int factor)
{
  XOffset_ = xoffset;
  YOffset_ = yoffset;
  Factor_ = factor;
}

void GuiBase::GetFactorOffset(int& xoffset, int& yoffset, int& factor)
{
  xoffset = XOffset_;
  yoffset = YOffset_;
  factor = Factor_;
}

int GuiBase::ShowImage(ImageBase& image, float min, float max)
{

  if (IsPyramid_>0) IsPyramid_--;
  //cout <<"GuiBase::ShowImage() "<< IsPyramid_<<endl;
  OrigPicture_ = image;
  int result=0;
  switch(image.GetStorageType()){
  case ImageBase::ST_unsignedchar:
    {
      Image<unsigned char> img;
      img.StealImage(image);

      Image<unsigned char> rgbimage;
      ImageConvert::Convert(img,rgbimage,ImageBase::CM_RGB);
      result=ShowConvertedImage_(rgbimage);

      image.StealImage(img);
    }
    break;
  case ImageBase::ST_float:
    {
      Image<float> img;
      img.StealImage(image);
      result=ConvertToUC_(img,min,max);
      image.StealImage(img);
    }
    break;
#ifdef BUILD_IMAGE_USHORT
  case ImageBase::ST_unsignedshortint:
    {
      Image<unsigned short int> img;
      img.StealImage(image);
      result=ConvertToUC_(img, min, max);
      image.StealImage(img);
    }
    break;
#endif
#ifdef BUILD_IMAGE_CHAR
  case ImageBase::ST_char:
    {
      Image<char> img;
      img.StealImage(image);
      result=ConvertToUC_(img,min,max);
      image.StealImage(img);
    }
    break;
#endif
#ifdef BUILD_IMAGE_SHORT
  case ImageBase::ST_shortint:
    {
      Image<short int> img;
      img.StealImage(image);
      result=ConvertToUC_(img,min,max);
      image.StealImage(img);
    }
    break;
#endif
#ifdef BUILD_IMAGE_INT
  case ImageBase::ST_int:
    {
      Image<int> img;
      img.StealImage(image);
      result=ConvertToUC_(img,min,max);
      image.StealImage(img);
    }
    break;
#endif
#ifdef BUILD_IMAGE_UINT
  case ImageBase::ST_unsignedint:
    {
      Image<unsigned int> img;
      img.StealImage(image);
      result=ConvertToUC_(img,min,max);
      image.StealImage(img);
    }
    break;
     break;
#endif
#ifdef BUILD_IMAGE_DOUBLE
  case ImageBase::ST_double:
    {
      Image<double> img;
      img.StealImage(image);
      result=ConvertToUC_(img,min,max);
      image.StealImage(img);
    }
    break;
#endif
  default:

    BIASERR("invalid storage type: "<<int(image.GetStorageType()) );

    return -1;
    break;
  }
  return result;
}

template <class PixelType>
int GuiBase::ConvertToUC_(Image<PixelType> &image, float min, float max)
{
//   cout <<"GuiBase::ConvertToUC_()"<<endl;
    Image<PixelType> tmpimage;
    tmpimage = image;
    tmpimage.ScaleShiftBetween(min, max);
    Image<unsigned char> ucimage, rgbimage;
    ImageConvert::ConvertST(tmpimage, ucimage, ImageBase::ST_unsignedchar);
    ImageConvert::Convert(ucimage, rgbimage, ImageBase::CM_RGB);
    return ShowConvertedImage_(rgbimage);
}

int GuiBase::ShowImage(PyramidImage<float>& pim)
{
  PyramidImage<float> tmp;
  tmp=pim;
  PyramidImage<unsigned char> im;
  im.Init(pim[0]->GetWidth(), pim[0]->GetHeight() , pim[0]->GetChannelCount(),
          pim.size());
  for (unsigned p=0; p<pim.size(); p++){
    tmp[p]->ScaleShiftBetween(0, 255);
    if (ImageConvert::ConvertST(*tmp[p], *im[p],
                                ImageBase::ST_unsignedchar)!=0){
      BIASERR("error converting image");
    }
  }
  return ShowImage(im);
}

int GuiBase::ShowImage(PyramidImage<unsigned char> &pim)
{
  Pyramid0Width_=pim[0]->GetWidth();
  Pyramid0Height_=pim[0]->GetHeight();
  PyramidLevels_ = pim.size();
  IsPyramid_=2;
  Image<unsigned char> im;
  pim.GetSingleImage(im);
  return ShowImage(im);
}

int GuiBase::ShowConvertedImage_(Image<unsigned char> &image)
{
  BIASERR("GuiBase::ShowConvertedImage_() must be overloaded!!");
  return -1;
}

int GuiBase::DestroyWindow()
{
  BIASERR("GuiBase::DestroyWindow() must be overloaded!!");
  return -1;
}

void GuiBase::SetTitle(string const& Title)
{
  BIASERR("GuiBase::SetTitle() must be overloaded!!");
  return ;
}


bool GuiBase::CheckForEvent(bool& KeyEvent, char& key, bool& Pressed,
                        int& Button, int& Xpos, int& Ypos)
{
  char tmp;
  if (CheckForMouseButtonEvent(Pressed, Button, Xpos, Ypos)){
    KeyEvent=false;
    return true;
  } else if ((tmp=CheckForKeyEvent()) != -1){
    key=tmp;
    KeyEvent=true;
    return true;
  }
  return false;
}

void GuiBase::WaitForEvent(bool& KeyEvent, char& key, bool& Pressed,
                       int& Button, int& Xpos, int& Ypos)
{
  key = -1;
  Button = -1;
  Xpos = Ypos = -1;
  while (WindowCreated_ && (key = CheckForKeyEvent()) == -1 &&
    !CheckForMouseButtonEvent(Pressed, Button, Xpos, Ypos)){
    #ifdef   WIN32
      Sleep(1000);
    #else  //not WIN32
      usleep(10000);
    #endif //WIN32
  }
  if (key == -1)
    KeyEvent = false;
  else
    KeyEvent = true;
}

bool GuiBase::CheckForEvent(char& key, bool& Pressed, int& Button,
            int& Xpos, int& Ypos)
{
  key = CheckForKeyEvent();
  Button = -1;
  Xpos = Ypos = -1;
  return (CheckForMouseButtonEvent(Pressed, Button, Xpos, Ypos) || (key!=-1));
}

char GuiBase::CheckForKeyEvent()
{
    char Key;
    if (KeyBuffer_ != -1){
    Key=KeyBuffer_;
    KeyBuffer_=-1;
    return Key;
    }
    return KeyBuffer_;
}


char GuiBase::WaitForKeyEvent()
{
  BIASDOUT(D_GUI_KEY,"WaitForKeyEvent()");
  char Key;
  while (WindowCreated_ && KeyBuffer_==-1){
    #ifdef   WIN32
      Sleep(1000);
    #else  //not WIN32
      usleep(10000);
    #endif //WIN32
  }
  Key=KeyBuffer_;
  KeyBuffer_=-1;
  BIASDOUT(D_GUI_KEY,"WaitForKeyEvent() : key pressed : "<<Key);
  return Key;
}

bool GuiBase::CheckForMouseButtonEvent(bool& Pressed, int& Button,
                     int& Xpos, int& Ypos)
{
  bool result=false;
  BIAS_MUTEX_LOCK(&MouseButtonMutex_);
  if (MouseButtonPressed_ == -1 && MouseButtonReleased_ == -1){
    result = false;
  } else {
    result = true;
    if (MouseButtonPressed_ != -1){
      Pressed = true;
      Button = MouseButtonPressed_;
      Xpos = MouseButtonPressX_;
      Ypos = MouseButtonPressY_;
      MouseButtonPressX_ = MouseButtonPressY_ = -1;
      MouseButtonPressed_ = -1;
    } else {
      Pressed = false;
      Button = MouseButtonReleased_;
      Xpos = MouseButtonReleaseX_;
      Ypos = MouseButtonReleaseY_;
      MouseButtonReleaseX_ = MouseButtonReleaseY_ = -1;
      MouseButtonReleased_ = -1;
    }
  }
  BIAS_MUTEX_UNLOCK(&MouseButtonMutex_);
  return result;
}

void GuiBase::WaitForMouseButtonEvent(bool& Pressed, int& Button,
                                      int& Xpos, int& Ypos)
{
  BIAS_MUTEX_LOCK(&MouseButtonMutex_);
  while (WindowCreated_ && MouseButtonPressed_ == -1 &&
         MouseButtonReleased_ == -1){
    BIAS_MUTEX_UNLOCK(&MouseButtonMutex_);
    #ifdef   WIN32
       Sleep(1000);
    #else  //not WIN32
       usleep(10000);
    #endif //WIN32
    BIAS_MUTEX_LOCK(&MouseButtonMutex_);
  }
  if (MouseButtonPressed_ != -1){
    Pressed = true;
    Button = MouseButtonPressed_;
    Xpos = MouseButtonPressX_;
    Ypos = MouseButtonPressY_;
    MouseButtonPressX_ = MouseButtonPressY_ = -1;
    MouseButtonPressed_ = -1;
    BIASCDOUT(D_GUI_MOUSE_BUTTON, "pressed at ("<<Xpos<<", "<<Ypos<<")"<<endl);
  } else {
    Pressed = false;
    Button = MouseButtonReleased_;
    Xpos = MouseButtonReleaseX_;
    Ypos = MouseButtonReleaseY_;
    MouseButtonReleaseX_ = MouseButtonReleaseY_ = -1;
    MouseButtonReleased_ = -1;
    BIASCDOUT(D_GUI_MOUSE_BUTTON, "released at ("<<Xpos<<", "<<Ypos<<")"<<endl);
  }
  BIAS_MUTEX_UNLOCK(&MouseButtonMutex_);
}