peak_ipl_color_corrector.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_image.hpp>
#include <peak_ipl/types/peak_ipl_pixel_format.hpp>
#include <peak_ipl/types/peak_ipl_simple_types.hpp>

#include <type_traits>
#include <algorithm>
#include <cmath>
#include <cstddef>
#include <limits>
#include <utility>
#include <vector>

namespace peak
{
namespace ipl
{

class Image;

struct ColorCorrectionFactors
{
    ColorCorrectionFactors(float facRR, float facGR, float facBR, float facRG, float facGG, float facBG, float facRB,
        float facGB, float facBB)
        : factorRR(facRR)
        , factorGR(facGR)
        , factorBR(facBR)
        , factorRG(facRG)
        , factorGG(facGG)
        , factorBG(facBG)
        , factorRB(facRB)
        , factorGB(facGB)
        , factorBB(facBB)
    {}

    ColorCorrectionFactors() = default;
    ~ColorCorrectionFactors() = default;
    ColorCorrectionFactors(ColorCorrectionFactors&& o) = default;
    ColorCorrectionFactors& operator=(ColorCorrectionFactors&& o) = default;
    ColorCorrectionFactors& operator=(const ColorCorrectionFactors& o) = default;
    ColorCorrectionFactors(const ColorCorrectionFactors& o) = default;

    bool operator==(const ColorCorrectionFactors& other) const
    {
        return (isEqual(factorRR, other.factorRR) && isEqual(factorGR, other.factorGR)
            && isEqual(factorBR, other.factorBR) && isEqual(factorRG, other.factorRG)
            && isEqual(factorGG, other.factorGG) && isEqual(factorBG, other.factorBG)
            && isEqual(factorRB, other.factorRB) && isEqual(factorGB, other.factorGB)
            && isEqual(factorBB, other.factorBB));
    }

    float factorRR;
    float factorGR;
    float factorBR;
    float factorRG;
    float factorGG;
    float factorBG;
    float factorRB;
    float factorGB;
    float factorBB;

private:
    template <class T>
    static typename std::enable_if<!std::numeric_limits<T>::is_integer, bool>::type isEqual(T x, T y)
    {
        return std::fabs(x - y) <= std::numeric_limits<T>::epsilon();
    }
};

class ColorCorrector final
{
public:
    ColorCorrector();
    ~ColorCorrector();
    ColorCorrector(const ColorCorrector& other) = delete;
    ColorCorrector& operator=(const ColorCorrector& other) = delete;
    ColorCorrector(ColorCorrector&& other) noexcept;
    ColorCorrector& operator=(ColorCorrector&& other) noexcept;

    void SetColorCorrectionFactors(peak::ipl::ColorCorrectionFactors colorCorrectorFactors);

    peak::ipl::ColorCorrectionFactors ColorCorrectionFactors();

    peak::ipl::ColorCorrectionFactors ColorCorrectionFactors() const;

    float Saturation() const;

    float SaturationMin() const;

    float SaturationMax() const;

    void SetSaturation(float saturation);

    bool IsPixelFormatSupported(PixelFormatName pixelFormatName) const;

    void ProcessInPlace(Image& image) const;

    Image Process(const Image& inputImage) const;

private:
    PEAK_IPL_COLOR_CORRECTOR_HANDLE m_backendHandle{};
};

inline ColorCorrector::ColorCorrector()
{
    ExecuteAndMapReturnCodes([&] { return PEAK_IPL_C_ABI_PREFIX PEAK_IPL_ColorCorrector_Construct(&m_backendHandle); });
}

inline ColorCorrector::~ColorCorrector()
{
    if (m_backendHandle)
    {
        (void)PEAK_IPL_C_ABI_PREFIX PEAK_IPL_ColorCorrector_Destruct(m_backendHandle);
    }
}

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

inline ColorCorrector& ColorCorrector::operator=(ColorCorrector&& other) noexcept
{
    if (this != &other)
    {
        (void)PEAK_IPL_C_ABI_PREFIX PEAK_IPL_ColorCorrector_Destruct(m_backendHandle);
        m_backendHandle = other.m_backendHandle;
        other.m_backendHandle = nullptr;
    }

    return *this;
}

inline void ColorCorrector::SetColorCorrectionFactors(peak::ipl::ColorCorrectionFactors colorCorrectorFactors)
{
    ExecuteAndMapReturnCodes([&] {
        return PEAK_IPL_C_ABI_PREFIX PEAK_IPL_ColorCorrector_SetColorCorrectionFactors(
            m_backendHandle, reinterpret_cast<float*>(&colorCorrectorFactors));
    });
}

inline peak::ipl::ColorCorrectionFactors ColorCorrector::ColorCorrectionFactors()
{
    size_t colorCorrectorFactorsSize = 0;

    ExecuteAndMapReturnCodes([&] {
        return PEAK_IPL_C_ABI_PREFIX PEAK_IPL_ColorCorrector_GetColorCorrectionFactors(
            m_backendHandle, nullptr, &colorCorrectorFactorsSize);
    });

    peak::ipl::ColorCorrectionFactors colorCorrectorFactors;

    ExecuteAndMapReturnCodes([&] {
        return PEAK_IPL_C_ABI_PREFIX PEAK_IPL_ColorCorrector_GetColorCorrectionFactors(
            m_backendHandle, reinterpret_cast<float*>(&colorCorrectorFactors), &colorCorrectorFactorsSize);
    });

    return colorCorrectorFactors;
}

inline peak::ipl::ColorCorrectionFactors ColorCorrector::ColorCorrectionFactors() const
{
    size_t colorCorrectorFactorsSize = 0;

    ExecuteAndMapReturnCodes([&] {
        return PEAK_IPL_C_ABI_PREFIX PEAK_IPL_ColorCorrector_GetColorCorrectionFactors(
            m_backendHandle, nullptr, &colorCorrectorFactorsSize);
    });

    peak::ipl::ColorCorrectionFactors colorCorrectorFactors;

    ExecuteAndMapReturnCodes([&] {
        return PEAK_IPL_C_ABI_PREFIX PEAK_IPL_ColorCorrector_GetColorCorrectionFactors(
            m_backendHandle, reinterpret_cast<float*>(&colorCorrectorFactors), &colorCorrectorFactorsSize);
    });

    return colorCorrectorFactors;
}

inline float ColorCorrector::Saturation() const
{
    float saturation;

    ExecuteAndMapReturnCodes([&] {
        return PEAK_IPL_C_ABI_PREFIX PEAK_IPL_ColorCorrector_GetSaturation(
            m_backendHandle, reinterpret_cast<float*>(&saturation));
    });

    return saturation;
}

inline float ColorCorrector::SaturationMin() const
{
    float saturationMin;

    ExecuteAndMapReturnCodes([&] {
        return PEAK_IPL_C_ABI_PREFIX PEAK_IPL_ColorCorrector_GetSaturationMin(
            m_backendHandle, reinterpret_cast<float*>(&saturationMin));
    });

    return saturationMin;
}

inline float ColorCorrector::SaturationMax() const
{
    float saturationMax;

    ExecuteAndMapReturnCodes([&] {
        return PEAK_IPL_C_ABI_PREFIX PEAK_IPL_ColorCorrector_GetSaturationMax(
            m_backendHandle, reinterpret_cast<float*>(&saturationMax));
    });

    return saturationMax;
}

inline void ColorCorrector::SetSaturation(float saturation)
{
    ExecuteAndMapReturnCodes([&] {
        return PEAK_IPL_C_ABI_PREFIX PEAK_IPL_ColorCorrector_SetSaturation(
            m_backendHandle, saturation);
    });
}

inline bool ColorCorrector::IsPixelFormatSupported(PixelFormatName pixelFormatName) const
{
    PEAK_IPL_BOOL8 isPixelFormatSupported = 0;

    ExecuteAndMapReturnCodes([&] {
        return PEAK_IPL_C_ABI_PREFIX PEAK_IPL_ColorCorrector_GetIsPixelFormatSupported(m_backendHandle,
            static_cast<PEAK_IPL_PIXEL_FORMAT>(pixelFormatName),
            reinterpret_cast<PEAK_IPL_BOOL8*>(&isPixelFormatSupported));
    });

    return isPixelFormatSupported > 0;
}

inline void ColorCorrector::ProcessInPlace(Image& image) const
{
    ExecuteAndMapReturnCodes([&] {
        return PEAK_IPL_C_ABI_PREFIX PEAK_IPL_ColorCorrector_ProcessInPlace(
            m_backendHandle, ImageBackendAccessor::BackendHandle(image));
    });
}

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

    return ImageBackendAccessor::CreateImage(outputImageHandle);
}

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