MultiSenseTypes.hh

Go to the documentation of this file.

 
#ifndef LibMultiSense_MultiSenseTypes_hh
#define LibMultiSense_MultiSenseTypes_hh
 
#include <stdint.h>
#include <climits>
#include <string>
#include <vector>
#include <iostream>
 
#if defined (CRL_HAVE_CONSTEXPR)
#define CRL_CONSTEXPR constexpr
#else
#define CRL_CONSTEXPR const
#endif
 
// Define MULTISENSE_API appropriately. This is needed to correctly link with
// LibMultiSense when it is built as a DLL on Windows.
#if !defined(MULTISENSE_API)
#if defined (_MSC_VER)
#if defined (MultiSense_STATIC)
#define MULTISENSE_API __declspec(dllexport)
#elif defined (MultiSense_EXPORTS)
#define MULTISENSE_API __declspec(dllexport)
#else
#define MULTISENSE_API __declspec(dllimport)
#endif
 
#else
#define MULTISENSE_API
#endif
 
#endif
 
#if defined (_MSC_VER)
/*
 * C4251 warns about exporting classes with members not marked as __declspec(export).
 * It is not easy to work around this without breaking the MultiSense API, but it
 * is safe to ignore this warning as long as the MultiSense DLL is compiled with the
 * same compiler version and STL version.
 */
#pragma warning (push)
#pragma warning (disable: 4251)
#endif
 
namespace crl {
namespace multisense {
 
typedef uint32_t VersionType;
 
typedef int32_t  Status;
 
//
// General status codes
 
static CRL_CONSTEXPR Status Status_Ok          =  0;
static CRL_CONSTEXPR Status Status_TimedOut    = -1;
static CRL_CONSTEXPR Status Status_Error       = -2;
static CRL_CONSTEXPR Status Status_Failed      = -3;
static CRL_CONSTEXPR Status Status_Unsupported = -4;
static CRL_CONSTEXPR Status Status_Unknown     = -5;
static CRL_CONSTEXPR Status Status_Exception   = -6;
 
typedef uint64_t DataSource;
 
static CRL_CONSTEXPR DataSource Source_Unknown                       = 0;
static CRL_CONSTEXPR DataSource Source_All                           = 0xffffffffffffffff;
static CRL_CONSTEXPR DataSource Source_Raw_Left                      = (1ull<<0);
static CRL_CONSTEXPR DataSource Source_Raw_Right                     = (1ull<<1);
static CRL_CONSTEXPR DataSource Source_Luma_Left                     = (1ull<<2);
static CRL_CONSTEXPR DataSource Source_Luma_Right                    = (1ull<<3);
static CRL_CONSTEXPR DataSource Source_Luma_Rectified_Left           = (1ull<<4);
static CRL_CONSTEXPR DataSource Source_Luma_Rectified_Right          = (1ull<<5);
static CRL_CONSTEXPR DataSource Source_Chroma_Left                   = (1ull<<6);
static CRL_CONSTEXPR DataSource Source_Chroma_Right                  = (1ull<<7);
static CRL_CONSTEXPR DataSource Source_Chroma_Rectified_Aux          = (1ull<<8);
static CRL_CONSTEXPR DataSource Source_Disparity                     = (1ull<<10);
static CRL_CONSTEXPR DataSource Source_Disparity_Left                = (1ull<<10); // same as Source_Disparity
static CRL_CONSTEXPR DataSource Source_Disparity_Right               = (1ull<<11);
static CRL_CONSTEXPR DataSource Source_Disparity_Cost                = (1ull<<12);
static CRL_CONSTEXPR DataSource Source_Jpeg_Left                     = (1ull<<16);
static CRL_CONSTEXPR DataSource Source_Rgb_Left                      = (1ull<<17);
static CRL_CONSTEXPR DataSource Source_Feature_Left                  = (1ull<<18);
static CRL_CONSTEXPR DataSource Source_Feature_Right                 = (1ull<<19);
static CRL_CONSTEXPR DataSource Source_Feature_Aux                   = (1ull<<32);
static CRL_CONSTEXPR DataSource Source_Ground_Surface_Spline_Data    = (1ull<<20);
static CRL_CONSTEXPR DataSource Source_Ground_Surface_Class_Image    = (1ull<<22);
static CRL_CONSTEXPR DataSource Source_AprilTag_Detections           = (1ull<<23);
static CRL_CONSTEXPR DataSource Source_Lidar_Scan                    = (1ull<<24);
static CRL_CONSTEXPR DataSource Source_Imu                           = (1ull<<25);
static CRL_CONSTEXPR DataSource Source_Pps                           = (1ull<<26);
static CRL_CONSTEXPR DataSource Source_Raw_Aux                       = (1ull<<27);
static CRL_CONSTEXPR DataSource Source_Luma_Aux                      = (1ull<<28);
static CRL_CONSTEXPR DataSource Source_Luma_Rectified_Aux            = (1ull<<29);
static CRL_CONSTEXPR DataSource Source_Chroma_Aux                    = (1ull<<30);
static CRL_CONSTEXPR DataSource Source_Disparity_Aux                 = (1ull<<31);
static CRL_CONSTEXPR DataSource Source_Compressed_Left               = (1ull<<9);
static CRL_CONSTEXPR DataSource Source_Compressed_Right              = (1ull<<13);
static CRL_CONSTEXPR DataSource Source_Compressed_Aux                = (1ull<<14);
static CRL_CONSTEXPR DataSource Source_Compressed_Rectified_Left     = (1ull<<15);
static CRL_CONSTEXPR DataSource Source_Compressed_Rectified_Right    = (1ull<<16);
static CRL_CONSTEXPR DataSource Source_Compressed_Rectified_Aux      = (1ull<<17);
 
static CRL_CONSTEXPR int Roi_Full_Image = 0;
static CRL_CONSTEXPR DataSource Exposure_Default_Source = Source_Luma_Left;
static CRL_CONSTEXPR float Exposure_Default_Target_Intensity = 0.5f;
static CRL_CONSTEXPR float Exposure_Default_Gain = 1.0f;
 
typedef uint32_t CameraProfile;
 
static CRL_CONSTEXPR CameraProfile User_Control = 0;
static CRL_CONSTEXPR CameraProfile Detail_Disparity = (1U<<0);
static CRL_CONSTEXPR CameraProfile High_Contrast = (1U<<1);
static CRL_CONSTEXPR CameraProfile Show_ROIs = (1U<<2);
static CRL_CONSTEXPR CameraProfile Ground_Surface = (1U<<3);
static CRL_CONSTEXPR CameraProfile Full_Res_Aux_Cam = (1U<<4);
static CRL_CONSTEXPR CameraProfile AprilTag = (1U<<5);
 
typedef uint32_t ImageCompressionCodec;
 
static CRL_CONSTEXPR ImageCompressionCodec H264 = 0;
 
typedef int16_t RemoteHeadChannel;
static CRL_CONSTEXPR RemoteHeadChannel Remote_Head_VPB         = -1;
static CRL_CONSTEXPR RemoteHeadChannel Remote_Head_0           = 0;
static CRL_CONSTEXPR RemoteHeadChannel Remote_Head_1           = 1;
static CRL_CONSTEXPR RemoteHeadChannel Remote_Head_2           = 2;
static CRL_CONSTEXPR RemoteHeadChannel Remote_Head_3           = 3;
static CRL_CONSTEXPR RemoteHeadChannel Remote_Head_Invalid     = SHRT_MAX;
 
struct RemoteHeadSyncGroup {
 
  RemoteHeadSyncGroup() {};
 
  RemoteHeadSyncGroup(const RemoteHeadChannel c,
                      const std::vector<RemoteHeadChannel> &r) :
    controller(c),
    responders(r) {};
 
  RemoteHeadChannel controller;
  std::vector<RemoteHeadChannel> responders;
 
};
 
/*
 * Trigger sources used to determine which input should be used to trigger
 * a frame capture on a device
 */
typedef uint32_t TriggerSource;
 
static CRL_CONSTEXPR TriggerSource Trigger_Internal    = 0;
static CRL_CONSTEXPR TriggerSource Trigger_External    = 1;
static CRL_CONSTEXPR TriggerSource Trigger_External_Inverted    = 2;
static CRL_CONSTEXPR TriggerSource Trigger_PTP    = 3;
 
class MULTISENSE_API HeaderBase {
public:
    virtual bool inMask(DataSource mask) { (void) mask; return true; };
    virtual ~HeaderBase() {};
};
 
namespace image {
 
class MULTISENSE_API Header : public HeaderBase {
public:
 
    DataSource  source;
    uint32_t    bitsPerPixel;
    uint32_t    width;
    uint32_t    height;
    int64_t     frameId;
    uint32_t    timeSeconds;
    uint32_t    timeMicroSeconds;
 
    uint32_t    exposure;
    float       gain;
    float       framesPerSecond;
    uint32_t    imageLength;
    const void *imageDataP;
 
    Header()
        : source(Source_Unknown) {};
 
    virtual bool inMask(DataSource mask) { return (mask & source) != 0;};
};
 
typedef void (*Callback)(const Header& header,
                         void         *userDataP);
 
class MULTISENSE_API ExposureConfig {
public:
    ExposureConfig():
      m_exposure(10000), m_aeEnabled(true), m_aeMax(5000000),  m_aeDecay(7), m_aeThresh(0.9f),
      m_autoExposureRoiX(0), m_autoExposureRoiY(0),
      m_autoExposureRoiWidth(Roi_Full_Image), m_autoExposureRoiHeight(Roi_Full_Image),
      m_aeTargetIntensity(Exposure_Default_Target_Intensity),
      m_gain(Exposure_Default_Gain) {};
 
    void setExposure          (uint32_t e) { m_exposure  = e; };
 
    void setAutoExposure      (bool e)     { m_aeEnabled = e; };
 
    void setAutoExposureMax   (uint32_t m) { m_aeMax     = m; };
 
    void setAutoExposureDecay (uint32_t d) { m_aeDecay   = d; };
 
    void setAutoExposureTargetIntensity (float d) { m_aeTargetIntensity   = d; };
 
    void setAutoExposureThresh(float t)    { m_aeThresh  = t; };
 
    void setAutoExposureRoi(uint16_t start_x, uint16_t start_y, uint16_t width, uint16_t height)
    {
        m_autoExposureRoiX = start_x;
        m_autoExposureRoiY = start_y;
        m_autoExposureRoiWidth = width;
        m_autoExposureRoiHeight = height;
    }
 
    void setGain(const float &g)    { m_gain  = g; };
 
    //
    // Query
 
    uint32_t exposure          () const { return m_exposure;  };
 
    bool     autoExposure      () const { return m_aeEnabled; };
 
    uint32_t autoExposureMax   () const { return m_aeMax;     };
 
    uint32_t autoExposureDecay () const { return m_aeDecay;   };
 
    float autoExposureTargetIntensity () const { return m_aeTargetIntensity;   };
 
    float    autoExposureThresh() const { return m_aeThresh;  };
 
    uint16_t autoExposureRoiX        () const { return m_autoExposureRoiX; };
 
    uint16_t autoExposureRoiY        () const { return m_autoExposureRoiY; };
 
    uint16_t autoExposureRoiWidth    () const { return m_autoExposureRoiWidth; };
 
    uint16_t autoExposureRoiHeight   () const { return m_autoExposureRoiHeight; };
 
    float gain() const { return m_gain; };
 
    private:
        uint32_t m_exposure;
        bool     m_aeEnabled;
        uint32_t m_aeMax;
        uint32_t m_aeDecay;
        float    m_aeThresh;
 
        uint16_t m_autoExposureRoiX;
        uint16_t m_autoExposureRoiY;
        uint16_t m_autoExposureRoiWidth;
        uint16_t m_autoExposureRoiHeight;
 
        float    m_aeTargetIntensity;
        float    m_gain;
};
 
class MULTISENSE_API Config {
public:
 
    //
    // User configurable member functions
 
    void setResolution        (uint32_t w,
                               uint32_t h) { m_width=w;m_height=h; };
 
    void setDisparities       (uint32_t d) { m_disparities=d;      };
 
    void setWidth             (uint32_t w) { m_width     = w;      };
 
    void setHeight            (uint32_t h) { m_height    = h;      };
 
    void setFps               (float f)    { m_fps       = f;      };
 
    void setGain              (float g)    { m_gain      = g; };
 
    void setExposure          (uint32_t e) { m_exposure.setExposure(e); };
 
    void setAutoExposure      (bool e)     { m_exposure.setAutoExposure(e); };
 
    void setAutoExposureMax   (uint32_t m) { m_exposure.setAutoExposureMax(m); };
 
    void setAutoExposureDecay (uint32_t d) { m_exposure.setAutoExposureDecay(d); };
 
    void setAutoExposureTargetIntensity (float d) { m_exposure.setAutoExposureTargetIntensity(d); };
 
    void setAutoExposureThresh(float t)    { m_exposure.setAutoExposureThresh(t); };
 
    void setWhiteBalance            (float r,
                                     float b)    { m_wbRed=r;m_wbBlue=b; };
 
    void setAutoWhiteBalance        (bool e)     { m_wbEnabled   = e;    };
 
    void setAutoWhiteBalanceDecay   (uint32_t d) { m_wbDecay     = d;    };
 
    void setAutoWhiteBalanceThresh  (float t)    { m_wbThresh    = t;    };
 
    void setStereoPostFilterStrength(float s)    { m_spfStrength = s;    };
 
    void setHdr                     (bool  e)    { m_hdrEnabled  = e;    };
 
    void setAutoExposureRoi(uint16_t start_x, uint16_t start_y, uint16_t width, uint16_t height)
    {
        m_exposure.setAutoExposureRoi(start_x, start_y, width, height);
    }
 
    void setCameraProfile(const CameraProfile &profile)
    {
        m_profile = profile;
    }
 
    void setGamma(const float g) { m_gamma = g; };
 
 
    //
    // Query
 
    uint32_t width       () const { return m_width;       };
 
    uint32_t height      () const { return m_height;      };
 
    uint32_t disparities () const { return m_disparities; };
 
    float    fps         () const { return m_fps;         };
 
    float    gain              () const { return m_gain;      };
 
 
    uint32_t exposure          () const { return m_exposure.exposure();  };
 
    bool     autoExposure      () const { return m_exposure.autoExposure(); };
 
    uint32_t autoExposureMax   () const { return m_exposure.autoExposureMax();     };
 
    uint32_t autoExposureDecay () const { return m_exposure.autoExposureDecay();   };
 
    float autoExposureTargetIntensity () const { return m_exposure.autoExposureTargetIntensity();   };
 
    float    autoExposureThresh() const { return m_exposure.autoExposureThresh();  };
 
    float    whiteBalanceRed         () const { return m_wbRed;       };
 
    float    whiteBalanceBlue        () const { return m_wbBlue;      };
 
    bool     autoWhiteBalance        () const { return m_wbEnabled;   };
 
    uint32_t autoWhiteBalanceDecay   () const { return m_wbDecay;     };
 
    float    autoWhiteBalanceThresh  () const { return m_wbThresh;    };
 
    float    stereoPostFilterStrength() const { return m_spfStrength; };
 
    bool     hdrEnabled              () const { return m_hdrEnabled;  };
 
    uint16_t autoExposureRoiX        () const { return m_exposure.autoExposureRoiX(); };
 
    uint16_t autoExposureRoiY        () const { return m_exposure.autoExposureRoiY(); };
 
    uint16_t autoExposureRoiWidth    () const { return m_exposure.autoExposureRoiWidth(); };
 
    uint16_t autoExposureRoiHeight   () const { return m_exposure.autoExposureRoiHeight(); };
 
    CameraProfile cameraProfile () const { return m_profile; };
 
    float gamma() const { return m_gamma; };
 
    //
    // Query camera calibration (read-only)
    //
    // These parameters are adjusted for the current operating resolution of the device.
 
    float fx()    const { return m_fx;    };
 
    float fy()    const { return m_fy;    };
 
    float cx()    const { return m_cx;    };
 
    float cy()    const { return m_cy;    };
 
    float tx()    const { return m_tx;    };
 
    float ty()    const { return m_ty;    };
 
    float tz()    const { return m_tz;    };
 
    float roll()  const { return m_roll;  };
 
    float pitch() const { return m_pitch; };
 
    float yaw()   const { return m_yaw;   };
 
    Config() : m_fps(5.0f), m_gain(1.0f),
               m_exposure(),
               m_wbBlue(1.0f), m_wbRed(1.0f), m_wbEnabled(true), m_wbDecay(3), m_wbThresh(0.5f),
               m_width(1024), m_height(544), m_disparities(128), m_spfStrength(0.5f),
               m_hdrEnabled(false),
               m_profile(User_Control),
               m_gamma(2.0),
               m_fx(0), m_fy(0), m_cx(0), m_cy(0),
               m_tx(0), m_ty(0), m_tz(0), m_roll(0), m_pitch(0), m_yaw(0) {};
private:
 
    float    m_fps, m_gain;
    ExposureConfig m_exposure;
    float    m_wbBlue;
    float    m_wbRed;
    bool     m_wbEnabled;
    uint32_t m_wbDecay;
    float    m_wbThresh;
    uint32_t m_width, m_height;
    uint32_t m_disparities;
    float    m_spfStrength;
    bool     m_hdrEnabled;
    CameraProfile m_profile;
    float    m_gamma;
 
protected:
 
    float    m_fx, m_fy, m_cx, m_cy;
    float    m_tx, m_ty, m_tz;
    float    m_roll, m_pitch, m_yaw;
};
 
class MULTISENSE_API AuxConfig {
public:
 
    //
    // User configurable member functions
 
 
    void setGain              (float g)    { m_gain      = g; };
 
    void setExposure          (uint32_t e) { m_exposure.setExposure(e); };
 
    void setAutoExposure      (bool e)     { m_exposure.setAutoExposure(e); };
 
    void setAutoExposureMax   (uint32_t m) { m_exposure.setAutoExposureMax(m); };
 
    void setAutoExposureDecay (uint32_t d) { m_exposure.setAutoExposureDecay(d); };
 
    void setAutoExposureTargetIntensity (float d) { m_exposure.setAutoExposureTargetIntensity(d); };
 
    void setAutoExposureThresh(float t)    { m_exposure.setAutoExposureThresh(t); };
 
    void setWhiteBalance            (float r,
                                     float b)    { m_wbRed=r;m_wbBlue=b; };
 
    void setAutoWhiteBalance        (bool e)     { m_wbEnabled   = e;    };
 
    void setAutoWhiteBalanceDecay   (uint32_t d) { m_wbDecay     = d;    };
 
    void setAutoWhiteBalanceThresh  (float t)    { m_wbThresh    = t;    };
 
    void setHdr                     (bool  e)    { m_hdrEnabled  = e;    };
 
    void setAutoExposureRoi(uint16_t start_x, uint16_t start_y, uint16_t width, uint16_t height)
    {
        m_exposure.setAutoExposureRoi(start_x, start_y, width, height);
    }
 
    void setCameraProfile(const CameraProfile &profile)
    {
        m_profile = profile;
    }
 
    void setGamma(const float g) { m_gamma = g; };
 
 
    void enableSharpening(const bool &s)    { m_sharpeningEnable  = s; };
 
    void setSharpeningPercentage(const float &s)    { m_sharpeningPercentage  = s; };
 
    void setSharpeningLimit(const uint8_t &s)    { m_sharpeningLimit  = s; };
 
    //
    // Query
    //
    //
    // Query camera calibration (read-only)
    //
    // These parameters are adjusted for the current operating resolution of the device.
 
    float fx()    const { return m_fx;    };
 
    float fy()    const { return m_fy;    };
 
    float cx()    const { return m_cx;    };
 
    float cy()    const { return m_cy;    };
 
    float    gain              () const { return m_gain;      };
 
    uint32_t exposure          () const { return m_exposure.exposure();  };
 
    bool     autoExposure      () const { return m_exposure.autoExposure(); };
 
    uint32_t autoExposureMax   () const { return m_exposure.autoExposureMax();     };
 
    uint32_t autoExposureDecay () const { return m_exposure.autoExposureDecay();   };
 
    float autoExposureTargetIntensity () const { return m_exposure.autoExposureTargetIntensity();   };
 
    float    autoExposureThresh() const { return m_exposure.autoExposureThresh();  };
 
    float    whiteBalanceRed         () const { return m_wbRed;       };
 
    float    whiteBalanceBlue        () const { return m_wbBlue;      };
 
    bool     autoWhiteBalance        () const { return m_wbEnabled;   };
 
    uint32_t autoWhiteBalanceDecay   () const { return m_wbDecay;     };
 
    float    autoWhiteBalanceThresh  () const { return m_wbThresh;    };
 
    bool     hdrEnabled              () const { return m_hdrEnabled;  };
 
    uint16_t autoExposureRoiX        () const { return m_exposure.autoExposureRoiX(); };
 
    uint16_t autoExposureRoiY        () const { return m_exposure.autoExposureRoiY(); };
 
    uint16_t autoExposureRoiWidth    () const { return m_exposure.autoExposureRoiWidth(); };
 
    uint16_t autoExposureRoiHeight   () const { return m_exposure.autoExposureRoiHeight(); };
 
    CameraProfile cameraProfile () const { return m_profile; };
 
    float gamma() const { return m_gamma; };
 
    bool enableSharpening() const { return m_sharpeningEnable; };
 
    float sharpeningPercentage() const { return m_sharpeningPercentage; };
 
    uint8_t sharpeningLimit() const { return m_sharpeningLimit; };
 
    AuxConfig() : m_gain(1.0f),
               m_exposure(),
               m_wbBlue(1.0f), m_wbRed(1.0f), m_wbEnabled(true), m_wbDecay(3), m_wbThresh(0.5f),
               m_hdrEnabled(false),
               m_profile(User_Control),
               m_gamma(2.0),
               m_sharpeningEnable(false), m_sharpeningPercentage(0.0f), m_sharpeningLimit(0),
               m_fx(0), m_fy(0), m_cx(0), m_cy(0) {};
private:
 
    float    m_gain;
    ExposureConfig m_exposure;
    float    m_wbBlue;
    float    m_wbRed;
    bool     m_wbEnabled;
    uint32_t m_wbDecay;
    float    m_wbThresh;
    bool     m_hdrEnabled;
    CameraProfile m_profile;
    float    m_gamma;
    bool     m_sharpeningEnable;
    float    m_sharpeningPercentage;
    uint8_t  m_sharpeningLimit;
 
protected:
 
    float    m_fx, m_fy, m_cx, m_cy;
};
 
class MULTISENSE_API Calibration {
public:
 
    class MULTISENSE_API Data {
    public:
 
        float M[3][3];
        float D[8];
        float R[3][3];
        float P[3][4];
    };
 
    Data left;
    Data right;
    Data aux;
};
 
class MULTISENSE_API TransmitDelay {
public:
 
    int delay;
 
};
 
class MULTISENSE_API PacketDelay {
public:
 
    bool enable;
 
};
 
class MULTISENSE_API Histogram {
public:
 
    Histogram() : channels(0),
                  bins(0),
                  data() {};
    uint32_t              channels;
    uint32_t              bins;
    std::vector<uint32_t> data;
};
 
class MULTISENSE_API RemoteHeadConfig {
public:
 
    RemoteHeadConfig() : m_syncGroups()
    {};
 
    RemoteHeadConfig(const std::vector<RemoteHeadSyncGroup> &sync_groups) :
        m_syncGroups(sync_groups)
    {}
 
    void setSyncGroups(const std::vector<RemoteHeadSyncGroup> &sync_groups) { m_syncGroups = sync_groups; }
 
    std::vector<RemoteHeadSyncGroup> syncGroups() const { return m_syncGroups; }
 
private:
 
    std::vector<RemoteHeadSyncGroup> m_syncGroups;
};
 
 
} // namespace image
 
namespace lidar {
 
typedef uint32_t RangeType;
typedef uint32_t IntensityType;
 
class MULTISENSE_API Header : public HeaderBase {
public:
 
    Header()
        : pointCount(0) {};
 
    uint32_t scanId;
    uint32_t timeStartSeconds;
    uint32_t timeStartMicroSeconds;
    uint32_t timeEndSeconds;
    uint32_t timeEndMicroSeconds;
    int32_t  spindleAngleStart;
    int32_t  spindleAngleEnd;
    int32_t  scanArc;
    uint32_t maxRange;
    uint32_t pointCount;
 
    const RangeType     *rangesP;
    const IntensityType *intensitiesP;  // device units
};
 
typedef void (*Callback)(const Header& header,
                         void         *userDataP);
 
class MULTISENSE_API Calibration {
public:
 
    float laserToSpindle[4][4];
    float cameraToSpindleFixed[4][4];
};
 
} // namespace lidar
 
namespace lighting {
 
static CRL_CONSTEXPR uint32_t MAX_LIGHTS     = 8;
static CRL_CONSTEXPR float    MAX_DUTY_CYCLE = 100.0;
 
class MULTISENSE_API Config {
public:
 
    void setFlash(bool onOff) { m_flashEnabled = onOff; };
 
    bool getFlash()     const { return m_flashEnabled;  };
 
    bool setDutyCycle(float percent) {
        if (percent < 0.0f || percent > MAX_DUTY_CYCLE)
            return false;
 
        std::fill(m_dutyCycle.begin(),
                  m_dutyCycle.end(),
                  percent);
        return true;
    };
 
    bool setDutyCycle(uint32_t i,
                      float    percent) {
        if (i >= MAX_LIGHTS ||
            percent < 0.0f || percent > MAX_DUTY_CYCLE)
            return false;
 
        m_dutyCycle[i] = percent;
        return true;
    };
 
    float getDutyCycle(uint32_t i) const {
        if (i >= MAX_LIGHTS)
            return 0.0f;
        return m_dutyCycle[i];
    };
 
    uint32_t getNumberOfPulses( ) const {
      return m_numberPulses;
    }
 
    bool setNumberOfPulses(const uint32_t numPulses) {
 
      m_numberPulses = numPulses;
      return true;
    }
 
    uint32_t getStartupTime( ) const {
      return m_lightStartupOffset_us;
    }
 
    bool setStartupTime(uint32_t ledTransientResponse_us) {
 
      m_lightStartupOffset_us = ledTransientResponse_us;
      return true;
    }
 
    bool getInvertPulse( ) const {
        return m_invertPulse;
    }
 
    bool setInvertPulse(const bool invert) {
        m_invertPulse = invert;
        return true;
    }
    /*
    * Enable a rolling shutter camera flash synchronization, this will Allow
    * an LED to flash with in sync with a rolling shutter imager, to reduce
    * the possibility of, seeing inconsistent lighting artifacts with rolling
    * shutter imagers.
    * Note: This feature is only available for Next Gen Stereo Cameras, with a
    * rolling shutter aux imager.
    *
    * @param enabled enable/disable the rolling shutter synchronization feature.
    *
    * @return True on success, False on failure
    */
    bool enableRollingShutterLedSynchronization(const bool enabled) {
      m_rollingShutterLedEnabled = enabled;
      return true;
    }
 
    bool getRollingShutterLedSynchronizationStatus(void) const {
      return m_rollingShutterLedEnabled;
    }
 
    Config() : m_flashEnabled(false), m_dutyCycle(MAX_LIGHTS, -1.0f),
               m_numberPulses(1), m_lightStartupOffset_us(0), m_invertPulse(false),
               m_rollingShutterLedEnabled(false) {};
 
private:
 
    bool               m_flashEnabled;
    std::vector<float> m_dutyCycle;
    uint32_t           m_numberPulses;
    uint32_t           m_lightStartupOffset_us;
    bool               m_invertPulse;
    bool               m_rollingShutterLedEnabled;
};
 
class MULTISENSE_API SensorStatus {
public:
 
    float ambientLightPercentage;
 
    SensorStatus() : ambientLightPercentage(100.0f) {};
};
 
} // namespace lighting
 
namespace pps {
 
class MULTISENSE_API Header : public HeaderBase {
public:
 
    int64_t sensorTime;
 
    uint32_t timeSeconds;
    uint32_t timeMicroSeconds;
};
 
typedef void (*Callback)(const Header& header,
                         void         *userDataP);
 
} // namespace pps
 
namespace imu {
 
class MULTISENSE_API Sample {
public:
 
    typedef uint16_t Type;
 
    static CRL_CONSTEXPR Type Type_Accelerometer = 1;
    static CRL_CONSTEXPR Type Type_Gyroscope     = 2;
    static CRL_CONSTEXPR Type Type_Magnetometer  = 3;
 
    Type       type;
    uint32_t   timeSeconds;
    uint32_t   timeMicroSeconds;
 
    float x;
 
    float y;
 
    float z;
 
    double time() const {
        return (static_cast<double>(timeSeconds) +
                1e-6 * static_cast<double>(timeMicroSeconds));
    };
};
 
class MULTISENSE_API Header : public HeaderBase {
public:
 
    uint32_t            sequence;
    std::vector<Sample> samples;
};
 
typedef void (*Callback)(const Header& header,
                         void         *userDataP);
 
class MULTISENSE_API Info {
public:
 
    typedef struct {
        float sampleRate;
        float bandwidthCutoff;
    } RateEntry;
 
    typedef struct {
        float range;
        float resolution;
    } RangeEntry;
 
    std::string             name;
    std::string             device;
    std::string             units;
    std::vector<RateEntry>  rates;
    std::vector<RangeEntry> ranges;
};
 
class MULTISENSE_API Config {
public:
 
    std::string name;
    bool        enabled;
    uint32_t    rateTableIndex;
    uint32_t    rangeTableIndex;
};
 
} // namespace imu
 
namespace compressed_image {
 
class MULTISENSE_API Header : public HeaderBase {
public:
 
    DataSource  source;
    uint32_t    bitsPerPixel;
    ImageCompressionCodec codec;
    uint32_t    width;
    uint32_t    height;
    int64_t     frameId;
    uint32_t    timeSeconds;
    uint32_t    timeMicroSeconds;
 
    uint32_t    exposure;
    float       gain;
    float       framesPerSecond;
    uint32_t    imageLength;
    const void *imageDataP;
 
    Header()
        : source(Source_Unknown) {};
 
    virtual bool inMask(DataSource mask) { return (mask & source) != 0;};
};
 
typedef void (*Callback)(const Header& header,
                         void         *userDataP);
 
} // namespace compressed_image
 
namespace ground_surface {
 
class MULTISENSE_API Header : public HeaderBase {
public:
    int64_t     frameId;
    int64_t     timestamp;
    uint8_t     success;
 
    uint32_t    controlPointsBitsPerPixel;
    uint32_t    controlPointsWidth;
    uint32_t    controlPointsHeight;
    const void *controlPointsImageDataP;
 
    float xzCellOrigin[2];
    float xzCellSize[2];
    float xzLimit[2];
    float minMaxAzimuthAngle[2];
 
    float extrinsics[6];
 
    float quadraticParams[6];
};
 
typedef void (*Callback)(const Header& header,
                         void         *userDataP);
 
} // namespace ground_surface
 
namespace apriltag {
 
class MULTISENSE_API Header : public HeaderBase {
public:
    struct ApriltagDetection {
        std::string family;
        uint32_t id;
        uint8_t hamming;
        float decisionMargin;
        double tagToImageHomography[3][3];
        double center[2];
        double corners[4][2];
    };
 
    int64_t     frameId;
    int64_t     timestamp;
    std::string imageSource;
    uint8_t     success;
    uint32_t    numDetections;
    std::vector<ApriltagDetection> detections;
};
 
typedef void (*Callback)(const Header& header,
                         void         *userDataP);
 
} // namespace apriltag
 
namespace feature_detector {
 
 
  static CRL_CONSTEXPR int RECOMMENDED_MAX_FEATURES_FULL_RES    = 5000;
  static CRL_CONSTEXPR int RECOMMENDED_MAX_FEATURES_QUARTER_RES = 1500;
 
 
  struct Feature {
    uint16_t x;
    uint16_t y;
    uint8_t angle;
    uint8_t resp;
    uint8_t octave;
    uint8_t descriptor;
  };
 
  struct Descriptor {
    uint32_t d[8]; //Descriptor is 32 bytes
  };
 
  class MULTISENSE_API Header : public HeaderBase {
  public:
 
      DataSource source;
      int64_t  frameId;
      uint32_t timeSeconds;
      uint32_t timeNanoSeconds;
      int64_t  ptpNanoSeconds;
      uint16_t octaveWidth;
      uint16_t octaveHeight;
      uint16_t numOctaves;
      uint16_t scaleFactor;
      uint16_t motionStatus;
      uint16_t averageXMotion;
      uint16_t averageYMotion;
      uint16_t numFeatures;
      uint16_t numDescriptors;
      std::vector<Feature> features;
      std::vector<Descriptor> descriptors;
  };
 
  typedef void (*Callback)(const Header& header,
                           void         *userDataP);
 
} // namespace feature_detector
 
 
namespace system {
 
class MULTISENSE_API DeviceMode {
public:
 
    uint32_t   width;
    uint32_t   height;
    DataSource supportedDataSources;
    int32_t    disparities;
 
    DeviceMode(uint32_t   w=0,
               uint32_t   h=0,
               DataSource d=0,
               int32_t    s=-1) :
        width(w),
        height(h),
        supportedDataSources(d),
        disparities(s) {};
};
 
class MULTISENSE_API VersionInfo {
public:
 
    std::string apiBuildDate;
    VersionType apiVersion;
 
    std::string sensorFirmwareBuildDate;
    VersionType sensorFirmwareVersion;
 
    uint64_t    sensorHardwareVersion;
    uint64_t    sensorHardwareMagic;
    uint64_t    sensorFpgaDna;
 
    VersionInfo() :
        apiVersion(0),
        sensorFirmwareVersion(0),
        sensorHardwareVersion(0),
        sensorHardwareMagic(0),
        sensorFpgaDna(0) {};
};
 
class MULTISENSE_API PcbInfo {
public:
 
    std::string name;
    uint32_t    revision;
 
    PcbInfo() : revision(0) {};
};
 
class MULTISENSE_API DeviceInfo {
public:
 
    static CRL_CONSTEXPR uint8_t MAX_PCBS                   = 8;
 
    static CRL_CONSTEXPR uint32_t HARDWARE_REV_MULTISENSE_SL                  = 1;
    static CRL_CONSTEXPR uint32_t HARDWARE_REV_MULTISENSE_S7                  = 2;
    static CRL_CONSTEXPR uint32_t HARDWARE_REV_MULTISENSE_S                   = HARDWARE_REV_MULTISENSE_S7; // alias for backward source compatibility
    static CRL_CONSTEXPR uint32_t HARDWARE_REV_MULTISENSE_M                   = 3;
    static CRL_CONSTEXPR uint32_t HARDWARE_REV_MULTISENSE_S7S                 = 4;
    static CRL_CONSTEXPR uint32_t HARDWARE_REV_MULTISENSE_S21                 = 5;
    static CRL_CONSTEXPR uint32_t HARDWARE_REV_MULTISENSE_ST21                = 6;
    static CRL_CONSTEXPR uint32_t HARDWARE_REV_MULTISENSE_C6S2_S27            = 7;
    static CRL_CONSTEXPR uint32_t HARDWARE_REV_MULTISENSE_S30                 = 8;
    static CRL_CONSTEXPR uint32_t HARDWARE_REV_MULTISENSE_S7AR                = 9;
    static CRL_CONSTEXPR uint32_t HARDWARE_REV_MULTISENSE_KS21                = 10;
    static CRL_CONSTEXPR uint32_t HARDWARE_REV_MULTISENSE_MONOCAM             = 11;
    static CRL_CONSTEXPR uint32_t HARDWARE_REV_MULTISENSE_REMOTE_HEAD_VPB     = 12;
    static CRL_CONSTEXPR uint32_t HARDWARE_REV_MULTISENSE_REMOTE_HEAD_STEREO  = 13;
    static CRL_CONSTEXPR uint32_t HARDWARE_REV_MULTISENSE_REMOTE_HEAD_MONOCAM = 14;
    static CRL_CONSTEXPR uint32_t HARDWARE_REV_MULTISENSE_KS21_SILVER         = 15;
    static CRL_CONSTEXPR uint32_t HARDWARE_REV_MULTISENSE_ST25                = 16;
    static CRL_CONSTEXPR uint32_t HARDWARE_REV_BCAM                           = 100;
    static CRL_CONSTEXPR uint32_t HARDWARE_REV_MONO                           = 101;
 
    static CRL_CONSTEXPR uint32_t IMAGER_TYPE_NONE           = 0;
    static CRL_CONSTEXPR uint32_t IMAGER_TYPE_CMV2000_GREY   = 1;
    static CRL_CONSTEXPR uint32_t IMAGER_TYPE_CMV2000_COLOR  = 2;
    static CRL_CONSTEXPR uint32_t IMAGER_TYPE_CMV4000_GREY   = 3;
    static CRL_CONSTEXPR uint32_t IMAGER_TYPE_CMV4000_COLOR  = 4;
    static CRL_CONSTEXPR uint32_t IMAGER_TYPE_FLIR_TAU2      = 7;
    static CRL_CONSTEXPR uint32_t IMAGER_TYPE_IMX104_COLOR   = 100;
    static CRL_CONSTEXPR uint32_t IMAGER_TYPE_AR0234_GREY    = 200;
    static CRL_CONSTEXPR uint32_t IMAGER_TYPE_AR0239_COLOR   = 202;
 
    static CRL_CONSTEXPR uint32_t LIGHTING_TYPE_NONE = 0;
    static CRL_CONSTEXPR uint32_t LIGHTING_TYPE_INTERNAL = 1;
    static CRL_CONSTEXPR uint32_t LIGHTING_TYPE_EXTERNAL = 2;
    static CRL_CONSTEXPR uint32_t LIGHTING_TYPE_PATTERN_PROJECTOR = 3;
    static CRL_CONSTEXPR uint32_t LIGHTING_TYPE_OUTPUT_TRIGGER = 4;
    static CRL_CONSTEXPR uint32_t LIGHTING_TYPE_PATTERN_PROJECTOR_AND_OUTPUT_TRIGGER = 5;
 
    std::string name;
    std::string buildDate;
    std::string serialNumber;
    uint32_t    hardwareRevision;
 
    std::vector<PcbInfo> pcbs;
 
    std::string imagerName;
    uint32_t    imagerType;
    uint32_t    imagerWidth;
    uint32_t    imagerHeight;
 
    std::string lensName;
    uint32_t    lensType;
    float       nominalBaseline;
    float       nominalFocalLength;
    float       nominalRelativeAperture;
 
    uint32_t    lightingType;
    uint32_t    numberOfLights;
 
    std::string laserName;
    uint32_t    laserType;
 
    std::string motorName;
    uint32_t    motorType;
    float       motorGearReduction;
 
    DeviceInfo() :
        hardwareRevision(0),
        imagerType(0),
        imagerWidth(0),
        imagerHeight(0),
        lensType(0),
        nominalBaseline(0.0),
        nominalFocalLength(0.0),
        nominalRelativeAperture(0.0),
        lightingType(0),
        numberOfLights(0),
        laserType(0),
        motorType(0),
        motorGearReduction(0.0) {};
};
 
class MULTISENSE_API NetworkConfig {
public:
 
    std::string ipv4Address;
    std::string ipv4Gateway;
    std::string ipv4Netmask;
 
    NetworkConfig() :
        ipv4Address("10.66.171.21"),
        ipv4Gateway("10.66.171.1"),
        ipv4Netmask("255.255.240.0") {};
 
    NetworkConfig(const std::string& a,
                  const std::string& g,
                  const std::string& n) :
        ipv4Address(a),
        ipv4Gateway(g),
        ipv4Netmask(n) {};
};
 
class MULTISENSE_API StatusMessage {
    public:
 
        double uptime;
 
        bool systemOk;
 
        bool laserOk;
 
        bool laserMotorOk;
 
        bool camerasOk;
 
        bool imuOk;
 
        bool externalLedsOk;
 
        bool processingPipelineOk;
 
        float powerSupplyTemperature;
 
        float fpgaTemperature;
 
        float leftImagerTemperature;
 
        float rightImagerTemperature;
 
        float inputVoltage;
 
        float inputCurrent;
 
        float fpgaPower;
 
        float logicPower;
 
        float imagerPower;
 
        StatusMessage():
            uptime(0.),
            systemOk(false),
            laserOk(false),
            laserMotorOk(false),
            camerasOk(false),
            imuOk(false),
            externalLedsOk(false),
            processingPipelineOk(false),
            powerSupplyTemperature(0.),
            fpgaTemperature(0.),
            leftImagerTemperature(0.),
            rightImagerTemperature(0.),
            inputVoltage(0.),
            inputCurrent(0.),
            fpgaPower(0.),
            logicPower(0.),
            imagerPower(0.) {};
};
 
class MULTISENSE_API ExternalCalibration {
    public:
 
        float x;
 
        float y;
 
        float z;
 
        float roll;
 
        float pitch;
 
        float yaw;
 
        ExternalCalibration():
            x(0.),
            y(0.),
            z(0.),
            roll(0.),
            pitch(0.),
            yaw(0.) {};
};
 
class MULTISENSE_API GroundSurfaceParams {
    public:
 
        int ground_surface_number_of_levels_x;
 
        int ground_surface_number_of_levels_z;
 
        int ground_surface_base_model;
 
        float ground_surface_pointcloud_grid_size;
 
        int ground_surface_min_points_per_grid;
 
        int ground_surface_pointcloud_decimation;
 
        float ground_surface_pointcloud_max_range_m;
 
        float ground_surface_pointcloud_min_range_m;
 
        float ground_surface_pointcloud_max_width_m;
 
        float ground_surface_pointcloud_min_width_m;
 
        float ground_surface_pointcloud_max_height_m;
 
        float ground_surface_pointcloud_min_height_m;
 
        float ground_surface_obstacle_height_thresh_m;
 
        float ground_surface_obstacle_percentage_thresh;
 
        int ground_surface_max_fitting_iterations;
 
        float ground_surface_adjacent_cell_search_size_m;
 
        GroundSurfaceParams():
            ground_surface_number_of_levels_x(4),
            ground_surface_number_of_levels_z(4),
            ground_surface_base_model(1),
            ground_surface_pointcloud_grid_size(0.5),
            ground_surface_min_points_per_grid(10),
            ground_surface_pointcloud_decimation(1),
            ground_surface_pointcloud_max_range_m(30.0),
            ground_surface_pointcloud_min_range_m(0.5),
            ground_surface_pointcloud_max_width_m(25.0),
            ground_surface_pointcloud_min_width_m(-25.0),
            ground_surface_pointcloud_max_height_m(10.0),
            ground_surface_pointcloud_min_height_m(-10.0),
            ground_surface_obstacle_height_thresh_m(2.0),
            ground_surface_obstacle_percentage_thresh(0.5),
            ground_surface_max_fitting_iterations(10),
            ground_surface_adjacent_cell_search_size_m(1.5) {};
};
 
class MULTISENSE_API ApriltagParams {
    public:
        std::string family;
 
        uint8_t max_hamming;
 
        double quad_detection_blur_sigma;
 
        double quad_detection_decimate;
 
        size_t min_border_width;
 
        bool refine_quad_edges;
 
        double decode_sharpening;
 
        ApriltagParams():
            family("tagStandard52h13"),
            max_hamming(0),
            quad_detection_blur_sigma(0.75),
            quad_detection_decimate(1.0),
            min_border_width(5),
            refine_quad_edges(false),
            decode_sharpening(0.25) {};
};
 
class MULTISENSE_API FeatureDetectorConfig {
 
    private:
 
        uint32_t m_numberOfFeatures;
 
        bool m_grouping;
 
        uint32_t m_motion;
 
    public:
        uint32_t numberOfFeatures() const { return m_numberOfFeatures; };
 
        bool grouping() const { return m_grouping; };
 
        bool motion() const { return m_motion; };
 
        void setNumberOfFeatures(const uint32_t &numberOfFeatures)    {
 
            if (numberOfFeatures > feature_detector::RECOMMENDED_MAX_FEATURES_FULL_RES)
            {
                std::cout << "WARNING: The number of features requested is above recommended level!" << '\n';
                std::cout << "If a performance impact is noticed reduce number of features and/or framerate of camera" << '\n';
                std::cout << "The recommended maximum camera settings when using the feature detector is:" << '\n';
                std::cout << "Quarter Res: 15FPS and 1500 Features" << '\n';
                std::cout << "Full    Res:  5FPS and 5000 Features" << '\n';
            }
 
            m_numberOfFeatures = numberOfFeatures;
 
        };
 
        void setGrouping(const bool &g)    {
            m_grouping = g;
        }
 
        void setMotion(const uint32_t &m)    {
            m_motion = m;
        }
 
        FeatureDetectorConfig():
            m_numberOfFeatures(feature_detector::RECOMMENDED_MAX_FEATURES_QUARTER_RES),
            m_grouping(true),
            m_motion(1)
        {};
};
 
class MULTISENSE_API PtpStatus {
    public:
        uint8_t gm_present;
 
        uint8_t gm_id[8] = {0};
 
        int64_t gm_offset;
 
        int64_t path_delay;
 
        uint16_t steps_removed;
 
        PtpStatus():
            gm_present(0),
            gm_offset(0),
            path_delay(0),
            steps_removed(0) {};
};
 
struct ChannelStatistics
{
    ChannelStatistics():
        numMissedHeaders(0),
        numDroppedAssemblers(0),
        numImageMetaData(0),
        numDispatchedImage(0),
        numDispatchedLidar(0),
        numDispatchedPps(0),
        numDispatchedImu(0),
        numDispatchedCompressedImage(0),
        numDispatchedGroundSurfaceSpline(0),
        numDispatchedAprilTagDetections(0)
    {
    };
 
    ~ChannelStatistics()
    {
    };
 
    //
    // The total number of sequence ids observed where headers appeared to have
    // been missed
    std::size_t numMissedHeaders;
 
    //
    // The number of UDP assemblers that were dropped from the depth cache
    // while awaiting assembly
    std::size_t numDroppedAssemblers;
 
    //
    // The number of image metadata messages that were received
    std::size_t numImageMetaData;
 
    //
    // The number of images that were dispatched
    std::size_t numDispatchedImage;
 
    //
    // The number of lidar scans that were dispatched
    std::size_t numDispatchedLidar;
 
    //
    // The number of dispatched PPS messages
    std::size_t numDispatchedPps;
 
    //
    // The number of dispatched IMU messages
    std::size_t numDispatchedImu;
 
    //
    // The number of dispatched compressed images
    std::size_t numDispatchedCompressedImage;
 
    //
    // The number of dispatched ground surface spline events
    std::size_t numDispatchedGroundSurfaceSpline;
 
    //
    // The number of dispatched AprilTag detection events
    std::size_t numDispatchedAprilTagDetections;
 
    //
    // The number of dispatached feature detections
    std::size_t numDispatchedFeatureDetections;
};
 
} // namespace system
} // namespace multisense
} // namespace crl
 
#if defined (_MSC_VER)
#pragma warning (pop)
#endif
 
#endif // LibMultiSense_MultiSenseTypes_hh