peak_afl_brightness_component.hpp

Go to the documentation of this file.

 
#pragma once
 
#include <peak_afl/peak_afl.hpp>
#include <peak_afl/pipeline/modules/controllers/detail/peak_afl_icontroller.hpp>
#include <peak_afl/pipeline/modules/controllers/features/peak_afl_brightness_limit.hpp>
 
#include <peak_common/detail/peak_common_defines.hpp>
 
namespace peak
{
namespace pipeline
{
namespace modules
{
namespace autofeature
{

enum class BrightnessComponentType
{
    Invalid,
    Exposure,
    AnalogGain,
    DigitalGain,
    CombinedGain,
    HostGain,
    Gain
};

PEAK_COMMON_NO_DISCARD inline std::string ToString(BrightnessComponentType type)
{
    switch (type)
    {
    case BrightnessComponentType::Exposure:
        return "ComponentExposure";
    case BrightnessComponentType::AnalogGain:
        return "ComponentAnalogGain";
    case BrightnessComponentType::DigitalGain:
        return "ComponentDigitalGain";
    case BrightnessComponentType::CombinedGain:
        return "ComponentCombinedGain";
    case BrightnessComponentType::HostGain:
        return "ComponentHostGain";
    case BrightnessComponentType::Gain:
        return "ComponentGain";
    default:
        break;
    }
 
    throw peak::common::InternalErrorException("Invalid component type!");
}

inline std::ostream& operator<<(std::ostream& os, BrightnessComponentType type)
{
    return os << ToString(type);
}
 
namespace detail
{
 
PEAK_COMMON_NO_DISCARD inline peak_afl_controller_brightness_component ToCType(BrightnessComponentType componentType)
{
    switch (componentType)
    {
    case BrightnessComponentType::Invalid:
        return PEAK_AFL_CONTROLLER_BRIGHTNESS_COMPONENT_INVALID;
    case BrightnessComponentType::Exposure:
        return PEAK_AFL_CONTROLLER_BRIGHTNESS_COMPONENT_EXPOSURE;
    case BrightnessComponentType::Gain:
        return PEAK_AFL_CONTROLLER_BRIGHTNESS_COMPONENT_GAIN;
    case BrightnessComponentType::AnalogGain:
        return PEAK_AFL_CONTROLLER_BRIGHTNESS_COMPONENT_ANALOG_GAIN;
    case BrightnessComponentType::DigitalGain:
        return PEAK_AFL_CONTROLLER_BRIGHTNESS_COMPONENT_DIGITAL_GAIN;
    case BrightnessComponentType::CombinedGain:
        return PEAK_AFL_CONTROLLER_BRIGHTNESS_COMPONENT_COMBINED_GAIN;
    case BrightnessComponentType::HostGain:
        return PEAK_AFL_CONTROLLER_BRIGHTNESS_COMPONENT_HOST_GAIN;
    default:
        throw peak::common::InvalidParameterException("Unknown brightness component type");
    }
}
 
class GenericAutoBrightness;
 
} // namespace detail

class BrightnessComponent
{
public:
    BrightnessComponent(const BrightnessComponent&) = delete;
    BrightnessComponent& operator=(const BrightnessComponent&) = delete;

    BrightnessComponent(BrightnessComponent&&) = delete;
    BrightnessComponent& operator=(BrightnessComponent&&) = delete;

    ~BrightnessComponent()
    {
        m_parent->UnRegisterComponentCallback(detail::ToCType(m_componentType));
    }

    using FinishedCallback = std::function<void()>;
    using FinishedCallbackHandle = FinishedCallback*;

    friend detail::GenericAutoBrightness;

    PEAK_COMMON_NO_DISCARD BrightnessComponentType GetType() const
    {
        return m_componentType;
    }

    void SetMode(ControllerMode mode)
    {
        m_parent->BrightnessComponentSetMode(detail::ToCType(m_componentType), detail::ToCType(mode));
    }

    PEAK_COMMON_NO_DISCARD ControllerMode GetMode() const
    {
        return detail::ToControllerMode(m_parent->BrightnessComponentGetMode(detail::ToCType(m_componentType)));
    }

    void SetLimit(const IntervalD& interval)
    {
        m_limit->Set(interval);
    }

    IntervalD GetLimit()
    {
        return m_limit->Get();
    }

    void Serialize(peak::common::serialization::IArchive& archive) const
    {
        archive.SetString("Mode", ToString(GetMode()));
 
        auto limitArchive = archive.CreateArchive();
        m_limit->Serialize(*limitArchive);
 
        archive.SetArchive("Limit", limitArchive);
    }

    void Deserialize(const peak::common::serialization::IArchive& archive)
    {
        auto limitArchive = archive.GetArchive("Limit");
        m_limit->Deserialize(*limitArchive);
 
        SetMode(detail::ToControllerMode(archive.GetString("Mode")));
    }

    FinishedCallbackHandle RegisterFinishedCallback(const BrightnessComponent::FinishedCallback& callback)
    {
        return m_FinishedCallbackManager.RegisterCallback(callback);
    }

    void UnregisterFinishedCallback(BrightnessComponent::FinishedCallbackHandle callbackHandle)
    {
        m_FinishedCallbackManager.UnregisterCallback(callbackHandle);
    }
 
private:
    BrightnessComponent(const std::shared_ptr<peak::afl::Controller>& parent, BrightnessComponentType componentType,
        std::unique_ptr<features::BrightnessLimit> limit)
        : m_parent{ parent }
        , m_componentType(componentType)
        , m_limit{ std::move(limit) }
    {
        m_parent->RegisterComponentCallback(detail::ToCType(m_componentType), [this]() { m_FinishedCallbackManager.TriggerCallbacks(); });
    }

    peak::core::TTriggerCallbackManager<BrightnessComponent::FinishedCallbackHandle, BrightnessComponent::FinishedCallback>
        m_FinishedCallbackManager;

    std::shared_ptr<peak::afl::Controller> m_parent;
    BrightnessComponentType m_componentType{};
    std::unique_ptr<features::BrightnessLimit> m_limit{};
};
} // namespace autofeature
} // namespace modules
} // namespace pipeline 
} // namespace peak