DepthSensor.h

#ifndef NUITRACK_DEPTHSENSOR_H_
#define NUITRACK_DEPTHSENSOR_H_

#include <vector>

#include "nuitrack/modules/HeaderOnlyAPI_Module.h"
#include "nuitrack/ModuleFunctions.h"
#include "nuitrack/types/Export.h"
#include "nuitrack/utils/ExceptionTranslator.h"
#include "nuitrack/types/DepthFrame.h"
#include "nuitrack/types/Vector3.h"
#include "nuitrack/types/OutputMode.h"
#include "nuitrack/capi/Nuitrack_CAPI.h"
#include "nuitrack/capi/DepthSensor_CAPI.h"
#include "nuitrack/utils/CallbackStruct.h"

#include <iostream>

namespace tdv
{
namespace nuitrack
{
class DepthSensor :public tdv::nuitrack::HeaderOnlyAPI_Module
{
public:

    typedef std::shared_ptr<DepthSensor> Ptr;

    typedef std::function<void (DepthFrame::Ptr)> OnNewFrame;

    static DepthSensor::Ptr create()
    {
        NuitrackModule* pimpl = NULL;
        ExceptionType exception_code = nuitrack_CreateDepthSensor(&pimpl);
        char exception_message[1024];
        nuitrack_GetExceptionMessage(pimpl, exception_message, 1024);
        ExceptionTranslator::generateExceptionByErrorCode(exception_code, exception_message);
        return std::shared_ptr<DepthSensor>(new DepthSensor(pimpl));
    }

    DepthSensor(NuitrackModule* pimpl)
    {
        _pimpl = pimpl;

        _callbackStruct = new CallbackStruct<DepthFrame::Ptr>();
        _callbackWrapper.setDepthSensor(this);
        _callbackWrapper.setFunctionAddress(&onNewFrameCallback);
        nuitrack_registerDepthSensorCallback(_pimpl, &_callbackWrapper);
    }

    virtual ~DepthSensor()
    {
        nuitrack_DestroyDepthSensor(_pimpl);
        if(_callbackStruct)
            delete _callbackStruct;
    }

    const OutputMode getOutputMode() const
    {
        OutputMode mode;
        nuitrack_GetDepthSensorOutputMode(_pimpl, &mode);
        return mode;
    }

    bool isMirror() const
    {
        return nuitrack_IsDepthSensorMirror(_pimpl);
    }

    void setMirror(bool mirror)
    {
        nuitrack_SetDepthSensorMirror(_pimpl, mirror);
    }

    uint64_t connectOnNewFrame(const OnNewFrame& callback)
    {
        return _callbackStruct->addCallback(callback);
    }


    void disconnectOnNewFrame(uint64_t handler)
    {
        _callbackStruct->deleteCallback(handler);
    }

    DepthFrame::Ptr getDepthFrame()
    {
        DepthSensorDataPtr data = nuitrack_GetDepthSensorData(_pimpl);
        DepthFrame::Ptr newFrame = DepthFrame::Ptr(new DepthFrame(data));
        return newFrame;
    }

    Vector3 convertProjToRealCoords(const Vector3& p) const
    {
        return nuitrack_ConvertProjToRealCoordsVector3(_pimpl, p);
    }

    virtual Vector3 convertProjToRealCoords(size_t x, size_t y, DepthFrame::DataType depth) const
    {
        return nuitrack_ConvertProjToRealCoordsXYZ(_pimpl, x, y, depth);
    }

    virtual Vector3 convertRealToProjCoords(const Vector3& p) const
    {
        return nuitrack_ConvertRealToProjCoordsVector3(_pimpl, p);
    }

    virtual Vector3 convertRealToProjCoords(float x, float y, float z) const
    {
        return nuitrack_ConvertRealToProjCoordsXYZ(_pimpl, x, y, z);
    }

    bool canUpdate() const
    {
        return nuitrack_GetNuitrackModuleCanUpdate(_pimpl);
    }

    virtual uint64_t getTimestamp()
    {
        return nuitrack_GetNuitrackModuleTimestamp(_pimpl);
    }

private:

    static void onNewFrameCallback(DepthSensorData* depthFrameImpl, DepthSensor* sensor)
    {
        DepthFrame::Ptr newFrame = DepthFrame::Ptr(new DepthFrame(depthFrameImpl));
        sensor->_callbackStruct->executeAllCallbacks(newFrame);
    }

    NuitrackModule* _pimpl;

    DepthSensorCallbackWrapper _callbackWrapper;

    CallbackStruct<DepthFrame::Ptr>* _callbackStruct;


};

} /* namespace nuitrack */
} /* namespace tdv */

#endif /* NUITRACK_DEPTHSENSOR_H_ */