StreamProfile.hpp

Go to the documentation of this file.

 
#pragma once
 
#include "Types.hpp"
 
#include <iostream>
#include <memory>
 
struct StreamProfileImpl;
struct StreamProfileListImpl;
 
namespace ob {
 
class VideoStreamProfile;
class GyroStreamProfile;
class AccelStreamProfile;
class Config;
 
class OB_EXTENSION_API StreamProfile : public std::enable_shared_from_this<StreamProfile> {
protected:
    std::unique_ptr<StreamProfileImpl> impl_;
 
public:
    StreamProfile(std::unique_ptr<StreamProfileImpl> impl);
    StreamProfile(StreamProfile &streamProfile);
    virtual ~StreamProfile() noexcept;
 
    OBFormat format() const;
 
    OBStreamType type() const;
 
    OBExtrinsic getExtrinsicTo(std::shared_ptr<StreamProfile> target);
 
    template <typename T> bool is();
 
    template <typename T> std::shared_ptr<T> as() {
        if(!is<T>()) {
            throw std::runtime_error("Unsupported operation. Object's type is not the required type.");
        }
 
        return std::static_pointer_cast<T>(std::const_pointer_cast<StreamProfile>(shared_from_this()));
    }
 
    friend class Sensor;
    friend class Config;
    friend class Pipeline;
};
 
class OB_EXTENSION_API VideoStreamProfile : public StreamProfile {
public:
    explicit VideoStreamProfile(StreamProfile &profile);
 
    explicit VideoStreamProfile(std::unique_ptr<StreamProfileImpl> impl);
 
    ~VideoStreamProfile() noexcept override;
 
    uint32_t fps() const;
 
    uint32_t width() const;
 
    uint32_t height() const;
 
    OBCameraIntrinsic getIntrinsic();
 
    OBCameraDistortion getDistortion();
};
 
class OB_EXTENSION_API AccelStreamProfile : public StreamProfile {
public:
    explicit AccelStreamProfile(StreamProfile &profile);
 
    explicit AccelStreamProfile(std::unique_ptr<StreamProfileImpl> impl);
 
    ~AccelStreamProfile() noexcept override;
 
    OBAccelFullScaleRange fullScaleRange() const;
 
    OBAccelSampleRate sampleRate() const;
 
    OBAccelIntrinsic getIntrinsic();
};
 
class OB_EXTENSION_API GyroStreamProfile : public StreamProfile {
public:
    explicit GyroStreamProfile(StreamProfile &profile);
 
    explicit GyroStreamProfile(std::unique_ptr<StreamProfileImpl> impl);
    ~GyroStreamProfile() noexcept override;
 
    OBGyroFullScaleRange fullScaleRange() const;
 
    OBGyroSampleRate sampleRate() const;
 
    OBGyroIntrinsic getIntrinsic();
};
 
template <typename T> bool StreamProfile::is() {
    switch(this->type()) {
    case OB_STREAM_VIDEO:
    case OB_STREAM_IR:
    case OB_STREAM_IR_LEFT:
    case OB_STREAM_IR_RIGHT:
    case OB_STREAM_COLOR:
    case OB_STREAM_DEPTH:
    case OB_STREAM_RAW_PHASE:
        return typeid(T) == typeid(VideoStreamProfile);
    case OB_STREAM_ACCEL:
        return typeid(T) == typeid(AccelStreamProfile);
    case OB_STREAM_GYRO:
        return typeid(T) == typeid(GyroStreamProfile);
    default:
        break;
    }
    return false;
}
 
class OB_EXTENSION_API StreamProfileList {
protected:
    std::unique_ptr<StreamProfileListImpl> impl_;
 
public:
    explicit StreamProfileList(std::unique_ptr<StreamProfileListImpl> impl);
    ~StreamProfileList() noexcept;
 
    uint32_t count() const;
 
    const std::shared_ptr<StreamProfile> getProfile(uint32_t index);
 
    const std::shared_ptr<VideoStreamProfile> getVideoStreamProfile(int width = OB_WIDTH_ANY, int height = OB_HEIGHT_ANY, OBFormat format = OB_FORMAT_ANY,
                                                                    int fps = OB_FPS_ANY);
 
    const std::shared_ptr<AccelStreamProfile> getAccelStreamProfile(OBAccelFullScaleRange fullScaleRange, OBAccelSampleRate sampleRate);
 
    const std::shared_ptr<GyroStreamProfile> getGyroStreamProfile(OBGyroFullScaleRange fullScaleRange, OBGyroSampleRate sampleRate);
};
 
}  // namespace ob