xv-sdk.h

#pragma once
 
#include <map>
#include <functional>
#if defined( __ANDROID__ )
#include "jni.h" 
#endif
#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 int registerAntiDistortionCallback(std::function<void (FisheyeImages const &)> cb ) = 0;
    virtual bool unregisterAntiDistortionCallback( int callbackID ) = 0;
 
    virtual bool checkAntiDistortionSupport() = 0;
 
    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,
    };
 
    enum class Mode {
        AF,
        MF,
        Unknown
    };
 
    virtual bool setCompensation(int compensation) = 0;
    virtual bool setAwb(int awb) = 0;
    virtual bool setResolution( const Resolution &resolution ) = 0;
    virtual bool isSupportAFRGB() = 0;
    virtual bool setRGBMode(const Mode &mode) = 0;
    virtual bool setRGBFocalDistance(unsigned char distance) = 0;
    virtual bool startCameras(int camIndex = 1) = 0;
    virtual bool stopCameras(int camIndex = 1) = 0;
    virtual bool setCamsResolution(const xv::ColorCamera::Resolution & resolution, int camIndex = 1) = 0;
    virtual bool setCamsFramerate(float framerate, int camIndex = 1) = 0;
    virtual int registerCam2Callback(std::function<void (ColorImage const &)> c ) = 0;
    virtual bool unregisterCam2Callback( int callbackID ) = 0;
    virtual const std::vector<Calibration>& calibration2() = 0;
    virtual bool checkCam2Support() = 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};
    enum class ColorDepthBase { RGB = 0, TOF = 1 };
    
    virtual bool setColorDepthBase(ColorDepthBase base) = 0;
    virtual ColorDepthBase getColoerDepthBase() = 0;
    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 std::shared_ptr<PointCloud> formatPmdCloudToPointCloudStruct(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 enableTofIr(bool enable) = 0;
 
    virtual bool setMode(int mode) = 0;
 
    virtual bool setSonyTofSetting(SonyTofLibMode mode, Resolution resolution, Framerate frameRate) = 0;
 
    virtual void setTofIrGamma(double gamma) = 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 pause() = 0;
 
    virtual bool resume() = 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 Pose poseScaleCalibration(const Pose& pose) = 0;
 
    virtual void poseReset() = 0;
    
    virtual int registerSharedMapCallback(std::function<void (std::vector<uint8_t> const&)> cb) = 0;
    
    virtual bool unregisterSharedMapCallback(int callbackId) = 0;
 
    virtual const std::vector<uint8_t>& getFirstSharedMap() = 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 ObjectDetectorRKNN3588 : virtual public Stream<std::vector<Det2dObject> const&> {
public:
    virtual bool setModel( const std::string &filepath ) = 0;
    virtual ~ObjectDetectorRKNN3588() {}
};
 
class SgbmCamera : virtual public Stream<SgbmImage const &>, virtual public Camera {
public:
    enum class Resolution {
        SGBM_640x480   = 0,  
        SGBM_1280x720  = 1,  
    };
    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 bool setSgbmResolution(const xv::SgbmCamera::Resolution & resolution) = 0;
    virtual xv::SgbmCamera::Resolution getSgbmResolution() = 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 BeiDouGPS : virtual public Stream<BeiDouGPSData const &>
{
public:
    virtual bool setMode(BeiDouGPSMode mode) = 0;
    virtual ~BeiDouGPS(){};
};
 
 
class GazeStream : virtual public Stream<XV_ET_EYE_DATA_EX const &>{
public:
 
    virtual void setConfigPath(std::string config) = 0;
 
    virtual void setUsrEyeReady() = 0;
 
    virtual void setGazeConfigs(GazeConfigs configs) = 0;
 
    virtual bool getGazeStatus() = 0;
 
    virtual void enableDump(bool enable) = 0;
 
    virtual ~GazeStream() {}
};
 
class IrisStream : virtual public Stream<XV_IRIS_DATA const &>{
public:
 
#if defined( __ANDROID__ )
    virtual bool start(JNIEnv* env, jobject thiz, std::string offlineS) = 0;
 
    virtual const char* onlineActive(JNIEnv *env, jobject context, const char* initLicense, const char* userId, const char* secret, int &activeResult) = 0;
#endif
    virtual void setUserName(std::string name) = 0;
 
    virtual int registerEnrollCallback(std::function<void (XV_IRIS_DATA const &)>) = 0;
    virtual bool UnregisterEnrollCallback(int callbackID) = 0;
 
    virtual int registerIdentifyCallback(std::function<void (XV_IRIS_DATA const &)>) = 0;
    virtual bool UnregisterIdentifyCallback(int callbackID) = 0;
 
    virtual bool loadIrisInfo(unsigned char* iris_features, int size) = 0;
 
    virtual void setConfigPath(std::string config) = 0;
 
    virtual ~IrisStream() {}
};
 
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 xv::HandPose>)> callback) = 0;
    virtual bool unregisterSlamKeypointsCallback(int callbackId) = 0;
 
    virtual ~GestureStream() {}
 
    virtual bool setPlatform( int platform , bool ego) = 0;
};
 
class GPSStream : virtual public Stream<std::vector<unsigned char> const &>{
public:
    virtual ~GPSStream() {}
};
 
class GPSDistanceStream : virtual public Stream<GPSDistanceData const &>{
public:
 
    virtual ~GPSDistanceStream() {}
};
 
class TerrestrialMagnetismStream : virtual public Stream<TerrestrialMagnetismData const &>{
public:
 
    virtual ~TerrestrialMagnetismStream() {}
};
 
class ExternalStream : virtual public Stream<xv::Pose const &>{
public:
 
   virtual int  registerRawCallback( std::function<void (xv::ExternalData const &)> rawExternalCallback) = 0;
   virtual bool unregisterRawCallback( int callbackId ) = 0;
 
   virtual int  registerFixedPoseCallback( std::function<void (xv::Pose const &)> fixedExternalCallback) = 0;
   virtual bool unregisterFixedPoseCallback( int callbackId ) = 0;
 
   virtual int registerRuntimePoseCallback( std::function<void (xv::Pose const&)> runtimeExternalCallback) = 0;
   virtual bool unregisterRuntimePoseCallback(int callbackId) = 0;
 
   virtual int registerScaledPoseCallback( std::function<void (xv::Pose const&)> scaledExternalCallback) = 0;
   virtual bool unregisterScaledPoseCallback(int callbackId) = 0;
 
   virtual bool getPose(Pose& pose) = 0;
 
   virtual void SetScaleArrayRange(int range) = 0;
   virtual void setScaleRange(double low, double high) = 0;
 
   virtual Vector3d rotationToEuler(Matrix3d const& rot) = 0;
 
   virtual void setResetStatus(bool status) = 0;
   virtual void setDeviceStopStatus(bool status) = 0;
 
   virtual void setTransform(const xv::Transform& transform) = 0;
 
   virtual void resumeLastPose(xv::Pose pose) = 0;
 
   virtual ~ExternalStream() {}
};
 
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 WirelessController
{
public:
    WirelessController(){}
    
    virtual ~WirelessController(){}
    
    virtual void start() = 0;
    
    virtual void stop() = 0;
    
    virtual int registerWirelessControllerDataCallback(std::function<void (const WirelessControllerData&)> poseCallback) = 0;
 
    virtual bool unregisterWirelessControllerDataCallback( int callbackID ) = 0;
 
    virtual void scanBleDevices(std::function<void(std::map<std::string,std::string>)> scanCallback) = 0;
 
    virtual bool connectBleDevice(const std::string& name, const std::string& macAddr) = 0;
 
    virtual bool disconnectBleDevice(const std::string& name, const std::string& macAddr) = 0;
    
    virtual bool pairingLeftWirelessController(const std::string& name, const std::string&macAddr) = 0;
 
    virtual void pairingLeftWirelessController(std::function<void (bool result)> resultCallback) = 0;
 
    virtual bool pairingRightWirelessController(const std::string& name, const std::string&macAddr) = 0;
    
    virtual void pairingRightWirelessController(std::function<void (bool result)> resultCallback) = 0;
 
    virtual void setSerialPointName(const std::string& serialName) = 0;
 
    virtual bool uploadMap(const std::string& mapName, WirelessControllerDataType type,std::function<void (bool)> const &callback) = 0;
 
    virtual void controlTest(bool enable, const WirelessControllerDataType& type,  std::function<void (float, WirelessControllerDataType)> const &callback = nullptr) = 0;
    
    virtual void putSharedMap(const std::vector<uint8_t>& buffer) = 0;
 
    virtual void putFirstSharedMap(const std::vector<uint8_t>& buffer) = 0;
 
    virtual bool changeSlamType(const WirelessControllerSlamType slamType, const WirelessControllerDataType deviceType) = 0;
 
    virtual void enableHeartBeat(bool enable) = 0;
 
    virtual bool registerSlam(const std::shared_ptr<Slam>& slam) = 0;
 
    virtual WirelessControllerSlamType getSlamType(const WirelessControllerDataType deviceType) = 0;
 
    virtual int registerWirelessControllerStateCallback(std::function<void (const WirelessControllerState &state)> callback) = 0;
 
    virtual bool unregisterWirelessControllerStateCallback( int callbackID ) = 0;
 
    virtual int testTransmissionTime(WirelessControllerDataType type) = 0;
 
    virtual void getWirelessControllerDeviceInformation(WirelessControllerDeviceInformation& information, const WirelessControllerDataType& deviceType) = 0;
    
    virtual void controlControllerVibration(int time, bool enable, const WirelessControllerDataType& deviceType) = 0;
};
 
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<IrisStream> iris() = 0;
 
    virtual std::shared_ptr<GestureStream> gesture() = 0;
 
    virtual std::shared_ptr<GPSStream> gpsModule() = 0;
 
    virtual std::shared_ptr<GPSDistanceStream> gpsDistanceModule() = 0;
 
    virtual std::shared_ptr<TerrestrialMagnetismStream> terrestrialMagnetismModule() = 0;
 
    virtual std::shared_ptr<ExternalStream> externalSensor() = 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<ObjectDetectorRKNN3588> objectDetectorRKNN3588() = 0;
 
    virtual std::shared_ptr<DeviceStatusStream> deviceStatus() = 0;
 
    virtual std::shared_ptr<WirelessController> wirelessController() = 0;
 
    virtual std::shared_ptr<BeiDouGPS> beiDouGPS() = 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, xv::SlamStartMode slamStartMode = xv::SlamStartMode::Normal, xv::DeviceSupport deviceSupport = xv::DeviceSupport ::ONLYUSB);
 
std::map<std::string,std::shared_ptr<Device>> getDevicesUntilTimeout(double timeOut = 0., const std::string& desc = "", xv::SlamStartMode slamStartMode = xv::SlamStartMode::Normal, xv::DeviceSupport deviceSupport = xv::DeviceSupport ::ONLYUSB);
 
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, xv::SlamStartMode slamStartMode = xv::SlamStartMode::Normal);
 
bool detachDevice(int fd );
 
std::string getDefaultDescription();
 
void getUTCTIme(DateTime* utc);
 
bool savePointCloudToPcd(const std::string &path, std::shared_ptr<PointCloud> const & point, int precision = 8, bool removeInvalidPoints = true);
 
 
}