peak_afl_brightness_algorithm.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 <memory>
 
namespace peak
{
namespace pipeline
{
namespace modules
{
namespace autofeature
{

enum class BrightnessAnalysisAlgorithm
{
    Median,
    Mean
};

PEAK_COMMON_NO_DISCARD inline std::string ToString(BrightnessAnalysisAlgorithm algorithm)
{
    if (algorithm == BrightnessAnalysisAlgorithm::Mean)
    {
        return "Mean";
    }
    if (algorithm == BrightnessAnalysisAlgorithm::Median)
    {
        return "Median";
    }
 
    throw peak::common::InvalidParameterException("The given brightness algorithm is unknown!");
}

inline std::ostream& operator<<(std::ostream& os, BrightnessAnalysisAlgorithm algorithm)
{
    return os << ToString(algorithm);
}
 
namespace features
{
 
namespace detail
{
 
PEAK_COMMON_NO_DISCARD inline BrightnessAnalysisAlgorithm ToBrightnessAnalysisAlgorithm(const std::string& algorithm)
{
    if (algorithm == "Median")
    {
        return BrightnessAnalysisAlgorithm::Median;
    }
    if (algorithm == "Mean")
    {
        return BrightnessAnalysisAlgorithm::Mean;
    }
 
    throw peak::common::InvalidParameterException("The given brightness algorithm " + algorithm + " is unknown!");
}
 
PEAK_COMMON_NO_DISCARD inline peak_afl_controller_brightness_algorithm ToCType(BrightnessAnalysisAlgorithm algorithm)
{
    if (algorithm == BrightnessAnalysisAlgorithm::Median)
    {
        return PEAK_AFL_CONTROLLER_BRIGHTNESS_ALGORITHM_MEDIAN;
    }
    if (algorithm == BrightnessAnalysisAlgorithm::Mean)
    {
        return PEAK_AFL_CONTROLLER_BRIGHTNESS_ALGORITHM_MEAN;
    }
 
    throw peak::common::InternalErrorException("The given brightness algorithm is unknown!");
}
 
PEAK_COMMON_NO_DISCARD inline BrightnessAnalysisAlgorithm ToBrightnessAnalysisAlgorithm(
    peak_afl_controller_brightness_algorithm algorithm)
{
    if (algorithm == PEAK_AFL_CONTROLLER_BRIGHTNESS_ALGORITHM_MEDIAN)
    {
        return BrightnessAnalysisAlgorithm::Median;
    }
    if (algorithm == PEAK_AFL_CONTROLLER_BRIGHTNESS_ALGORITHM_MEAN)
    {
        return BrightnessAnalysisAlgorithm::Mean;
    }
 
    throw peak::common::InternalErrorException("The given brightness algorithm is unknown!");
}
} // namespace detail

class BrightnessAlgorithm : public IFeature<BrightnessAnalysisAlgorithm>
{
public:
    explicit BrightnessAlgorithm(std::shared_ptr<peak::afl::Controller> controller)
        : m_controller{ std::move(controller) }
    {}

    void Set(const BrightnessAnalysisAlgorithm& value) override
    {
        m_controller->SetBrightnessAlgorithm(detail::ToCType(value));
    }

    PEAK_COMMON_NO_DISCARD BrightnessAnalysisAlgorithm Get() const override
    {
        return detail::ToBrightnessAnalysisAlgorithm(m_controller->GetBrightnessAlgorithm());
    }

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

    void Deserialize(const peak::common::serialization::IArchive& archive) override
    {
        Set(detail::ToBrightnessAnalysisAlgorithm(archive.GetString("BrightnessAlgorithm")));
    }
 
private:
    std::shared_ptr<peak::afl::Controller> m_controller;
};
 
} // namespace features
} // namespace autofeature
} // namespace modules
} // namespace pipeline 
} // namespace peak