camera.h

Go to the documentation of this file.

 
#pragma once
 
#include <vector>
 
#include <flyby/payload/component/component.h>
#include <flyby/util/error.h>
 
namespace flyby {
    enum CameraType : uint8_t {
        STANDARD = 0,
        THERMAL,
    };

    enum ZoomType : uint8_t {
        MM = 0,
        MULTIPLIER,
    };

    enum FocusMode : uint8_t {
        F_AUTOMATIC = 0,
        F_MANUAL,
    };

    enum ExposureProgramMode : uint8_t {
        P_MANUAL = 0,
        P_AUTOMATIC,
        P_APERTURE_PRIORITY,
        P_SHUTTER_PRIORITY,
    };

    enum TouchMode : uint8_t { T_DISABLED = 0, T_TRACKING, T_DETECTION };

    enum IRPalette : uint8_t {
        WHITEHOT = 0,
        BLACKHOT,
        LAVA,
        IRONBOW,
        ARCTIC,
        GLOBOW,
        RAINBOW,
        RAINBOWHC,
        HOTTEST,
        ICEFIRE,
    };

    class CameraInterface : public Component {
    public:
        virtual void take_picture() = 0;
 
        virtual void start_video_recording() = 0;
 
        virtual void stop_video_recording() = 0;
 
        virtual void set_optical_zoom_level(unsigned int level) = 0;
 
        virtual unsigned int get_optical_zoom_level() = 0;
 
        virtual std::vector<unsigned int> get_optical_zoom_range() = 0;
 
        virtual ZoomType get_optical_zoom_type() = 0;
 
        virtual void set_digital_zoom_level(unsigned int level) = 0;
 
        virtual unsigned int get_digital_zoom_level() = 0;
 
        virtual std::vector<unsigned int> get_digital_zoom_range() = 0;
 
        virtual FocusMode get_focus_mode() = 0;
 
        virtual void set_focus_mode(FocusMode mode) = 0;
 
        virtual unsigned int get_focus_position() = 0;
 
        virtual std::vector<unsigned int> get_focus_position_range() = 0;
 
        virtual void set_focus_position(unsigned int position) = 0;
 
        virtual unsigned int get_iso_level() = 0;
 
        virtual std::vector<unsigned int> get_iso_range() = 0;
 
        virtual void set_iso_level(unsigned int level) = 0;
 
        virtual unsigned int get_shutter_speed() = 0;
 
        virtual std::vector<unsigned int> get_shutter_speed_range() = 0;
 
        virtual void set_shutter_speed(unsigned int speed) = 0;
 
        virtual ExposureProgramMode get_exposure_program_mode() = 0;
 
        virtual void set_exposure_program_mode(ExposureProgramMode mode) = 0;
 
        virtual unsigned int get_aperture() = 0;
 
        virtual std::vector<unsigned int> get_aperture_range() = 0;
 
        virtual void set_aperture(unsigned int aperture) = 0;
 
        virtual std::string get_white_balance() = 0;
 
        virtual std::vector<std::string> get_white_balance_options() = 0;
 
        virtual void set_white_balance(std::string wb) = 0;
 
        [[nodiscard]] virtual bool get_zoom() const = 0;
 
        [[nodiscard]] virtual bool get_gimbal() const = 0;
 
        [[nodiscard]] virtual bool get_picture() const = 0;
 
        [[nodiscard]] virtual bool get_video() const = 0;
 
        [[nodiscard]] virtual bool get_touch() const = 0;
 
        [[nodiscard]] virtual CameraType get_type() const = 0;
 
        [[nodiscard]] virtual bool is_recording() const = 0;
 
        [[nodiscard]] virtual TouchMode get_touch_mode() const = 0;
 
        virtual void set_touch_mode(TouchMode mode) = 0;
 
        virtual void set_touch_position(unsigned int x, unsigned int y) = 0;
 
    private:
        using Component::Component;
    };

    class IRInterface {
    public:
        virtual IRPalette get_color_palette() = 0;
 
        virtual void set_color_palette(IRPalette palette) = 0;
 
        virtual std::vector<IRPalette> get_color_palette_options() = 0;
    };

    class Camera : public CameraInterface {
    public:
        Camera()
            : Camera(std::string()) {}

        explicit Camera(const std::string& name)
            : CameraInterface(name),
              m_type { CameraType::STANDARD } {}
 
        ~Camera() override = default;

        void take_picture() override {
            throw not_implemented_error();
        }

        void start_video_recording() override {
            throw not_implemented_error();
        }

        void stop_video_recording() override {
            throw not_implemented_error();
        }

        void set_optical_zoom_level([[maybe_unused]] unsigned int level) override {
            throw not_implemented_error();
        }

        unsigned int get_optical_zoom_level() override {
            throw not_implemented_error();
        }

        std::vector<unsigned int> get_optical_zoom_range() override {
            throw not_implemented_error();
        }

        ZoomType get_optical_zoom_type() override {
            throw not_implemented_error();
        }

        void set_digital_zoom_level([[maybe_unused]] unsigned int level) override {
            throw not_implemented_error();
        }

        unsigned int get_digital_zoom_level() override {
            throw not_implemented_error();
        }

        std::vector<unsigned int> get_digital_zoom_range() override {
            throw not_implemented_error();
        }

        unsigned int get_iso_level() override {
            throw not_implemented_error();
        }

        std::vector<unsigned int> get_iso_range() override {
            throw not_implemented_error();
        }

        void set_iso_level([[maybe_unused]] unsigned int level) override {
            throw not_implemented_error();
        }

        unsigned int get_shutter_speed() override {
            throw not_implemented_error();
        }

        std::vector<unsigned int> get_shutter_speed_range() override {
            throw not_implemented_error();
        }

        void set_shutter_speed([[maybe_unused]] unsigned int speed) override {
            throw not_implemented_error();
        }

        ExposureProgramMode get_exposure_program_mode() override {
            throw not_implemented_error();
        }

        void set_exposure_program_mode([[maybe_unused]] ExposureProgramMode mode) override {
            throw not_implemented_error();
        }

        unsigned int get_aperture() override {
            throw not_implemented_error();
        }

        std::vector<unsigned int> get_aperture_range() override {
            throw not_implemented_error();
        }

        void set_aperture([[maybe_unused]] unsigned int aperture) override {
            throw not_implemented_error();
        }

        std::string get_white_balance() override {
            throw not_implemented_error();
        }

        std::vector<std::string> get_white_balance_options() override {
            throw not_implemented_error();
        }

        void set_white_balance([[maybe_unused]] std::string wb) override {
            throw not_implemented_error();
        }

        FocusMode get_focus_mode() override {
            throw not_implemented_error();
        }

        void set_focus_mode([[maybe_unused]] FocusMode mode) override {
            throw not_implemented_error();
        }

        unsigned int get_focus_position() override {
            throw not_implemented_error();
        }

        std::vector<unsigned int> get_focus_position_range() override {
            throw not_implemented_error();
        }

        void set_focus_position([[maybe_unused]] unsigned int position) override {
            throw not_implemented_error();
        }

        [[nodiscard]] bool get_zoom() const final {
            return m_zoom;
        }

        [[nodiscard]] bool get_gimbal() const final {
            return m_gimbal;
        }

        [[nodiscard]] bool get_picture() const final {
            return m_picture;
        }

        [[nodiscard]] bool get_video() const final {
            return m_video;
        }

        [[nodiscard]] bool get_touch() const final {
            return m_touch;
        }

        [[nodiscard]] CameraType get_type() const final {
            return m_type;
        }

        [[nodiscard]] bool is_recording() const final {
            return m_is_recording;
        }

        [[nodiscard]] TouchMode get_touch_mode() const final {
            return m_touch_mode;
        }

        void set_touch_mode(TouchMode mode) override {
            m_touch_mode = mode;
        }

        void set_touch_position([[maybe_unused]] unsigned int x, [[maybe_unused]] unsigned int y) override {
            throw not_implemented_error();
        }
 
    protected:
        CameraType m_type;

        bool m_picture { false };

        bool m_video { false };

        bool m_touch { false };

        bool m_zoom { false };

        bool m_gimbal { false };

        bool m_is_recording { false };

        TouchMode m_touch_mode { T_DISABLED };
    };

    class IRCamera : public Camera, public IRInterface {
    public:
        IRCamera()
            : IRCamera(std::string()) {}

        explicit IRCamera(const std::string& name)
            : Camera(name) {
            m_type = CameraType::THERMAL;
        }

        IRPalette get_color_palette() override {
            throw not_implemented_error();
        }

        void set_color_palette([[maybe_unused]] IRPalette palette) override {
            throw not_implemented_error();
        }

        std::vector<IRPalette> get_color_palette_options() override {
            throw not_implemented_error();
        }
    };
}  // namespace flyby