camera_control.hpp

#pragma once
 
#include <functional>
#include <memory>
#include <optional>
#include <string>
#include <variant>
#include <vector>
 
namespace auterion {
class CameraControlImpl;
 
class CameraControl {
   public:
    using Value = std::variant<int64_t, double, std::string>;
 
    enum class Mode {
        Readable,
        Writable,
        ReadWrite,
    };
 
    enum class ControlId {
        Exposure,  
        Gain,
        AutoExposureMode,  
    };
 
    static std::string toString(ControlId control) {
        switch (control) {
            case ControlId::Exposure:
                return "ExposureTimeAb";
            case ControlId::Gain:
                return "Gain";
            case ControlId::AutoExposureMode:
                return "AeMode";
        }
        return "Unknown";
    }
 
    struct Control {
        std::string name;
        Mode mode;
        std::optional<Value> default_value;
    };
 
    CameraControl(std::unique_ptr<CameraControlImpl> impl);
    ~CameraControl() = default;
 
    CameraControl(const CameraControl& other) = delete;
    CameraControl& operator=(const CameraControl& other) = delete;
    CameraControl(CameraControl&& other) = delete;
    CameraControl& operator=(CameraControl&& other) = delete;
 
    std::vector<Control> enumerate() const;
 
    std::vector<std::optional<Value>> get(const std::vector<std::string>& control_names) const;
    std::optional<Value> get(const std::string& control_name) const;
    std::optional<Value> get(const ControlId& control) const { return get(toString(control)); }
 
    bool set(const std::vector<std::string>& control_names, const std::vector<Value>& values) const;
    bool set(const std::string& control_name, const Value& value) const;
    bool set(const ControlId& control, const Value& value) const {
        return set(toString(control), value);
    }
 
    using EnumerateCallback =
        std::function<void(const std::optional<std::vector<Control>>& controls)>;
    using GetCallback = std::function<void(const std::vector<std::optional<Value>>& values)>;
    using SetCallback = std::function<void(const std::vector<bool>& accepted)>;
 
    bool available() const;
    void enumerate(EnumerateCallback callback) const;
    void get(const std::vector<std::string>& control_names, GetCallback callback) const;
    void set(const std::vector<std::string>& control_names, const std::vector<Value>& values,
             SetCallback callback) const;
   private:
    std::unique_ptr<CameraControlImpl> _impl;
};
 
}  // namespace auterion