VideoSource_Kinect2.hh

#ifndef VIDEOSOURCE_KINECT2_HH
#define VIDEOSOURCE_KINECT2_HH

#include <VideoSource/VideoSource_Base.hh>
#include <Image/Camera.hh>
#include <libfreenect2/libfreenect2.hpp>
#include <libfreenect2/frame_listener.hpp>
#include <semaphore.h>

namespace BIAS
{
  /** @class VideoSource_Kinect2
      @brief Use the Kinect2 class to grab images from the Microsoft Kinect2.
      The VideoSource_Kinect2 allows you to grab the HD color camera image
      with GrabSingle(), the depth image with GrabSingleDepth(), and the IR
      image with GrabSingleIR().
      Before calling OpenDevice(), set a desired mode with SetMode() to
      control which images you want to grab. You have to grab all images in
      the mode you have selected initially.
      @author jordt 10/14, fkellner 03/15
   */
  class BIASVideoSource_EXPORT VideoSource_Kinect2
    : public VideoSource, public libfreenect2::FrameListener
  {
  public:

    enum Kinect2Mode {
      all = 0,    ///< get color, ir and depth images (default)
      depthAndIr, ///< get depth and ir only
      color       ///< get color only
    };

    VideoSource_Kinect2();

    virtual ~VideoSource_Kinect2();

    void SetMode(Kinect2Mode mode);

    /// Opens first device found, OpenDevice(0)
    /// @return Returns -1 if no device is available and -2 if an error happened while opening
    virtual int OpenDevice();

    /// Opens device by id. Use GetNumDevices() to determine the number of available Kinect2s
    /// @return Returns -1 if no device is available and -2 if an error happened while opening
    virtual int OpenDevice(int device);

    /// Close device, if no other kinect cameras are in use, context is deleted (i.e. close usb bus connection)
    virtual int CloseDevice();

    /// Start grabbing
    virtual int PreGrab();

    /// Stop grabbing
    virtual int PostGrab();

    /// kinect 2 color image will be 1920x1080, RGB.
    virtual int InitImage(BIAS::ImageBase &Image);

    /// kinect 2 depth image will be 512x424, float in Millimeters
    virtual int InitDepthImage(BIAS::ImageBase &Image);

    /// kinect 2 ir image will be 512x424, single channel unsigned char
    virtual int InitIrImage(BIAS::ImageBase &Image);

    /// all kinect 2 ir phase images in 512x242, nine channel float
    virtual int InitIrFullImage(ImageBase &Image);

    /// grab single color image. Note: This image has already been jpeg compressed
    virtual int GrabSingle(BIAS::Camera <unsigned char> &image);

    /// grab the raw ir data dump (very fast).
    //virtual int GrabSingleRawIrData(Kinect2RawIrData &data);

    /// grab the raw ir data dump (very fast). It contains a 11 bit information for each of the
    /// 512*424 pixels + 1 bit magic, so the complete data dump has the size of
    /// 512*424*11/8 = 298496 bytes. This function expects this memory already allocated.
    //virtual int GrabSingleRawIrData(unsigned char* data);

    /// grab the ir sum image computed from the phase images.
    virtual int GrabSingleIR(BIAS::Camera <float> &image);

    /// grab all raw ir images (fast) as a 9 channel float image. The image contains 3 phase
    /// images for each of the 3 frequencies.
    virtual int GrabSingleIRFull(BIAS::Camera <float> &image);

    /// grab the depth image (slow). Use this function only if no high framerates are required, since
    /// the conversion from ir to depth image is done on the cpu and requires a lot computation.
    virtual int GrabSingleDepth(BIAS::Camera <float> &image);

    /// Return the number of available Kinect 2 devices
    virtual int GetNumDevices();

    /// No standard capabilities here
    virtual int GetCapabilities(VideoSourceCapabilities &caps);

    /// No standard capabilities here
    virtual int GetCapabilities(const char *device, VideoSourceCapabilities &caps);

    virtual bool onNewFrame(libfreenect2::Frame::Type type, libfreenect2::Frame *frame);

  private:

    static libfreenect2::Freenect2 *freenect2_;
    libfreenect2::Freenect2Device *dev_;
    libfreenect2::PacketPipeline *pipeline_;

    static const int buffersize_ = 4;

    class imbuffer
    {
    public:
      imbuffer() : curProd(0), curCons(0) {
        sem_init(&sProd,true,buffersize_);
        sem_init(&sCons,true,0);
        for (int i=0;i<buffersize_;i++) buffer[i].Init(512,424,1);
      }
      Image<float> buffer[buffersize_];
      sem_t sProd;
      sem_t sCons;
      int curProd, curCons;
    };

    // unused, but for later
    class colorbuffer
    {
    public:
      colorbuffer() : curProd(0), curCons(0) {
        sem_init(&sProd,true,buffersize_);
        sem_init(&sCons,true,0);
        for (int i=0;i<buffersize_;i++) buffer[i].Init(1920,1080,3);
      }
      Image<unsigned char> buffer[buffersize_];
      sem_t sProd;
      sem_t sCons;
      int curProd, curCons;
    };

    imbuffer depthbuffer_;
    imbuffer irbuffer_;
    colorbuffer colorbuffer_;

    Kinect2Mode grabMode_;

    int numDevices_;
  };

}

#endif // VIDEOSOURCE_KINECT2_HH