image.h

Go to the documentation of this file.

#pragma once
#include <functional>
#include <optional>
#include <chrono>
#include "image_frame.h"
#include "field.h"
#ifdef WEBCFACE_MESON
#include "webcface-config.h"
#else
#include "webcface/common/webcface-config.h"
#endif
 
WEBCFACE_NS_BEGIN
 
class WEBCFACE_DLL Image : protected Field {
    const Image &request(std::optional<int> rows, std::optional<int> cols,
                         ImageCompressMode cmp_mode, int quality,
                         std::optional<ImageColorMode> color_mode,
                         std::optional<double> frame_rate) const;
 
  public:
    Image() = default;
    Image(const Field &base);
    Image(const Field &base, const SharedString &field)
        : Image(Field{base, field}) {}
 
    using Field::lastName;
    using Field::member;
    using Field::name;
    using Field::nameW;
    Image child(StringInitializer field) const {
        return this->Field::child(static_cast<SharedString &>(field));
    }
    [[deprecated]]
    Image child(int index) const {
        return this->Field::child(std::to_string(index));
    }
    Image operator[](StringInitializer field) const { return child(std::move(field)); }
    [[deprecated]]
    Image operator[](int index) const {
        return child(std::to_string(index));
    }
    Image parent() const { return this->Field::parent(); }
 
    const Image &
    onChange(std::function<void WEBCFACE_CALL_FP(Image)> callback) const;
    template <typename F, typename std::enable_if_t<std::is_invocable_v<F>,
                                                    std::nullptr_t> = nullptr>
    const Image &onChange(F callback) const {
        return onChange(
            [callback = std::move(callback)](const auto &) { callback(); });
    }
    template <typename T>
    [[deprecated]] void appendListener(T &&callback) const {
        onChange(std::forward<T>(callback));
    }
 
    const Image &set(const ImageFrame &img) const;
    const Image &operator=(const ImageFrame &img) const {
        this->set(img);
        return *this;
    }
 
  protected:
    const Image &tryRequest() const;
 
  public:
    [[deprecated("Ambiguous image size")]]
    const Image &
    request(std::optional<int> rows, std::optional<int> cols = std::nullopt,
            std::optional<ImageColorMode> color_mode = std::nullopt,
            std::optional<double> frame_rate = std::nullopt) const {
        return request(rows, cols, ImageCompressMode::raw, 0, color_mode,
                       frame_rate);
    }
    const Image &
    request(std::optional<SizeOption> size = std::nullopt,
            std::optional<ImageColorMode> color_mode = std::nullopt,
            std::optional<double> frame_rate = std::nullopt) const {
        return request(size.value_or(SizeOption{}).rows(),
                       size.value_or(SizeOption{}).cols(),
                       ImageCompressMode::raw, 0, color_mode, frame_rate);
    }
    [[deprecated("Ambiguous image size")]]
    const Image &
    request(std::optional<int> rows, std::optional<int> cols,
            ImageCompressMode cmp_mode, int quality,
            std::optional<double> frame_rate = std::nullopt) const {
        return request(rows, cols, cmp_mode, quality, std::nullopt, frame_rate);
    }
    const Image &
    request(std::optional<SizeOption> size, ImageCompressMode cmp_mode,
            int quality,
            std::optional<double> frame_rate = std::nullopt) const {
        return request(size.value_or(SizeOption{}).rows(),
                       size.value_or(SizeOption{}).cols(), cmp_mode, quality,
                       std::nullopt, frame_rate);
    }
    std::optional<ImageFrame> tryGet() const;
    ImageFrame get() const { return tryGet().value_or(ImageFrame{}); }
 
    // operator ImageFrame() const { return get(); }
 
    bool exists() const;
 
    [[deprecated]] std::chrono::system_clock::time_point time() const;
 
    const Image &free() const;
 
    const Image &clear() const;
 
    template <typename T, typename std::enable_if_t<std::is_same_v<T, Image>,
                                                    std::nullptr_t> = nullptr>
    bool operator==(const T &other) const {
        return static_cast<Field>(*this) == static_cast<Field>(other);
    }
    template <typename T, typename std::enable_if_t<std::is_same_v<T, Image>,
                                                    std::nullptr_t> = nullptr>
    bool operator!=(const T &other) const {
        return static_cast<Field>(*this) != static_cast<Field>(other);
    }
};
 
WEBCFACE_NS_END