peak_afl_basic_auto_features.hpp

Go to the documentation of this file.

 
#pragma once
 
#include <peak_afl/pipeline/modules/controllers/peak_afl_basic_auto_brightness.hpp>
#include <peak_afl/pipeline/modules/controllers/peak_afl_basic_auto_white_balance.hpp>
#include <peak_afl/pipeline/modules/detail/peak_afl_generic_auto_features.hpp>
 
#include <peak_common_c/detail/peak_common_defines.h>
#include <peak_common/exceptions/peak_common_exceptions.hpp>
#include <peak/device/peak_device.hpp>
 
namespace peak
{
namespace pipeline
{
namespace modules
{

class BasicAutoFeatures : public IAutoFeature
{
public:
    explicit BasicAutoFeatures(const std::shared_ptr<peak::core::Device>& device)
        : m_genericModule{ device, false }
    {}

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

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

    PEAK_COMMON_NO_DISCARD const char* GetType() const override
    {
        return "BasicAutoFeatures";
    }

    PEAK_COMMON_NO_DISCARD peak::common::Any Process(const peak::common::Any& input) const override
    {
        return m_genericModule.Process(input);
    }

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

    void SetGainModule(std::shared_ptr<peak::pipeline::modules::IGain> gainModule) override
    {
        m_genericModule.SetGainModule(gainModule);
    }

    void SetColorCorrectionMatrix(const std::array<float, 9>& ccm) override
    {
        m_genericModule.SetColorCorrectionMatrix(ccm);
    }

    void SetEnabled(const bool enabled) override
    {
        m_genericModule.SetEnabled(enabled);
    }

    PEAK_COMMON_NO_DISCARD bool IsEnabled() const override
    {
        return m_genericModule.IsEnabled();
    }

    PEAK_COMMON_NO_DISCARD autofeature::BasicAutoBrightness& AutoBrightness() const
    {
        auto* controller = m_genericModule.GetController(autofeature::ControllerType::Brightness);
        if (controller != nullptr)
        {
            return *static_cast<autofeature::BasicAutoBrightness*>(controller);
        }
        throw peak::afl::error::NotSupportedException(
            "Brightness controller is not supported for the current device!", PEAK_AFL_STATUS_NOT_SUPPORTED);
    }

    PEAK_COMMON_NO_DISCARD bool HasAutoBrightness() const
    {
        return m_genericModule.HasController(autofeature::ControllerType::Brightness);
    }

    PEAK_COMMON_NO_DISCARD autofeature::BasicAutoFocus& AutoFocus() const
    {
        auto* controller = m_genericModule.GetController(autofeature::ControllerType::Focus);
        if (controller != nullptr)
        {
            return *static_cast<autofeature::BasicAutoFocus*>(controller);
        }
 
        throw peak::afl::error::NotSupportedException(
            "Focus controller is not supported for the current device!", PEAK_AFL_STATUS_NOT_SUPPORTED);
    }

    PEAK_COMMON_NO_DISCARD bool HasAutoFocus() const
    {
        return m_genericModule.HasController(autofeature::ControllerType::Focus);
    }

    PEAK_COMMON_NO_DISCARD autofeature::BasicAutoWhiteBalance& AutoWhiteBalance() const
    {
        auto* controller = m_genericModule.GetController(autofeature::ControllerType::WhiteBalance);
        if (controller != nullptr)
        {
            return *static_cast<autofeature::BasicAutoWhiteBalance*>(controller);
        }
 
        throw peak::afl::error::NotSupportedException(
            "White balance controller is not supported for the current device!", PEAK_AFL_STATUS_NOT_SUPPORTED);
    }

    PEAK_COMMON_NO_DISCARD bool HasAutoWhiteBalance() const
    {
        return m_genericModule.HasController(autofeature::ControllerType::WhiteBalance);
    }

    void SetAllModes(autofeature::ControllerMode mode)
    {
        for (auto* controller : m_genericModule.GetControllers())
        {
            controller->SetMode(mode);
        }
    }

    void SetAllSkipFrames(uint32_t value)
    {
        auto* brightnessController = m_genericModule.GetController(autofeature::ControllerType::Brightness);
        if (brightnessController != nullptr)
        {
            static_cast<autofeature::BasicAutoBrightness*>(brightnessController)->SetSkipFrames(value);
        }
 
        auto* focusController = m_genericModule.GetController(autofeature::ControllerType::Focus);
        if (focusController != nullptr)
        {
            static_cast<autofeature::BasicAutoFocus*>(focusController)->SetSkipFrames(value);
        }
 
        auto* awbController = m_genericModule.GetController(autofeature::ControllerType::WhiteBalance);
        if (awbController != nullptr)
        {
            static_cast<autofeature::BasicAutoWhiteBalance*>(awbController)->SetSkipFrames(value);
        }
    }
 
private:
    detail::GenericAutoFeatures m_genericModule;
};
 
 
} /* namespace modules */
} /* namespace pipeline */
} /* namespace peak */