GuiCV.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
*/



#ifdef WIN32
#  define _CRT_SECURE_NO_WARNINGS
#endif
#include <Base/Common/BIASpragma.hh> // required for strcpy deprecated warnings

#include "GuiCV.hh"
#include <sstream>

#ifdef BIAS_HAVE_OPENCV
#  include <cv.h>
#  include <highgui.h>
#endif


using namespace BIAS;
using namespace std;

GuiCV::GuiCV(bool ShowMousePos) : GuiBase(ShowMousePos)
{
  IplImage_ = NULL;
}

GuiCV::GuiCV(const string& Title, bool ShowMousePos) : GuiBase(Title, ShowMousePos)
{
  IplImage_ = NULL;
}

GuiCV::GuiCV(const GuiCV& gui) : GuiBase(gui)
{
  IplImage_ = NULL;
}

GuiCV::~GuiCV()
{
  BIASDOUT(D_GUI_DESTRUCT, "GuiCV destructor started");
  if (WindowCreated_){
    DestroyWindow();
  }
  BIASDOUT(D_GUI_DESTRUCT, "GuiCV destructor finished");

  if (IplImage_ != NULL)
  {
    delete IplImage_;
  }
}

void GuiCV::SetTitle(string const& Title)
{
  if (WindowCreated_)
  {
    // OpenCV does not support changing the title,
    // so create a new window.
    DestroyWindow();
    Title_ = Title;
    ShowConvertedImage_(CurrentImage_);
  }
  else
  {
    Title_ = Title;
  }
}

int GuiCV::DestroyWindow()
{
  cvDestroyWindow(Title_.c_str());
  WindowCreated_ = false;
  return 0;
}

char GuiCV::CheckForKeyEvent()
{
  const int key = cvWaitKey(1);
  return (char)key;
}

char GuiCV::WaitForKeyEvent()
{
  int key = cvWaitKey();
  return (char)key;
}

void GuiCV::WaitForMouseButtonEvent(bool& Pressed, int& Button, 
                                    int& Xpos, int& Ypos)
{
  while (WindowCreated_ && MouseButtonPressed_ == -1 && 
         MouseButtonReleased_ == -1) {
    cvWaitKey(100);
  }
  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_);
}

int GuiCV::ShowConvertedImage_(Image<unsigned char> &image)
{
  if (!WindowCreated_)
  {
    cvNamedWindow(Title_.c_str(), 0);
    cvSetMouseCallback(Title_.c_str(), GuiCV::StaticMouseCallback, this);
    WindowCreated_ = true;
  }

  if (image.GetWidth() % 4 == 0)
  {
    CurrentImage_ = image;
  }
  else
  {
    int newWidth = (image.GetWidth() / 4) * 4 + 4;
    int newHeight = image.GetHeight();
    CurrentImage_.Release();
    CurrentImage_.Init(newWidth, newHeight, image.GetChannelCount());
    CurrentImage_.FillImageWithConstValue((unsigned char)0);
    for (unsigned int y = 0; y < image.GetHeight(); y++)
    {
      for (unsigned int x = 0; x < image.GetWidth(); x++)
      {
        for (unsigned short c = 0; c < (unsigned short)image.GetChannelCount(); c++)
        {
          CurrentImage_.SetPixel(image.PixelValue(x, y, c),  x, y, c );
        }
      }
    }
  }

  CreateIplImageShared(&CurrentImage_, IplImage_);
  cvShowImage(Title_.c_str(), IplImage_);
  cvWaitKey(2);

  return 0;
}

void GuiCV::MouseCallback(int event, int x, int y, int flags)
{
  switch (event)
  {
  case CV_EVENT_MOUSEMOVE:
    MousePosX_ = x;
    MousePosY_ = y;
    break;
  case CV_EVENT_LBUTTONDOWN:
    MouseButtonPressed_ = 1;
    MouseButtonPressX_ = x;
    MouseButtonPressY_ = y;
    break;
  case CV_EVENT_RBUTTONDOWN:
    MouseButtonPressed_ = 3;
    MouseButtonPressX_ = x;
    MouseButtonPressY_ = y;
    break;
  case CV_EVENT_MBUTTONDOWN:
    MouseButtonPressed_ = 2;
    MouseButtonPressX_ = x;
    MouseButtonPressY_ = y;
    break;
  case CV_EVENT_LBUTTONUP:
    MouseButtonReleased_ = 1;
    MouseButtonReleaseX_ = x;
    MouseButtonReleaseY_ = y;
    break;
  case CV_EVENT_RBUTTONUP:
    MouseButtonReleased_ = 3;
    MouseButtonReleaseX_ = x;
    MouseButtonReleaseY_ = y;
    break;
  case CV_EVENT_MBUTTONUP:
    MouseButtonReleased_ = 2;
    MouseButtonReleaseX_ = x;
    MouseButtonReleaseY_ = y;
    break;
  }
}

void GuiCV::StaticMouseCallback(int event, int x, int y,
                                int flags, void* param)
{
  static_cast<GuiCV*>(param)->MouseCallback(event, x, y, flags);
}

int GuiCV::CreateIplImageShared(const BIAS::ImageBase* p_src, IplImage* &p_dest)
{
  if (p_src==NULL){
    BIASERR("ImageBase ptr p_src is NULL.");
    return -1;
  };
  BIASASSERT(p_src!=NULL);
  if (p_dest==NULL) {
    p_dest=new IplImage;
    //if (p_imgIpl==p_dest) p_imgIplDestroyable = true;
  };
  BIASASSERT(p_dest!=NULL); 

#ifdef BIAS_DEBUG
  if (!p_src->IsInterleaved() || !((p_src->GetWidth() % 4) == 0) ) {
    BIASERR("Only interleaved images with modulo 4 with are currently supported, sorry.");
    BIASBREAK;
  }
#endif // BIAS_DEBUG


  // OpenCV supports only interleaved IPL_DATA_ORDER_PIXEL: 
  BIASASSERT( p_src->IsInterleaved() );

  // OpenCV supports only size modulo 4 image width
  // to have pixel boundaries on 32bit aligned memory
  // we would need stride, otherwise
#ifdef BIAS_DEBUG
  if ( p_src->GetWidth() % 4 != 0 ) {
    BIASERR("Image width is not multiple of 4 :"<< p_src->GetWidth()
      <<"x"<< p_src->GetHeight());
  }

#endif
  BIASASSERT( p_src->GetWidth() % 4 == 0 );

  // OK
  // initialize only the header without data area: 
  CvSize imgSize;
  imgSize.width  = p_src->GetWidth();    
  imgSize.height = p_src->GetHeight();
  // pixel depth in bits
  int depth=0;
  switch (p_src->GetStorageType()) {
    case BIAS::ImageBase::ST_char:
      depth=IPL_DEPTH_8S; break;
    case BIAS::ImageBase::ST_unsignedchar:
      depth=IPL_DEPTH_8U; break;
    case BIAS::ImageBase::ST_float:
      depth=IPL_DEPTH_32F; break;
    case BIAS::ImageBase::ST_double:
      depth=IPL_DEPTH_64F; break;
    case BIAS::ImageBase::ST_shortint:
      depth=IPL_DEPTH_16S; break;
    case BIAS::ImageBase::ST_unsignedshortint:
      depth=IPL_DEPTH_16U; break;
    case BIAS::ImageBase::ST_int:
      depth=IPL_DEPTH_32S; break;

    case BIAS::ImageBase::ST_unsignedint:
      // unsupported (?)
      BIASERR("you try to wrap a BIAS unsigned int Image with OpenCV. This format may be unsupported by OpenCV! (JW)");
      depth=IPL_DEPTH_32S|IPL_DEPTH_SIGN;
    default:
      BIASERR("unsupported Storagetype in BIAS image for BIAs->ipl image wrapper. GetStorageType="<<p_src->GetStorageType() );
      BIASBREAK; // DBG
      return -1;
  }

  // fill header struct with useful values: 
  cvInitImageHeader( p_dest, 
    imgSize, 
    depth,
    p_src->GetChannelCount(), 
    IPL_ORIGIN_TL, // origin top left
    4 // alignment
    );

  // share the data area: (pointer to aligned image data) do NOT copy
  p_dest->imageData = (char*)(p_src->GetImageData());


  // get the color model and channel seq. right:
  switch (p_src->GetColorModel()){
    case BIAS::ImageBase::CM_RGB:
      // tested, works on Win32 
      strcpy( p_dest->colorModel, "RGB");
      strcpy( p_dest->channelSeq, "RGB");
      break;
    case BIAS::ImageBase::CM_BGR:
      // untested but should work because it's OpenCv native format.
      strcpy( p_dest->colorModel, "RGB");
      strcpy( p_dest->channelSeq, "BGR");
      break;
    case BIAS::ImageBase::CM_BGRA:
      // untested.
      strcpy( p_dest->colorModel, "RGBA");
      strcpy( p_dest->channelSeq, "BGRA");
      break;
    case BIAS::ImageBase::CM_RGBA:
      // untested.
      strcpy( p_dest->colorModel, "RGBA");
      strcpy( p_dest->channelSeq, "RGBA");
      break;
    case BIAS::ImageBase::CM_Grey:
      // untested.
      strcpy( p_dest->colorModel, "GREY");
      strcpy( p_dest->channelSeq, "GREY");
      break;
    default:
      BIASERR("unsupported color model for OpenCV wrapping. ChannelSeq may be wrong.");
      return -2;
  };

  return 0;
}