xv-sdk.h

#pragma once

#include <map>
#include <functional>

#include "xv-types.h"

namespace xv {

class Device;


template <typename T>
class Stream {
public:

 using Data = T;

 virtual bool start() = 0;
 virtual bool stop() = 0;

 virtual int registerCallback(std::function<void (T)>) = 0;
 virtual bool unregisterCallback(int callbackId) = 0;

};

class Camera {
public:

 virtual const std::vector<Calibration>& calibration();

 // TODO add more settings like AWB in later release
 virtual bool setResolution( int resolution );
 virtual bool setFramerate( float framerate );

 // aecMode 0:auto 1:manual
 virtual bool setExposure( int aecMode = 0, int exposureGain = 0, float exposureTimeMs = 0.0 );

 virtual bool setBrightness( int brightness );

 virtual ~Camera(){}
};

class ImuSensor : virtual public Stream<Imu const &> {
public:

 virtual ~ImuSensor(){}
};

class EventStream : virtual public Stream<Event const &> {
public:

 virtual ~EventStream(){}
};

class OrientationStream : virtual public Stream<Orientation const &> {
public:

 virtual bool get(Orientation& pose, double prediction = 0.) = 0;

 virtual bool getAt(Orientation& pose, double timestamp) = 0;
 virtual ~OrientationStream(){}
};

class FisheyeCameras : virtual public Stream<FisheyeImages const &>, virtual public Camera {
public:
 virtual ~FisheyeCameras(){}
};

class Display {
public:

 virtual const std::vector<Calibration>& calibration() = 0;

 virtual bool open() = 0;

 virtual bool close() = 0;

 virtual bool setBrightnessLevel( int level ) = 0;
};

class ColorCamera : virtual public Stream<ColorImage const &>, virtual public Camera {
public:
 enum class Resolution {
 RGB_1920x1080 = 0, 
 RGB_1280x720 = 1, 
 RGB_640x480 = 2, 
 RGB_320x240 = 3, 
 RGB_2560x1920 = 4, 
 RGB_3840x2160 = 5,
 };

 virtual bool setResolution( const Resolution &resolution ) = 0;

 virtual ~ColorCamera(){}
};

class TofCamera : virtual public Stream<DepthImage const &>, virtual public Camera {
public:
 enum class StreamMode { DepthOnly = 0, CloudOnly, DepthAndCloud, None, CloudOnLeftHandSlam};
 enum class DistanceMode { Short = 0, Middle, Long };
 enum class SonyTofLibMode { IQMIX_DF ,IQMIX_SF, LABELIZE_DF ,LABELIZE_SF ,M2MIX_DF ,M2MIX_SF };
 enum class Framerate{ FPS_5 ,FPS_10 ,FPS_15 ,FPS_20 ,FPS_25 ,FPS_30 };
 enum class Resolution{ Unknown = -1,VGA = 0 ,QVGA ,HQVGA};
 enum class Manufacturer {Unknown = -1, Pmd = 0, Sony};

 virtual int registerColorDepthImageCallback(std::function<void(const DepthColorImage&)>) = 0;
 virtual bool unregisterColorDepthImageCallback(int callbackId) = 0;

 virtual std::shared_ptr<PointCloud> depthImageToPointCloud(DepthImage const &) const = 0;

 virtual bool setStreamMode(StreamMode mode) = 0;

 virtual bool setDistanceMode(DistanceMode mode) = 0;

 virtual Resolution getResolution() = 0;

 virtual Manufacturer getManufacturer() = 0;

 virtual bool setLibWorkMode(SonyTofLibMode mode) = 0;

 virtual bool setMode(int mode) = 0;

 virtual bool setSonyTofSetting(SonyTofLibMode mode, Resolution resolution, Framerate frameRate) = 0;

 virtual void setFilterFile(std::string filePath) = 0;

 virtual ~TofCamera() {}
};

class Slam : virtual public Stream<Pose const&> {

public:
 enum class Mode { Edge = 0, Mixed, EdgeFusionOnHost };

 virtual Mode mode() const = 0;

 virtual bool start() override = 0;

 virtual bool start(Mode mode) = 0;

 virtual bool reset() = 0;

 virtual bool getPose(Pose& pose, double prediction = 0.) = 0;

 virtual bool getPoseAt(Pose& pose, double timestamp) = 0;

 virtual int registerVisualPoseCallback(std::function<void (const Pose&)> lostCallback) = 0;
 virtual bool unregisterVisualPoseCallback(int callbackId) = 0;
 #define XVSDK_HAS_SLAM_VISUAL_POSE_CALLBACK

 virtual int registerLostCallback(std::function<void ()> lostCallback) = 0;
 virtual bool unregisterLostCallback(int callbackId) = 0;

 virtual int registerStereoPlanesCallback(std::function<void (std::shared_ptr<const std::vector<Plane>>)> planeCallback) = 0;
 virtual bool unregisterStereoPlanesCallback(int callbackId) = 0;
 virtual bool clearStereoPlanes() = 0;

 virtual int registerTofPlanesCallback(std::function<void (std::shared_ptr<const std::vector<Plane>>)> planeCallback) = 0;
 virtual bool unregisterTofPlanesCallback(int callbackId) = 0;
 virtual bool clearTofPlanes() = 0;


 virtual int registerMapCallback(std::function<void (std::shared_ptr<const xv::SlamMap>)> mapCallback) = 0;
 virtual bool unregisterMapCallback(int callbackId) = 0;

 virtual bool loadMapAndSwitchToCslam(std::streambuf& mapStream, std::function<void(int /* status of load map */)> done_callback, std::function<void(float)> localized_on_reference_map={}) = 0;
 virtual bool saveMapAndSwitchToCslam(std::streambuf& mapStream, std::function<void(int /* status of save map */, int /* map quality */)> done_callback, std::function<void(float)> localized_on_reference_map={}) = 0;

 virtual ~Slam() {}
};

class ObjectDetector : virtual public Stream<std::vector<Object> const&> {
public:
 enum class Source { LEFT = 0, RIGHT, RGB, TOF };

 virtual bool setDescriptor( const std::string &filepath ) = 0;
 virtual bool setModel( const std::string &filepath ) = 0;
 virtual bool setSource( const Source &source ) = 0;
 virtual xv::ObjectDetector::Source getSource() const = 0;
 virtual xv::ObjectDescriptor getDescriptor() const = 0;

 virtual int registerCnnRawCallback(std::function<void (std::shared_ptr<CnnRawWrapper> const&)> poseCallback) = 0;
 virtual bool unregisterCnnRawCallback(int callbackId) = 0;

 virtual ~ObjectDetector() {}
};

class SgbmCamera : virtual public Stream<SgbmImage const &>, virtual public Camera {
public:

 enum class Mode { Hardware = 0, Software };
 virtual Mode mode() const = 0;

 virtual bool start(const std::string &sgbmConfig) = 0;
 virtual bool start(const sgbm_config &sgbmConfig) = 0;
 virtual bool setConfig(const std::string &sgbmConfig) = 0;

 virtual std::shared_ptr<PointCloud> depthImageToPointCloud(SgbmImage const &sgbmImage) const = 0;
 virtual ~SgbmCamera() {}
};

class ThermalCamera : virtual public Stream<ThermalImage const &>, virtual public Camera {
public:

 enum class Mode { TEMPERATURE = 0, TEMPERTURE = 0, GREY };
 virtual bool setMode( Mode mode ) = 0;
 virtual ~ThermalCamera() {}
};

class EyetrackingCamera : virtual public Stream<EyetrackingImage const &>, virtual public Camera {
public:

 virtual bool setExposure( int leftGain, float leftTimeMs, int rightGain, float rightTimeMs ) = 0;

 virtual bool setLedBrighness( int eye, int led, int brightness ) = 0;

 virtual ~EyetrackingCamera() {}
};

class GazeStream : virtual public Stream<XV_ET_EYE_DATA_EX const &>{
public:

 virtual ~GazeStream() {}
};

class GestureStream : virtual public Stream<GestureData const &> {
public:

 virtual int registerDynamicGestureCallback(std::function<void (GestureData const &)>) = 0;
 virtual bool UnregisterDynamicGestureCallback(int callbackID) = 0;

 virtual int registerKeypointsCallback(std::function<void (std::shared_ptr<const std::vector<keypoint>>)> callback) = 0;
 virtual bool unregisterKeypointsCallback(int callbackId) = 0;

 virtual int registerSlamKeypointsCallback(std::function<void (std::shared_ptr<const std::vector<keypoint>>)> callback) = 0;
 virtual bool unregisterSlamKeypointsCallback(int callbackId) = 0;

 virtual void setConfigPath(std::string config) = 0;

 virtual ~GestureStream() {}
};

class GestureStreamEX : virtual public Stream<GestureData const &>{
public:

 virtual bool start(void* jvm) = 0;

 virtual int registerPosCallback(std::function<void (std::shared_ptr<const std::vector<xv::Pose>>)> callback) = 0;
 virtual bool unregisterPosCallback(int callbackId) = 0;

 virtual GestureData getGesture(xv::Pose pose, double timestamp) = 0;

 virtual std::vector<xv::Pose> GetGesturePose(xv::Pose pose, double timestamp) = 0;

 virtual ~GestureStreamEX() {}
};

class MicStream : virtual public Stream<MicData const &> {
public:

 virtual ~MicStream() {}
};

class Speaker {
public:

 virtual bool enable() = 0;
 virtual bool disable() = 0;
 virtual int send(const std::uint8_t *data, int len) = 0;

 virtual bool play(const std::string &path) = 0;
 virtual bool play(const std::uint8_t *data, int len) = 0;
 virtual bool isPlaying() = 0;
 virtual int registerPlayEndCallback( std::function<void ()> ) = 0;
 virtual bool unregisterPlayEndCallback( int callbackId ) = 0;

 virtual ~Speaker() {}
};

class DeviceStatusStream : virtual public Stream<std::vector<unsigned char> const &> {
public:

 virtual ~DeviceStatusStream(){}
};


class Device {

public:


 virtual std::map<std::string, std::string> info() = 0;

 virtual std::shared_ptr<Slam> slam() = 0;

 virtual std::shared_ptr<ImuSensor> imuSensor() = 0;

 virtual std::shared_ptr<EventStream> eventStream() = 0;

 virtual std::shared_ptr<OrientationStream> orientationStream() = 0;

 virtual std::shared_ptr<FisheyeCameras> fisheyeCameras() = 0;

 virtual std::shared_ptr<ColorCamera> colorCamera() = 0;

 virtual std::shared_ptr<TofCamera> tofCamera() = 0;

 virtual std::shared_ptr<SgbmCamera> sgbmCamera() = 0;

 virtual std::shared_ptr<ThermalCamera> thermalCamera() = 0;

 virtual std::shared_ptr<EyetrackingCamera> eyetracking() = 0;

 virtual std::shared_ptr<GazeStream> gaze() = 0;

 virtual std::shared_ptr<GestureStream> gesture() = 0;

 virtual std::shared_ptr<GestureStreamEX> gestureEX() = 0;

 virtual std::shared_ptr<MicStream> mic() = 0;

 virtual std::shared_ptr<Speaker> speaker() = 0;

 virtual std::shared_ptr<Display> display() = 0;

 virtual std::shared_ptr<ObjectDetector> objectDetector() = 0;

 virtual std::shared_ptr<DeviceStatusStream> deviceStatus() = 0;

 virtual bool sleep(int level = 0) = 0;
 virtual bool wakeup() = 0;

 virtual bool control(const DeviceSetting &setting) = 0;

 virtual bool hidWriteAndRead(const std::vector<unsigned char> &command, std::vector<unsigned char> &result) = 0;
 virtual bool uvcWriteAndRead(const std::vector<unsigned char> &command, std::vector<unsigned char> &result) = 0;
 virtual bool vscWriteAndRead(const std::vector<unsigned char> &command, std::vector<unsigned char> &result) = 0;

 virtual bool enableSync(bool isEnable) = 0;

 virtual std::string id() const = 0;

 virtual ~Device(){}

};


Version version();

std::map<std::string,std::shared_ptr<Device>> getDevices(double timeOut = 0., const std::string& desc = "", bool* stopWaiting = nullptr);

void setLogLevel(LogLevel l);

int registerPlugEventCallback(const std::function<void (std::shared_ptr<Device> device, PlugEventType type)> &Callback, const std::string& desc = "");
bool unregisterHotplugCallback( int callbackID );

std::shared_ptr<Device> getDevice(int fd);
std::shared_ptr<Device> getDevice(int fd, std::string const& desc);

bool detachDevice(int fd );

std::string getDefaultDescription();

void getUTCTIme(DateTime* utc);

}