GuiBase.hh

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

#ifndef __GuiBase_hh__
#define __GuiBase_hh__

#include <bias_config.h>
#ifndef BIAS_HAVE_PTHREADS
#  error BIAS_HAVE_PTHREADS not defined. But BIAS::GuiBase needs pthreads (on Unix and Win32). Please enable USE_PTHREADS in CMake configure step.
#endif
#include <pthread.h>

#include <fstream>
#include <string>

#include <Base/Debug/Debug.hh>
#include <Base/Debug/Error.hh>
#include <Base/Image/Image.hh>
#include <Image/PyramidImage.hh>

/// SetDebugLevel uses the following flags
#define D_GUI_DESTRUCT     0x0001
#define D_GUI_MAIN         0x0002
#define D_GUI_SIGNAL       0x0004
#define D_GUI_KEY          0x0008
#define D_GUI_MUTEX        0x0010
#define D_GUI_MOUSE_BUTTON 0x0020

//#define BIAS_MUTEX_DEBUG
#ifdef BIAS_MUTEX_DEBUG
#define BIAS_MUTEX_LOCK(arg)\
      cerr <<__FILE__<<":"<<__LINE__<<" attempting to lock mutex .. "<<#arg;\
      cerr.flush();\
      pthread_mutex_lock(arg);\
      cerr <<" .. got lock\n";

#define BIAS_MUTEX_UNLOCK(arg)\
      cerr <<__FILE__<<":"<<__LINE__<<" unlocking mutex .. "<<#arg;\
      cerr.flush();\
      pthread_mutex_unlock(arg);\
      cerr <<" .. unlocked\n";
#else
#  define BIAS_MUTEX_LOCK(arg) pthread_mutex_lock(arg);
#  define BIAS_MUTEX_UNLOCK(arg) pthread_mutex_unlock(arg);
#endif

namespace BIAS
{
  /** @class GuiBase
      @brief Gui is a simple windowing environment...

      This is a base class and should not be used directly.
  */
  class BIASGui_EXPORT GuiBase : public Debug
  {
  public:
    GuiBase(bool ShowMousePos = true);

    /// as standard constructor, also sets Title_ 
    GuiBase(std::string const& Title,bool ShowMousePos = true);

    GuiBase(const GuiBase& gui);

    virtual ~GuiBase();

    virtual void SetTitle(std::string const& Title);

    std::string GetTitle(){return Title_;};

    /// stops the main loop and closes the window
    virtual int DestroyWindow();

    /** @brief shows/updates the image shown in window.

        This method accepts all different template instances and
        converts them to unsigned char before calling 
        ShowConvertedImage_()    */    
    virtual int ShowImage(ImageBase &image,float min=0.0,float max=255.0);

    virtual int ShowImage(PyramidImage<unsigned char> &pim);
    virtual int ShowImage(PyramidImage<float> &pim);


    /** @brief checks if any key is pressed and returns it 
        returns -1 if no key is pressed
        @author Felix Woelk */
    virtual char CheckForKeyEvent();

    /** waits until a key is pressed and returns it
        @status tested 
        @author Felix Woelk */
    virtual char WaitForKeyEvent();

    inline int GetMouseX(){ return MousePosX_;};
    inline int GetMouseY(){ return MousePosY_;};
  
    /** @brief waits until any mouse button is pressed or released

        Xpos and Ypos are set to the coordinates within the drawing area
        Pressed is set to true if the button was pressed and to false if the 
        button was released
        Button is set to th mouse button no: 1 = left, 2 = middle, 3 = right */
    virtual void WaitForMouseButtonEvent(bool& Pressed, int& Button, 
                     int& Xpos, int& Ypos);

    /** return true if mouse button is pressed or released, false else
        see WaitForMouseButtonEvent for detailed description */
    virtual bool CheckForMouseButtonEvent(bool& Pressed, int& Button, 
                      int& Xpos, int& Ypos);

    /** waits for either KeyEvent or MouseButtonEvent, KeyEvent is set to true
        if key is pressed, the other variables are set as in 
        WaitForKeyEvent and WaitForMouseButtonEvent */
    virtual void WaitForEvent(bool& KeyEvent, char& key, bool& Pressed, 
                  int& Button, int& Xpos, int& Ypos);

    /** as above but does return immediate with true if event occured */
    virtual bool CheckForEvent(bool& KeyEvent, char& key, bool& Pressed, 
                   int& Button,int& Xpos, int& Ypos);

    /** as above but does return immediate with true if event occured 
        if key != -1 key event occured, if Xpos != -1 && YPos != -1
        MouseButton Event occured, also both is possible */
    virtual bool CheckForEvent(char& key, bool& Pressed, int& Button, 
                       int& Xpos, int& Ypos);

 
    /** sets offset and factor for mouse position 
        mouse position in (e.g. zoomed) window is calculated as follows:
        x = real_xpos/factor + xoffset;
        y = real_ypos/factor + yoffset;
        real_x/ypos are in the window coordinate system */
    virtual void SetFactorOffset(int xoffset, int yoffset, int factor);

    /** gets offset and factor for mouse position 
        mouse position in (e.g. zoomed) window is calculated as follows:
        x = real_xpos/factor + xoffset;
        y = real_ypos/factor + yoffset;
        real_x/ypos are in the window coordinate system */
    virtual void GetFactorOffset(int& xoffset, int& yoffset, int& factor);
    /** returns true if window is closed by user via x button
        @author woelk 05/2003 */
    inline bool Closed()
    { return !WindowCreated_; }

  protected:

    /** Set up thread and stuff. Must be overloaded 
        Derived class::Init_() should call GuiBase::Init_()
        first.
    */
    virtual void Init_(bool ShowMousePos);

    /// Does the real update of the image shown in window. Must be overloaded
    virtual int ShowConvertedImage_(Image<unsigned char> &image);


    bool ShowMouse_; // shall mouse position be shown?
    bool WindowCreated_;
    /// if the following 3 variables are set , Buffer_ is already allocated
    unsigned int Width_;  
    unsigned int Height_;
    unsigned int nChannels_;
    unsigned int Pyramid0Width_;
    unsigned int Pyramid0Height_;
    unsigned int PyramidLevels_;

    int MousePosX_;
    int MousePosY_;
    int MouseButtonPressed_;
    int MouseButtonPressX_;
    int MouseButtonPressY_;
    int MouseButtonReleased_;
    int MouseButtonReleaseX_;
    int MouseButtonReleaseY_;

    /// This is the original representation of the picture
    ImageBase OrigPicture_;

    std::string Title_;
    char KeyBuffer_;
    int Factor_; // zoom factor for mouse position
    int XOffset_, YOffset_; // offset for mouse position 
    int IsPyramid_; // set to 1 if PryramidImage is displayed, else to zero 

    static pthread_mutex_t MouseButtonMutex_;
    static bool BaseInitialized_;

    template <class PixelType>
    int ConvertToUC_(Image<PixelType> &image,float min, float max);
    
    /// test if internal variables Width_, Height_ and nChannels_
    /// are set correct for image
    /// these 3 variables are used as an indicator if Buffer_ is 
    /// allocated in right size
    inline bool TestImage_(Image<unsigned char> &image)
    { return ( ( Width_ == image.GetWidth() ) &&
               ( Height_ == image.GetHeight() ) &&
               ( nChannels_ == image.GetChannelCount() ) ); };

  };

} // namepsace BIAS
#endif // __Gui_hh__