peak_icv_debayer_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/pipeline/types/peak_icv_debayer_channel_layout.hpp>
#include <peak_icv/pipeline/types/peak_icv_processing_policy.hpp>
#include <peak_icv/types/peak_icv_image.hpp>
#include <peak_icv_c/algorithms/preprocessing/peak_icv_image_converter.h>
 
#include <algorithm>
#include <sstream>
#include <string>
 
namespace peak
{
namespace pipeline
{
namespace detail
{
 
enum class DebayerConversionPolicy
{
    Bypass,      
    BayerOnly,   
    BayerAndMono 
};
 
PEAK_COMMON_NO_DISCARD inline std::string ToString(const DebayerConversionPolicy& policy)
{
    if (policy == DebayerConversionPolicy::BayerAndMono)
    {
        return "BayerAndMono";
    }
    if (policy == DebayerConversionPolicy::BayerOnly)
    {
        return "BayerOnly";
    }
    if (policy == DebayerConversionPolicy::Bypass)
    {
        return "Bypass";
    }
    const auto policyStr = std::to_string(static_cast<int>(policy));
    throw peak::icv::NotSupportedException("The given debayer conversion policy " + policyStr + " is unknown!");
}
 
PEAK_COMMON_NO_DISCARD inline DebayerConversionPolicy ToDebayerConversionPolicy(const std::string& policy)
{
    if (policy == "BayerAndMono")
    {
        return DebayerConversionPolicy::BayerAndMono;
    }
    if (policy == "BayerOnly")
    {
        return DebayerConversionPolicy::BayerOnly;
    }
    if (policy == "Bypass")
    {
        return DebayerConversionPolicy::Bypass;
    }
    throw peak::icv::NotSupportedException("The given debayer conversion policy " + policy + " is unknown!");
}
 
class DebayerModule : public modules::IModule
{
public:
    DebayerModule();
 
    ~DebayerModule() override;
 
    DebayerModule(const DebayerModule& other) = delete;
 
    DebayerModule(DebayerModule&& other) noexcept;
 
    DebayerModule& operator=(const DebayerModule& other) = delete;
 
    DebayerModule& operator=(DebayerModule&& 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 SetChannelLayout(DebayerChannelLayout layout);
 
    PEAK_COMMON_NO_DISCARD DebayerChannelLayout GetChannelLayout() const;
 
    void SetConversionPolicy(DebayerConversionPolicy policy);
 
    PEAK_COMMON_NO_DISCARD DebayerConversionPolicy GetConversionPolicy() const;
 
    void SetTargetBitDepth(size_t bitDepth)
    {
        m_targetBitDepth = bitDepth;
    }
 
    void SetProcessingPolicy(ProcessingPolicy policy);
 
    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:
    PEAK_COMMON_NO_DISCARD peak::common::PixelFormat GetOutputFormat(peak::common::PixelFormat inputFormat) const;
    PEAK_COMMON_NO_DISCARD size_t GetOutputBitDepth(size_t inputBitDepth) const;
 
    static void ValidateChannelLayout(DebayerChannelLayout layout);
    static void ValidateConversionPolicy(DebayerConversionPolicy policy);
 
    static constexpr int moduleVersion{ 1 };
    static constexpr auto conversionPolicyKey{ "ConversionPolicy" };
    static constexpr auto channelLayoutKey{ "ChannelLayout" };
 
    peak_icv_image_converter_handle m_handle{};
    DebayerChannelLayout m_channelLayout{ DebayerChannelLayout::RGB };
    DebayerConversionPolicy m_conversionPolicy{ DebayerConversionPolicy::BayerOnly };
 
    size_t m_targetBitDepth{ 8 };
    ProcessingPolicy m_processingPolicy{ ProcessingPolicy::Fast };
 
    bool m_enabled{ true };
};
 
inline DebayerModule::DebayerModule()
{
    peak::icv::detail::ExecuteAndMapReturnCodes([&] {
        return PEAK_ICV_C_ABI_PREFIX peak_icv_Preprocessing_ImageConverter_Create(&m_handle);
    });
}
 
inline DebayerModule::~DebayerModule()
{
    if (m_handle != nullptr)
    {
        std::ignore = PEAK_ICV_C_ABI_PREFIX peak_icv_Preprocessing_ImageConverter_Destroy(m_handle);
    }
}
 
inline DebayerModule::DebayerModule(DebayerModule&& other) noexcept
{
    m_channelLayout = other.m_channelLayout;
    m_conversionPolicy = other.m_conversionPolicy;
    m_enabled = other.m_enabled;
 
    std::swap(m_handle, other.m_handle);
}
 
inline DebayerModule& DebayerModule::operator=(DebayerModule&& other) noexcept
{
    if (this != &other)
    {
        m_channelLayout = other.m_channelLayout;
        m_conversionPolicy = other.m_conversionPolicy;
        m_enabled = other.m_enabled;
        std::swap(m_handle, other.m_handle);
    }
 
    return *this;
}
 
inline void DebayerModule::Serialize(peak::common::serialization::IArchive& archive) const
{
    archive.SetBool("Enabled", IsEnabled());
    archive.SetInt("Version", moduleVersion);
 
    archive.SetString(channelLayoutKey, ToString(m_channelLayout));
    archive.SetString(conversionPolicyKey, ToString(m_conversionPolicy));
}
 
inline void DebayerModule::Deserialize(const peak::common::serialization::IArchive& archive)
{
    const auto version = archive.GetInt("Version");
    detail::ValidateVersion(version, GetType());
 
    SetEnabled(archive.GetBool("Enabled"));
    m_channelLayout = ToDebayerChannelLayout(archive.GetString(channelLayoutKey));
    m_conversionPolicy = ToDebayerConversionPolicy(archive.GetString(conversionPolicyKey));
}
 
inline void DebayerModule::ResetToDefault()
{
    m_channelLayout = DebayerChannelLayout::RGB;
    m_conversionPolicy = DebayerConversionPolicy::BayerOnly;
}
 
inline void DebayerModule::SetEnabled(bool enabled)
{
    m_enabled = enabled;
}
 
inline bool DebayerModule::IsEnabled() const
{
    return m_enabled;
}
 
inline const char* DebayerModule::GetType() const
{
    return "Debayer";
}
 
inline void DebayerModule::SetChannelLayout(DebayerChannelLayout layout)
{
    ValidateChannelLayout(layout);
    m_channelLayout = layout;
}
 
inline DebayerChannelLayout DebayerModule::GetChannelLayout() const
{
    return m_channelLayout;
}
 
inline void DebayerModule::SetConversionPolicy(DebayerConversionPolicy policy)
{
    ValidateConversionPolicy(policy);
    m_conversionPolicy = policy;
}
 
inline DebayerConversionPolicy DebayerModule::GetConversionPolicy() const
{
    return m_conversionPolicy;
}
 
inline size_t DebayerModule::GetOutputBitDepth(const size_t inputBitDepth) const
{
    if (m_processingPolicy == ProcessingPolicy::Fast)
    {
        return (std::min)(inputBitDepth, m_targetBitDepth);
    }
    if (m_processingPolicy == ProcessingPolicy::Enhanced)
    {
        return (std::max)(inputBitDepth, m_targetBitDepth);
    }
    return inputBitDepth;
}
 
inline peak::common::PixelFormat DebayerModule::GetOutputFormat(peak::common::PixelFormat inputFormat) const
{
    if (m_conversionPolicy == DebayerConversionPolicy::Bypass)
    {
        return inputFormat;
    }
 
    const peak::common::PixelFormatInfo info(inputFormat);
 
    if (!info.IsSingleChannel())
    {
        return inputFormat;
    }
 
    const auto isBayer = info.HasChannel(peak::common::Channel::Bayer);
    const auto isMono = info.HasIntensityChannel();
 
    if (!isBayer && (!isMono || m_conversionPolicy != DebayerConversionPolicy::BayerAndMono))
    {
        return inputFormat;
    }
 
    const auto inputBitDepth = info.GetStorageBitsPerChannel();
    const auto outputBitDepth = GetOutputBitDepth(inputBitDepth);
 
    if (outputBitDepth <= 8)
    {
        switch (m_channelLayout)
        {
        case DebayerChannelLayout::RGB:
            return peak::common::PixelFormat::RGB8;
        case DebayerChannelLayout::BGR:
            return peak::common::PixelFormat::BGR8;
        case DebayerChannelLayout::RGBA:
            return peak::common::PixelFormat::RGBa8;
        case DebayerChannelLayout::BGRA:
            return peak::common::PixelFormat::BGRa8;
        }
    }
    if (outputBitDepth <= 10)
    {
        switch (m_channelLayout)
        {
        case DebayerChannelLayout::RGB:
            return peak::common::PixelFormat::RGB10;
        case DebayerChannelLayout::BGR:
            return peak::common::PixelFormat::BGR10;
        case DebayerChannelLayout::RGBA:
            return peak::common::PixelFormat::RGBa10;
        case DebayerChannelLayout::BGRA:
            return peak::common::PixelFormat::BGRa10;
        }
    }
 
    switch (m_channelLayout)
    {
    case DebayerChannelLayout::RGB:
        return peak::common::PixelFormat::RGB12;
    case DebayerChannelLayout::BGR:
        return peak::common::PixelFormat::BGR12;
    case DebayerChannelLayout::RGBA:
        return peak::common::PixelFormat::RGBa12;
    case DebayerChannelLayout::BGRA:
        return peak::common::PixelFormat::BGRa12;
    }
 
    std::ostringstream oss;
    oss << "0x" << std::uppercase << std::hex << static_cast<int>(inputFormat);
    throw peak::icv::NotSupportedException("The given input pixel format " + oss.str() + " is unknown!");
}
 
inline void DebayerModule::ValidateChannelLayout(DebayerChannelLayout layout)
{
    if (layout != DebayerChannelLayout::RGB && layout != DebayerChannelLayout::BGR && layout != DebayerChannelLayout::RGBA
        && layout != DebayerChannelLayout::BGRA)
    {
        throw peak::icv::NotSupportedException("The given channel layout " + ToString(layout) + " is invalid!");
    }
}
 
inline void DebayerModule::ValidateConversionPolicy(DebayerConversionPolicy policy)
{
    if (policy != DebayerConversionPolicy::BayerOnly && policy != DebayerConversionPolicy::BayerAndMono
        && policy != DebayerConversionPolicy::Bypass)
    {
        throw peak::icv::NotSupportedException("The given conversion policy " + ToString(policy) + " is invalid!");
    }
}
 
inline void DebayerModule::SetProcessingPolicy(ProcessingPolicy policy)
{
    m_processingPolicy = policy;
}
 
inline peak::icv::Image DebayerModule::Process(const peak::icv::Image& input) const
{
    return Process(peak::common::Any(input)).AnyCast<peak::icv::Image>();
}
 
inline peak::common::Any DebayerModule::Process(const peak::common::Any& input) const
{
    if (!IsEnabled())
    {
        return input;
    }
 
    const auto& inputImage = input.AnyCast<peak::icv::Image>();
 
    const auto inputFormat = inputImage.GetPixelFormat();
    const auto outputFormat = GetOutputFormat(inputFormat);
 
    if (inputFormat == outputFormat)
    {
        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>(outputFormat), &outputHandle);
    });
 
    return peak::common::Any(peak::common::detail::BackendAccessor<peak::icv::Image>::CreateInstance(outputHandle));
}
 
inline void DebayerModule::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