peak_icv_unpack_module.hpp

Go to the documentation of this file.

 
#pragma once
 
#include <peak_common/pipeline/modules/peak_common_imodule.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 <utility>
 
namespace peak
{
namespace pipeline
{
namespace detail
{
class UnpackModule : public modules::IModule
{
public:
    UnpackModule();
 
    ~UnpackModule() override;
 
    UnpackModule(const UnpackModule& other) = delete;
 
    UnpackModule(UnpackModule&& other) noexcept;
 
    UnpackModule& operator=(const UnpackModule& other) = delete;
 
    UnpackModule& operator=(UnpackModule&& other) noexcept;
 
    void Serialize(peak::common::serialization::IArchive& archive) const override;
 
    void Deserialize(const peak::common::serialization::IArchive& archive) override;
 
    void SetEnabled(bool enable) override;
 
    PEAK_COMMON_NO_DISCARD bool IsEnabled() const override;
 
    PEAK_COMMON_NO_DISCARD const char* GetType() const override;
 
    void ResetToDefault() override;
 
    void SetTargetBitDepth(size_t bitDepth);
 
 
    size_t GetTargetBitDepth() const;
 
    void SetProcessingPolicy(ProcessingPolicy policy);
 
    ProcessingPolicy GetProcessingPolicy() 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:
    PEAK_COMMON_NO_DISCARD static peak::common::PixelFormat GetOutputFormat(
        peak::common::PixelFormat inputFormat, size_t outputBitDepth);
    PEAK_COMMON_NO_DISCARD size_t GetOutputBitDepth(size_t inputBitDepth) const;
 
    PEAK_COMMON_NO_DISCARD static peak::common::PixelFormat BayerBGFormat(size_t bitDepth);
    PEAK_COMMON_NO_DISCARD static peak::common::PixelFormat BayerGBFormat(size_t bitDepth);
    PEAK_COMMON_NO_DISCARD static peak::common::PixelFormat BayerGRFormat(size_t bitDepth);
    PEAK_COMMON_NO_DISCARD static peak::common::PixelFormat BayerRGFormat(size_t bitDepth);
    PEAK_COMMON_NO_DISCARD static peak::common::PixelFormat MonoFormat(size_t bitDepth);
 
    peak_icv_image_converter_handle m_handle{};
 
    size_t m_targetBitDepth{ 8 };
    ProcessingPolicy m_policy{ ProcessingPolicy::Fast };
};
 
inline UnpackModule::UnpackModule()
{
    peak::icv::detail::ExecuteAndMapReturnCodes([&] {
        return PEAK_ICV_C_ABI_PREFIX peak_icv_Preprocessing_ImageConverter_Create(&m_handle);
    });
}
 
inline UnpackModule::~UnpackModule()
{
    if (m_handle != nullptr)
    {
        std::ignore = PEAK_ICV_C_ABI_PREFIX peak_icv_Preprocessing_ImageConverter_Destroy(m_handle);
    }
}
 
inline UnpackModule::UnpackModule(UnpackModule&& other) noexcept
{
    std::swap(m_handle, other.m_handle);
}
 
inline UnpackModule& UnpackModule::operator=(UnpackModule&& other) noexcept
{
    if (this != &other)
    {
        std::swap(m_handle, other.m_handle);
    }
 
    return *this;
}
 
inline void UnpackModule::Serialize(peak::common::serialization::IArchive& archive) const
{
    std::ignore = archive;
}
 
inline void UnpackModule::Deserialize(const peak::common::serialization::IArchive& archive)
{
    std::ignore = archive;
}
 
inline void UnpackModule::SetEnabled(bool enable)
{
    std::ignore = enable;
}
 
inline bool UnpackModule::IsEnabled() const
{
    return true;
}
 
inline const char* UnpackModule::GetType() const
{
    return "Unpack";
}
 
inline peak::common::PixelFormat UnpackModule::GetOutputFormat(
    const peak::common::PixelFormat inputFormat, const size_t outputBitDepth)
{
    switch (inputFormat)
    {
    case peak::common::PixelFormat::BayerBG8:
    case peak::common::PixelFormat::BayerBG10:
    case peak::common::PixelFormat::BayerBG10p:
    case peak::common::PixelFormat::BayerBG10g40IDS:
    case peak::common::PixelFormat::BayerBG12:
    case peak::common::PixelFormat::BayerBG12p:
    case peak::common::PixelFormat::BayerBG12g24IDS:
        return BayerBGFormat(outputBitDepth);
 
    case peak::common::PixelFormat::BayerGB8:
    case peak::common::PixelFormat::BayerGB10:
    case peak::common::PixelFormat::BayerGB10p:
    case peak::common::PixelFormat::BayerGB10g40IDS:
    case peak::common::PixelFormat::BayerGB12:
    case peak::common::PixelFormat::BayerGB12p:
    case peak::common::PixelFormat::BayerGB12g24IDS:
        return BayerGBFormat(outputBitDepth);
 
    case peak::common::PixelFormat::BayerGR8:
    case peak::common::PixelFormat::BayerGR10:
    case peak::common::PixelFormat::BayerGR10p:
    case peak::common::PixelFormat::BayerGR10g40IDS:
    case peak::common::PixelFormat::BayerGR12:
    case peak::common::PixelFormat::BayerGR12p:
    case peak::common::PixelFormat::BayerGR12g24IDS:
        return BayerGRFormat(outputBitDepth);
 
    case peak::common::PixelFormat::BayerRG8:
    case peak::common::PixelFormat::BayerRG10:
    case peak::common::PixelFormat::BayerRG10p:
    case peak::common::PixelFormat::BayerRG10g40IDS:
    case peak::common::PixelFormat::BayerRG12:
    case peak::common::PixelFormat::BayerRG12p:
    case peak::common::PixelFormat::BayerRG12g24IDS:
        return BayerRGFormat(outputBitDepth);
 
    case peak::common::PixelFormat::Mono8:
    case peak::common::PixelFormat::Mono10:
    case peak::common::PixelFormat::Mono10p:
    case peak::common::PixelFormat::Mono10g40IDS:
    case peak::common::PixelFormat::Mono12:
    case peak::common::PixelFormat::Mono12p:
    case peak::common::PixelFormat::Mono12g24IDS:
        return MonoFormat(outputBitDepth);
 
    case peak::common::PixelFormat::YUV420_8_YY_UV_SemiplanarIDS:
    case peak::common::PixelFormat::YUV420_8_YY_VU_SemiplanarIDS:
    case peak::common::PixelFormat::YUV422_8_UYVY:
        return peak::common::PixelFormat::RGB8;
 
    default:
        return inputFormat;
    }
}
 
inline peak::common::PixelFormat UnpackModule::BayerBGFormat(const size_t bitDepth)
{
    if (bitDepth >= 12)
    {
        return peak::common::PixelFormat::BayerBG12;
    }
    if (bitDepth >= 10)
    {
        return peak::common::PixelFormat::BayerBG10;
    }
    return peak::common::PixelFormat::BayerBG8;
}
 
inline peak::common::PixelFormat UnpackModule::BayerGBFormat(const size_t bitDepth)
{
    if (bitDepth >= 12)
    {
        return peak::common::PixelFormat::BayerGB12;
    }
    if (bitDepth >= 10)
    {
        return peak::common::PixelFormat::BayerGB10;
    }
    return peak::common::PixelFormat::BayerGB8;
}
 
inline peak::common::PixelFormat UnpackModule::BayerGRFormat(const size_t bitDepth)
{
    if (bitDepth >= 12)
    {
        return peak::common::PixelFormat::BayerGR12;
    }
    if (bitDepth >= 10)
    {
        return peak::common::PixelFormat::BayerGR10;
    }
    return peak::common::PixelFormat::BayerGR8;
}
 
inline peak::common::PixelFormat UnpackModule::BayerRGFormat(const size_t bitDepth)
{
    if (bitDepth >= 12)
    {
        return peak::common::PixelFormat::BayerRG12;
    }
    if (bitDepth >= 10)
    {
        return peak::common::PixelFormat::BayerRG10;
    }
    return peak::common::PixelFormat::BayerRG8;
}
 
inline peak::common::PixelFormat UnpackModule::MonoFormat(const size_t bitDepth)
{
    if (bitDepth >= 12)
    {
        return peak::common::PixelFormat::Mono12;
    }
    if (bitDepth >= 10)
    {
        return peak::common::PixelFormat::Mono10;
    }
    return peak::common::PixelFormat::Mono8;
}
 
inline void UnpackModule::ResetToDefault()
{
    m_policy = ProcessingPolicy::Fast;
    m_targetBitDepth = 8;
}
 
inline void UnpackModule::SetTargetBitDepth(const size_t bitDepth)
{
    m_targetBitDepth = bitDepth;
}
 
inline size_t UnpackModule::GetTargetBitDepth() const
{
    return m_targetBitDepth;
}
 
inline void UnpackModule::SetProcessingPolicy(const ProcessingPolicy policy)
{
    m_policy = policy;
}
 
inline ProcessingPolicy UnpackModule::GetProcessingPolicy() const
{
    return m_policy;
}
 
inline peak::icv::Image UnpackModule::Process(const peak::icv::Image& input) const
{
    return Process(peak::common::Any(input)).AnyCast<peak::icv::Image>();
}
 
inline size_t UnpackModule::GetOutputBitDepth(const size_t inputBitDepth) const
{
    if (m_policy == ProcessingPolicy::Fast)
    {
        return (std::min)(inputBitDepth, m_targetBitDepth);
    }
    if (m_policy == ProcessingPolicy::Enhanced)
    {
        return (std::max)(inputBitDepth, m_targetBitDepth);
    }
    return inputBitDepth;
}
 
inline peak::common::Any UnpackModule::Process(const peak::common::Any& input) const
{
    const auto& inputImage = input.AnyCast<peak::icv::Image>();
 
    const auto inputFormat = inputImage.GetPixelFormat();
    const auto inputBitDepth = peak::common::PixelFormatInfo(inputFormat).GetStorageBitsPerChannel();
    const auto outputBitDepth = GetOutputBitDepth(inputBitDepth);
    const auto outputFormat = GetOutputFormat(inputFormat, outputBitDepth);
 
    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, peak::common::detail::CppPixelFormatToCPixelFormat(outputFormat), &outputHandle);
    });
 
    return peak::common::Any(peak::common::detail::BackendAccessor<peak::icv::Image>::CreateInstance(outputHandle));
}
 
inline void UnpackModule::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