peak_afl_advanced_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_brightness_limit.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 <memory>
#include <utility>
#include <vector>
 
namespace peak
{
namespace pipeline
{
namespace modules
{
namespace autofeature
{

class AdvancedAutoBrightness : public detail::IController
{
    using ProcessingCallback = std::function<void()>;
 
public:
    friend BrightnessComponent;

    explicit AdvancedAutoBrightness(peak::afl::Manager& manager, ProcessingCallback callback)
        : IController(manager)
        , m_genericController{ manager, std::move(callback),
            { BrightnessComponentType::Exposure, BrightnessComponentType::AnalogGain, BrightnessComponentType::DigitalGain,
                BrightnessComponentType::CombinedGain, BrightnessComponentType::HostGain } }
    {}

    ~AdvancedAutoBrightness() override = default;

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

    void Serialize(peak::common::serialization::IArchive& archive) const override
    {
        m_genericController.Serialize(archive);
    }

    void Deserialize(const peak::common::serialization::IArchive& archive) override
    {
        m_genericController.Deserialize(archive);
    }

    PEAK_COMMON_NO_DISCARD ControllerType GetType() const override
    {
        return m_genericController.GetType();
    }

    void SetMode(ControllerMode mode) override
    {
        m_genericController.SetMode(mode);
    }

    PEAK_COMMON_NO_DISCARD ControllerMode GetMode() const override
    {
        return m_genericController.GetMode();
    }

    PEAK_COMMON_NO_DISCARD bool IsRunning() const override
    {
        return m_genericController.IsRunning();
    }

    PEAK_COMMON_NO_DISCARD features::SkipFrames& SkipFrames()
    {
        return m_genericController.SkipFrames();
    }

    PEAK_COMMON_NO_DISCARD features::AutoTarget& AutoTarget()
    {
        return m_genericController.AutoTarget();
    }

    PEAK_COMMON_NO_DISCARD features::AutoTolerance& AutoTolerance()
    {
        return m_genericController.AutoTolerance();
    }

    PEAK_COMMON_NO_DISCARD features::AutoPercentile& AutoPercentile()
    {
        return m_genericController.AutoPercentile();
    }

    PEAK_COMMON_NO_DISCARD features::Roi& Roi()
    {
        return m_genericController.Roi();
    }

    PEAK_COMMON_NO_DISCARD features::BrightnessAlgorithm& AnalysisAlgorithm()
    {
        return m_genericController.AnalysisAlgorithm();
    }

    PEAK_COMMON_NO_DISCARD BrightnessComponent& Exposure() const
    {
        return m_genericController.ExposureComponent();
    }

    PEAK_COMMON_NO_DISCARD bool HasExposure() const
    {
        return m_genericController.HasExposureComponent();
    }

    PEAK_COMMON_NO_DISCARD BrightnessComponent& AnalogGain() const
    {
        return m_genericController.AnalogGainComponent();
    }

    PEAK_COMMON_NO_DISCARD bool HasAnalogGain() const
    {
        return m_genericController.HasAnalogGainComponent();
    }

    PEAK_COMMON_NO_DISCARD BrightnessComponent& DigitalGain() const
    {
        return m_genericController.DigitalGainComponent();
    }

    PEAK_COMMON_NO_DISCARD bool HasDigitalGain() const
    {
        return m_genericController.HasDigitalGainComponent();
    }

    PEAK_COMMON_NO_DISCARD BrightnessComponent& CombinedGain() const
    {
        return m_genericController.CombinedGainComponent();
    }

    PEAK_COMMON_NO_DISCARD bool HasCombinedGain() const
    {
        return m_genericController.HasCombinedGainComponent();
    }

    PEAK_COMMON_NO_DISCARD BrightnessComponent& HostGain() const
    {
        return m_genericController.HostGainComponent();
    }

    PEAK_COMMON_NO_DISCARD bool HasHostGain() const
    {
        return m_genericController.HasHostGainComponent();
    }

    PEAK_COMMON_NO_DISCARD std::vector<BrightnessComponent*> GetComponents() const
    {
        return m_genericController.GetComponents();
    }

    PEAK_COMMON_NO_DISCARD BrightnessComponent* GetComponent(BrightnessComponentType componentType) const
    {
        return m_genericController.GetComponent(componentType);
    }

    void ResetToDefault() override
    {
        m_genericController.ResetToDefault();
    }

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

    void UnregisterFinishedCallback(IController::FinishedCallbackHandle callbackHandle)
    {
        m_genericController.UnregisterFinishedCallback(callbackHandle);
    }
 
private:
    detail::GenericAutoBrightness m_genericController; 
};
 
} // namespace autofeature
} // namespace modules
} // namespace pipeline 
} // namespace peak