peak_afl_basic_auto_brightness.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_generic_auto_brightness.hpp>
#include <peak_afl/pipeline/modules/controllers/detail/peak_afl_icontroller.hpp>
#include <peak_afl/pipeline/modules/controllers/features/peak_afl_auto_percentile.hpp>
#include <peak_afl/pipeline/modules/controllers/features/peak_afl_auto_target.hpp>
#include <peak_afl/pipeline/modules/controllers/features/peak_afl_auto_tolerance.hpp>
#include <peak_afl/pipeline/modules/controllers/features/peak_afl_brightness_algorithm.hpp>
#include <peak_afl/pipeline/modules/controllers/features/peak_afl_brightness_component.hpp>
#include <peak_afl/pipeline/modules/controllers/features/peak_afl_roi.hpp>
 
#include <peak_common_c/detail/peak_common_defines.h>
#include <peak_common/exceptions/peak_common_exceptions.hpp>
 
#include <utility>
#include <vector>
 
namespace peak
{
namespace pipeline
{
namespace modules
{
namespace autofeature
{

enum class AutoBrightnessPolicy
{
    ExposureAndGain,
    ExposureOnly,
    GainOnly
};

PEAK_COMMON_NO_DISCARD inline std::string ToString(AutoBrightnessPolicy policy)
{
    switch (policy)
    {
    case AutoBrightnessPolicy::ExposureAndGain:
        return "ExposureAndGain";
    case AutoBrightnessPolicy::ExposureOnly:
        return "ExposureOnly";
    case AutoBrightnessPolicy::GainOnly:
        return "GainOnly";
    }
 
    throw peak::afl::error::InvalidParameterException("The given policy is unknown!", PEAK_AFL_STATUS_INVALID_PARAMETER);
}
 
inline std::ostream& operator<<(std::ostream& os, AutoBrightnessPolicy policy)
{
    return os << ToString(policy);
}
 
namespace detail
{
 
PEAK_COMMON_NO_DISCARD inline AutoBrightnessPolicy ToAutoBrightnessPolicy(const std::string& name)
{
    if (name == "ExposureAndGain")
    {
        return AutoBrightnessPolicy::ExposureAndGain;
    }
    if (name == "ExposureOnly")
    {
        return AutoBrightnessPolicy::ExposureOnly;
    }
    if (name == "GainOnly")
    {
        return AutoBrightnessPolicy::GainOnly;
    }
 
    throw peak::afl::error::InternalErrorException("Invalid brightness policy!", PEAK_AFL_STATUS_ERROR);
}
} // namespace detail
class BasicAutoBrightness : public detail::IController
{
    using ProcessingCallback = std::function<void()>;
 
public:
    friend BrightnessComponent;

    explicit BasicAutoBrightness(peak::afl::Manager& manager, ProcessingCallback callback)
        : IController(manager)
        , m_genericController{ manager, std::move(callback), { BrightnessComponentType::Exposure, BrightnessComponentType::Gain } }
    {}

    ~BasicAutoBrightness() override = default;

    void SetMode(ControllerMode mode) override
    {
        auto* exposureComponent = GetExposureComponent();
        if (exposureComponent != nullptr)
        {
            const auto controllerMode = (m_policy == AutoBrightnessPolicy::ExposureOnly
                                            || m_policy == AutoBrightnessPolicy::ExposureAndGain) ?
                mode :
                ControllerMode::Off;
 
            exposureComponent->SetMode(controllerMode);
        }
 
        auto* gainComponent = GetGainComponent();
        if (gainComponent != nullptr)
        {
            const auto controllerMode = (m_policy == AutoBrightnessPolicy::GainOnly || m_policy == AutoBrightnessPolicy::ExposureAndGain) ?
                mode :
                ControllerMode::Off;
 
            gainComponent->SetMode(controllerMode);
        }
 
        m_cachedMode = mode;
    }

    PEAK_COMMON_NO_DISCARD ControllerMode GetMode() const override
    {
        auto* const exposureComponent = GetExposureComponent();
        if (exposureComponent != nullptr)
        {
            if (exposureComponent->GetMode() == ControllerMode::Continuous)
            {
                return ControllerMode::Continuous;
            }
        }
 
        auto* const gainComponent = GetGainComponent();
        if (gainComponent != nullptr)
        {
            return gainComponent->GetMode();
        }
 
        return ControllerMode::Off;
    }

    PEAK_COMMON_NO_DISCARD bool IsRunning() const override
    {
        return GetMode() != ControllerMode::Off;
    }

    void SetAnalysisAlgorithm(BrightnessAnalysisAlgorithm algorithm)
    {
        m_genericController.AnalysisAlgorithm().Set(algorithm);
    }

    PEAK_COMMON_NO_DISCARD BrightnessAnalysisAlgorithm GetAnalysisAlgorithm() const
    {
        return m_genericController.AnalysisAlgorithm().Get();
    }

    void SetAutoPercentile(double value)
    {
        m_genericController.AutoPercentile().Set(value);
    }

    PEAK_COMMON_NO_DISCARD double GetAutoPercentile() const
    {
        return m_genericController.AutoPercentile().Get();
    }

    PEAK_COMMON_NO_DISCARD RangeD GetAutoPercentileRange() const
    {
        return m_genericController.AutoPercentile().GetRange();
    }

    void SetAutoTarget(uint32_t value)
    {
        m_genericController.AutoTarget().Set(value);
    }

    PEAK_COMMON_NO_DISCARD uint32_t GetAutoTarget() const
    {
        return m_genericController.AutoTarget().Get();
    }

    PEAK_COMMON_NO_DISCARD peak::common::RangeU GetAutoTargetRange() const
    {
        return m_genericController.AutoTarget().GetRange();
    }

    void SetAutoTolerance(uint32_t value)
    {
        m_genericController.AutoTolerance().Set(value);
    }

    PEAK_COMMON_NO_DISCARD uint32_t GetAutoTolerance() const
    {
        return m_genericController.AutoTolerance().Get();
    }

    PEAK_COMMON_NO_DISCARD peak::common::RangeU GetAutoToleranceRange() const
    {
        return m_genericController.AutoTolerance().GetRange();
    }

    void SetSkipFrames(uint32_t value)
    {
        m_genericController.SkipFrames().Set(value);
    }

    PEAK_COMMON_NO_DISCARD uint32_t GetSkipFrames() const
    {
        return m_genericController.SkipFrames().Get();
    }

    PEAK_COMMON_NO_DISCARD peak::common::RangeU GetSkipFramesRange() const
    {
        return m_genericController.SkipFrames().GetRange();
    }

    void SetRoi(const peak::common::Rectangle& roi)
    {
        m_genericController.Roi().Set(roi);
    }

    PEAK_COMMON_NO_DISCARD peak::common::Rectangle GetRoi()
    {
        return m_genericController.Roi().Get();
    }

    void SetPolicy(AutoBrightnessPolicy policy)
    {
        m_policy = policy;
        SetMode(m_cachedMode);
    }

    PEAK_COMMON_NO_DISCARD AutoBrightnessPolicy GetPolicy() const
    {
        return m_policy;
    }

    void ResetToDefault() override
    {
        m_policy = AutoBrightnessPolicy::ExposureAndGain;
        m_cachedMode = ControllerMode::Off;
        m_genericController.ResetToDefault();
    }

    IController::FinishedCallbackHandle RegisterFinishedCallback(const IController::FinishedCallback& callback)
    {
        return m_genericController.RegisterFinishedCallback(callback);
    }

    void UnregisterFinishedCallback(IController::FinishedCallbackHandle callbackHandle)
    {
        m_genericController.UnregisterFinishedCallback(callbackHandle);
    }

    void SetExposureLimit(const IntervalD& interval)
    {
        auto* component = GetExposureComponent();
        if (component == nullptr)
        {
            throw peak::afl::error::NotSupportedException(
                "Exposure component is not supported for the current device!", PEAK_AFL_STATUS_NOT_SUPPORTED);
        }
 
        component->SetLimit(interval);
    }

    PEAK_COMMON_NO_DISCARD IntervalD GetExposureLimit() const
    {
        auto* component = GetExposureComponent();
        if (component != nullptr)
        {
            return component->GetLimit();
        }
 
        throw peak::afl::error::NotSupportedException(
            "Exposure component is not supported for the current device!", PEAK_AFL_STATUS_NOT_SUPPORTED);
    }

    void SetGainLimit(const IntervalD& interval)
    {
        auto* component = GetGainComponent();
        if (component == nullptr)
        {
            throw peak::afl::error::NotSupportedException(
                "Gain component is not supported for the current device!", PEAK_AFL_STATUS_NOT_SUPPORTED);
        }
 
        component->SetLimit(interval);
    }

    PEAK_COMMON_NO_DISCARD IntervalD GetGainLimit() const
    {
        auto* component = GetGainComponent();
        if (component != nullptr)
        {
            return component->GetLimit();
        }
 
        throw peak::afl::error::NotSupportedException(
            "Gain component is not supported for the current device!", PEAK_AFL_STATUS_NOT_SUPPORTED);
    }
 
private:
    AutoBrightnessPolicy m_policy{ AutoBrightnessPolicy::ExposureAndGain }; 
    detail::GenericAutoBrightness m_genericController; 
    ControllerMode m_cachedMode{ ControllerMode::Off }; 

    BrightnessComponent* GetExposureComponent() const
    {
        return m_genericController.GetComponent(BrightnessComponentType::Exposure);
    }

    BrightnessComponent* GetGainComponent() const
    {
        return m_genericController.GetComponent(BrightnessComponentType::Gain);
    }

    PEAK_COMMON_NO_DISCARD std::string GetName() const override
    {
        return "BasicAutoBrightness";
    }

    void Serialize(peak::common::serialization::IArchive& archive) const override
    {
        m_genericController.Serialize(archive);
 
        archive.SetString("Policy", ToString(m_policy));
    }

    void Deserialize(const peak::common::serialization::IArchive& archive) override
    {
        m_genericController.Deserialize(archive);
 
        m_cachedMode = GetMode();
        SetPolicy(detail::ToAutoBrightnessPolicy(archive.GetString("Policy")));
    }

    PEAK_COMMON_NO_DISCARD ControllerType GetType() const override
    {
        return m_genericController.GetType();
    }
};
 
} // namespace autofeature
} // namespace modules
} // namespace pipeline 
} // namespace peak