peak_icv_pixel_format_conversion_module.hpp

Go to the documentation of this file.

 
#pragma once
 
#include <peak_common/pipeline/modules/peak_common_imodule.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_image_converter.h>
 
namespace peak
{
namespace pipeline
{
namespace detail
{
 
class PixelFormatConversionModule : public modules::IModule
{
public:
    PixelFormatConversionModule();
 
    ~PixelFormatConversionModule() override;
 
    PixelFormatConversionModule(const PixelFormatConversionModule& other) = delete;
 
    PixelFormatConversionModule(PixelFormatConversionModule&& other) noexcept;
 
    PixelFormatConversionModule& operator=(const PixelFormatConversionModule& other) = delete;
 
    PixelFormatConversionModule& operator=(PixelFormatConversionModule&& 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 SetOutputPixelFormat(peak::common::PixelFormat format);
 
    PEAK_COMMON_NO_DISCARD peak::common::PixelFormat GetOutputPixelFormat() 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;
 
    void ReleaseBuffers() const;
 
private:
    static constexpr int moduleVersion{ 1 };
    static constexpr auto outputPixelFormatKey{ "OutputPixelFormat" };
 
    peak::common::PixelFormat m_outputPixelFormat{ peak::common::PixelFormat::RGB8 };
    bool m_enabled{ true };
    peak_icv_image_converter_handle m_handle{};
};
 
inline PixelFormatConversionModule::PixelFormatConversionModule()
{
    peak::icv::detail::ExecuteAndMapReturnCodes([&] {
        return PEAK_ICV_C_ABI_PREFIX peak_icv_Preprocessing_ImageConverter_Create(&m_handle);
    });
}
 
inline PixelFormatConversionModule::~PixelFormatConversionModule()
{
    if (m_handle != nullptr)
    {
        std::ignore = PEAK_ICV_C_ABI_PREFIX peak_icv_Preprocessing_ImageConverter_Destroy(m_handle);
    }
}
 
inline PixelFormatConversionModule::PixelFormatConversionModule(PixelFormatConversionModule&& other) noexcept
{
    m_outputPixelFormat = other.m_outputPixelFormat;
    m_enabled = other.m_enabled;
    std::swap(m_handle, other.m_handle);
}
 
inline PixelFormatConversionModule& PixelFormatConversionModule::operator=(PixelFormatConversionModule&& other) noexcept
{
    if (this != &other)
    {
        m_outputPixelFormat = other.m_outputPixelFormat;
        m_enabled = other.m_enabled;
        std::swap(m_handle, other.m_handle);
    }
 
    return *this;
}
 
inline void PixelFormatConversionModule::Serialize(peak::common::serialization::IArchive& archive) const
{
    archive.SetBool("Enabled", IsEnabled());
    archive.SetInt("Version", moduleVersion);
 
    archive.SetString(outputPixelFormatKey, peak::common::PixelFormatInfo(m_outputPixelFormat).GetName());
}
 
inline void PixelFormatConversionModule::Deserialize(const peak::common::serialization::IArchive& archive)
{
    const auto version = archive.GetInt("Version");
    detail::ValidateVersion(version, GetType());
 
    SetEnabled(archive.GetBool("Enabled"));
    m_outputPixelFormat = peak::common::PixelFormatInfo(archive.GetString(outputPixelFormatKey)).GetPixelFormat();
}
 
inline void PixelFormatConversionModule::SetOutputPixelFormat(peak::common::PixelFormat format)
{
    m_outputPixelFormat = format;
}
 
inline peak::common::PixelFormat PixelFormatConversionModule::GetOutputPixelFormat() const
{
    return m_outputPixelFormat;
}
 
inline void PixelFormatConversionModule::ResetToDefault()
{
    m_outputPixelFormat = peak::common::PixelFormat::RGB8;
}
 
inline void PixelFormatConversionModule::SetEnabled(bool enabled)
{
    m_enabled = enabled;
}
 
inline bool PixelFormatConversionModule::IsEnabled() const
{
    return m_enabled;
}
 
inline const char* PixelFormatConversionModule::GetType() const
{
    return "PixelFormatConversion";
}
 
inline peak::icv::Image PixelFormatConversionModule::Process(const peak::icv::Image& input) const
{
    return Process(peak::common::Any(input)).AnyCast<peak::icv::Image>();
}
 
inline peak::common::Any PixelFormatConversionModule::Process(const peak::common::Any& input) const
{
    if (!IsEnabled())
    {
        return input;
    }
 
    const auto& inputImage = input.AnyCast<peak::icv::Image>();
 
    const auto inputFormat = inputImage.GetPixelFormat();
 
    if (inputFormat == m_outputPixelFormat)
    {
        return input;
    }
 
    auto* const inputImageHandle = peak::common::detail::BackendAccessor<peak::icv::Image>::BackendHandle(inputImage);
    peak_icv_image_handle outputHandle = nullptr;
 
    peak::icv::detail::ExecuteAndMapReturnCodes([&] {
        return PEAK_ICV_C_ABI_PREFIX peak_icv_Preprocessing_ImageConverter_Convert(
            m_handle, inputImageHandle, static_cast<peak_common_pixel_format>(m_outputPixelFormat), &outputHandle);
    });
 
    return peak::common::Any(peak::common::detail::BackendAccessor<peak::icv::Image>::CreateInstance(outputHandle));
}
 
inline void PixelFormatConversionModule::ReleaseBuffers() const
{
    peak::icv::detail::ExecuteAndMapReturnCodes([&] {
        return PEAK_ICV_C_ABI_PREFIX peak_icv_Preprocessing_ImageConverter_ReleaseBuffers(m_handle);
    });
}
 
} // namespace detail
} // namespace pipeline 
} // namespace peak