ShowCamWxThreads.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 __ShowCamWxThreads_hh__
#define __ShowCamWxThreads_hh__

#include <bias_config.h>
#include <wx/wx.h>

#include <Gui/StringConv.hh>
#include <Image/Camera.hh>
#include <Image/ImagePackage.hh>
#include <Base/Image/ImageIO.hh>
#include <Base/Debug/TimeMeasure.hh>

#include <VideoSource/VideoSource_Base.hh>

#include <Base/Common/TimeStamp.hh>


namespace BIAS {

  /**
     @class  ImageSaveThread
     @brief  This class creates a thread which stores an image in a file
     if rescale is not zero then the stored image is downsampled
     by this factor.
     @author Christoffer Menk
  */
  class ImageSaveThread : public wxThread
  {
  public:
    // Constructor for single images
    ImageSaveThread(std::string                           cameraName,
                    const int&                            downsample,
                    wxMutex*                              BufferAccessMutex,
                    bool&                                 writeToBuffer,
                    unsigned int&                         readIndex,
                    unsigned int&                         writeIndex,
                            BIAS::Camera<unsigned char>*          img,
                            BIAS::Camera<unsigned char>*          imgCenter,
                    BIAS::Camera<unsigned char>*          imgRight,
                            BIAS::Camera<float>*                  imgDepth,
                    BIAS::Camera<float>*                  imgAmp,
                    BIAS::Camera<float>*                  imgInt,
                            std::vector<Camera<unsigned char>* >* imageBuffer,
                            std::vector<Camera<unsigned char>* >* imageBufferCenter,
                    std::vector<Camera<unsigned char>* >* imageBufferRight,
                            std::vector<Camera<float>* >*         imageBufferPmdDepth,
                    std::vector<Camera<float>* >*         imageBufferPmdAmp,
                    std::vector<Camera<float>* >*         imageBufferPmdInt,
                    bool saveToStream = false);

    ~ImageSaveThread() {}

    virtual ExitCode Entry();

    void SetSaveDirectory(std::string &path){saveDirectory_ = path;};
      void ResetCounter(){ImageCounter_=0;};
      void FinishSaving();

  private:
      void SaveImage_(Camera <unsigned char>* im, std::string name);
      void SaveImage_(Camera <float>* imF, std::string name);

      int mapNameToStreamIdx_(std::string name);

  private:
    std::string saveDirectory_;
    std::string cameraName_;

    int DownSample_;
    unsigned int ImageCounter_;

    BIAS::Camera<unsigned char> *Img_;
    BIAS::Camera<unsigned char> *ImgCenter_;
    BIAS::Camera<unsigned char> *ImgRight_;
    BIAS::Camera<unsigned char> *Img2D_;

    BIAS::Camera<float>         *ImgDepth_;
    BIAS::Camera<float>         *ImgAmp_;
    BIAS::Camera<float>         *ImgInt_;

    std::vector<Camera<unsigned char>* > *ImageBuffer_;
    std::vector<Camera<unsigned char>* > *ImageBufferCenter_;
    std::vector<Camera<unsigned char>* > *ImageBufferRight_;
    std::vector<Camera<float>* >         *ImageBufferPMDDepth_;
    std::vector<Camera<float>* >         *ImageBufferPMDAmp_;
    std::vector<Camera<float>* >         *ImageBufferPMDInt_;
    std::vector<Camera<float>* >         *ImageBufferFloat_;

    wxMutex* BufferAccess_;
    bool* WriteToBuffer_;
    unsigned int* WriteIndex_;
    unsigned int* ReadIndex_;

    std::vector<ImagePackage*> ips_;
    std::vector<bool> bStreamOpen_;
    bool stream_;
  };


  /** ***************************************************************
     @class  GrabSingleThread
     @brief  This class creates a thread which grabs a single image
     @author Christoffer Menk
  */
  class GrabSingleThread : public wxThread
  {
  public:

    enum {
      DCAM = 0,
      XB3,
      SR,
      ZESS,
      PMDTEC,
      UEYE,
      DSHOW,
      V4L,
      KINECT,
      FREENECT2,
      INVALID
    };

    GrabSingleThread(BIAS::VideoSource  *cam,
                     wxCondition        *ClientCondition,
                     wxCondition        *ServerCondition,
                     wxMutex            *mutexClientCondition,
                     wxMutex            *mutexServerCondition,
                     unsigned int       threadNumber,
                     wxMutex            *BufferAccessMutex,
                     bool&              writeToBuffer,
                     unsigned int&      readIndex,
                     unsigned int&      writeIndex,

                     BIAS::Camera<unsigned char> *img,
                     BIAS::Camera<unsigned char> *imgCenter,
                     BIAS::Camera<unsigned char> *imgRight,
                     BIAS::Camera<float>         *imgDepth,
                     BIAS::Camera<float>         *imgAmp,
                     BIAS::Camera<float>         *imgInt,
                     BIAS::Camera<unsigned char> *imgAll,

                     std::vector<Camera<unsigned char>* > *imageBuffer,
                     std::vector<Camera<unsigned char>* > *imageBufferCenter,
                     std::vector<Camera<unsigned char>* > *imageBufferRight,
                     std::vector<Camera<float>* >*         imageBufferPMDDepth,
                     std::vector<Camera<float>* >*         imageBufferPMDAmp,
                     std::vector<Camera<float>* >*         imageBufferPMDInt);

    virtual ~GrabSingleThread(){};
    void    SetWriteToBuffer(bool buffer){*WriteToBuffer_ = buffer;};
    ExitCode Entry();
    void     OnExit() {};

  private:
    BIAS::VideoSource  *Cam_;
    bool               *WriteToBuffer_;
    wxMutex            *mutexClientCondition_;
    wxMutex            *mutexServerCondition_;
    wxCondition        *ClientCondition_;
    wxCondition        *ServerCondition_;
    unsigned int       threadNumber_;
    wxMutex            *BufferAccess_;
    unsigned int       *WriteIndex_;
    unsigned int       *ReadIndex_;
    unsigned int       BufferSize_;
    BIAS::Camera<unsigned char>*          Img_;
    BIAS::Camera<unsigned char>*          ImgCenter_;
    BIAS::Camera<unsigned char>*          ImgRight_;
    BIAS::Camera<unsigned char>*          AllImages_;
    BIAS::Camera<float>*                  ImgDepth_;
    BIAS::Camera<float>*                  ImgAmp_;
    BIAS::Camera<float>*                  ImgInt_;

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

    std::vector<Camera<float>* >*         ImageBufferPMDDepth_;
    std::vector<Camera<float>* >*         ImageBufferPMDAmp_;
    std::vector<Camera<float>* >*         ImageBufferPMDInt_;
    unsigned int camtype_;
  };


  /** ***************************************************************
     @class  GrabMasterThread
     @brief  Thread for synchronizing grabbing from multiple threads
     @author Falko Kellner
  */
  class GrabMasterThread : public wxThread
  {
  public:

    GrabMasterThread(std::vector<BIAS::VideoSource*> *Cameras,
                 std::vector<wxCondition*>        *ClientCondition,
                 std::vector<wxCondition*>        *ServerCondition,
                 std::vector<wxMutex*>            *mutexClientCondition,
                 std::vector<wxMutex*>            *mutexServerCondition
                     );

    virtual ~GrabMasterThread(){};
    ExitCode Entry();
    void     OnExit() {};
    double fps_;
    unsigned int FrameCounter_;

  private:
    std::vector<wxMutex*>            *mutexClientCondition_;
    std::vector<wxMutex*>            *mutexServerCondition_;
    std::vector<wxCondition*>        *ClientCondition_;
    std::vector<wxCondition*>        *ServerCondition_;
    std::vector<BIAS::VideoSource*> *Cameras_;

    TimeMeasure StopWatch_;
  };


} // end of namespace BIAS

#endif // __ShowCamWxThreads_hh__