peak_icv_default_pipeline.hpp

Go to the documentation of this file.

 
#pragma once
 
#include <peak_common/pipeline/peak_common_pipeline_base.hpp>
#include <peak_common/pipeline/modules/peak_common_iautofeature_module.hpp>
#include <peak_common/types/peak_common_pixel_format.hpp>
#include <peak_icv/pipeline/detail/peak_icv_color_matrix_transformation_module.hpp>
#include <peak_icv/pipeline/detail/peak_icv_debayer_module.hpp>
#include <peak_icv/pipeline/detail/peak_icv_downsampling_module.hpp>
#include <peak_icv/pipeline/detail/peak_icv_gain_module.hpp>
#include <peak_icv/pipeline/detail/peak_icv_hotpixel_correction_module.hpp>
#include <peak_icv/pipeline/detail/peak_icv_mono_conversion_module.hpp>
#include <peak_icv/pipeline/detail/peak_icv_pixel_format_conversion_module.hpp>
#include <peak_icv/pipeline/detail/peak_icv_sharpening_module.hpp>
#include <peak_icv/pipeline/detail/peak_icv_tone_curve_correction_module.hpp>
#include <peak_icv/pipeline/detail/peak_icv_transformation_module.hpp>
#include <peak_icv/pipeline/detail/peak_icv_unpack_module.hpp>
#include <peak_icv/pipeline/features/peak_icv_binning_feature.hpp>
#include <peak_icv/pipeline/features/peak_icv_color_correction_feature.hpp>
#include <peak_icv/pipeline/features/peak_icv_decimation_feature.hpp>
#include <peak_icv/pipeline/features/peak_icv_digital_black_feature.hpp>
#include <peak_icv/pipeline/features/peak_icv_gain_feature.hpp>
#include <peak_icv/pipeline/features/peak_icv_gamma_feature.hpp>
#include <peak_icv/pipeline/features/peak_icv_hotpixel_correction_feature.hpp>
#include <peak_icv/pipeline/features/peak_icv_mirror_feature.hpp>
#include <peak_icv/pipeline/features/peak_icv_rotation_feature.hpp>
#include <peak_icv/pipeline/features/peak_icv_saturation_feature.hpp>
#include <peak_icv/pipeline/features/peak_icv_sharpening_feature.hpp>
#include <peak_icv/pipeline/types/peak_icv_processing_policy.hpp>
#include <peak_icv/serialization/peak_icv_archive.hpp>
#include <peak_icv/serialization/peak_icv_deserializer.hpp>
#include <peak_icv/serialization/peak_icv_serializer.hpp>
 
#include <unordered_map>
#include <chrono>
#include <ctime>
#include <iomanip>
 
namespace peak
{
namespace pipeline
{
 
class DefaultPipeline final : public PipelineBase
{
public:
    DefaultPipeline();
 
    ~DefaultPipeline() override;
 
    PEAK_COMMON_NO_DISCARD std::string ExportSettingsToString() const override;
 
    void ImportSettingsFromString(const std::string& settings) override;
 
    void ResetToDefault() override;
 
    PEAK_COMMON_NO_DISCARD const char* GetType() const override;
 
    PEAK_COMMON_NO_DISCARD peak::icv::Image Process(const peak::icv::Image& image) const;
 
    PEAK_COMMON_NO_DISCARD peak::icv::Image Process(const peak::common::IImageView& imageView) const;
 
    PEAK_COMMON_NO_DISCARD peak::icv::Image operator<<(const peak::icv::Image& image) const;
 
    PEAK_COMMON_NO_DISCARD peak::icv::Image operator<<(const peak::common::IImageView& imageView) const;
 
    void ReleaseBuffers() const;
 
    PEAK_COMMON_NO_DISCARD features::MirrorFeature& Mirror() const;
 
    PEAK_COMMON_NO_DISCARD features::RotationFeature& Rotation() const;
 
    PEAK_COMMON_NO_DISCARD features::GainFeature& Gain() const;
 
    PEAK_COMMON_NO_DISCARD features::ColorCorrectionFeature& ColorCorrection() const;
 
    PEAK_COMMON_NO_DISCARD features::SaturationFeature& Saturation() const;
 
    PEAK_COMMON_NO_DISCARD features::GammaFeature& Gamma() const;
 
    PEAK_COMMON_NO_DISCARD features::DigitalBlackFeature& DigitalBlack() const;
 
    PEAK_COMMON_NO_DISCARD features::SharpeningFeature& Sharpening() const;
 
    PEAK_COMMON_NO_DISCARD features::HotpixelCorrectionFeature& HotpixelCorrection() const;
 
    PEAK_COMMON_NO_DISCARD features::BinningFeature& Binning() const;
 
    PEAK_COMMON_NO_DISCARD features::DecimationFeature& Decimation() const;
 
    void SetOutputPixelFormat(peak::common::PixelFormat format);
 
    PEAK_COMMON_NO_DISCARD peak::common::PixelFormat GetOutputPixelFormat() const;
 
    void SetProcessingPolicy(ProcessingPolicy policy);
 
    PEAK_COMMON_NO_DISCARD ProcessingPolicy GetProcessingPolicy() const
    {
        return m_processingPolicy;
    }
 
    void SetAutoFeatureModule(const std::shared_ptr<modules::IAutoFeature>& autoFeatureModule);
 
private:
    static std::string GetCurrentIsoUtcTime();
 
    PEAK_COMMON_NO_DISCARD std::vector<std::shared_ptr<modules::IModule>> GetModules() const override;
    PEAK_COMMON_NO_DISCARD std::vector<std::shared_ptr<features::IFeature>> GetFeatures() const;
 
    PEAK_COMMON_NO_DISCARD inline peak::common::Any Process(const peak::common::Any& input) const override;
 
    peak::common::Any operator<<(const peak::common::Any& input) override
    {
        return Process(input);
    }
 
    ProcessingPolicy m_processingPolicy{ ProcessingPolicy::Fast };
 
    std::shared_ptr<detail::UnpackModule> m_unpack{ std::make_shared<detail::UnpackModule>() };
    std::shared_ptr<detail::HotpixelCorrectionModule> m_hotpixel{ std::make_shared<detail::HotpixelCorrectionModule>() };
    std::shared_ptr<detail::DownsamplingModule> m_binning{ std::make_shared<detail::DownsamplingModule>(
        detail::DownsamplingMode::BinningAverage, "Binning") };
    std::shared_ptr<detail::DownsamplingModule> m_decimation{ std::make_shared<detail::DownsamplingModule>(
        detail::DownsamplingMode::Decimation, "Decimation") };
    std::shared_ptr<detail::TransformationModule> m_transformation{ std::make_shared<detail::TransformationModule>() };
    std::shared_ptr<detail::GainModule> m_gain{ std::make_shared<detail::GainModule>() };
    std::shared_ptr<detail::DebayerModule> m_debayer{ std::make_shared<detail::DebayerModule>() };
    std::shared_ptr<detail::ColorMatrixTransformationModule> m_colorCorrection{
        std::make_shared<detail::ColorMatrixTransformationModule>()
    };
    std::shared_ptr<detail::MonoConversionModule> m_monoConversion{ std::make_shared<detail::MonoConversionModule>() };
    std::shared_ptr<detail::SharpeningModule> m_sharpening{ std::make_shared<detail::SharpeningModule>() };
    std::shared_ptr<detail::ToneCurveCorrectionModule> m_toneCurveCorrection{ std::make_shared<detail::ToneCurveCorrectionModule>() };
    std::shared_ptr<detail::PixelFormatConversionModule> m_finalConversion{ std::make_shared<detail::PixelFormatConversionModule>() };
 
    std::shared_ptr<features::HotpixelCorrectionFeature> m_hotpixelFeature{ new features::HotpixelCorrectionFeature{ *m_hotpixel } };
    std::shared_ptr<features::BinningFeature> m_binningFeature{ new features::BinningFeature{ *m_binning } };
    std::shared_ptr<features::DecimationFeature> m_decimationFeature{ new features::DecimationFeature{ *m_decimation } };
    std::shared_ptr<features::MirrorFeature> m_mirrorFeature{ new features::MirrorFeature{ *m_transformation } };
    std::shared_ptr<features::RotationFeature> m_rotationFeature{ new features::RotationFeature{ *m_transformation } };
    std::shared_ptr<features::GainFeature> m_gainFeature{ new features::GainFeature{ *m_gain } };
    std::shared_ptr<features::ColorCorrectionFeature> m_colorCorrectionFeature{ new features::ColorCorrectionFeature{
        *m_colorCorrection } };
    std::shared_ptr<features::SaturationFeature> m_saturationFeature{ new features::SaturationFeature{ *m_colorCorrection } };
    std::shared_ptr<features::SharpeningFeature> m_sharpeningFeature{ new features::SharpeningFeature{ *m_sharpening } };
    std::shared_ptr<features::GammaFeature> m_gammaFeature{ new features::GammaFeature{ *m_toneCurveCorrection } };
    std::shared_ptr<features::DigitalBlackFeature> m_digitalBlackFeature{ new features::DigitalBlackFeature{ *m_toneCurveCorrection } };
 
    std::shared_ptr<modules::IAutoFeature> m_autoFeatureModule;
 
    constexpr static int pipelineVersion{ 1 };
};
 
inline DefaultPipeline::DefaultPipeline()
{
    m_monoConversion->SetEnabled(false);
 
    const auto format = m_finalConversion->GetOutputPixelFormat();
 
    const auto bitDepth = peak::common::PixelFormatInfo(format).GetStorageBitsPerChannel();
    m_unpack->SetProcessingPolicy(m_processingPolicy);
    m_unpack->SetTargetBitDepth(bitDepth);
    m_debayer->SetProcessingPolicy(m_processingPolicy);
    m_debayer->SetTargetBitDepth(bitDepth);
}
 
inline DefaultPipeline::~DefaultPipeline()
{
    if (m_autoFeatureModule)
    {
        m_autoFeatureModule->SetGainModule(nullptr);
    }
}
 
inline std::string DefaultPipeline::ExportSettingsToString() const
{
    const auto archive = std::make_shared<peak::icv::Archive>();
 
    const auto moduleList = GetModules();
    std::vector<std::shared_ptr<peak::common::serialization::IArchive>> modules;
    modules.reserve(moduleList.size());
 
    for (const auto& module : moduleList)
    {
        if (module == nullptr)
        {
            continue;
        }
        auto moduleArchive = archive->CreateArchive();
        moduleArchive->SetString("Type", module->GetType());
 
        auto moduleDataArchive = moduleArchive->CreateArchive();
        module->Serialize(*moduleDataArchive);
        moduleArchive->SetArchive("Data", moduleDataArchive);
        modules.push_back(moduleArchive);
    }
    archive->SetArchiveArray("Modules", modules);
    archive->SetInt("Version", pipelineVersion);
    archive->SetString("Type", GetType());
    archive->SetString("Creation", GetCurrentIsoUtcTime());
 
    peak::icv::Serializer serializer;
 
    std::stringstream ss;
    serializer.Write(*archive, ss);
    return ss.str();
}
 
inline void DefaultPipeline::ImportSettingsFromString(const std::string& settings)
{
    peak::icv::Deserializer deserializer;
 
    std::stringstream ss;
    ss << settings;
    const auto archive = deserializer.Read(ss);
 
    const auto version = archive->GetInt("Version");
 
    if (version < 1)
    {
        throw peak::icv::CorruptedException(
            "The 'Version' entry " + std::to_string(version) + " in the settings string is invalid! Must be at least 1.");
    }
 
    const auto pipelineType = archive->GetString("Type");
    if (pipelineType != GetType())
    {
        throw peak::icv::CorruptedException(
            "The settings for " + pipelineType + " are not compatible with this pipeline (" + GetType() + ").");
    }
 
    std::vector<std::shared_ptr<modules::IModule>> modules;
    if (m_autoFeatureModule == nullptr)
    {
        modules = { m_unpack, m_hotpixel, m_binning, m_decimation, m_transformation, m_gain, m_debayer, m_colorCorrection, m_monoConversion,
            m_sharpening, m_toneCurveCorrection, m_finalConversion };
    }
    else
    {
        modules = { m_unpack, m_hotpixel, m_binning, m_decimation, m_transformation, m_gain, m_debayer, m_colorCorrection,
            m_autoFeatureModule, m_monoConversion, m_sharpening, m_toneCurveCorrection, m_finalConversion };
    }
 
    std::unordered_map<std::string, std::shared_ptr<peak::common::serialization::IArchive>> archiveMap;
    auto moduleArchives = archive->GetArchiveArray("Modules");
 
    for (const auto& moduleArchive : moduleArchives)
    {
        const auto moduleType = moduleArchive->GetString("Type");
        const auto data = moduleArchive->GetArchive("Data");
        archiveMap.emplace(moduleType, data);
    }
 
    for (const auto& module : modules)
    {
        const auto found = archiveMap.find(module->GetType());
        if (found == archiveMap.end())
        {
            throw peak::icv::IOException(std::string("The settings for module ") + module->GetType() + " are missing!");
        }
 
        module->Deserialize(*found->second);
    }
}
 
inline void DefaultPipeline::ResetToDefault()
{
    for (const auto& module : GetModules())
    {
        module->ResetToDefault();
        module->SetEnabled(true);
    }
    for (const auto& feature : GetFeatures())
    {
        feature->ResetToDefault();
        feature->SetEnabled(true);
    }
    m_monoConversion->SetEnabled(false);
}
 
inline const char* DefaultPipeline::GetType() const
{
    return "DefaultPipeline";
}
 
inline void DefaultPipeline::ReleaseBuffers() const
{
    m_unpack->ReleaseBuffers();
    m_debayer->ReleaseBuffers();
    m_monoConversion->ReleaseBuffers();
    m_finalConversion->ReleaseBuffers();
}
 
inline features::MirrorFeature& DefaultPipeline::Mirror() const
{
    return *m_mirrorFeature;
}
 
inline features::RotationFeature& DefaultPipeline::Rotation() const
{
    return *m_rotationFeature;
}
 
inline features::GainFeature& DefaultPipeline::Gain() const
{
    return *m_gainFeature;
}
 
inline features::ColorCorrectionFeature& DefaultPipeline::ColorCorrection() const
{
    return *m_colorCorrectionFeature;
}
 
inline features::SaturationFeature& DefaultPipeline::Saturation() const
{
    return *m_saturationFeature;
}
 
inline features::GammaFeature& DefaultPipeline::Gamma() const
{
    return *m_gammaFeature;
}
 
inline features::DigitalBlackFeature& DefaultPipeline::DigitalBlack() const
{
    return *m_digitalBlackFeature;
}
 
inline features::SharpeningFeature& DefaultPipeline::Sharpening() const
{
    return *m_sharpeningFeature;
}
 
inline features::HotpixelCorrectionFeature& DefaultPipeline::HotpixelCorrection() const
{
    return *m_hotpixelFeature;
}
 
inline features::BinningFeature& DefaultPipeline::Binning() const
{
    return *m_binningFeature;
}
 
inline features::DecimationFeature& DefaultPipeline::Decimation() const
{
    return *m_decimationFeature;
}
 
inline peak::common::Any DefaultPipeline::Process(const peak::common::Any& input) const
{
    auto data = input;
 
    for (const auto& mod : GetModules())
    {
        if (!mod)
        {
            continue;
        }
 
        try
        {
            data = mod->Process(data);
        }
        catch (const peak::icv::Exception& e)
        {
            const auto errorCode = e.GetStatus();
            const auto* const what = e.what();
            const auto* const moduleType = mod->GetType();
 
            const auto errorText = std::string{ "[" } + moduleType + "] " + what;
            switch (errorCode)
            {
            case PEAK_ICV_STATUS_LIBRARY_NOT_INITIALIZED:
            case PEAK_ICV_STATUS_DYNAMIC_DEPENDENCY_MISSING:
                throw peak::icv::InvalidConfigurationException(errorText, errorCode);
            case PEAK_ICV_STATUS_INVALID_HANDLE:
            case PEAK_ICV_STATUS_INVALID_BUFFER_SIZE:
            case PEAK_ICV_STATUS_MISMATCH:
            case PEAK_ICV_STATUS_NULL_POINTER:
            case PEAK_ICV_STATUS_NOT_SUPPORTED:
            case PEAK_ICV_STATUS_NOT_POSSIBLE:
                throw peak::icv::NotSupportedException(errorText);
            case PEAK_ICV_STATUS_CORRUPTED:
                throw peak::icv::CorruptedException(errorText);
            case PEAK_ICV_STATUS_OUT_OF_RANGE:
                throw peak::icv::OutOfRangeException(errorText);
            case PEAK_ICV_STATUS_INTERNAL_ERROR:
                throw peak::icv::Exception(errorText, errorCode);
            default:
                throw peak::icv::Exception("Generic Error!", errorCode);
            }
        }
    }
 
    if (input.AnyCast<peak::icv::Image>().GetData() == data.AnyCast<peak::icv::Image>().GetData())
    {
        return peak::common::Any(data.AnyCast<peak::icv::Image>().Copy());
    }
    return data;
}
 
inline peak::icv::Image DefaultPipeline::Process(const peak::icv::Image& image) const
{
    return Process(peak::common::Any(image)).AnyCast<peak::icv::Image>();
}
 
inline peak::icv::Image DefaultPipeline::Process(const peak::common::IImageView& imageView) const
{
    return Process(peak::icv::Image(imageView));
}
 
inline peak::icv::Image DefaultPipeline::operator<<(const peak::icv::Image& image) const
{
    return Process(image);
}
 
inline peak::icv::Image DefaultPipeline::operator<<(const peak::common::IImageView& imageView) const
{
    return Process(imageView);
}
 
inline peak::common::PixelFormat DefaultPipeline::GetOutputPixelFormat() const
{
    return m_finalConversion->GetOutputPixelFormat();
}
 
inline void DefaultPipeline::SetOutputPixelFormat(peak::common::PixelFormat format)
{
    const peak::common::PixelFormatInfo info(format);
 
    const bool isBayerFormat = info.IsSingleChannel() && info.HasChannel(peak::common::Channel::Bayer);
    const bool isMonoFormat = info.IsSingleChannel() && info.HasIntensityChannel();
 
    if (isBayerFormat)
    {
        m_debayer->SetConversionPolicy(detail::DebayerConversionPolicy::Bypass);
    }
    else if (isMonoFormat)
    {
        m_debayer->SetConversionPolicy(detail::DebayerConversionPolicy::BayerOnly);
        m_debayer->SetChannelLayout(DebayerChannelLayout::RGB);
    }
    else
    {
        m_debayer->SetConversionPolicy(detail::DebayerConversionPolicy::BayerAndMono);
 
        if (info.HasChannel(peak::common::Channel::Red) && info.HasChannel(peak::common::Channel::Green)
            && info.HasChannel(peak::common::Channel::Blue))
        {
            m_debayer->SetConversionPolicy(detail::DebayerConversionPolicy::BayerAndMono);
            switch (format)
            {
            case peak::common::PixelFormat::RGB8:
            case peak::common::PixelFormat::RGB10:
            case peak::common::PixelFormat::RGB12:
                m_debayer->SetChannelLayout(DebayerChannelLayout::RGB);
                break;
            case peak::common::PixelFormat::RGBa8:
            case peak::common::PixelFormat::RGBa10:
            case peak::common::PixelFormat::RGBa12:
                m_debayer->SetChannelLayout(DebayerChannelLayout::RGBA);
                break;
            case peak::common::PixelFormat::BGR8:
            case peak::common::PixelFormat::BGR10:
            case peak::common::PixelFormat::BGR12:
                m_debayer->SetChannelLayout(DebayerChannelLayout::BGR);
                break;
            case peak::common::PixelFormat::BGRa8:
            case peak::common::PixelFormat::BGRa10:
            case peak::common::PixelFormat::BGRa12:
                m_debayer->SetChannelLayout(DebayerChannelLayout::BGRA);
                break;
            default:
                break;
            }
        }
    }
 
    m_monoConversion->SetEnabled(isMonoFormat);
 
    m_finalConversion->SetOutputPixelFormat(format);
 
    const auto bitDepth = info.GetStorageBitsPerChannel();
    m_unpack->SetTargetBitDepth(bitDepth);
    m_debayer->SetTargetBitDepth(bitDepth);
}
 
inline void DefaultPipeline::SetProcessingPolicy(ProcessingPolicy policy)
{
    m_processingPolicy = policy;
 
    m_unpack->SetProcessingPolicy(m_processingPolicy);
    m_debayer->SetProcessingPolicy(m_processingPolicy);
}
 
inline void DefaultPipeline::SetAutoFeatureModule(const std::shared_ptr<modules::IAutoFeature>& autoFeatureModule)
{
    if (m_autoFeatureModule != nullptr)
    {
        m_autoFeatureModule->SetGainModule(nullptr);
    }
 
    m_autoFeatureModule = autoFeatureModule;
 
    m_colorCorrection->SetAutoFeatureModule(m_autoFeatureModule);
 
    if (m_autoFeatureModule != nullptr)
    {
        m_autoFeatureModule->SetGainModule(m_gain);
    }
}
 
inline std::string DefaultPipeline::GetCurrentIsoUtcTime()
{
    const auto now = std::chrono::system_clock::now();
    const std::time_t nowC = std::chrono::system_clock::to_time_t(now);
    std::tm tm{};
 
#if defined(_WIN32) || defined(_WIN64)
    gmtime_s(&tm, &nowC);
#else
    gmtime_r(&nowC, &tm);
#endif
 
    std::ostringstream oss;
    oss << std::put_time(&tm, "%Y-%m-%dT%H:%M:%SZ");
    return oss.str();
}
 
inline std::vector<std::shared_ptr<modules::IModule>> DefaultPipeline::GetModules() const
{
    if (m_autoFeatureModule == nullptr)
    {
        return { m_unpack, m_hotpixel, m_binning, m_decimation, m_transformation, m_gain, m_debayer, m_colorCorrection, m_monoConversion,
            m_sharpening, m_toneCurveCorrection, m_finalConversion };
    }
 
    return { m_unpack, m_hotpixel, m_binning, m_decimation, m_transformation, m_gain, m_debayer, m_colorCorrection, m_autoFeatureModule,
        m_monoConversion, m_sharpening, m_toneCurveCorrection, m_finalConversion };
}
 
inline std::vector<std::shared_ptr<features::IFeature>> DefaultPipeline::GetFeatures() const
{
    return { m_hotpixelFeature, m_binningFeature, m_decimationFeature, m_mirrorFeature, m_rotationFeature, m_gainFeature,
        m_colorCorrectionFeature, m_saturationFeature, m_sharpeningFeature, m_gammaFeature, m_digitalBlackFeature };
}
 
} // namespace pipeline 
} // namespace peak