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 {
        STANDARD = 0,
        THERMAL
    };
 
    enum ZoomType {
        MM = 0,
        MULTIPLIER
    };
 
    enum FocusMode {
        F_AUTOMATIC = 0,
        F_MANUAL
    };
 
    enum ExposureProgramMode {
        P_MANUAL = 0,
        P_AUTOMATIC,
        P_APERTURE_PRIORITY,
        P_SHUTTER_PRIORITY
    };
 
    enum IRPalette {
        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(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(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 float get_aperture() = 0;
 
        virtual std::vector<float> get_aperture_range() = 0;
 
        virtual void set_aperture(float 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 CameraType get_type() const = 0;
 
        [[nodiscard]] virtual bool is_recording() const = 0;
 
    private:
        using Component::Component;
    };
 
    class IRCameraInterface : virtual public CameraInterface {
    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 : virtual 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(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(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(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(unsigned int speed) override {
            throw not_implemented_error();
        }
 
        ExposureProgramMode get_exposure_program_mode() override {
            throw not_implemented_error();
        }
 
        void set_exposure_program_mode(ExposureProgramMode mode) override {
            throw not_implemented_error();
        }
 
        float get_aperture() override {
            throw not_implemented_error();
        }
 
        std::vector<float> get_aperture_range() override {
            throw not_implemented_error();
        }
 
        void set_aperture(float 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(std::string wb) override {
            throw not_implemented_error();
        }
 
        FocusMode get_focus_mode() override {
            throw not_implemented_error();
        }
 
        void set_focus_mode(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(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]] CameraType get_type() const final {
            return m_type;
        }
 
        [[nodiscard]] bool is_recording() const final {
            return m_is_recording;
        }
 
    protected:
 
        CameraType m_type;
 
        bool m_picture { false };
 
        bool m_video { false };
 
        bool m_zoom { false };
 
        bool m_gimbal { false };
 
        bool m_is_recording { false };
    };
 
    class IRCamera : virtual public Camera, virtual public IRCameraInterface {
    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(IRPalette palette) override {
            throw not_implemented_error();
        }
 
        std::vector<IRPalette> get_color_palette_options() override {
            throw not_implemented_error();
        }
    };
}