ShowCamWxFrame.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 __ShowCamWxFrame_hh__
#define __ShowCamWxFrame_hh__

#include <Base/Common/BIASpragmaStart.hh>
#include <bias_config.h>

#ifdef WIN32
#include "Base/Common/W32Compat.hh"
#endif

#include <wx/wx.h>
#include <wx/toolbar.h>
#include <wx/listbox.h>
#include <wx/splitter.h>

#include <Gui/StringConv.hh>
#include <Gui/ImageCanvas.hh>
#include <Gui/ParamGUI.hh>
#include <Gui/VideoSource_Controller_Base.hh>
#include <Gui/wxTauControlFrame.h>

#include <Image/Camera.hh>
#include <Base/Image/ImageIO.hh>
#include <Base/Debug/TimeMeasure.hh>
#include <Filter/Rescale.hh>
#include <Utils/Param.hh>

#include <VideoSource/VideoSource_Base.hh>
#include <VideoSource/VideoSource_Net.hh>
#include <VideoSource/VideoSource_Shm.hh>
#include "ShowCamWxThreads.hh"

#ifdef BIAS_HAVE_PANTILT_DP
#include <PanTilt/DPPanTiltControl.hh>
#include <PanTilt/DPPanTiltControlDialog.hh>
#endif

#ifdef BIAS_HAVE_PANTILT
#include <Gui/wxViscaControlFrame.h>
#endif

#ifdef BIAS_HAVE_TIFF
#ifdef BIAS_HAVE_XML2
#include <VideoSource/VideoSource_ShmPMD.hh>
#endif
#endif

#ifdef BIAS_HAVE_V4L
#  include <VideoSource/VideoSource_V4L.hh>
#endif // BIAS_HAVE_V4L

#ifdef BIAS_HAVE_UEYE
#  include <VideoSource/VideoSource_uEye.hh>
#endif // BIAS_HAVE_UEYE

#ifdef BIAS_HAVE_DCAM
#  include "ShowCamWxFormat7Frame.hh"
#  include <VideoSource/VideoSource_DCAM.hh>
#  include <VideoSource/VideoSource_DCAM_BumbleBee.hh>
#endif // BIAS_HAVE_DCAM

#ifdef BIAS_HAVE_PMD_PMDTec
#  include <Image/PMDImageProc.hh>
#  include <VideoSource/VideoSource_PMD.hh>
#endif // BIAS_HAVE_PMD_PMDTec

#ifdef BIAS_HAVE_PMD_PMDZess
#  include <VideoSource/VideoSource_PMDZess.hh>
#endif // BIAS_HAVE_PMD_PMDZess

#ifdef BIAS_HAVE_SWISSRANGER
#  include <VideoSource/VideoSource_SwissRanger.hh>
#endif

#ifdef BIAS_HAVE_KINECT
#  include <VideoSource/VideoSource_Kinect.hh>
#endif

#ifdef BIAS_HAVE_OPENNI
#  include <VideoSource/VideoSource_OpenNI.hh>
#endif

#ifdef BIAS_HAVE_KINECT2
#  include <VideoSource/VideoSource_Kinect2.hh>
#endif

#ifdef BIAS_HAVE_DSHOW
#  include <VideoSource/VideoSource_DSHOW.hh>
#endif

/**
   @class  ShowCamWxFrame
   @brief  This class is the main frame of the ShowCamWx Application
   @author Christoffer Menk, Ingo Schiller, Benjamin Angerer
*/

#define NUMBER_CAMERAS 9

namespace BIAS {

  // event ids
  enum {
    ID_Timer = wxID_HIGHEST+332,
    ID_Grab,
    ID_GrabContinuous,
    ID_GrabToStream,
    ID_Key,
    ID_Fit,  
    ID_CAMERAS_LISTBOX,
    ID_SPLITTER_WINDOW,
    ID_HIDE_CAMERALIST,
    ID_SHOW_CAMERALIST,
    ID_KeepScroll,
    ID_Show1,
    ID_Show2,
    ID_Show3,
    ID_Show4,
    ID_Show5,
    ID_Show6,
    ID_Show7,
    ID_Show8,
    ID_Show9,
    ID_SaveParameters,
    ID_ShowParameters,
    ID_Controller,
    ID_Paramframe,
    ID_Disable,
    ID_Frame1,
    ID_Frame2,
    ID_FindIEEE1394,
    ID_FindUEYE,
    ID_FindSwissranger,
    ID_FindZess,
    ID_FindPMDTec,
    ID_FindWebcams,
    ID_FindKinect,
    ID_FindOpenNI,
    ID_FindKinect2,
    ID_OpenFlirController,
    ID_OpenViscaController,
    ID_OpenDPController
  };

  class ShowCamWxFrame : public wxFrame, public BIAS::ParamGUI
  {
  public:
    /** \brief Constructor */
    ShowCamWxFrame(const wxString& title, const wxPoint& pos, const wxSize& size);
    /** \brief Destructor */
    virtual ~ShowCamWxFrame();

    /** \brief Initializes all paramaters for param file */
    void InitParams(int &argc, char *argv[]);

    /** \brief Initialize cameras with param file. Only call after InitParams(). */
    void InitCameras();
#ifdef BIAS_HAVE_PANTILT_DP
    /** \brief Initialize Pan Tilt Unit. Only call after InitParams(). */
    bool InitPanTiltUnit();
#endif
    /** \brief Tries to open all specified camera devices. Only call after
        cameras are initialized.  */
    void OpenDevices();

    /** \brief Creates the menu of the main window. */
    void CreateMenu();

    /** \brief Creates the menu for the available cameras */
    void CreateCameraMenu();

    /** \brief Starts the saving from all images to disk from all activated cameras */
    void StartSavingImagesToDisk();

    /** \brief Stops the saving from all images to disk from all activated cameras */
    void StopSavingImagesToDisk();

    /** \brief Shows the parameter GUI*/
    void ShowParamGUI();

#ifdef BIAS_HAVE_DCAM
    /** \brief Shows the IEEE1394 Format7 selector frame*/
    int ShowFormat7Selector(int camindex, dc1394video_mode_t mode);
#endif

  protected:
    /** \brief Save a image from camera with index cameraIndex.*/
    void SaveImageUnthreaded_(int cameraIndex);
    /** \brief Creates the master thread for handling cameras*/
    int CreateMasterThread_();
    /** \brief Creates the thread for grabbing images for a camera*/
    int CreateGrabThreadForCamera_(int cameraIndex);
    /** \brief Creates the thread for saving images for a camera*/
    int CreateImageSaveThreadForCamera_(int cameraIndex);

    #ifdef BIAS_HAVE_PANTILT_DP
    /** \brief if the directed preception pantilt is used a projection
     * is constructed from the angles and written to the image meta data  */
    void GetProjectionFromPanTilt_(BIAS::Projection &projHeader);
        #endif
    /** \brief Grabs an image frmo a camera without using threads  */
    void GrabSingleImageUnthreadedFromCamera_(int cameraIndex);
    /** \brief Selects the current image and shows it in image canvas  */
    void SelectAndShowCameraImage_();

    /** \brief Parses the color models from param file to enum EColorModel  */
    void ParseColorModels();
    /** \brief Initializes combined image for selected camera (usb pmd) */
    void InitCombinedImage();
    /** \brief called on end to close cams and exit */
    void CleanUpAndExit();
    /** \brief try to open the device with index camindex*/
    int OpenDevice(int camindex);
    /** \brief try to close the device with index camindex*/
    int CloseDevice(int camindex);
    /** \brief try to initialze the device with index camindex*/
    void InitCamera(int camindex);
    /** \brief Selects a mode from the menu of multiple modes are
     * offered for a camera, used e.g. for IEEE1394 cameras*/
    int SelectedModeFromMenu(int camindex);

    /** \brief Adds a ueye camera to the menu*/
    void AddUEyeCameraToMenu(int camindex, std::string camId, bool fromFile);
    /** \brief Adds a v4l or DShow camera to the menu*/
    void AddWebcamToMenu(std::string name,int camindex, bool fromFile);

#ifdef BIAS_HAVE_DCAM
    /** \brief Adds a IEEE1394/Firewire camera to the menu*/
    void AddIEEECameraToMenu(int camindex,int IEEEIndex, bool fromFile);
#endif
#ifdef BIAS_HAVE_PMD_PMDZess
    void AddZessCameraToMenu(int camindex, bool fromFile, std::string paramFile);
#endif // BIAS_HAVE_PMD_PMDZess
#ifdef BIAS_HAVE_PMD_PMDTec
    void AddPMDTecCameraToMenu(int camindex, bool fromFile);
#endif // BIAS_HAVE_PMD_PMDTec
#ifdef BIAS_HAVE_SWISSRANGER
    void AddSwissRangerCameraToMenu(int camindex, bool fromFile);
#endif // BIAS_HAVE_SWISSRANGER
#ifdef BIAS_HAVE_KINECT
    void AddKinectCameraToMenu(int camindex, bool fromFile);
#endif // BIAS_HAVE_SWISSRANGER
#ifdef BIAS_HAVE_OPENNI
    void AddOpenNICameraToMenu(int camindex, bool fromFile);
#endif // BIAS_HAVE_SWISSRANGER

#ifdef BIAS_HAVE_KINECT2
    void AddKinect2CameraToMenu(int camindex, bool fromFile);
#endif // BIAS_HAVE_SWISSRANGER

    // functions for event handling
    void OnWindowClose(wxCloseEvent& event);
    void OnQuit(wxCommandEvent& event);
    void OnAbout(wxCommandEvent &event);
    void OnGrab(wxCommandEvent& event);
    void OnGrabContinuous(wxCommandEvent& event);
    void OnGrabToStream(wxCommandEvent& event);
    void OnShowImage(wxCommandEvent& event);
    void OnShowController(wxCommandEvent& event);
    void OnSaveParameters(wxCommandEvent& event);
    void OnShowParameters(wxCommandEvent& event);
    void OnFindIEEE1394(wxCommandEvent& event);
    void OnFindUEye(wxCommandEvent& event);
    void OnFindPMDZess(wxCommandEvent& event);
    void OnFindPMDTec(wxCommandEvent& event);
    void OnFindSwissRanger(wxCommandEvent& event);
    void OnFindKinect(wxCommandEvent& event);
    void OnFindOpenNI(wxCommandEvent& event);
    void OnFindKinect2(wxCommandEvent& event);
    void OnFindWebcams(wxCommandEvent& event);
    void OnOpenFlirController(wxCommandEvent& event);
    void OnOpenViscaController(wxCommandEvent& event);
    void OnOpenDPController(wxCommandEvent& event);
    void OnChangeDeviceChannel(wxCommandEvent& event);
    void OnChangeVideoMode(wxCommandEvent& event);
    void OnChangeActivate(wxCommandEvent& event);
    void OnChangeTrigger(wxCommandEvent& event);
    void OnChangeFirewireB(wxCommandEvent& event);
    void OnTimer(wxTimerEvent& event);
    void OnKey(wxKeyEvent& event);
    void OnFit(wxCommandEvent& event);
    void OnKeepScrollPosition(wxCommandEvent& event);
    void OnClickCamerasListBox(wxCommandEvent& event);
    void OnHideCamerasListBox(wxCommandEvent& event);
    void OnShowCamerasListBox(wxCommandEvent& event);

    // variables for parameters
    int *ParamCameras_[NUMBER_CAMERAS];                 // camera model
    int *ParamWidth_[NUMBER_CAMERAS];                   // width of cameras
    int *ParamHeight_[NUMBER_CAMERAS];                  // height of camera
    int *ParamDown_[NUMBER_CAMERAS];                    // rescale factor
    int *ParamPort_[NUMBER_CAMERAS];                    // port of NET cameras
    std::string *ParamIP_[NUMBER_CAMERAS];              // ip of NET cameras
    std::string *ParamDevice_[NUMBER_CAMERAS];          // device name of camera
    std::string *ParamBitFile_[NUMBER_CAMERAS];         // bit file for pmd cameras
    int *ParamColorModel_[NUMBER_CAMERAS];              // color model of camera
    double *ParamFPS_[NUMBER_CAMERAS];                  // frames per second for camera

#ifdef BIAS_HAVE_PANTILT_DP
    // include the Pan-Tilt-Unit?
    bool *bUsePanTiltUnit_;
    //Pan Tilt Control
    BIAS::DPPanTiltControl *panTiltControl_;
    BIAS::DPPanTiltControlDialog *panTiltControlDialog_;
#endif
#ifdef BIAS_HAVE_PANTILT
    wxViscaControlFrame *viscaControllerFrame_;
#endif
    // vector for all cameras read from param file
    std::vector<BIAS::VideoSource*> Cameras_;
    std::vector<BIAS::ImageBase::EColorModel> ColorModels_;
    std::vector<BIAS::VideoSource_Controller_Base*> VideoControllers_;

    unsigned int FrameCounter_;
    unsigned int GrabCounter_;
    unsigned int LastWidth_, LastHeight_;
    unsigned int Win32DCAMNumber_;
    unsigned int ShowXB3_;
    unsigned int dDirIndex_;
    unsigned int dSingleDirIndex_;

    int NumCamSel_;
    int Delay_;
    int NumOfCams_;
    int ActiveCameras_;
    int FirstCameraID_;
    int LastCameraID_;
    int NumIEEECams_;

    bool TimerActive_;
    bool CleanedUp_;
    bool InitCameras_;
    bool InitParams_;
    bool OpenedDevices_;
    bool bSaveImages_;
    bool bSaveToStream_;
    bool bWriteBuffered_;
    bool EmptyDevice_;
    bool bSingleSaveDirCreated_;

    std::string currentSaveDir_;
    std::string currentSingleSaveDir_;
    std::string sourcePlugin_;
    std::string procPlugin_;

    // camera images
    std::vector<BIAS::Camera<unsigned char>* > CamImg_;
    std::vector<BIAS::Camera<float>* > CamImgPMDDepth_;
    std::vector<BIAS::Camera<float>* > CamImgPMDInt_;
    std::vector<BIAS::Camera<float>* > CamImgPMDAmp_;

    // images for usb pmd cameras
    BIAS::Camera<unsigned char> CamImgCombined_;

    // extra images for bumblebee bx3
    std::vector<BIAS::Camera<unsigned char>* > CamImgMiddle_;
    std::vector<BIAS::Camera<unsigned char>* > CamImgRight_;
    std::vector<BIAS::Camera<unsigned char>* > XB3AllInOne_;

    // thread handling variables
    std::vector<wxCondition*> ServerCondition_;
    std::vector<wxCondition*> ClientsCondition_;
    std::vector<wxMutex*> ServerMutex_;
    std::vector<wxMutex*> ClientsMutex_;

    std::vector<bool> ThreadInited_;

    std::vector<BIAS::GrabSingleThread*> grabSingleThread_;    
    std::vector<BIAS::ImageSaveThread*>  saveThreads_;
    // the master thread syncronising the grab and save threads
    BIAS::GrabMasterThread* grabMasterThread_;

    std::vector<std::vector<Camera<unsigned char>* >* > ImageBuffer_;
    std::vector<std::vector<Camera<unsigned char>* >* > ImageBufferMiddle_;
    std::vector<std::vector<Camera<unsigned char>* >* > ImageBufferRight_;

    // for pmd
    std::vector<std::vector<Camera<float>* >* > ImageBufferPMDDepth_;
    std::vector<std::vector<Camera<float>* >* > ImageBufferPMDAmp_;
    std::vector<std::vector<Camera<float>* >* > ImageBufferPMDInt_;

    std::vector<unsigned int> WriteIndex_;
    std::vector<unsigned int> ReadIndex_;
    std::vector<wxMutex*> BufferAccess_;

    BIAS::Camera<unsigned char> ShowImage_;

    std::vector<bool> CameraActive_;
    std::vector<bool> CameraInitialized_;
    std::vector<bool> SetFirewireB_;
    std::vector<bool> SetTrigger_;
    std::vector<bool> SetUserMode_;
    std::vector<float> SelectedFps_;
    std::vector<BIAS::Vector2<int> > Format7LeftTop_;
    std::vector<BIAS::Vector2<int> > Format7WidthHeight_;
    std::vector<int> Format7BpP_;
    std::vector<int> Format7ColorMode_;
    std::vector<ImageBase::EColorModel> ViewColorMode_;
    std::vector<int> DeviceChannel_;
    std::vector<std::vector<std::string> > DeviceChannelNames_;

    BIAS::ImageCanvas *IC_;
    wxSplitterWindow  *splitterWindow_;
    wxPanel           *cameraListPanel_;
    wxListBox         *cameraListBox_;
    wxButton *pButtonGrab, *pButtonContinuous, *pButtonStream,*pButtonController;
    wxButton *pButtonIEEE1394,*pButtonSR,*pButtonPMDTec,*pButtonWebCams;
    wxCheckBox *pCheckBoxFit,*pCheckBoxKeepScrollPosition;
    wxTauControlFrame *tauControllerFrame_;
    wxTimer Timer_;
    TimeMeasure StopWatch_;
    wxFrame *paramFrame_;
    wxNotebook *paramNotebook_;
    wxMenu *menuShow;
    wxMenu* CameraMenu_;

#ifdef BIAS_HAVE_DCAM
    std::vector<CameraInfo> IEEECameraInfo_;
    ShowCamWxFormat7Frame *format7Frame_;
#endif

    std::vector<std::string> cameraNames_;

    DECLARE_EVENT_TABLE()
  }; // end of class

} // end of namespace MIP

#include <Base/Common/BIASpragmaEnd.hh>

#endif // __ShowCamWxFrame_hh__