VideoSource_uEye.hh

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

Copyright (C) 2003-2015 (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 __BIASVIDEOSOURCE_UEYE_HH__
#define __BIASVIDEOSOURCE_UEYE_HH__

#include <bias_config.h>
#ifdef WIN32
#  include <windows.h>
#endif

#include <uEye.h>
#include <Image/Camera.hh>
#include <VideoSource/VideoSource_Base.hh>

#include <pthread.h>
#include <semaphore.h>

namespace BIAS
{
  /** 
      \class VideoSource_uEye
      \ingroup g_videosource
      \author ischiller
      \brief This class extends VideoSource for the use of IDS uEye devices.
  */
  class BIASVideoSource_EXPORT VideoSource_uEye : public VideoSource
  {
  public:

    VideoSource_uEye();

    std::vector<std::string> GetDevices();

    ~VideoSource_uEye();

    int OpenDevice();
    int OpenDevice(const char *dev);
    int CloseDevice();

    int GrabSingle(BIAS::Camera <unsigned char>  &image);
    int InitImage(BIAS::ImageBase &Image);
  
    int PreGrab();
    int PostGrab();
  
    /** @brief Use mode 0 to disable, 1 for weak, and 2 for strong enhancement.
        @author ischiller
     */
    int SetEdgeEnhancement(int mode);

    virtual void SetExternalTriggerMode(unsigned int mode);
    virtual void SetExternalTrigger(bool trigger = true);
    virtual void SetExternalTriggerDelay(unsigned int delay);

    virtual bool HasControlShutter();
    virtual int SetShutter(float exptime); // shutter is given in seconds
    virtual float GetShutter();

    int SetExposure(float exptime); // same as shutter
    float GetExposure();

    virtual bool HasControlGain();
    virtual void SetAutoGain(bool autoGain);
    virtual bool GetAutoGain();
    virtual int SetGain(float g);
    virtual float GetGain();

    virtual bool HasControlWhiteBalance();
    virtual int SetWhiteBalance(float rvalue,float bvalue);
    virtual int GetWhiteBalance(float &rvalue,float &bvalue);
    virtual void GetWhiteBalanceRange(float &bmin,float &bmax);
    virtual void OnePushWhiteBalance();

    virtual bool HasControlBrightness(); // this is hardware gamma
    virtual int SetBrightness(float bright);
    virtual float GetBrightness();
    virtual void GetBrightnessRange(float &min, float &max);
    virtual bool GetAutoBrightness();
    virtual void SetAutoBrightness(bool autoBrightness);

  protected:

    int GetPixelClock_() const;
    void SetPixelClock_(int value);

    /** @brief Defines a structure describing a uEye camera instance. */
    struct CuEye
    {
      std::string name;
      DWORD   camId;
      DWORD   deviceId;
      std::string model;
      std::string serNo;
      bool    available;
      HIDS    hCam;
      char*   pImageMem;
      int     nImageID;
      int     RenderMode;
      SENSORINFO SensorInfo;
      CAMINFO CamInfo;
      int     nBitsPerPixel;
      bool    bLive;
      bool    bOpened;
    };

    static bool sortBySerial_(const VideoSource_uEye::CuEye a, const VideoSource_uEye::CuEye b);
    static int ScanBus();
    static std::vector<CuEye> cams_;

    CuEye cam_;
 
    unsigned int pixelClock_;
    unsigned int pixelClockMin_, pixelClockMax_, pixelClockInc_, pixelClockDefault_;

    std::vector< char* > imageBuffer_;
    int camBufferId_;
    char *camBuffer_;

    int prodBufferIdx_;
    int consBufferIdx_;
    int bytesize_;
    int triggerMode_;

#ifdef WIN32
    HANDLE hEvent_;
#endif

    /** @brief Defines a thread for asynchronous uEye camera capturing. */
    class UeyeGrabThread
    {
    public:
      UeyeGrabThread(VideoSource_uEye *parent);
      virtual ~UeyeGrabThread();
      static void* run(void *parent);
      void start();
      void stop();
      bool isRunning();
    protected:
      pthread_t *thread_;
      VideoSource_uEye *parent_;
      bool stopRequest_;
      bool isRunning_;
    };

    UeyeGrabThread grabThread_;

    sem_t prodsem_, conssem_;

    bool isMaster_;

  };

}
#endif