device.h

Go to the documentation of this file.

#ifndef OSP_DEVICE_H
#define OSP_DEVICE_H

#include <atomic>
#include <cassert>
#include <chrono>
#include <iostream>
#include <list>
#include <memory>

#include <osp/calib/camera.h>
#include <osp/exports/sdk_export.h>
#include <osp/types/mat.h>
#include <osp/types/range.h>
#include <osp/types/size.h>

namespace osp {

class OSP_SDK_EXPORT Status
{
public:
    enum class Code
    {
        Success,            
        Unavailable,        
        Unauthenticated,    
        InvalidArgument,    
        PermissionDenied,   
        Unknown             
    };

    Status(Code code, std::string errMsg = std::string());

    bool ok();

    Code statusCode();

    std::string errorMessage();

private:
    Code m_code;
    std::string m_errMsg;
};

struct Frame
{
    struct Metadata
    {
        Metadata()
            : timestamp(0)
            , sensorAnalogGain(0)
            , sensorExposureTime(0)
            , sensorSensitivity(0)
            , ispDigitalGain(0)
            , sceneLux(0)
            , achievedFps(0)
        {}

        int64_t timestamp;              
        float sensorAnalogGain;         
        uint64_t sensorExposureTime;    
        uint32_t sensorSensitivity;     
        float ispDigitalGain;           
        float sceneLux;                 
        float achievedFps;              
    };

    Metadata metadata;                  
    Matrix<uint8_t, 3> sourceImage0;    
    Matrix<uint8_t, 3> sourceImage1;    
    Matrix<uint8_t, 3> sourceImage2;    
    Matrix<uint8_t, 3> image;           
    Matrix<uint16_t, 1> distanceMap;    
    Matrix<Point3d<float>> pointcloud;  
};

struct PasswordCredentials
{
    std::string password;
};

enum class CameraModelType
{
    Camera0,
    Camera1,
    Camera2,
//    StereoLeftA,
//    StereoRightA,
//    StereoLeftB,
//    StereoRightB,
    Target
};

enum class StereoMatchingMode
{
    Quality,    
    Fast        
};

enum class StereoMatchingResolution
{
    Low,        
    Middle,     
    High,       
};

enum class TemperatureSensor
{
    CPU,
    GPU,
    Board
};

enum class ImageCompression
{
    None,       
    Lossless,   
    Lossy       
};

struct StreamSettings
{
    StreamSettings() : imageCompression{ImageCompression::None} {}

    ImageCompression imageCompression;  
};

struct StereoMatchingBmParams
{
    // not implemented
};

struct StereoMatchingSgmParams
{
    enum ScanLineDirection
    {
        ScanLineLeftRight           = 1 << 0,   
        ScanLineTopLeftBottomRight  = 1 << 1,   
        ScanLineTopBottom           = 1 << 2,   
        ScanLineTopRightBottomLeft  = 1 << 3,   
        ScanLineRightLeft           = 1 << 4,   
        ScanLineBottomRightTopLeft  = 1 << 5,   
        ScanLineBottomTop           = 1 << 6,   
        ScanLineBottomLeftTopRight  = 1 << 7,   
        ScanLineCross = ScanLineLeftRight | ScanLineRightLeft | ScanLineTopBottom | ScanLineBottomTop,

        ScanLineAll                 = 0xFF      
    };

    StereoMatchingSgmParams()
        : maxDisparity(96)
        , p1(8)
        , p2(32)
        , sad(3)
        , ctWinSize(3)
        , hcWinSize(5)
        , clip(31)
        , maxDiff(5)
        , uniqueness(15)
        , scanlines(ScanLineAll)
        , filterTopArea(false)
        , pyramidalStereo(true)
    {}

    int32_t maxDisparity;           
    int32_t p1;                     
    int32_t p2;                     
    int32_t sad;                    
    int32_t ctWinSize;              
    int32_t hcWinSize;              
    int32_t clip;                   
    int32_t maxDiff;                
    int32_t uniqueness;             
    int scanlines;                  
    bool filterTopArea;             
    bool pyramidalStereo;           
};

struct StereoMatchingParams
{
    StereoMatchingBmParams bmParams;
    StereoMatchingSgmParams sgmParams;
};


OSP_SDK_EXPORT bool operator==(const StereoMatchingBmParams &lhs, const StereoMatchingBmParams &rhs);
OSP_SDK_EXPORT bool operator==(const StereoMatchingSgmParams &lhs, const StereoMatchingSgmParams &rhs);
OSP_SDK_EXPORT bool operator==(const StereoMatchingParams &lhs, const StereoMatchingParams &rhs);

class OSP_SDK_EXPORT Device
{
public:
    class Private;

    struct Info
    {
        std::string type;           
        std::string serialNumber;   
        std::string uri;            
        bool passwordRequired;      
    };

    enum class CaptureMode
    {
        RAW,    
        RGBD    
    };

    enum class StereoConfiguration
    {
        Binocular,
        Trinocular
    };

    virtual ~Device();

    Status open(std::string uri);

    void close();

    Status login(const PasswordCredentials &credentials);

    void logout();

    bool setPasswordCredentials(const PasswordCredentials &credentials);

    Info info();

    bool reboot();

    bool poweroff();

    Status start();

    void stop();

    bool running();

    std::unique_ptr<osp::Frame> getFrame(std::chrono::milliseconds timeout = std::chrono::milliseconds(0));

    float temperature(TemperatureSensor sensor);

    Camera getCameraModel(CameraModelType type);

    void setCameraModel(CameraModelType type, Camera model);

    void saveCurrentCameraModelsAsDefault();

    void setExtrinsic(Extrinsic extrinsic);

    Extrinsic getExtrinsic();

    CaptureMode captureMode() const;

    Status setCaptureMode(CaptureMode mode);

    bool exposureAutoLock();

    Range<uint64_t> exposureRange();

    float exposureCompensation();

    Range<float> gainRange();

    Range<float> digitalGainRange();

    float frameRate();

    bool setExposureAutoLock(bool lock);

    bool setExposureRange(Range<uint64_t> range);

    bool setExposureCompensation(float ev);

    bool setGainRange(Range<float> range);

    bool setDigitalGainRange(Range<float> range);

    bool setFrameRate(float frameRate);

    StereoConfiguration stereoConfiguration();

    bool setStereoConfiguration(StereoConfiguration config);

    StereoMatchingMode stereoMatchingMode();

    bool setStereoMatchingMode(StereoMatchingMode mode);

    osp::Size<size_t> stereoMatchingResolution();

    bool setStereoMatchingResolution(const osp::Size<size_t> &resolution);

    StreamSettings streamSettings() const;

    void setStreamSettings(const StreamSettings &streamSettings);


    StereoMatchingParams stereoMatchingParams() const;

    bool setStereoMatchingParams(const StereoMatchingParams &stereoMatchingParams);


protected:
    Device();

private:
    std::unique_ptr<Private> m_p;
};

class OSP_SDK_EXPORT DeviceManager
{
public:
    class Private;
    virtual ~DeviceManager();

    static DeviceManager &get();

    std::vector<Device::Info> getDevices();

    std::unique_ptr<Device> request(const Device::Info &info, bool useTls = false);

    std::unique_ptr<Device> request(const std::string &uri, bool useTls = false);

    void rescan();

protected:
    DeviceManager();

private:
    std::unique_ptr<Private> m_p;
};

}

#endif // OSP_DEVICE_H