FusionCamera.hpp

#ifndef FUSION_CAMERA_HPP
#define FUSION_CAMERA_HPP
 
#include "DvsenseHal/camera/DvsCameraUtils.hpp"
#include "DvsenseHal/EventStream/RawEventStreamFormat.hpp"
#include "DvsenseBase/EventBase/EventTypes.hpp"
#include "DvsenseBase/ApsBase/ApsTypes.h"
#include "DvsenseBase/Utils/TypeUtils.hpp"
#include "DvsenseHal/camera/tools/CameraTool.h"
 
#ifdef _WIN32
#define DVSENSE_API __declspec(dllexport)
#else
#define DVSENSE_API
#endif // _WIN32
namespace dvsense
{
 
    class DvsCameraManager;
    class DVSENSE_API FusionCamera
    {
    private:
        friend DvsCameraManager;
 
    public:
        FusionCamera(CameraDescription cameraDesc)
        {
            cameraDesc_ = cameraDesc;
        };
 
        virtual const bool isConnected() = 0;
 
        const CameraDescription getDescription()
        {
            return cameraDesc_;
        }
 
        virtual uint32_t addEventsStreamHandleCallback(EventsStreamHandleCallback cb) = 0;
 
        virtual bool removeEventsStreamHandleCallback(uint32_t callback_id) = 0;
 
        virtual uint32_t addApsFrameCallback(FrameCallback cb) = 0;
 
        virtual bool removeApsFrameCallback(uint32_t callback_id) = 0;
 
        virtual uint32_t addSyncSignalCallback(DvsTriggerInCallback cb) = 0;
        
        virtual bool removeSyncSignalCallback(uint32_t callback_id) = 0;
        virtual bool getNextBatch(Event2DVector &event_batch) = 0;
 
        virtual void setBatchEventsNum(uint64_t n) = 0;
 
        virtual void setBatchEventsTime(TimeStamp n) = 0;
 
        virtual int start(STREAM_TYPE type = FUSION_STREAM) = 0;
 
        virtual int stop(STREAM_TYPE type = FUSION_STREAM) = 0;
 
        virtual int destroy() = 0;
 
        virtual int startRecording(std::string file_path, std::string file_name,  STREAM_TYPE stream_type = FUSION_STREAM) = 0;
        
        virtual int stopRecording(STREAM_TYPE stream_type = FUSION_STREAM) = 0;
 
        virtual uint16_t getWidth(STREAM_TYPE type = DVS_STREAM) = 0;
 
        virtual uint16_t getHeight(STREAM_TYPE type = DVS_STREAM) = 0;
 
        const std::vector<ToolInfo> getAllToolsInfo();
 
        const ToolInfo getToolInfo(ToolType type);
 
        const std::shared_ptr<CameraTool> getTool(ToolType type);
 
        const std::shared_ptr<CameraTool> getTool(std::string tool_name);
        
        virtual void setStatisticInfoCallback(DsStatisticInfoCallback cb) {};
 
        virtual bool writeCalibrationFile(std::string file_path) = 0;
 
        virtual bool readCalibrationParam(CalibratorParameters &param) = 0;
 
        virtual bool getFirmwareVersion(std::string &version) = 0;
 
        bool exportCameraConfigParams(std::string json_file_path);
 
        bool loadCameraConfigParams(std::string json_file_path);
 
    protected:
        CameraDescription cameraDesc_;
 
        virtual int init() = 0;
 
        // tools
        std::map<ToolType, std::shared_ptr<CameraTool>> tools_;
    };
 
} // namespace dvsense
 
#endif // FUSION_CAMERA_HPP