peak_icv_sharpening_module.hpp

Go to the documentation of this file.

 
#pragma once
 
#include <peak_common/pipeline/modules/peak_common_imodule.hpp>
#include <peak_common/types/peak_common_interval.hpp>
#include <peak_icv/pipeline/detail/peak_icv_pipeline_utils.hpp>
#include <peak_icv/types/peak_icv_image.hpp>
#include <peak_icv_c/algorithms/filters/peak_icv_image_filter_sharpening.h>
 
namespace peak
{
namespace pipeline
{
namespace detail
{
 
class SharpeningModule : public modules::IModule
{
public:
    SharpeningModule() = default;
 
    ~SharpeningModule() override = default;
 
    SharpeningModule(const SharpeningModule& other) = delete;
 
    SharpeningModule(SharpeningModule&& other) noexcept;
 
    SharpeningModule& operator=(const SharpeningModule& other) = delete;
 
    SharpeningModule& operator=(SharpeningModule&& other) noexcept;
 
    void Serialize(peak::common::serialization::IArchive& archive) const override;
 
 
    void Deserialize(const peak::common::serialization::IArchive& archive) override;
 
    void SetEnabled(bool enabled) override;
 
    PEAK_COMMON_NO_DISCARD bool IsEnabled() const override;
 
    PEAK_COMMON_NO_DISCARD const char* GetType() const override;
 
    void ResetToDefault() override;
 
    void SetLevel(uint32_t level);
 
    PEAK_COMMON_NO_DISCARD uint32_t GetLevel() const;
 
    PEAK_COMMON_NO_DISCARD peak::common::IntervalU GetLevelRange() const;
 
    PEAK_COMMON_NO_DISCARD peak::icv::Image Process(const peak::icv::Image& input) const;
 
    PEAK_COMMON_NO_DISCARD peak::common::Any Process(const peak::common::Any& input) const override;
 
private:
    static constexpr int moduleVersion{ 1 };
    static constexpr auto levelKey{ "Level" };
 
    uint32_t m_level{ 0 };
 
    bool m_enabled{ true };
};
 
inline SharpeningModule::SharpeningModule(SharpeningModule&& other) noexcept
{
    m_enabled = other.m_enabled;
}
 
inline SharpeningModule& SharpeningModule::operator=(SharpeningModule&& other) noexcept
{
    if (this != &other)
    {
        m_enabled = other.m_enabled;
    }
 
    return *this;
}
 
inline void SharpeningModule::Serialize(peak::common::serialization::IArchive& archive) const
{
    archive.SetInt("Version", moduleVersion);
    archive.SetBool("Enabled", IsEnabled());
 
    archive.SetInt(levelKey, m_level);
}
 
inline void SharpeningModule::Deserialize(const peak::common::serialization::IArchive& archive)
{
    const auto version = archive.GetInt("Version");
    detail::ValidateVersion(version, GetType());
 
    SetEnabled(archive.GetBool("Enabled"));
 
    m_level = static_cast<uint32_t>(archive.GetInt(levelKey));
}
 
inline void SharpeningModule::SetEnabled(bool enabled)
{
    m_enabled = enabled;
}
 
inline bool SharpeningModule::IsEnabled() const
{
    return m_enabled;
}
 
inline const char* SharpeningModule::GetType() const
{
    return "Sharpening";
}
 
inline void SharpeningModule::ResetToDefault()
{
    m_level = 0;
}
 
inline void SharpeningModule::SetLevel(const uint32_t level)
{
    auto range = GetLevelRange();
    if (level < range.GetMinimum() || level > range.GetMaximum())
    {
        throw peak::icv::OutOfRangeException(std::string("The given level value " + std::to_string(level) + " is out of range!"));
    }
    m_level = level;
}
 
inline uint32_t SharpeningModule::GetLevel() const
{
    return m_level;
}
 
inline peak::common::IntervalU SharpeningModule::GetLevelRange() const
{
    peak_common_interval_u cRange{};
    peak::icv::detail::ExecuteAndMapReturnCodes([&] {
        return PEAK_ICV_C_ABI_PREFIX peak_icv_ImageFilter_Sharpening_GetRange(&cRange);
    });
 
    return { cRange.minimum, cRange.maximum };
}
 
inline peak::icv::Image SharpeningModule::Process(const peak::icv::Image& input) const
{
    return Process(peak::common::Any(input)).AnyCast<peak::icv::Image>();
}
 
inline peak::common::Any SharpeningModule::Process(const peak::common::Any& input) const
{
    if (!IsEnabled() || m_level == 0)
    {
        return input;
    }
 
    const auto& inputImage = input.AnyCast<peak::icv::Image>();
 
    const auto pixelFormat = inputImage.GetPixelFormat();
    const peak::common::PixelFormatInfo info(pixelFormat);
    const auto isSupportedMonoImage = pixelFormat == peak::common::PixelFormat::Mono8
        || pixelFormat == peak::common::PixelFormat::Mono10 || pixelFormat == peak::common::PixelFormat::Mono12;
    const auto isColorImage = info.HasChannel(peak::common::Channel::Red) && info.HasChannel(peak::common::Channel::Green)
        && info.HasChannel(peak::common::Channel::Blue);
    const auto isSupportedColorImage = isColorImage && pixelFormat != peak::common::PixelFormat::RGB10p32
        && pixelFormat != peak::common::PixelFormat::BGR10p32;
    if (!isSupportedMonoImage && !isSupportedColorImage)
    {
        return input;
    }
 
    auto* const inputImageHandle = peak::common::detail::BackendAccessor<peak::icv::Image>::BackendHandle(inputImage);
 
    peak::icv::detail::ExecuteAndMapReturnCodes([&] {
        return PEAK_ICV_C_ABI_PREFIX peak_icv_ImageFilter_Sharpening_ProcessInPlace(inputImageHandle, m_level);
    });
 
    return peak::common::Any{ inputImage };
}
 
} // namespace detail
} // namespace pipeline 
} // namespace peak