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 = PEAK_IPL_IMAGE_TRANSFORMER_ROTATION_ANGLE_DEGREE_90_COUNTERCLOCKWISE,
        Degree90Clockwise = PEAK_IPL_IMAGE_TRANSFORMER_ROTATION_ANGLE_DEGREE_90_CLOCKWISE,
        Degree180 = PEAK_IPL_IMAGE_TRANSFORMER_ROTATION_ANGLE_DEGREE_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 */