peak_afl_sharpness_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_c/detail/peak_common_defines.h>
 
#include <memory>
 
namespace peak
{
namespace pipeline
{
namespace modules
{
namespace autofeature
{
enum class FocusSharpnessAlgorithm
{
    Auto PEAK_AFL_DEPRECATED_ENUM_ATTR,
    Tenengrad,
    Sobel,
    MeanScore,
    HistogramVariance
};

PEAK_COMMON_NO_DISCARD inline std::string ToString(FocusSharpnessAlgorithm algorithm)
{
    // clang-format off
    PEAK_AFL_BEGIN_DISABLE_DEPRECATED_WARNINGS
    if (algorithm == FocusSharpnessAlgorithm::Auto)
    {
        return "Auto";
    }
    PEAK_AFL_END_DISABLE_DEPRECATED_WARNINGS
    // clang-format on
    if (algorithm == FocusSharpnessAlgorithm::HistogramVariance)
    {
        return "HistogramVariance";
    }
    if (algorithm == FocusSharpnessAlgorithm::MeanScore)
    {
        return "MeanScore";
    }
    if (algorithm == FocusSharpnessAlgorithm::Sobel)
    {
        return "Sobel";
    }
    if (algorithm == FocusSharpnessAlgorithm::Tenengrad)
    {
        return "Tenengrad";
    }
    throw peak::afl::error::InvalidParameterException(
        "The given focus sharpness algorithm is unknown!", PEAK_AFL_STATUS_INVALID_PARAMETER);
}

inline std::ostream& operator<<(std::ostream& os, FocusSharpnessAlgorithm algorithm)
{
    return os << ToString(algorithm);
}
 
namespace features
{
namespace detail
{
PEAK_COMMON_NO_DISCARD inline FocusSharpnessAlgorithm ToFocusSharpnessAlgorithm(const std::string& algorithm)
{
    if (algorithm == "Auto")
    {
        // clang-format off
        PEAK_AFL_BEGIN_DISABLE_DEPRECATED_WARNINGS
        return FocusSharpnessAlgorithm::Auto;
        PEAK_AFL_END_DISABLE_DEPRECATED_WARNINGS
        // clang-format on
    }
    if (algorithm == "Tenengrad")
    {
        return FocusSharpnessAlgorithm::Tenengrad;
    }
    if (algorithm == "Sobel")
    {
        return FocusSharpnessAlgorithm::Sobel;
    }
    if (algorithm == "MeanScore")
    {
        return FocusSharpnessAlgorithm::MeanScore;
    }
    if (algorithm == "HistogramVariance")
    {
        return FocusSharpnessAlgorithm::HistogramVariance;
    }
 
    throw peak::afl::error::InvalidParameterException(
        "The given focus sharpness algorithm " + algorithm + " is unknown!", PEAK_AFL_STATUS_INVALID_PARAMETER);
}
 
PEAK_COMMON_NO_DISCARD inline FocusSharpnessAlgorithm ToFocusSharpnessAlgorithm(peak_afl_controller_sharpness_algorithm algorithm)
{
    // clang-format off
    PEAK_AFL_BEGIN_DISABLE_DEPRECATED_WARNINGS
    switch (algorithm)
    {
    case PEAK_AFL_CONTROLLER_SHARPNESS_ALGORITHM_AUTO:
        return FocusSharpnessAlgorithm::Auto;
    case PEAK_AFL_CONTROLLER_SHARPNESS_ALGORITHM_TENENGRAD:
        return FocusSharpnessAlgorithm::Tenengrad;
    case PEAK_AFL_CONTROLLER_SHARPNESS_ALGORITHM_SOBEL:
        return FocusSharpnessAlgorithm::Sobel;
    case PEAK_AFL_CONTROLLER_SHARPNESS_ALGORITHM_MEAN_SCORE:
        return FocusSharpnessAlgorithm::MeanScore;
    case PEAK_AFL_CONTROLLER_SHARPNESS_ALGORITHM_HISTOGRAM_VARIANCE:
        return FocusSharpnessAlgorithm::HistogramVariance;
    }
    PEAK_AFL_END_DISABLE_DEPRECATED_WARNINGS
    // clang-format on
 
    throw peak::afl::error::InternalErrorException("Invalid focus sharpness algorithm!", PEAK_AFL_STATUS_ERROR);
}
 
PEAK_COMMON_NO_DISCARD inline peak_afl_controller_sharpness_algorithm ToCType(FocusSharpnessAlgorithm algorithm)
{
    // clang-format off
    PEAK_AFL_BEGIN_DISABLE_DEPRECATED_WARNINGS
    switch (algorithm)
    {
    case FocusSharpnessAlgorithm::Auto:
        return PEAK_AFL_CONTROLLER_SHARPNESS_ALGORITHM_AUTO;
    case FocusSharpnessAlgorithm::Tenengrad:
        return PEAK_AFL_CONTROLLER_SHARPNESS_ALGORITHM_TENENGRAD;
    case FocusSharpnessAlgorithm::Sobel:
        return PEAK_AFL_CONTROLLER_SHARPNESS_ALGORITHM_SOBEL;
    case FocusSharpnessAlgorithm::MeanScore:
        return PEAK_AFL_CONTROLLER_SHARPNESS_ALGORITHM_MEAN_SCORE;
    case FocusSharpnessAlgorithm::HistogramVariance:
        return PEAK_AFL_CONTROLLER_SHARPNESS_ALGORITHM_HISTOGRAM_VARIANCE;
    }
    PEAK_AFL_END_DISABLE_DEPRECATED_WARNINGS
    // clang-format on
 
    throw peak::afl::error::InternalErrorException("Invalid focus sharpness algorithm!", PEAK_AFL_STATUS_ERROR);
}
} // namespace detail

class SharpnessAlgorithm : public IListFeature<FocusSharpnessAlgorithm>
{
public:
    explicit SharpnessAlgorithm(std::shared_ptr<peak::afl::Controller> controller)
        : m_controller{ std::move(controller) }
    {}

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

    PEAK_COMMON_NO_DISCARD FocusSharpnessAlgorithm Get() const override
    {
        return detail::ToFocusSharpnessAlgorithm(m_controller->GetSharpnessAlgorithm());
    }

    PEAK_COMMON_NO_DISCARD std::vector<FocusSharpnessAlgorithm> GetList() const override
    {
        const auto cAlgorithms = m_controller->GetSharpnessAlgorithmList();
        std::vector<FocusSharpnessAlgorithm> algorithms;
        algorithms.reserve(cAlgorithms.size());
 
        std::transform(std::cbegin(cAlgorithms), std::cend(cAlgorithms), std::back_inserter(algorithms),
            [](const auto& value) { return detail::ToFocusSharpnessAlgorithm(value); });
        return algorithms;
    }

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

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