KinectInterface.h

Go to the documentation of this file.

/*
 * This file is part of the OpenKinect Project. http://www.openkinect.org
 *
 * Copyright (c) 2010 individual OpenKinect contributors. See the CONTRIB file
 * for details.
 *
 * This code is licensed to you under the terms of the Apache License, version
 * 2.0, or, at your option, the terms of the GNU General Public License,
 * version 2.0. See the APACHE20 and GPL2 files for the text of the licenses,
 * or the following URLs:
 * http://www.apache.org/licenses/LICENSE-2.0
 * http://www.gnu.org/licenses/gpl-2.0.txt
 *
 * If you redistribute this file in source form, modified or unmodified, you
 * may:
 *   1) Leave this header intact and distribute it under the same terms,
 *      accompanying it with the APACHE20 and GPL20 files, or
 *   2) Delete the Apache 2.0 clause and accompany it with the GPL2 file, or
 *   3) Delete the GPL v2 clause and accompany it with the APACHE20 file
 * In all cases you must keep the copyright notice intact and include a copy
 * of the CONTRIB file.
 *
 * Binary distributions must follow the binary distribution requirements of
 * either License.
 */

//----------------------------------------------------------------------------------------------------------------------
//----------------------------------------------------------------------------------------------------------------------

#ifndef QKINECT_H__
#define QKINECT_H__
#include <QObject>
#include <QThread>
#include <stdexcept>
#include <QMutex>
#include <QMutexLocker>
#include <vector>
#include <libfreenect.h>
#include "opencv2/opencv.hpp"

//----------------------------------------------------------------------------------------------------------------------
//----------------------------------------------------------------------------------------------------------------------

class QKinectProcessEvents : public QThread
{
public :
    //----------------------------------------------------------------------------------------------------------------------
    //----------------------------------------------------------------------------------------------------------------------
    inline QKinectProcessEvents(
                                                            freenect_context *_ctx
                                                         )
                                                            {m_ctx=_ctx;}
    //----------------------------------------------------------------------------------------------------------------------
    //----------------------------------------------------------------------------------------------------------------------
    inline void setActive(){m_active=true;}
    //----------------------------------------------------------------------------------------------------------------------
    //----------------------------------------------------------------------------------------------------------------------
    inline void setInActive(){m_active=false;}
protected :
    //----------------------------------------------------------------------------------------------------------------------
    //----------------------------------------------------------------------------------------------------------------------
    void run();

private :
    //----------------------------------------------------------------------------------------------------------------------
    //----------------------------------------------------------------------------------------------------------------------
    bool m_active;
    //----------------------------------------------------------------------------------------------------------------------
    //----------------------------------------------------------------------------------------------------------------------
    freenect_context *m_ctx;
};

//----------------------------------------------------------------------------------------------------------------------
//----------------------------------------------------------------------------------------------------------------------

class KinectInterface : public QObject
{
// must include this macro so we inherit all the core QT features such as singnals and slots
Q_OBJECT
public :

    //----------------------------------------------------------------------------------------------------------------------
    //----------------------------------------------------------------------------------------------------------------------
    static KinectInterface *instance();
    //----------------------------------------------------------------------------------------------------------------------
    //----------------------------------------------------------------------------------------------------------------------
    inline void setUserDeviceNumber(int _m) {m_userDeviceNumber=_m;}
    //----------------------------------------------------------------------------------------------------------------------
    //----------------------------------------------------------------------------------------------------------------------
    void shutDownKinect();

    //----------------------------------------------------------------------------------------------------------------------
    //----------------------------------------------------------------------------------------------------------------------
    void setBoxObject(int _topX,int _topY, int _width, int _height);

    //----------------------------------------------------------------------------------------------------------------------
    //----------------------------------------------------------------------------------------------------------------------
    void setBoundsDefined(bool _isBoundsDefined);

    //----------------------------------------------------------------------------------------------------------------------
    //----------------------------------------------------------------------------------------------------------------------
    cv::Rect& getBoxObject();

    //----------------------------------------------------------------------------------------------------------------------
    //----------------------------------------------------------------------------------------------------------------------
    void toggleTracking();

    //----------------------------------------------------------------------------------------------------------------------
    //----------------------------------------------------------------------------------------------------------------------
    bool getTrackingFlag();

    //----------------------------------------------------------------------------------------------------------------------
    //----------------------------------------------------------------------------------------------------------------------
    bool getBounds();


public slots :

    //----------------------------------------------------------------------------------------------------------------------

    //----------------------------------------------------------------------------------------------------------------------
    void setVideoMode(
                                        int _mode
                                     );

    //----------------------------------------------------------------------------------------------------------------------
    //----------------------------------------------------------------------------------------------------------------------
    bool getDepth(cv::Mat &o_buffer
                             );
    //----------------------------------------------------------------------------------------------------------------------
    //----------------------------------------------------------------------------------------------------------------------
    bool getDepthRaw(
                                     cv::Mat &o_buffer, float *o_depthinmBuffer
                                    );
    //----------------------------------------------------------------------------------------------------------------------
    //----------------------------------------------------------------------------------------------------------------------
    bool getDepth16Bit(cv::Mat &o_buffer
                                        );


    bool getDepthSliced(cv::Mat &o_buffer
                                        );
    //----------------------------------------------------------------------------------------------------------------------
    //----------------------------------------------------------------------------------------------------------------------
    bool getRGB(cv::Mat &o_buffer );
    //----------------------------------------------------------------------------------------------------------------------
    //----------------------------------------------------------------------------------------------------------------------
    void startDepth();
    //----------------------------------------------------------------------------------------------------------------------
    //----------------------------------------------------------------------------------------------------------------------
    void stopDepth();
    //----------------------------------------------------------------------------------------------------------------------
    //----------------------------------------------------------------------------------------------------------------------
    void startVideo();
    //----------------------------------------------------------------------------------------------------------------------
    //----------------------------------------------------------------------------------------------------------------------
    void stopVideo();
    //----------------------------------------------------------------------------------------------------------------------
    //----------------------------------------------------------------------------------------------------------------------
    void toggleVideoState(
                                                bool _mode
                                             );
    //----------------------------------------------------------------------------------------------------------------------
    //----------------------------------------------------------------------------------------------------------------------
    void toggleDepthState(
                                                bool _mode
                                             );
    //----------------------------------------------------------------------------------------------------------------------
    //----------------------------------------------------------------------------------------------------------------------
    inline freenect_context *getContext(){return m_ctx;}


    void setDepthVolumeLower(double _inputLowerDepth);


    void setDepthVolumeHigher(double _inputHigherDepth);




private :
    //----------------------------------------------------------------------------------------------------------------------
    //----------------------------------------------------------------------------------------------------------------------
    KinectInterface();
    //----------------------------------------------------------------------------------------------------------------------
    //----------------------------------------------------------------------------------------------------------------------
    ~KinectInterface();
    //----------------------------------------------------------------------------------------------------------------------
    //----------------------------------------------------------------------------------------------------------------------
    Q_DISABLE_COPY(KinectInterface)
    //----------------------------------------------------------------------------------------------------------------------
    //----------------------------------------------------------------------------------------------------------------------
    bool init();
    //----------------------------------------------------------------------------------------------------------------------
    //----------------------------------------------------------------------------------------------------------------------
    static KinectInterface *s_instance;
    //----------------------------------------------------------------------------------------------------------------------
    //----------------------------------------------------------------------------------------------------------------------
    freenect_context *m_ctx;
    //----------------------------------------------------------------------------------------------------------------------
    //----------------------------------------------------------------------------------------------------------------------
    freenect_device *m_dev;
    //----------------------------------------------------------------------------------------------------------------------
    //----------------------------------------------------------------------------------------------------------------------
    int m_userDeviceNumber;

    //----------------------------------------------------------------------------------------------------------------------
    //----------------------------------------------------------------------------------------------------------------------
    cv::Mat m_bufferDepth;
    //----------------------------------------------------------------------------------------------------------------------
    //----------------------------------------------------------------------------------------------------------------------
    cv::Mat m_bufferVideo,m_nextBuffer,m_prevBuffer, m_diffBuffer, m_bufferVideoGray;
    //----------------------------------------------------------------------------------------------------------------------
    //----------------------------------------------------------------------------------------------------------------------
    cv::Mat m_bufferDepthRaw;

    float  m_bufferDepthinM[640 * 480];

    //std::map<int, float[640*480]> m_originalFrameDepth1;
    //----------------------------------------------------------------------------------------------------------------------
    //----------------------------------------------------------------------------------------------------------------------
    cv::Mat m_bufferDepthRaw16;

    //----------------------------------------------------------------------------------------------------------------------
    //----------------------------------------------------------------------------------------------------------------------
    std::vector<float> m_gamma;
    //----------------------------------------------------------------------------------------------------------------------
    //----------------------------------------------------------------------------------------------------------------------
    bool m_newRgbFrame;
    //----------------------------------------------------------------------------------------------------------------------
    //----------------------------------------------------------------------------------------------------------------------
    bool m_newDepthFrame;
    //----------------------------------------------------------------------------------------------------------------------
    //----------------------------------------------------------------------------------------------------------------------
    bool m_stopDevice;
    //----------------------------------------------------------------------------------------------------------------------
    //----------------------------------------------------------------------------------------------------------------------
    bool m_deviceActive;

  //----------------------------------------------------------------------------------------------------------------------
  //----------------------------------------------------------------------------------------------------------------------
  unsigned int m_resolutionRGBBytes;
  //----------------------------------------------------------------------------------------------------------------------
  //----------------------------------------------------------------------------------------------------------------------
  unsigned int m_resolutionDepthBytes;

    //----------------------------------------------------------------------------------------------------------------------
    //----------------------------------------------------------------------------------------------------------------------
    QKinectProcessEvents *m_process;
    //----------------------------------------------------------------------------------------------------------------------
    //----------------------------------------------------------------------------------------------------------------------
    QMutex m_mutex;


    int m_threshValue;

    double m_depthLower, m_depthHigher;

    cv::Rect m_selectedBoxCoords;

    bool m_toggleTracking,m_setBounds;


    //----------------------------------------------------------------------------------------------------------------------
    //----------------------------------------------------------------------------------------------------------------------
    void depthFunc(
                                    freenect_device *_dev,
                                    void *o_depth,
                                    uint32_t _timestamp
                                );
    //----------------------------------------------------------------------------------------------------------------------
    //----------------------------------------------------------------------------------------------------------------------
    void rgbFunc(
                                freenect_device *_dev,
                                void *o_rgb,
                                uint32_t _timestamp
                            );


    //----------------------------------------------------------------------------------------------------------------------
    //----------------------------------------------------------------------------------------------------------------------
    void grabDepth(
                                    void *_depth,
                                    uint32_t timestamp
                                );
    //----------------------------------------------------------------------------------------------------------------------
    //----------------------------------------------------------------------------------------------------------------------
    void grabVideo(
                                    void *_video,
                                    uint32_t timestamp
                                );
    //----------------------------------------------------------------------------------------------------------------------
    //----------------------------------------------------------------------------------------------------------------------
    static inline void depthCallback(
                                                                     freenect_device *_dev,
                                                                     void *_depth,
                                                                     uint32_t _timestamp=0
                                                                    )
    {
        Q_UNUSED(_dev);

        KinectInterface *kinect=KinectInterface::instance();
        kinect->grabDepth(_depth,_timestamp);
    }
    //----------------------------------------------------------------------------------------------------------------------
    //----------------------------------------------------------------------------------------------------------------------

    static inline void videoCallback(
                                                                     freenect_device *_dev,
                                                                     void *_video,
                                                                     uint32_t _timestamp=0
                                                                    )
    {
        Q_UNUSED(_dev);

        KinectInterface *kinect=KinectInterface::instance();
        kinect->grabVideo(_video, _timestamp);
    }




};



#endif