MultiSenseTypes.hh

Go to the documentation of this file.

 
#ifndef LibMultiSense_MultiSenseTypes_hh
#define LibMultiSense_MultiSenseTypes_hh
 
#include <stdint.h>
 
#include <string>
#include <vector>
 
#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 uint32_t DataSource;
 
static CRL_CONSTEXPR DataSource Source_Unknown                       = 0;
static CRL_CONSTEXPR DataSource Source_All                           = 0xffffffff;
static CRL_CONSTEXPR DataSource Source_Raw_Left                      = (1U<<0);
static CRL_CONSTEXPR DataSource Source_Raw_Right                     = (1U<<1);
static CRL_CONSTEXPR DataSource Source_Luma_Left                     = (1U<<2);
static CRL_CONSTEXPR DataSource Source_Luma_Right                    = (1U<<3);
static CRL_CONSTEXPR DataSource Source_Luma_Rectified_Left           = (1U<<4);
static CRL_CONSTEXPR DataSource Source_Luma_Rectified_Right          = (1U<<5);
static CRL_CONSTEXPR DataSource Source_Chroma_Left                   = (1U<<6);
static CRL_CONSTEXPR DataSource Source_Chroma_Right                  = (1U<<7);
static CRL_CONSTEXPR DataSource Source_Chroma_Rectified_Aux          = (1U<<8);
static CRL_CONSTEXPR DataSource Source_Disparity                     = (1U<<10);
static CRL_CONSTEXPR DataSource Source_Disparity_Left                = (1U<<10); // same as Source_Disparity
static CRL_CONSTEXPR DataSource Source_Disparity_Right               = (1U<<11);
static CRL_CONSTEXPR DataSource Source_Disparity_Cost                = (1U<<12);
static CRL_CONSTEXPR DataSource Source_Jpeg_Left                     = (1U<<16);
static CRL_CONSTEXPR DataSource Source_Rgb_Left                      = (1U<<17);
static CRL_CONSTEXPR DataSource Source_Ground_Surface_Spline_Data    = (1U<<20);
static CRL_CONSTEXPR DataSource Source_Ground_Surface_Class_Image    = (1U<<22);
static CRL_CONSTEXPR DataSource Source_Lidar_Scan                    = (1U<<24);
static CRL_CONSTEXPR DataSource Source_Imu                           = (1U<<25);
static CRL_CONSTEXPR DataSource Source_Pps                           = (1U<<26);
static CRL_CONSTEXPR DataSource Source_Raw_Aux                       = (1U<<27);
static CRL_CONSTEXPR DataSource Source_Luma_Aux                      = (1U<<28);
static CRL_CONSTEXPR DataSource Source_Luma_Rectified_Aux            = (1U<<29);
static CRL_CONSTEXPR DataSource Source_Chroma_Aux                    = (1U<<30);
static CRL_CONSTEXPR DataSource Source_Disparity_Aux                 = (1U<<31);
static CRL_CONSTEXPR DataSource Source_Compressed_Left               = (1U<<9);
static CRL_CONSTEXPR DataSource Source_Compressed_Right              = (1U<<13);
static CRL_CONSTEXPR DataSource Source_Compressed_Aux                = (1U<<14);
static CRL_CONSTEXPR DataSource Source_Compressed_Rectified_Left     = (1U<<15);
static CRL_CONSTEXPR DataSource Source_Compressed_Rectified_Right    = (1U<<16);
static CRL_CONSTEXPR DataSource Source_Compressed_Rectified_Aux      = (1U<<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 Active_Head_0 = (1U<<5);
static CRL_CONSTEXPR CameraProfile Active_Head_1 = (1U<<6);
static CRL_CONSTEXPR CameraProfile Active_Head_2 = (1U<<7);
static CRL_CONSTEXPR CameraProfile Active_Head_3 = (1U<<8);
 
 
typedef uint32_t ImageCompressionCodec;
 
static CRL_CONSTEXPR ImageCompressionCodec H264 = 0;
 
class MULTISENSE_API DirectedStream {
public:
 
    static CRL_CONSTEXPR uint16_t DFL_UDP_PORT = 10001;
 
    DataSource  mask;
    std::string address;
    uint16_t    udpPort;
    uint32_t    fpsDecimation;
 
    DirectedStream() {};
 
    DirectedStream(DataSource         m,
                   const std::string& addr,
                   uint16_t           p=DFL_UDP_PORT,
                   uint32_t           dec=1) :
        mask(m),
        address(addr),
        udpPort(p),
        fpsDecimation(dec) {};
};
 
/*
 * 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;
    uint32_t headId;
    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.75f),
      m_autoExposureRoiX(0), m_autoExposureRoiY(0),
      m_autoExposureRoiWidth(Roi_Full_Image), m_autoExposureRoiHeight(Roi_Full_Image),
      m_exposureSource(Exposure_Default_Source),  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 setExposureSource(const DataSource &s)    { m_exposureSource  = s; };
 
    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; };
 
    DataSource exposureSource() const { return m_exposureSource; };
 
    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;
        DataSource m_exposureSource;
 
        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 setCamMode          (int m) { m_cam_mode=m; };
 
    void setOffset         (int o) { m_offset=o; };
 
    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_primary_exposure.setExposure(e); };
 
    void setAutoExposure      (bool e)     { m_primary_exposure.setAutoExposure(e); };
 
    void setAutoExposureMax   (uint32_t m) { m_primary_exposure.setAutoExposureMax(m); };
 
    void setAutoExposureDecay (uint32_t d) { m_primary_exposure.setAutoExposureDecay(d); };
 
    void setAutoExposureTargetIntensity (float d) { m_primary_exposure.setAutoExposureTargetIntensity(d); };
 
    void setAutoExposureThresh(float t)    { m_primary_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 setStoreSettingsInFlash    (bool e)     {m_storeSettingsInFlash = e;    };
 
    void setAutoExposureRoi(uint16_t start_x, uint16_t start_y, uint16_t width, uint16_t height)
    {
        m_primary_exposure.setAutoExposureRoi(start_x, start_y, width, height);
    }
 
    void setExposureSource(const DataSource &s)    { m_primary_exposure.setExposureSource(s); };
 
    void setCameraProfile(const CameraProfile &profile)
    {
        m_profile = profile;
    }
 
    void setPrimaryExposure (const ExposureConfig &c ) { m_primary_exposure = c; };
 
    void setSecondaryExposures(const std::vector<ExposureConfig> &c) { m_secondary_exposures = c; };
 
    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; };
 
    int camMode () const { return m_cam_mode; };
 
    int offset () const { return m_offset; };
 
    float    fps         () const { return m_fps;         };
 
    float    gain              () const { return m_gain;      };
 
 
    uint32_t exposure          () const { return m_primary_exposure.exposure();  };
 
    bool     autoExposure      () const { return m_primary_exposure.autoExposure(); };
 
    uint32_t autoExposureMax   () const { return m_primary_exposure.autoExposureMax();     };
 
    uint32_t autoExposureDecay () const { return m_primary_exposure.autoExposureDecay();   };
 
    float autoExposureTargetIntensity () const { return m_primary_exposure.autoExposureTargetIntensity();   };
 
    float    autoExposureThresh() const { return m_primary_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;  };
 
    bool     storeSettingsInFlash    () const { return m_storeSettingsInFlash; };
 
    uint16_t autoExposureRoiX        () const { return m_primary_exposure.autoExposureRoiX(); };
 
    uint16_t autoExposureRoiY        () const { return m_primary_exposure.autoExposureRoiY(); };
 
    uint16_t autoExposureRoiWidth    () const { return m_primary_exposure.autoExposureRoiWidth(); };
 
    uint16_t autoExposureRoiHeight   () const { return m_primary_exposure.autoExposureRoiHeight(); };
 
    DataSource exposureSource() const { return m_primary_exposure.exposureSource(); };
 
    CameraProfile cameraProfile () const { return m_profile; };
 
    ExposureConfig primaryExposure() const { return m_primary_exposure; };
 
    std::vector<ExposureConfig> secondaryExposures() const { return m_secondary_exposures; };
 
    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_primary_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_cam_mode(0), m_offset(-1), m_spfStrength(0.5f),
               m_hdrEnabled(false), m_storeSettingsInFlash(false),
               m_profile(User_Control),
               m_secondary_exposures(),
               m_gamma(1.5),
               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_primary_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;
    int      m_cam_mode;
    int      m_offset;
    float    m_spfStrength;
    bool     m_hdrEnabled;
    bool     m_storeSettingsInFlash;
    CameraProfile m_profile;
    std::vector<ExposureConfig> m_secondary_exposures;
    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 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 SensorCalibration {
public:
 
    uint8_t adc_gain[2];
 
    int16_t bl_offset[2];
 
    uint8_t vramp[2];
 
};
 
class MULTISENSE_API TransmitDelay {
public:
 
    int delay;
 
};
 
class MULTISENSE_API Histogram {
public:
 
    Histogram() : channels(0),
                  bins(0),
                  data() {};
    uint32_t              channels;
    uint32_t              bins;
    std::vector<uint32_t> data;
};
 
} // 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.0 || 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.0 || 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];
    };
 
    Config() : m_flashEnabled(false), m_dutyCycle(MAX_LIGHTS, -1.0f) {};
 
private:
 
    bool               m_flashEnabled;
    std::vector<float> m_dutyCycle;
};
 
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;
    uint32_t headId;
    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;
 
    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 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_BCAM                = 100;
    static CRL_CONSTEXPR uint32_t HARDWARE_REV_MONO                = 101;
 
    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_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_SL_INTERNAL = 1;
    static CRL_CONSTEXPR uint32_t LIGHTING_TYPE_S21_EXTERNAL = 2;
 
    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 PtpStatus {
};
 
} // namespace system
} // namespace multisense
} // namespace crl
 
#if defined (_MSC_VER)
#pragma warning (pop)
#endif
 
#endif // LibMultiSense_MultiSenseTypes_hh