MultiSenseTypes.hh

Go to the documentation of this file.

#ifndef LibMultiSense_MultiSenseTypes_hh
#define LibMultiSense_MultiSenseTypes_hh

#include <stdint.h>

#include <string>
#include <vector>

//
// Add compatibility for C++ 11
#if __cplusplus > 199711L
// This compiler supports C++11.
#define CRL_CONSTEXPR constexpr
#else
// This compiler does not support C++11.
#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_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               = (1<<0);
static CRL_CONSTEXPR DataSource Source_Raw_Right              = (1<<1);
static CRL_CONSTEXPR DataSource Source_Luma_Left              = (1<<2);
static CRL_CONSTEXPR DataSource Source_Luma_Right             = (1<<3);
static CRL_CONSTEXPR DataSource Source_Luma_Rectified_Left    = (1<<4);
static CRL_CONSTEXPR DataSource Source_Luma_Rectified_Right   = (1<<5);
static CRL_CONSTEXPR DataSource Source_Chroma_Left            = (1<<6);
static CRL_CONSTEXPR DataSource Source_Chroma_Right           = (1<<7);
static CRL_CONSTEXPR DataSource Source_Disparity              = (1<<10);
static CRL_CONSTEXPR DataSource Source_Disparity_Left         = (1<<10); // same as Source_Disparity
static CRL_CONSTEXPR DataSource Source_Disparity_Right        = (1<<11);
static CRL_CONSTEXPR DataSource Source_Disparity_Cost         = (1<<12);
static CRL_CONSTEXPR DataSource Source_Jpeg_Left              = (1<<16);
static CRL_CONSTEXPR DataSource Source_Rgb_Left               = (1<<17);
static CRL_CONSTEXPR DataSource Source_Lidar_Scan             = (1<<24);
static CRL_CONSTEXPR DataSource Source_Imu                    = (1<<25);
static CRL_CONSTEXPR DataSource Source_Pps                    = (1<<26);

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;



class MULTISENSE_API HeaderBase {
public:
    virtual bool inMask(DataSource 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 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_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 setAutoExposureThresh(float t)    { m_aeThresh  = 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;    };


    //
    // 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_exposure;  };

    bool     autoExposure      () const { return m_aeEnabled; };

    uint32_t autoExposureMax   () const { return m_aeMax;     };

    uint32_t autoExposureDecay () const { return m_aeDecay;   };

    float    autoExposureThresh() const { return m_aeThresh;  };

    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;  };



    //
    // 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(10000), m_aeEnabled(true), m_aeMax(5000000), m_aeDecay(7), m_aeThresh(0.75f),
               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_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;
    uint32_t m_exposure;
    bool     m_aeEnabled;
    uint32_t m_aeMax;
    uint32_t m_aeDecay;
    float    m_aeThresh;
    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;

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;
};

class MULTISENSE_API SensorCalibration {
public:

    uint8_t adc_gain[2];

    int16_t bl_offset[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;
static CRL_CONSTEXPR float    MAX_AMBIENT_LIGHTING = 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 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 uint32_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_BCAM             = 100;

    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 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.) {};
};

}; // namespace system
}; // namespace multisense
}; // namespace crl

#if defined (_MSC_VER)
#pragma warning (pop)
#endif

#endif // LibMultiSense_MultiSenseTypes_hh