peak_icv_transformation_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_rotation.hpp>
#include <peak_icv/types/peak_icv_image.hpp>
#include <peak_icv_c/algorithms/preprocessing/peak_icv_image_transformation.h>
 
namespace peak
{
namespace pipeline
{
 
namespace features
{
class MirrorFeature;
class RotationFeature;
} // namespace features
 
namespace detail
{
 
class TransformationModule : public modules::IModule
{
public:
    TransformationModule() = default;
 
    ~TransformationModule() override = default;
 
    TransformationModule(const TransformationModule& other) = delete;
 
    TransformationModule(TransformationModule&& other) noexcept;
 
    TransformationModule& operator=(const TransformationModule& other) = delete;
 
    TransformationModule& operator=(TransformationModule&& 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 SetMirrorLeftRightEnabled(bool enabled);
 
    void SetMirrorUpDownEnabled(bool enabled);
 
    PEAK_COMMON_NO_DISCARD bool IsMirrorLeftRightEnabled() const;
 
    PEAK_COMMON_NO_DISCARD bool IsMirrorUpDownEnabled() const;
 
    void SetRotationAngle(Rotation angle);
 
    PEAK_COMMON_NO_DISCARD Rotation GetRotationAngle() 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;
 
private:
#ifndef DOXYGEN_SHOULD_SKIP_THIS
    friend class features::MirrorFeature;
    friend class features::RotationFeature;
#endif
 
    void SetMirrorEnabled(bool enabled);
    PEAK_COMMON_NO_DISCARD bool IsMirrorEnabled() const;
 
    void SetRotationEnabled(bool enabled);
    PEAK_COMMON_NO_DISCARD bool IsRotationEnabled() const;
 
    static constexpr int moduleVersion{ 1 };
    static constexpr auto mirrorKey{ "Mirror" };
    static constexpr auto rotationKey{ "Rotation" };
    static constexpr auto mirrorLeftRightKey{ "LeftRight" };
    static constexpr auto mirrorUpDownKey{ "UpDown" };
    static constexpr auto rotationAngleKey{ "Angle" };
    static constexpr Rotation defaultRotation{ Rotation::None };
 
    bool m_leftRight{ false };
    bool m_upDown{ false };
    Rotation m_angle{ defaultRotation };
 
    bool m_mirrorEnabled{ true };
    bool m_rotationEnabled{ true };
};
 
inline void TransformationModule::SetEnabled(bool enabled)
{
    m_mirrorEnabled = enabled;
    m_rotationEnabled = enabled;
}
 
inline bool TransformationModule::IsEnabled() const
{
    return m_mirrorEnabled || m_rotationEnabled;
}
 
inline const char* TransformationModule::GetType() const
{
    return "TransformationModule";
}
 
inline TransformationModule::TransformationModule(TransformationModule&& other) noexcept
{
    m_leftRight = other.m_leftRight;
    m_upDown = other.m_upDown;
    m_angle = other.m_angle;
    m_mirrorEnabled = other.m_mirrorEnabled;
    m_rotationEnabled = other.m_rotationEnabled;
}
 
inline TransformationModule& TransformationModule::operator=(TransformationModule&& other) noexcept
{
    if (this != &other)
    {
        m_leftRight = other.m_leftRight;
        m_upDown = other.m_upDown;
        m_angle = other.m_angle;
        m_mirrorEnabled = other.m_mirrorEnabled;
        m_rotationEnabled = other.m_rotationEnabled;
    }
 
    return *this;
}
 
inline void TransformationModule::Serialize(peak::common::serialization::IArchive& archive) const
{
    archive.SetInt("Version", moduleVersion);
 
    const auto mirrorArchive = archive.CreateArchive();
    const auto rotationArchive = archive.CreateArchive();
 
    mirrorArchive->SetBool("Enabled", m_mirrorEnabled);
    rotationArchive->SetBool("Enabled", m_rotationEnabled);
 
    mirrorArchive->SetBool(mirrorLeftRightKey, m_leftRight);
    mirrorArchive->SetBool(mirrorUpDownKey, m_upDown);
 
    rotationArchive->SetInt(rotationAngleKey, static_cast<int64_t>(m_angle));
 
    archive.SetArchive(mirrorKey, mirrorArchive);
    archive.SetArchive(rotationKey, rotationArchive);
}
 
inline void TransformationModule::Deserialize(const peak::common::serialization::IArchive& archive)
{
    const auto version = archive.GetInt("Version");
    detail::ValidateVersion(version, GetType());
 
    const auto mirrorArchive = archive.GetArchive(mirrorKey);
    const auto rotationArchive = archive.GetArchive(rotationKey);
 
    m_mirrorEnabled = mirrorArchive->GetBool("Enabled");
    m_rotationEnabled = rotationArchive->GetBool("Enabled");
 
    m_leftRight = mirrorArchive->GetBool(mirrorLeftRightKey);
    m_upDown = mirrorArchive->GetBool(mirrorUpDownKey);
 
    const auto rotation = rotationArchive->GetInt(rotationAngleKey);
    if (rotation != 0 && rotation != 90 && rotation != 180 && rotation != 270)
    {
        throw peak::common::NotSupportedException("The given rotation angle " + std::to_string(rotation) + " is invalid!");
    }
    m_angle = static_cast<Rotation>(rotation);
}
 
inline void TransformationModule::ResetToDefault()
{
    m_leftRight = false;
    m_upDown = false;
    m_angle = defaultRotation;
}
 
inline void TransformationModule::SetMirrorLeftRightEnabled(bool enabled)
{
    m_leftRight = enabled;
}
 
inline void TransformationModule::SetMirrorUpDownEnabled(bool enabled)
{
    m_upDown = enabled;
}
 
inline bool TransformationModule::IsMirrorLeftRightEnabled() const
{
    return m_leftRight;
}
 
inline bool TransformationModule::IsMirrorUpDownEnabled() const
{
    return m_upDown;
}
 
inline void TransformationModule::SetRotationAngle(Rotation angle)
{
    if (static_cast<uint32_t>(angle) % 90 != 0 || static_cast<uint32_t>(angle) > 270)
    {
        throw peak::icv::NotSupportedException("The given rotation angle is not supported.");
    }
    m_angle = angle;
}
 
inline Rotation TransformationModule::GetRotationAngle() const
{
    return m_angle;
}
 
inline peak::icv::Image TransformationModule::Process(const peak::icv::Image& input) const
{
    return Process(peak::common::Any(input)).AnyCast<peak::icv::Image>();
}
 
inline peak::common::Any TransformationModule::Process(const peak::common::Any& input) const
{
    const auto mirrorNeedsProcessing = m_mirrorEnabled && (m_leftRight || m_upDown);
    const auto rotationNeedsProcessing = m_rotationEnabled && (m_angle != Rotation::None);
 
    if (!mirrorNeedsProcessing && !rotationNeedsProcessing)
    {
        return input;
    }
 
    const auto& inputImage = input.AnyCast<peak::icv::Image>();
 
    auto* const inputImageHandle = peak::common::detail::BackendAccessor<peak::icv::Image>::BackendHandle(inputImage);
 
    const peak_icv_preprocessing_transformation_parameters parameters{ m_mirrorEnabled && m_leftRight, m_mirrorEnabled && m_upDown,
        m_rotationEnabled ? static_cast<peak_icv_preprocessing_transformation_rotation_angle>(m_angle) :
                            PEAK_ICV_PREPROCESSING_TRANSFORMATION_ROTATION_NONE };
 
    peak_common_pixel_format outputPixelFormat;
 
    peak::icv::detail::ExecuteAndMapReturnCodes([&] {
        return PEAK_ICV_C_ABI_PREFIX peak_icv_Preprocessing_Transformation_GetOutputPixelFormat(
            static_cast<peak_common_pixel_format>(inputImage.GetPixelFormat()), parameters, &outputPixelFormat);
    });
 
    const auto transpose = m_rotationEnabled && (m_angle == Rotation::Degree90Clockwise || m_angle == Rotation::Degree90Counterclockwise);
    const auto outputSize = transpose ? inputImage.GetSize().Transposed() : inputImage.GetSize();
    peak::icv::Image outputImage{ static_cast<peak::common::PixelFormat>(outputPixelFormat), outputSize };
    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_Transformation_Process(inputImageHandle, parameters, outputImageHandle);
    });
 
    return peak::common::Any(outputImage);
}
 
inline void TransformationModule::SetMirrorEnabled(bool enabled)
{
    m_mirrorEnabled = enabled;
}
 
inline bool TransformationModule::IsMirrorEnabled() const
{
    return m_mirrorEnabled;
}
 
inline void TransformationModule::SetRotationEnabled(bool enabled)
{
    m_rotationEnabled = enabled;
}
 
inline bool TransformationModule::IsRotationEnabled() const
{
    return m_rotationEnabled;
}
 
} // namespace detail
} // namespace pipeline 
} // namespace peak