xv-types.h

#pragma once
#define NOMINMAX
 
#include <array>
#include <vector>
#include <limits>
#include <string>
#include <memory>
 
#if defined(__ANDROID__) && !defined(__x86_64__)
#define __XV_DRIVER_ONLY__
#endif
 
namespace xv {
 
enum class LogLevel {
        debug = 1,
        info,
        warn,
        err,
        critical,
        off
};
 
enum class SlamStartMode {
    Normal,
    VisionOnly,
    VisionWithGYRO
};
 
enum DeviceSupport {
    ONLYUSB,
    ONLYDRIVER,
    USBANDDRIVER,
    ONLY_WIRELESS_CONTROLLER
};
 
 
enum class PlugEventType { Plugin, Unplug };
 
#pragma pack(1)
 
struct ExpSetting{
    std::uint32_t iso_value;
    std::uint32_t exp_abs;
    std::uint8_t  exp_mode;
    std::int8_t   exp_level;
    std::uint8_t  exp_anti;    // ANTIBANDING_MODES
    std::uint8_t  iso_mode;
};
 
struct AwbSetting
{
    std::uint8_t awb_mode;
    std::uint8_t awb_lock;
};
 
struct AfSetting
{
    std::uint8_t af_mode;
    std::uint8_t af_dist;
};
 
struct DeviceSetting
{
    std::uint32_t cmd;   //sensorId:8 + channel:8 + sensorCmd:16
 
    union {
        std::uint8_t val[24];
        AwbSetting awb;
        ExpSetting exp;
        AfSetting  af;
        std::int16_t val16;
        std::int32_t val32;
    }args;
};
 
struct IspAecSetting
{
    int32_t maxIsoGainValue;
    int32_t minIsoGainValue;
    int32_t maxExposureTimeUs;
    int32_t minExposureTimeUs;
    uint8_t targetMeanPixelValue;
    int32_t ratioIso;
    int32_t cpt_aec_no_modify_range;
    float exposureTime_control_porprotion_value;
    float exposureTime_control_integral_value;
    float isoGain_control_porprotion_value;
    float isoGain_control_integral_value;
    uint32_t ISP_AEC_MODE;
};
 
#pragma pack()
struct Version{
    Version( int major = 0, int minor = 0, int patch = 0 );
    Version( const std::string &s );
 
    int major = 0; 
    int minor = 0; 
    int patch = 0; 
 
    int key() const;
    std::string toString() const;
 
    static int (max)();
};
 
bool operator<(const Version &a, const Version &b);
bool operator<=(const Version &a, const Version &b);
bool operator==(const Version &a, const Version &b);
bool operator!=(const Version &a, const Version &b);
bool operator>=(const Version &a, const Version &b);
bool operator>(const Version &a, const Version &b);
 
std::ostream& operator<<(std::ostream& o, Version const& v);
template<class F> using Vector2 = std::array<F,2>; 
template<class F> using Vector3 = std::array<F,3>; 
template<class F> using Vector4 = std::array<F,4>; 
template<class F> using Matrix3 = std::array<F,9>; 
 
typedef Vector2<bool> Vector2b; 
typedef Vector3<bool> Vector3b; 
typedef Vector4<bool> Vector4b; 
typedef Vector2<double> Vector2d; 
typedef Vector3<double> Vector3d; 
typedef Vector4<double> Vector4d; 
typedef Matrix3<double> Matrix3d; 
typedef Vector2<float> Vector2f; 
typedef Vector3<float> Vector3f; 
typedef Vector4<float> Vector4f; 
typedef Matrix3<float> Matrix3f; 
 
Vector4f rotationToQuaternion(Matrix3f const& rot);
Vector4d rotationToQuaternion(Matrix3d const& rot);
 
Matrix3f quaternionToRotation(Vector4f const& q);
 
Matrix3d quaternionToRotation(Vector4d const& q);
 
Matrix3f quaternionsToRotation(Vector4f const& q);
 
Vector3d rotationToPitchYawRoll(Matrix3d const& rot);
 
Vector3f rotationToPitchYawRoll(Matrix3f const& rot);
 
namespace details {
 
template <class F=double>
class Transform_ {
 
protected:
    Vector3<F> m_translation;
    Matrix3<F> m_rotation;
 
public:
 
    static Transform_ Identity() {
        return Transform_({0.,0,0},{1.,0,0,0,1,0,0,0,1});
    }
 
    Transform_() {};
    Transform_(Vector3<F> const& t, Matrix3<F> const& r={}) : m_translation(t), m_rotation(r) {};
 
    Transform_& operator*=(Transform_ const& q);
 
    Vector3<F> const& translation() const {return m_translation;}
    void setTranslation(Vector3<F> const& v) {m_translation = v;}
    void setTranslation(F const* v) {std::copy(v, v+3, m_translation.data());}
 
    Matrix3<F> const& rotation() const {return m_rotation;}
    void setRotation(Matrix3<F> const& v) {m_rotation = v;}
    void setRotation(F const* v) {std::copy(v, v+9, m_rotation.data());}
 
    F x() const { return m_translation[0]; }
    F y() const { return m_translation[1]; }
    F z() const { return m_translation[2]; }
    Transform_<F> inverse() const;
};
 
template <class F=double>
Transform_<F> operator*(Transform_<F> lhs, const Transform_<F>& rhs) {
    lhs *= rhs;
    return lhs;
}
 
Vector3d operator*(const Transform_<double>& a, const Vector3d& p);
 
Vector3f operator*(const Transform_<float>& a, const Vector3f& p);
 
Transform_<float> inverse(const Transform_<float>& t);
 
Transform_<double> inverse(const Transform_<double>& t);
 
 
template <class F=double>
class TransformQuat_ {
 
protected:
    Vector3<F> m_translation;
    Vector4<F> m_quaternions;
 
public:
 
    static TransformQuat_ Identity() {
        return TransformQuat_({0.,0,0},{0.,0,0,0,1});
    }
 
    TransformQuat_() {}
    TransformQuat_(Vector3<F> const& t, Vector4<F> const& q={}) : m_translation(t), m_quaternions(q) {}
 
    TransformQuat_& operator*=(TransformQuat_ const& q);
 
    Vector3<F> const& translation() const;
    void setTranslation(Vector3<F> const& v);
    void setTranslation(F const* v);
 
    Vector4<F> const& quaternion() const;
    void setQuaternion(Vector4<F> const& v);
    void setQuaternion(F const* v);
 
    F x() const { return m_translation[0]; }
    F y() const { return m_translation[1]; }
    F z() const { return m_translation[2]; }
 
    F qx() const { return m_quaternions[0]; }
    F qy() const { return m_quaternions[1]; }
    F qz() const { return m_quaternions[2]; }
    F qw() const { return m_quaternions[3]; }
};
template <class F=double>
TransformQuat_<F> operator*(TransformQuat_<F> lhs, const TransformQuat_<F>& rhs) {
    lhs *= rhs;
    return lhs;
}
 
template <class F=double>
class PoseQuat_ : public TransformQuat_<F> {
    double m_hostTimestamp = std::numeric_limits<double>::infinity();
    std::int64_t m_edgeTimestampUs = std::numeric_limits<std::int64_t>::min();
 
public:
 
    PoseQuat_() {}
    PoseQuat_(double t, TransformQuat_<F>const& tr={}) : m_hostTimestamp(t), TransformQuat_<F> (tr) {}
    PoseQuat_(std::int64_t t, TransformQuat_<F>const& tr={}) : m_edgeTimestampUs(t), TransformQuat_<F> (tr) {}
    PoseQuat_(double t, std::int64_t te,  TransformQuat_<F>const& tr={}) : m_hostTimestamp(t), m_edgeTimestampUs(te), TransformQuat_<F> (tr) {}
 
    std::int64_t edgeTimestampUs() const {return m_edgeTimestampUs;};
    void setEdgeTimestampUs(std::int64_t t) { m_edgeTimestampUs = t;};
    double hostTimestamp() const {return m_hostTimestamp;};
    void setHostTimestamp(double t) {m_hostTimestamp = t;};
};
 
template <class F=double>
class PoseRot_ : public Transform_<F> {
    double m_hostTimestamp = std::numeric_limits<double>::infinity();
    std::int64_t m_edgeTimestampUs = std::numeric_limits<std::int64_t>::min();
 
public:
    PoseRot_() {}
    PoseRot_(double t, Transform_<F>const& tr={}) : m_hostTimestamp(t), Transform_<F> (tr) {}
    PoseRot_(std::int64_t t, Transform_<F>const& tr={}) : m_edgeTimestampUs(t), Transform_<F> (tr) {}
    PoseRot_(double t, std::int64_t te,  Transform_<F>const& tr={}) : m_hostTimestamp(t), m_edgeTimestampUs(te), Transform_<F> (tr) {}
 
    std::int64_t edgeTimestampUs() const {return m_edgeTimestampUs;};
    void setEdgeTimestampUs(std::int64_t t) { m_edgeTimestampUs = t;};
    double hostTimestamp() const {return m_hostTimestamp;};
    void setHostTimestamp(double t) {m_hostTimestamp = t;};
};
 
template <class F=double>
class Pose_ : public details::PoseRot_<F> {
 
private:
 
    Vector4<F> m_quaternions;
    double m_confidence = 0;
 
public:
 
    static Pose_ Identity() {
        return Pose_({0.,0,0},{1.,0,0,0,1,0,0,0,1});
    }
 
    Pose_() {}
 
    Pose_(double c) : m_confidence(c) {}
 
    Pose_(Vector3<F> const& translation, Matrix3<F> const& rotation,
          double hostTimestamp = std::numeric_limits<double>::infinity(), std::int64_t edgeTimestamp = (std::numeric_limits<std::int64_t>::min)(), double c=0.)
        : m_confidence(c), PoseRot_<F>::PoseRot_(hostTimestamp, edgeTimestamp, {translation, rotation}), m_quaternions(rotationToQuaternion(rotation)) {}
 
    double confidence() const {return m_confidence;}
 
    void setConfidence(double c) { m_confidence = c;}
 
    Vector4<F> const& quaternion() const {return m_quaternions;}
    void setQuaternion(Vector4<F> const& v) {
        m_quaternions = v;
        PoseRot_<F>::m_rotation = quaternionToRotation(Pose_<F>::m_quaternions);
    };
    void setQuaternion(F const* v) {
        std::copy(v, v+4, m_quaternions.data());
        PoseRot_<F>::m_rotation = quaternionToRotation(Pose_<F>::m_quaternions);
    };
    void setRotation(Matrix3<F> const& v) {
        PoseRot_<F>::m_rotation = v;
        m_quaternions = rotationToQuaternion(PoseRot_<F>::m_rotation);
    };
    void setRotation(F const* v) {
        std::copy(v, v+9, PoseRot_<F>::m_rotation.data());
        m_quaternions = rotationToQuaternion(PoseRot_<F>::m_rotation);
    };
 
 
 
};
 
template <class F>
class PosePred_ : public Pose_<F> {
 
protected:
    Vector3<F> m_linearVelocity = Vector3<F>{0.,0.,0.};
    Vector3<F> m_angularVelocity = Vector3<F>{0.,0.,0.};
    Vector3<F> m_linearAcceleration = Vector3<F>{0.,0.,0.};
    Vector3<F> m_angularAcceleration = Vector3<F>{0.,0.,0.};
 
public:
 
    static PosePred_ Identity() {
        return PosePred_({0.,0,0},{1.,0,0,0,1,0,0,0,1});
    }
 
    PosePred_() {}
 
    PosePred_(double c) : Pose_<F>::Pose_(c) {}
 
    PosePred_(Vector3<F> const& translation, Matrix3<F> const& rotation,
          double hostTimestamp = std::numeric_limits<double>::infinity(), std::int64_t edgeTimestamp = (std::numeric_limits<std::int64_t>::min)(), double c=0.)
        : Pose_<F>::Pose_(translation, rotation, hostTimestamp, edgeTimestamp, c) {}
 
    Transform_<F> const& transform() const { return *this; }
 
    Vector3<F> const& linearVelocity() const {return m_linearVelocity; }
    Vector3<F> const& angularVelocity() const {return m_angularVelocity; }
    void setLinearVelocity(Vector3<F> const& v) { m_linearVelocity=v; }
    void setLinearVelocity(F const* v) {
            std::copy(v, v+3, m_linearVelocity.data());
    }
    void setAngularVelocity(Vector3<F> const& v) { m_angularVelocity=v; }
    void setAngularVelocity(F const* v) {
        std::copy(v, v+3, m_angularVelocity.data());
    }
 
    Vector3<F> const& linearAcceleration() const {return m_linearAcceleration; }
    Vector3<F> const& angularAcceleration() const {return m_angularAcceleration; }
    void setLinearAcceleration(Vector3<F> const& v) { m_linearAcceleration=v; }
    void setLinearAcceleration(F const* v) {
            std::copy(v, v+3, m_linearAcceleration.data());
    }
    void setAngularAcceleration(Vector3<F> const& v) { m_angularAcceleration=v; }
    void setAngularAcceleration(F const* v) {
        std::copy(v, v+3, m_angularAcceleration.data());
    }
};
 
}
 
struct Transform : public details::Transform_<double> {
    Transform();
    Transform(details::Transform_<double> && o);
    Transform(Vector3d const& t, Matrix3d const& r);
};
struct TransformF : public details::Transform_<float> {
    TransformF();
    TransformF(details::Transform_<float> && o);
    TransformF(Vector3f const& t, Matrix3f const& r);
};
 
Vector3f operator*(const TransformF& a, const Vector3f& p);
Vector3d operator*(const Transform& lhs, const Vector3d& rhs);
TransformF inverse(const TransformF& t);
Transform inverse(const Transform& t);
 
 
struct TransformQuat : public details::TransformQuat_<double> {
    TransformQuat();
    TransformQuat(Vector3d const& t, Vector4d const& q);
};
struct TransformQuatF : public details::TransformQuat_<float> {
    TransformQuatF();
    TransformQuatF(Vector3f const& t, Vector4f const& q);
};
 
struct PolynomialDistortionCameraModel {
    int w;
    int h;
    double fx;
    double fy;
    double u0;
    double v0;
    std::array<double,5> distor;
    PolynomialDistortionCameraModel();
};
 
struct UnifiedCameraModel {
    int w;
    int h;
    double fx;
    double fy;
    double u0;
    double v0;
    double xi;
};
 
struct UcmCameraCalibration {
    Transform pose;
    UnifiedCameraModel intrinsics;
};
 
struct PdmCameraCalibration {
    Transform pose;
    PolynomialDistortionCameraModel intrinsics;
};
 
struct Pose : public details::PosePred_<double> {
    static Pose Identity() {
        return Pose({0.,0,0},{1.,0,0,0,1,0,0,0,1});
    }
    Pose();
    Pose(Vector3d const& translation, Matrix3d const& rotation,
          double hostTimestamp = std::numeric_limits<double>::infinity(), std::int64_t edgeTimestamp = (std::numeric_limits<std::int64_t>::min)(), double c=0.);
    Pose prediction(double dt) const;
};
 
struct PoseF : public details::PosePred_<float> {
    static Pose Identity() {
        return Pose({0.,0,0},{1.,0,0,0,1,0,0,0,1});
    }
    PoseF();
    PoseF(Vector3f const& translation, Matrix3f const& rotation,
          double hostTimestamp = std::numeric_limits<double>::infinity(), std::int64_t edgeTimestamp = (std::numeric_limits<std::int64_t>::min)(), double c=0.);
 
    PoseF prediction(double dt) const;
};
 
struct Event {
    double hostTimestamp = std::numeric_limits<double>::infinity(); 
    std::int64_t edgeTimestampUs = (std::numeric_limits<std::int64_t>::min)(); 
    int type = 0; 
    int state = 0; 
};
 
class Orientation {
 
    Matrix3d m_rotation;
    Vector4d m_quaternions; 
    Vector3d m_angularVelocity = Vector3d{0.,0.,0.};
    Vector3d m_angularAcceleration = Vector3d{0.,0.,0.};
 
public:
    double hostTimestamp = std::numeric_limits<double>::infinity(); 
    std::int64_t edgeTimestampUs = (std::numeric_limits<std::int64_t>::min)(); 
 
    Orientation();
 
    Orientation(Matrix3d const& rotation,
          double hostTimestamp = std::numeric_limits<double>::infinity(), std::int64_t edgeTimestamp = (std::numeric_limits<std::int64_t>::min)());
 
    Orientation(Vector4d const& quaternion,
          double hostTimestamp = std::numeric_limits<double>::infinity(), std::int64_t edgeTimestamp = (std::numeric_limits<std::int64_t>::min)());
 
    Vector4d const& quaternion() const;
    void setQuaternion(Vector4d const& v);
    void setQuaternion(double const* v);
 
    Matrix3d const& rotation() const {return m_rotation;}
 
    void setRotation(Matrix3d const& v);
    void setRotation(double const* v);
    Vector3d const& angularVelocity() const;
 
    void setAngularVelocity(Vector3d const& v);
 
    void setAngularVelocity(double const* v);
 
    void setAngularAcceleration(Vector3d const& v);
 
    void setAngularAcceleration(double const* v);
 
    Orientation prediction(double dt) const;
 
};
 
struct Plane {
    std::string id;
 
    Vector3d normal;
 
    double d;
 
    std::vector<Vector3d> points;
 
    std::vector<Vector3d> vertices;
    std::vector<std::array<uint32_t,3>> triangles;
};
 
 
struct SlamMap
{
  std::vector<Vector3d> vertices;
};
 
class CameraModel {
public:
    virtual std::int32_t width() const {return 0; }
    virtual std::int32_t height() const {return 0; }
    virtual bool project(double const* /*p3d*/, double* /*p2d*/) const {return false;};
    virtual bool raytrace(double const* /*p2d*/, double* /*p3d*/) const {return false;};
};
 
struct Calibration {
    Transform pose; 
    std::vector<UnifiedCameraModel> ucm; 
    std::vector<PolynomialDistortionCameraModel> pdcm; 
    std::vector<std::shared_ptr<CameraModel>> camerasModel; 
};
 
struct Imu {
    Vector3d gyro; 
    Vector3d accel; 
    Vector3b accelSaturation; 
    Vector3d magneto; 
    double temperature; 
    double hostTimestamp = std::numeric_limits<double>::infinity(); 
    std::int64_t edgeTimestampUs = (std::numeric_limits<std::int64_t>::min)(); 
};
 
struct GrayScaleImage {
    std::size_t width; 
    std::size_t height; 
    std::shared_ptr<const std::uint8_t> data; 
};
 
struct FisheyeImages {
    double hostTimestamp = std::numeric_limits<double>::infinity(); 
    std::int64_t edgeTimestampUs = (std::numeric_limits<std::int64_t>::min)(); 
    std::vector<GrayScaleImage> images; 
    std::int64_t id;
};
 
struct RgbImage {
    std::size_t width = 0; 
    std::size_t height = 0; 
    std::shared_ptr<const std::uint8_t> data = nullptr; 
    RgbImage(std::size_t _width, std::size_t _height, std::shared_ptr<const std::uint8_t> _data) : width(_width), height(_height),data(_data) {}
};
 
struct ColorImage {
    enum class Codec { YUYV = 0, YUV420p, JPEG, NV12, BITSTREAM};
    Codec codec = Codec::YUYV;
    std::size_t width = 0; 
    std::size_t height = 0; 
    std::shared_ptr<const std::uint8_t> data = nullptr; 
    unsigned int dataSize = 0;
    double hostTimestamp = std::numeric_limits<double>::infinity(); 
    std::int64_t edgeTimestampUs = (std::numeric_limits<std::int64_t>::min)(); 
    RgbImage toRgb() const;
};
 
struct sgbm_config
    {
        int32_t enable_dewarp;
        float dewarp_zoom_factor;
        int32_t enable_disparity;
        int32_t enable_depth;
        int32_t enable_point_cloud;
        float baseline;
        float fov;
        uint8_t disparity_confidence_threshold;
        float homography[9];
        int32_t enable_gamma;
        float gamma_value;
        int32_t enable_gaussian;
        uint8_t mode;//standard 0 /Default:LRcheck 1 /Extended 2 /Subpixel 3
        uint16_t max_distance;//mm
        uint16_t min_distance;//mm
 
        inline bool operator==(const sgbm_config &cmp) const
        {
            return (enable_dewarp == cmp.enable_dewarp &&
                    dewarp_zoom_factor == cmp.dewarp_zoom_factor &&
                    enable_disparity == cmp.enable_disparity &&
                    enable_depth == cmp.enable_depth &&
                    enable_point_cloud == cmp.enable_point_cloud &&
                    baseline == cmp.baseline &&
                    fov == cmp.fov &&
                    disparity_confidence_threshold == cmp.disparity_confidence_threshold);
        }
        inline bool operator!=(const sgbm_config &cmp) const
        {
            return !(*this == cmp);
        }
    };
 
struct DepthImage {
    enum class Type { Depth_16 = 0, Depth_32, IR, Cloud, Raw, Eeprom, IQ };
    Type type = Type::Depth_32;
    std::size_t width = 0; 
    std::size_t height = 0; 
    double  confidence = 0.0; 
    std::shared_ptr<const std::uint8_t> data = nullptr; 
    unsigned int dataSize = 0;
    double hostTimestamp = std::numeric_limits<double>::infinity(); 
    std::int64_t edgeTimestampUs = (std::numeric_limits<std::int64_t>::min)(); 
    RgbImage toRgb() const;
};
 
struct DepthColorImage {
    std::size_t width = 0; 
    std::size_t height = 0; 
    std::shared_ptr<const std::uint8_t> data = nullptr; 
    double hostTimestamp = std::numeric_limits<double>::infinity(); 
};
 
struct PointCloud {
    double hostTimestamp = std::numeric_limits<double>::infinity(); 
    std::int64_t edgeTimestampUs = (std::numeric_limits<std::int64_t>::min)(); 
    std::vector<Vector3f> points;
};
 
struct BeiDouGPSData
{
    uint8_t data_ready_flag; // 0:invalid   1:valid
    double lat_data; //Latitude data   
    uint8_t latdir;  //latdir == 1(lat_data  is north latitude)  latdir == 2(lat_data  is south latitude)
    double lon_data; //Longitude data
    uint8_t londir;  //londir == 1(lon_data is east longitude)  londir == 2(lon_data is west longitude) 
    int satellite_num;  //Number of satellites
    uint8_t mode;       //mode == 1 (GPS + BDS)  mode == 2(BDS)
};
 
enum class BeiDouGPSMode
{
    BDS_SINGLE = 0,
    BDS_GPS_MIX = 1
};
 
struct Object {
    enum class Shape { BoundingBox = 0, Human, HandSkeleton };
    struct keypoint {
        double x = -1, y = -1, z = -1;
    };
 
    Shape shape = Shape::BoundingBox;
 
    int typeID = -1;
    std::string type = "";
    double x = 0;
    double y = 0;
    double width = 0;
    double height = 0;
    double confidence = 0.0f;
 
    std::vector<keypoint> keypoints;
};
 
struct Det2dObject{
    struct keypoint {
        double x = -1, y = -1, z = -1;
    };
 
    int idx;
    std::string name;
    float score;
    float left, top, width, height;
    std::vector<keypoint> keypoints;
    Det2dObject(){};
    Det2dObject(int i, const std::string& n, float s, float l, float t, float w, float h) : 
        idx(i), name(n), score(s), left(l), top(t), width(w), height(h) {}
    Det2dObject(int i, const std::string& n, float s, float l, float t, float w, float h, std::vector<keypoint> pts) : 
        idx(i), name(n), score(s), left(l), top(t), width(w), height(h), keypoints(pts){}
};
 
struct CnnRawWrapper{
    std::shared_ptr<float> raw_data = nullptr;
    unsigned int raw_data_length;
    double hostTimestamp;
    uint64_t edgeTimestamp;
};
 
 
 
 
struct ObjectDescriptor{
    std::string type;
    std::vector<std::string> classes;
    double threshold = 0.5;
    bool flipStereo = false;
    bool flipRgb = false;
    bool flipTof = false;
    bool enable_3dbbox = false;
    std::vector<double> prior_bbox_z;   
};
 
struct SgbmImage {
    enum class Type { Disparity = 0, Depth, PointCloud, None};
    Type type;
    SgbmImage() : type(Type::None) {}
    explicit SgbmImage(Type t) : type(t) {}
    std::size_t width = 0; 
    std::size_t height = 0; 
    std::shared_ptr<const std::uint8_t> data = nullptr; 
    unsigned int dataSize = 0;
    double hostTimestamp = std::numeric_limits<double>::infinity(); 
    std::int64_t edgeTimestampUs = (std::numeric_limits<std::int64_t>::min)(); 
    RgbImage toRgb() const;
};
 
struct ThermalImage {
    enum class Codec {UYVY};
    const Codec codec;
    explicit ThermalImage(Codec t) : codec(t) {}
    std::size_t width = 0; 
    std::size_t height = 0; 
    std::shared_ptr<const std::uint8_t> data = nullptr; 
    unsigned int dataSize = 0;
    double hostTimestamp = std::numeric_limits<double>::infinity(); 
    std::int64_t edgeTimestampUs = (std::numeric_limits<std::int64_t>::min)(); 
    RgbImage toRgb() const;
 
    //  InfraredImage(std::shared_ptr<const std::uint8_t> ptr) :
    //     data(ptr)
    // {
 
    // }
    // std::size_t width = 0; //!< width of the image (in pixel)
    // std::size_t height = 0; //!< height of the image (in pixel)
    // std::shared_ptr<const std::uint8_t> data = nullptr; //! image of depth
    // unsigned int dataSize = 0;
    // double hostTimestamp = std::numeric_limits<double>::infinity(); //!< host timestamp of the physical measurement (in second based on the `std::chrono::steady_clock`).
    // std::int64_t edgeTimestampUs = (std::numeric_limits<std::int64_t>::min)(); //!< timestamp of the physical measurement (in microsecond based on edge clock).
};
 
struct EyetrackingImage {
    double hostTimestamp = std::numeric_limits<double>::infinity(); 
    std::int64_t edgeTimestampUs = (std::numeric_limits<std::int64_t>::min)(); 
    std::vector<GrayScaleImage> images; 
};
 
struct MicData {
    double hostTimestamp = std::numeric_limits<double>::infinity(); 
    std::int64_t edgeTimestampUs = (std::numeric_limits<std::int64_t>::min)(); 
    std::shared_ptr<const std::uint8_t> data = nullptr; 
    unsigned int dataSize = 0;
};
 
struct keypoint {
    float x = -1;
    float y = -1;
    float z = -1;
};
 
struct GestureData {
    int index[2] = {-1,-1};
    keypoint position[2];
    keypoint slamPosition[2];
    double hostTimestamp = std::numeric_limits<double>::infinity(); 
    std::int64_t edgeTimestampUs = (std::numeric_limits<std::int64_t>::min)(); 
    float distance;
    float confidence;
};
 
enum class ResolutionMode{
    R_VGA,
    R_720P
};
 
typedef union XV_ET_POINT_2D
{
    struct {
        float x, y;
    };
    float seq[2];
}xv_ETPoint2D;
 
typedef union XV_ET_POINT_3D
{
    struct {
        float x, y, z;
    };
    float seq[3];
}xv_ETPoint3D;
 
enum XV_ET_EYE_TYPE {
    L_EYE = 1,
    R_EYE = 2
};
typedef XV_ET_EYE_TYPE xv_ETEyeType;
 
enum XV_ET_MODE {
    track = 3,
    iris = 5
};
typedef XV_ET_MODE xv_ETMode;
 
struct XV_ET_INIT_PARAM {
    xv_ETMode mode;
    char configPath[260];
};
typedef XV_ET_INIT_PARAM xv_ETInitParam;
 
typedef struct XV_ET_COEFFICIENT {
    unsigned char buf[1024];
}xv_ETCoefficient;
 
 
enum XV_EyeGazeExDataValidity {
    EYE_GAZE_EXDATA_SCORE = 0,
};
 
struct XV_ET_GAZE_POINT
{
    unsigned int gazeBitMask;
    xv_ETPoint3D gazePoint;
    xv_ETPoint3D rawPoint;
    xv_ETPoint3D smoothPoint;
    xv_ETPoint3D gazeOrigin;
    xv_ETPoint3D gazeDirection;
    float re;
    unsigned int exDataBitMask;
    float exData[32];
};
 
struct XV_ET_PUPIL_INFO
{
    unsigned int pupilBitMask;
    xv_ETPoint2D pupilCenter;
    float pupilDistance;
    float pupilDiameter;
    float pupilDiameterMM;
    float pupilMinorAxis;
    float pupilMinorAxisMM;
};
 
struct XV_ET_EYE_EXDATA
{
    unsigned int eyeDataExBitMask;
    int blink;
    float openness;
    float eyelidUp;
    float eyelidDown;
};
 
struct XV_ET_EYE_DATA_EX
{
    unsigned long long timestamp;
    int recommend;
    XV_ET_GAZE_POINT recomGaze;
    XV_ET_GAZE_POINT leftGaze;
    XV_ET_GAZE_POINT rightGaze;
 
    XV_ET_PUPIL_INFO leftPupil;
    XV_ET_PUPIL_INFO rightPupil;
 
    XV_ET_EYE_EXDATA leftExData;
    XV_ET_EYE_EXDATA rightExData;
 
    int leftEyeMove;
    int rightEyeMove;
    float ipd;
};
 
typedef enum GazeStatus {
    GAZE_STATUS_OK,
 
    GAZE_STATUS_ERROR,
 
    GAZE_STATUS_INITIALIZE_FAILED,
 
    GAZE_STATUS_TERMINATE_FAILED,
 
    GAZE_STATUS_INVALID_PARAMETER,
 
    GAZE_STATUS_INVALID_OPERATION,
 
    GAZE_STATUS_DEVICE_NOT_AVAILABLE,
 
    GAZE_STATUS_TIMED_OUT,
 
    GAZE_STATUS_MEM_ALLOCATION_FAILED
}
GazeStatus;
 
 
typedef enum CalibrationApiStatus {
    CALIBRATION_API_STATUS_COMPLETE_AUTOMATICALLY,
 
    CALIBRATION_API_STATUS_COMPLETE_MANUALLY,
 
    CALIBRATION_API_STATUS_ACCEPT_CALLING,
 
    CALIBRATION_API_STATUS_DO_NOT_CALL,
 
    CALIBRATION_API_STATUS_BUSY
}
CalibrationApiStatus;
 
typedef struct CalibrationStatus {
    CalibrationApiStatus enter_status;
 
    CalibrationApiStatus collect_status;
 
    CalibrationApiStatus setup_status;
 
    CalibrationApiStatus compute_apply_status;
 
    CalibrationApiStatus leave_status;
 
    CalibrationApiStatus reset_status;
}
CalibrationStatus;
 
typedef struct GazeCalibrationData {
    void* data = nullptr;
 
    size_t size;
 
    ~GazeCalibrationData()
    {
        if (data != nullptr)
        {
            free(data);
            data = nullptr;
        }
    };
}
GazeCalibrationData;
 
struct XV_IRIS_DATA
{
    std::vector<char> name;
    std::vector<unsigned char> feature;
    int size;
    int error;
};
 
struct DateTime {
  int Y, M, D;
  int h, m;
  int s;
};
 
struct GPSDistanceData {
  int           distance;
  int           signal;
  unsigned char sum;
};
 
struct Triple
{
  Vector2<unsigned short> p2d;
  size_t i3d;
  Triple(Vector2<unsigned short> const& p2, size_t i3): p2d(p2), i3d(i3) {}
};
struct PointMatches
{
    FisheyeImages fisheyeImages;
    std::vector<std::vector<Triple>> matches;
};
 
struct TerrestrialMagnetismData
{
    float offset[3];
    float angles[3];
    float magnetic[3];
    int level;
};
 
struct HandPose{
    std::vector<Pose> pose; // 26 + 26
    float scale[2];   // 1 + 1
    int status[2] = {-1,-1};
    double timestamp[2];
    double fisheye_timestamp;
};
 
struct ExternalData {
    int             tv_sec;
    int             tv_msec;
    std::uint8_t    state;
    float           x;
    float           y;
    float           z;
    float           pitch;
    float           roll;
    float           yaw;
    double          hostTimestamp;
};
 
enum WirelessControllerDataType
{
    UNKNOW = 0,
    LEFT = 0xC4,
    RIGHT = 0xC5,
    ALL = 0xC6
};
struct WirelessControllerData
{
    WirelessControllerDataType type;
    Pose pose;
    uint8_t keyTrigger;
    uint8_t keySide;
    int16_t rocker_x;
    int16_t rocker_y;
    uint8_t key;
};
 
enum WirelessControllerSlamType 
{
    VIO = 1,
    CSLAM = 2,
    REAL_TIME_SHARED_MAP = 3
};
 
struct WirelessControllerState
{
    std::string name;
    std::string mac;
    int state;
};
 
struct WirelessControllerDeviceInformation
{
    uint8_t battery;            // 1 bytes
    uint8_t temp;               // 1 bytes
};
 
struct GazeConfigs
{
    int screenWidth;
    int screenHeight;
    float ipdDist;
    int srValue;
};
 
}