peak_afl_brightness_limit.hpp

Go to the documentation of this file.

 
#pragma once
 
#include <peak_afl/peak_afl.hpp>
#include <peak_afl/pipeline/modules/controllers/features/peak_afl_ifeature.hpp>
 
#include <peak_common/detail/peak_common_defines.hpp>
#include <peak_common/types/peak_common_interval.hpp>
 
#include <memory>
 
namespace peak
{
namespace pipeline
{
namespace modules
{
namespace autofeature
{
namespace features
{

class BrightnessLimit : public IFeature<IntervalD>
{
public:
    void Serialize(peak::common::serialization::IArchive& archive) const override
    {
        const auto interval = Get();
        archive.SetDouble("Min", interval.GetMinimum());
        archive.SetDouble("Max", interval.GetMaximum());
    }

    void Deserialize(const peak::common::serialization::IArchive& archive) override
    {
        IntervalD interval{ archive.GetDouble("Min"), archive.GetDouble("Max") };
        Set(interval);
    }
};

class BrightnessExposureLimit : public BrightnessLimit
{
public:
    explicit BrightnessExposureLimit(std::shared_ptr<peak::afl::Controller> controller)
        : m_controller{ std::move(controller) }
    {}

    void Set(const IntervalD& value) override
    {
        m_controller->SetExposureLimit({ value.GetMinimum(), value.GetMaximum() });
    }

    PEAK_COMMON_NO_DISCARD IntervalD Get() const override
    {
        const auto result = m_controller->GetExposureLimit();
        return { result.min, result.max };
    }
 
private:
    std::shared_ptr<peak::afl::Controller> m_controller;
};

class BrightnessGainLimit : public BrightnessLimit
{
public:
    explicit BrightnessGainLimit(std::shared_ptr<peak::afl::Controller> controller)
        : m_controller{ std::move(controller) }
    {}

    void Set(const IntervalD& value) override
    {
        m_controller->SetGainLimit({ value.GetMinimum(), value.GetMaximum() });
    }

    PEAK_COMMON_NO_DISCARD IntervalD Get() const override
    {
        const auto result = m_controller->GetGainLimit();
        return { result.min, result.max };
    }
 
private:
    std::shared_ptr<peak::afl::Controller> m_controller;
};

class BrightnessGainAnalogLimit : public BrightnessLimit
{
public:
    explicit BrightnessGainAnalogLimit(std::shared_ptr<peak::afl::Controller> controller)
        : m_controller{ std::move(controller) }
    {}

    void Set(const IntervalD& value) override
    {
        m_controller->SetGainAnalogLimit({ value.GetMinimum(), value.GetMaximum() });
    }

    PEAK_COMMON_NO_DISCARD IntervalD Get() const override
    {
        const auto result = m_controller->GetGainAnalogLimit();
        return { result.min, result.max };
    }
 
private:
    std::shared_ptr<peak::afl::Controller> m_controller;
};

class BrightnessGainDigitalLimit : public BrightnessLimit
{
public:
    explicit BrightnessGainDigitalLimit(std::shared_ptr<peak::afl::Controller> controller)
        : m_controller{ std::move(controller) }
    {}

    void Set(const IntervalD& value) override
    {
        m_controller->SetGainDigitalLimit({ value.GetMinimum(), value.GetMaximum() });
    }

    PEAK_COMMON_NO_DISCARD IntervalD Get() const override
    {
        const auto result = m_controller->GetGainDigitalLimit();
        return { result.min, result.max };
    }
 
private:
    std::shared_ptr<peak::afl::Controller> m_controller;
};

class BrightnessGainCombinedLimit : public BrightnessLimit
{
public:
    explicit BrightnessGainCombinedLimit(std::shared_ptr<peak::afl::Controller> controller)
        : m_controller{ std::move(controller) }
    {}

    void Set(const IntervalD& value) override
    {
        m_controller->SetGainCombinedLimit({ value.GetMinimum(), value.GetMaximum() });
    }

    PEAK_COMMON_NO_DISCARD IntervalD Get() const override
    {
        const auto result = m_controller->GetGainCombinedLimit();
        return { result.min, result.max };
    }
 
private:
    std::shared_ptr<peak::afl::Controller> m_controller;
};

class BrightnessGainHostLimit : public BrightnessLimit
{
public:
    explicit BrightnessGainHostLimit(std::shared_ptr<peak::afl::Controller> controller)
        : m_controller{ std::move(controller) }
    {}

    void Set(const IntervalD& value) override
    {
        m_controller->SetGainHostLimit({ value.GetMinimum(), value.GetMaximum() });
    }

    PEAK_COMMON_NO_DISCARD IntervalD Get() const override
    {
        const auto result = m_controller->GetGainHostLimit();
        return { result.min, result.max };
    }
 
private:
    std::shared_ptr<peak::afl::Controller> m_controller;
};
 
} // namespace features
} // namespace autofeature
} // namespace modules
} // namespace pipeline 
} // namespace peak