peak_afl_basic_auto_focus.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_focus.hpp>
#include <peak_afl/pipeline/modules/controllers/detail/peak_afl_icontroller.hpp>
#include <peak_afl/pipeline/modules/controllers/features/peak_afl_focus_limit.hpp>
#include <peak_afl/pipeline/modules/controllers/features/peak_afl_hysteresis.hpp>
#include <peak_afl/pipeline/modules/controllers/features/peak_afl_search_algorithm.hpp>
#include <peak_afl/pipeline/modules/controllers/features/peak_afl_sharpness_algorithm.hpp>
#include <peak_afl/pipeline/modules/controllers/features/peak_afl_weighted_rois.hpp>
 
#include <peak_common_c/detail/peak_common_defines.h>
 
namespace peak
{
namespace pipeline
{
namespace modules
{
namespace autofeature
{
class BasicAutoFocus : public detail::IController
{
public:
    explicit BasicAutoFocus(peak::afl::Manager& manager)
        : IController(manager)
        , m_genericController(manager)
    {}

    ~BasicAutoFocus() override = default;

    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();
    }

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

    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 SetHysteresis(uint8_t value)
    {
        m_genericController.Hysteresis().Set(value);
    }

    PEAK_COMMON_NO_DISCARD uint8_t GetHysteresis() const
    {
        return m_genericController.Hysteresis().Get();
    }

    PEAK_COMMON_NO_DISCARD peak::common::RangeU8 GetHysteresisRange() const
    {
        return m_genericController.Hysteresis().GetRange();
    }

    void SetSharpnessAlgorithm(FocusSharpnessAlgorithm algorithm)
    {
        m_genericController.SharpnessAlgorithm().Set(algorithm);
    }

    PEAK_COMMON_NO_DISCARD FocusSharpnessAlgorithm GetSharpnessAlgorithm() const
    {
        return m_genericController.SharpnessAlgorithm().Get();
    }

    void SetSearchAlgorithm(FocusSearchAlgorithm algorithm)
    {
        m_genericController.SearchAlgorithm().Set(algorithm);
    }

    PEAK_COMMON_NO_DISCARD FocusSearchAlgorithm GetSearchAlgorithm() const
    {
        return m_genericController.SearchAlgorithm().Get();
    }

    void SetFocusLimit(const peak::common::Interval& limit)
    {
        m_genericController.FocusLimit().Set(limit);
    }

    PEAK_COMMON_NO_DISCARD peak::common::Interval GetFocusLimit() const
    {
        return m_genericController.FocusLimit().Get();
    }

    void SetWeightedROIs(const std::vector<WeightedROI>& rois)
    {
        m_genericController.WeightedROIs().Set(rois);
    }

    PEAK_COMMON_NO_DISCARD std::vector<WeightedROI> GetWeightedROIs() const
    {
        return m_genericController.WeightedROIs().Get();
    }

    void ResetWeightedROIs() const
    {
        m_genericController.WeightedROIs().SetPreset(RoiPreset::Center);
    }

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

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

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

    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();
    }
};
} // namespace autofeature
} // namespace modules
} // namespace pipeline 
} // namespace peak