peak_ipl_image_transformer.hpp

Go to the documentation of this file.

#pragma once

#include <peak_ipl/backend/peak_ipl_backend.h>
#include <peak_ipl/exception/peak_ipl_exception.hpp>
#include <peak_ipl/types/peak_ipl_pixel_format.hpp>
#include <peak_ipl/types/peak_ipl_simple_types.hpp>

namespace peak
{
namespace ipl
{

class Image;

class ImageTransformer final
{
public:
    enum class RotationAngle : uint16_t
    {
        Degree90Counterclockwise = 90,
        Degree90Clockwise = 270,
        Degree180 = 180
    };

    ImageTransformer();
    
    ~ImageTransformer();

    ImageTransformer(const ImageTransformer& other);

    ImageTransformer& operator=(const ImageTransformer& other);

    ImageTransformer(ImageTransformer&& other) noexcept;

    ImageTransformer& operator=(ImageTransformer&& other) noexcept;

    PEAK_IPL_NO_DISCARD Image MirrorUpDown(const Image& inputImage) const;

    PEAK_IPL_NO_DISCARD Image MirrorLeftRight(const Image& inputImage) const;

    PEAK_IPL_NO_DISCARD Image MirrorUpDownLeftRight(const Image& inputImage) const;

    void MirrorUpDownInPlace(Image& image) const;

    void MirrorLeftRightInPlace(Image& image) const;

    void MirrorUpDownLeftRightInPlace(Image& image) const;

    PEAK_IPL_NO_DISCARD Image Rotate(const Image& inputImage, RotationAngle rotationAngle) const;

    void RotateInPlace(Image& image, RotationAngle rotationAngle) const;

private:
    PEAK_IPL_IMAGE_TRANSFORMER_HANDLE m_backendHandle{};
};

} /* namespace ipl */
} /* namespace peak */

#include <peak_ipl/types/peak_ipl_image.hpp>


namespace peak
{
namespace ipl
{

inline ImageTransformer::ImageTransformer()
{
    ExecuteAndMapReturnCodes([&] { return PEAK_IPL_C_ABI_PREFIX PEAK_IPL_ImageTransformer_Construct(&m_backendHandle); });
}


inline ImageTransformer::~ImageTransformer()
{
    if (m_backendHandle)
    {
        (void)PEAK_IPL_C_ABI_PREFIX PEAK_IPL_ImageTransformer_Destruct(m_backendHandle);
    }
}

inline ImageTransformer::ImageTransformer(const ImageTransformer& other)
{
    if (other.m_backendHandle)
    {
        ExecuteAndMapReturnCodes([&] { return PEAK_IPL_C_ABI_PREFIX PEAK_IPL_ImageTransformer_Acquire(other.m_backendHandle); });
    }

    m_backendHandle = other.m_backendHandle;
}

inline ImageTransformer& ImageTransformer::operator=(const ImageTransformer& other)
{
    if (this != &other)
    {
        if (m_backendHandle)
        {
            (void)PEAK_IPL_C_ABI_PREFIX PEAK_IPL_ImageTransformer_Destruct(m_backendHandle);
        }

        if (other.m_backendHandle)
        {
            ExecuteAndMapReturnCodes(
                [&] { return PEAK_IPL_C_ABI_PREFIX PEAK_IPL_ImageTransformer_Acquire(other.m_backendHandle); });
        }
    }

    m_backendHandle = other.m_backendHandle;

    return *this;
}

inline ImageTransformer::ImageTransformer(ImageTransformer&& other) noexcept
{
    *this = std::move(other);
}

inline ImageTransformer& ImageTransformer::operator=(ImageTransformer&& other) noexcept
{
    if (this != &other)
    {
        if (m_backendHandle != nullptr)
        {
            (void)PEAK_IPL_C_ABI_PREFIX PEAK_IPL_ImageTransformer_Destruct(m_backendHandle);
        }

        m_backendHandle = other.m_backendHandle;
        other.m_backendHandle = nullptr;
    }

    return *this;
}

inline Image ImageTransformer::MirrorUpDown(const Image& inputImage) const
{
    PEAK_IPL_IMAGE_HANDLE outputImageHandle = nullptr;
    ExecuteAndMapReturnCodes([&] {
        return PEAK_IPL_C_ABI_PREFIX PEAK_IPL_ImageTransformer_MirrorUpDown(
            m_backendHandle, ImageBackendAccessor::BackendHandle(inputImage), &outputImageHandle);
    });

    return ImageBackendAccessor::CreateImage(outputImageHandle);
}

inline Image ImageTransformer::MirrorLeftRight(const Image& inputImage) const
{
    PEAK_IPL_IMAGE_HANDLE outputImageHandle = nullptr;
    ExecuteAndMapReturnCodes([&] {
        return PEAK_IPL_C_ABI_PREFIX PEAK_IPL_ImageTransformer_MirrorLeftRight(
            m_backendHandle, ImageBackendAccessor::BackendHandle(inputImage), &outputImageHandle);
    });

    return ImageBackendAccessor::CreateImage(outputImageHandle);
}

inline Image ImageTransformer::MirrorUpDownLeftRight(const Image& inputImage) const
{
    PEAK_IPL_IMAGE_HANDLE outputImageHandle = nullptr;
    ExecuteAndMapReturnCodes([&] {
        return PEAK_IPL_C_ABI_PREFIX PEAK_IPL_ImageTransformer_MirrorUpDownLeftRight(
            m_backendHandle, ImageBackendAccessor::BackendHandle(inputImage), &outputImageHandle);
    });

    return ImageBackendAccessor::CreateImage(outputImageHandle);
}

inline void ImageTransformer::MirrorUpDownInPlace(Image& image) const
{
    ExecuteAndMapReturnCodes([&] {
        return PEAK_IPL_C_ABI_PREFIX PEAK_IPL_ImageTransformer_MirrorUpDownInPlace(
            m_backendHandle, ImageBackendAccessor::BackendHandle(image));
    });
}

inline void ImageTransformer::MirrorLeftRightInPlace(Image& image) const
{
    ExecuteAndMapReturnCodes([&] {
        return PEAK_IPL_C_ABI_PREFIX PEAK_IPL_ImageTransformer_MirrorLeftRightInPlace(
            m_backendHandle, ImageBackendAccessor::BackendHandle(image));
    });
}

inline void ImageTransformer::MirrorUpDownLeftRightInPlace(Image& image) const
{
    ExecuteAndMapReturnCodes([&] {
        return PEAK_IPL_C_ABI_PREFIX PEAK_IPL_ImageTransformer_MirrorUpDownLeftRightInPlace(
            m_backendHandle, ImageBackendAccessor::BackendHandle(image));
    });
}

inline Image ImageTransformer::Rotate(const Image& inputImage, RotationAngle rotationAngle) const
{
    PEAK_IPL_IMAGE_HANDLE outputImageHandle = nullptr;
    ExecuteAndMapReturnCodes([&] {
        return PEAK_IPL_C_ABI_PREFIX PEAK_IPL_ImageTransformer_Rotate(m_backendHandle,
            ImageBackendAccessor::BackendHandle(inputImage), &outputImageHandle,
            static_cast<PEAK_IPL_IMAGE_TRANSFORMER_ROTATION_ANGLE_t>(rotationAngle));
    });

    return ImageBackendAccessor::CreateImage(outputImageHandle);
}


inline void ImageTransformer::RotateInPlace(Image& image, RotationAngle rotationAngle) const
{
    ExecuteAndMapReturnCodes([&] {
        return PEAK_IPL_C_ABI_PREFIX PEAK_IPL_ImageTransformer_RotateInPlace(m_backendHandle,
            ImageBackendAccessor::BackendHandle(image),
            static_cast<PEAK_IPL_IMAGE_TRANSFORMER_ROTATION_ANGLE_t>(rotationAngle));
    });
}


} /* namespace ipl */
} /* namespace peak */