peak_icv_downsampling_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_any.hpp>
#include <peak_common/types/peak_common_interval.hpp>
#include <peak_icv/exceptions/peak_icv_exception.hpp>
#include <peak_icv/pipeline/detail/peak_icv_pipeline_utils.hpp>
#include <peak_icv/types/peak_icv_image.hpp>
#include <peak_icv_c/algorithms/preprocessing/peak_icv_downsampling.h>
 
namespace peak
{
namespace pipeline
{
 
namespace detail
{
 
enum class DownsamplingMode
{
    BinningAverage = 0,
 
    BinningSum = 1,
 
    Decimation = 2,
};
 
PEAK_COMMON_NO_DISCARD inline std::string ToString(DownsamplingMode mode)
{
    if (mode == DownsamplingMode::BinningAverage)
    {
        return "BinningAverage";
    }
    if (mode == DownsamplingMode::BinningSum)
    {
        return "BinningSum";
    }
    if (mode == DownsamplingMode::Decimation)
    {
        return "Decimation";
    }
    const auto modeStr = std::to_string(static_cast<int>(mode));
    throw peak::icv::NotSupportedException("The given downsampling mode " + modeStr + " is unknown!");
}
 
PEAK_COMMON_NO_DISCARD inline DownsamplingMode ToMode(const std::string& mode)
{
    if (mode == "BinningAverage")
    {
        return DownsamplingMode::BinningAverage;
    }
    if (mode == "BinningSum")
    {
        return DownsamplingMode::BinningSum;
    }
    if (mode == "Decimation")
    {
        return DownsamplingMode::Decimation;
    }
    throw peak::icv::NotSupportedException("The given downsampling mode " + mode + " is unknown!");
}
 
class DownsamplingModule : public modules::IModule
{
public:
    explicit DownsamplingModule();
 
    explicit DownsamplingModule(DownsamplingMode defaultMode, std::string customName);
 
    ~DownsamplingModule() override;
 
    DownsamplingModule(const DownsamplingModule& other) = delete;
 
    DownsamplingModule(DownsamplingModule&& other) noexcept;
 
    DownsamplingModule& operator=(const DownsamplingModule& other) = delete;
 
    DownsamplingModule& operator=(DownsamplingModule&& other) noexcept;
 
    void SetEnabled(bool enabled) override;
 
    PEAK_COMMON_NO_DISCARD bool IsEnabled() const override;
 
    void Serialize(peak::common::serialization::IArchive& archive) const override;
 
    void Deserialize(const peak::common::serialization::IArchive& archive) override;
 
    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;
 
    PEAK_COMMON_NO_DISCARD const char* GetType() const override;
 
    void SetCustomType(const std::string& type);
 
    void ResetToDefault() override;
 
    void SetX(uint32_t x);
 
    void SetY(uint32_t y);
 
    PEAK_COMMON_NO_DISCARD uint32_t GetX() const;
 
    PEAK_COMMON_NO_DISCARD uint32_t GetY() const;
 
    PEAK_COMMON_NO_DISCARD peak::common::IntervalU GetRange() const;
 
    void SetMode(const DownsamplingMode& mode);
 
    PEAK_COMMON_NO_DISCARD DownsamplingMode GetMode() const;
 
private:
    static constexpr auto modeKey{ "Mode" };
    static constexpr auto xKey = "X";
    static constexpr auto yKey = "Y";
    static constexpr auto defaultModeKey = "DefaultMode";
 
    static constexpr int moduleVersion = 1;
 
    DownsamplingMode m_defaultMode{ DownsamplingMode::BinningAverage };
 
    peak_icv_downsampling_handle m_handle{};
    bool m_enabled{ true };
 
    std::string m_customType;
};
 
inline DownsamplingModule::DownsamplingModule()
    : DownsamplingModule(DownsamplingMode::BinningAverage, {})
{}
 
inline DownsamplingModule::DownsamplingModule(DownsamplingMode defaultMode, std::string customName)
    : m_defaultMode{ defaultMode }
    , m_customType{ std::move(customName) }
{
    peak::icv::detail::ExecuteAndMapReturnCodes([&] {
        return PEAK_ICV_C_ABI_PREFIX peak_icv_Preprocessing_Downsampling_Create(
            &m_handle, peak_icv_downsampling_factor{ 1, 1 }, static_cast<peak_icv_downsampling_mode>(m_defaultMode));
    });
}
 
inline DownsamplingModule::~DownsamplingModule()
{
    if (m_handle != nullptr)
    {
        std::ignore = PEAK_ICV_C_ABI_PREFIX peak_icv_Preprocessing_Downsampling_Destroy(m_handle);
    }
}
 
inline DownsamplingModule::DownsamplingModule(DownsamplingModule&& other) noexcept
    : m_defaultMode{ std::exchange(other.m_defaultMode, DownsamplingMode::BinningAverage) }
    , m_handle{ std::exchange(other.m_handle, nullptr) }
    , m_enabled{ std::exchange(other.m_enabled, false) }
{}
 
inline DownsamplingModule& DownsamplingModule::operator=(DownsamplingModule&& other) noexcept
{
    if (this != &other)
    {
        if (m_handle != nullptr)
        {
            peak::icv::detail::ExecuteAndMapReturnCodes([&] {
                return PEAK_ICV_C_ABI_PREFIX peak_icv_Preprocessing_Downsampling_Destroy(m_handle);
            });
        }
 
        m_handle = std::exchange(other.m_handle, nullptr);
        m_enabled = std::exchange(other.m_enabled, false);
        m_defaultMode = std::exchange(other.m_defaultMode, DownsamplingMode::BinningAverage);
    }
 
    return *this;
}
 
inline void DownsamplingModule::SetEnabled(const bool enabled)
{
    m_enabled = enabled;
}
 
inline bool DownsamplingModule::IsEnabled() const
{
    return m_enabled;
}
 
inline void DownsamplingModule::Serialize(peak::common::serialization::IArchive& archive) const
{
    archive.SetInt("Version", moduleVersion);
    archive.SetBool("Enabled", IsEnabled());
 
    archive.SetInt(xKey, GetX());
    archive.SetInt(yKey, GetY());
 
    const auto& mode = GetMode();
    archive.SetString(modeKey, ToString(mode));
 
    archive.SetString(defaultModeKey, ToString(m_defaultMode));
}
 
inline void DownsamplingModule::Deserialize(const peak::common::serialization::IArchive& archive)
{
    const auto version = archive.GetInt("Version");
    detail::ValidateVersion(version, GetType());
 
    SetEnabled(archive.GetBool("Enabled"));
 
    SetX(static_cast<uint32_t>(archive.GetInt(xKey)));
    SetY(static_cast<uint32_t>(archive.GetInt(yKey)));
 
    SetMode(ToMode(archive.GetString(modeKey)));
    m_defaultMode = ToMode(archive.GetString(defaultModeKey));
}
 
inline peak::icv::Image DownsamplingModule::Process(const peak::icv::Image& input) const
{
    return Process(peak::common::Any(input)).AnyCast<peak::icv::Image>();
}
 
inline peak::common::Any DownsamplingModule::Process(const peak::common::Any& input) const
{
    auto needsProcessing = [&] {
        bool value{};
        peak::icv::detail::ExecuteAndMapReturnCodes([&] {
            return PEAK_ICV_C_ABI_PREFIX peak_icv_Preprocessing_Downsampling_NeedsProcessing(m_handle, &value);
        });
        return value;
    };
 
    if (!IsEnabled() || !needsProcessing())
    {
        return input;
    }
 
    const auto& inputImage = input.AnyCast<peak::icv::Image>();
    auto* const inputImageHandle = peak::common::detail::BackendAccessor<peak::icv::Image>::BackendHandle(inputImage);
 
    peak_common_size outputImageSize{};
    peak::icv::detail::ExecuteAndMapReturnCodes([&] {
        return PEAK_ICV_C_ABI_PREFIX peak_icv_Preprocessing_Downsampling_GetOutputImageSize(m_handle, inputImageHandle, &outputImageSize);
    });
 
    peak::icv::Image outputImage{ inputImage.GetPixelFormat(), { outputImageSize.width, outputImageSize.height } };
    auto* const outputImageHandle = peak::common::detail::BackendAccessor<peak::icv::Image>::BackendHandle(outputImage);
 
    peak::icv::detail::ExecuteAndMapReturnCodes([&] {
        return PEAK_ICV_C_ABI_PREFIX peak_icv_Preprocessing_Downsampling_Process(m_handle, inputImageHandle, outputImageHandle);
    });
 
    return peak::common::Any{ outputImage };
}
 
inline const char* DownsamplingModule::GetType() const
{
    if (!m_customType.empty())
    {
        return m_customType.c_str();
    }
    return "Downsampling";
}
 
inline void DownsamplingModule::ResetToDefault()
{
    SetX(1);
    SetY(1);
    SetMode(m_defaultMode);
}
 
inline void DownsamplingModule::SetX(uint32_t x)
{
    peak::icv::detail::ExecuteAndMapReturnCodes([&] {
        return PEAK_ICV_C_ABI_PREFIX peak_icv_Preprocessing_Downsampling_SetFactor(m_handle, peak_icv_downsampling_factor{ x, GetY() });
    });
}
 
inline void DownsamplingModule::SetY(uint32_t y)
{
    peak::icv::detail::ExecuteAndMapReturnCodes([&] {
        return PEAK_ICV_C_ABI_PREFIX peak_icv_Preprocessing_Downsampling_SetFactor(m_handle, peak_icv_downsampling_factor{ GetX(), y });
    });
}
 
inline uint32_t DownsamplingModule::GetX() const
{
    peak_icv_downsampling_factor factor{};
 
    peak::icv::detail::ExecuteAndMapReturnCodes([&] {
        return PEAK_ICV_C_ABI_PREFIX peak_icv_Preprocessing_Downsampling_GetFactor(m_handle, &factor);
    });
 
    return factor.x;
}
 
inline uint32_t DownsamplingModule::GetY() const
{
    peak_icv_downsampling_factor factor{};
 
    peak::icv::detail::ExecuteAndMapReturnCodes([&] {
        return PEAK_ICV_C_ABI_PREFIX peak_icv_Preprocessing_Downsampling_GetFactor(m_handle, &factor);
    });
 
    return factor.y;
}
 
inline peak::common::IntervalU DownsamplingModule::GetRange() const
{
    peak_common_interval_u cRange{};
 
    peak::icv::detail::ExecuteAndMapReturnCodes([&] {
        return PEAK_ICV_C_ABI_PREFIX peak_icv_Preprocessing_Downsampling_GetRange(m_handle, &cRange);
    });
 
    return { cRange.minimum, cRange.maximum };
}
 
inline void DownsamplingModule::SetMode(const DownsamplingMode& mode)
{
    peak::icv::detail::ExecuteAndMapReturnCodes([&] {
        return PEAK_ICV_C_ABI_PREFIX peak_icv_Preprocessing_Downsampling_SetMode(
            m_handle, static_cast<peak_icv_downsampling_mode>(mode));
    });
}
 
inline DownsamplingMode DownsamplingModule::GetMode() const
{
    peak_icv_downsampling_mode mode{};
 
    peak::icv::detail::ExecuteAndMapReturnCodes([&] {
        return PEAK_ICV_C_ABI_PREFIX peak_icv_Preprocessing_Downsampling_GetMode(m_handle, &mode);
    });
 
    return static_cast<DownsamplingMode>(mode);
}
 
} // namespace detail
} // namespace pipeline 
} // namespace peak