MultiSenseChannel.hh

Go to the documentation of this file.

 
#pragma once
 
#include <functional>
#include <optional>
 
#include "MultiSenseTypes.hh"
 
namespace multisense {
 
class MULTISENSE_API Channel {
public:
    enum class ChannelImplementation
    {
        LEGACY
    };
 
    struct ReceiveBufferConfig
    {
        size_t num_small_buffers = 100;
        size_t small_buffer_size = 1500;
        size_t num_large_buffers = 32;
        size_t large_buffer_size = 1920*1200*3;
    };
 
    struct Config
    {
        std::string ip_address = "10.66.171.21";
 
        std::optional<int16_t> mtu = static_cast<uint16_t>(1500);
 
        std::optional<std::chrono::milliseconds> receive_timeout = std::chrono::milliseconds(500);
 
        uint16_t command_port{9001};
 
        std::optional<std::string> interface = std::nullopt;
 
        ReceiveBufferConfig receive_buffer_configuration{};
 
        bool connect_on_initialization = true;
    };
 
    static std::unique_ptr<Channel> create(const Config &config,
                                           const ChannelImplementation &impl = ChannelImplementation::LEGACY);
 
    Channel() = default;
 
    Channel(const Channel&) = delete;
    Channel& operator=(const Channel&) = delete;
 
    Channel(Channel&&) noexcept = default;
    Channel& operator=(Channel&&) noexcept = default;
 
    virtual ~Channel() = default;
 
    virtual Status start_streams(const std::vector<DataSource> &sources) = 0;
 
    virtual Status stop_streams(const std::vector<DataSource> &sources) = 0;
 
    virtual void add_image_frame_callback(std::function<void(const ImageFrame&)> callback) = 0;
 
    virtual void add_imu_frame_callback(std::function<void(const ImuFrame&)> callback) = 0;
 
    virtual Status connect(const Config &config) = 0;
 
    virtual void disconnect() = 0;
 
    virtual std::optional<ImageFrame> get_next_image_frame() = 0;
 
    virtual std::optional<ImuFrame> get_next_imu_frame() = 0;
 
    virtual MultiSenseConfig get_config() = 0;
 
    virtual Status set_config(const MultiSenseConfig &config) = 0;
 
    virtual StereoCalibration get_calibration() = 0;
 
    virtual Status set_calibration(const StereoCalibration &calibration) = 0;
 
    virtual MultiSenseInfo get_info() = 0;
 
    virtual Status set_device_info(const MultiSenseInfo::DeviceInfo &device_info, const std::string &key) = 0;
 
    virtual std::optional<MultiSenseStatus> get_system_status() = 0;
 
    virtual Status set_network_config(const MultiSenseInfo::NetworkInfo &config,
                                      const std::optional<std::string> &broadcast_interface) = 0;
};
 
}