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 <peak_ipl/types/peak_ipl_color_correction_factors.hpp>
#include <peak_ipl/algorithm/peak_ipl_chromatic_adaption.hpp>
 
#include <type_traits>
#include <algorithm>
#include <cmath>
#include <cstddef>
#include <limits>
#include <utility>
#include <vector>

namespace peak
{
namespace ipl
{
 
class Image;

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

    void SetColorCorrectionFactors(ColorCorrectionFactors colorCorrectorFactors);

    PEAK_IPL_NO_DISCARD peak::ipl::ColorCorrectionFactors ColorCorrectionFactors();

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

    PEAK_IPL_NO_DISCARD float Saturation() const;

    PEAK_IPL_NO_DISCARD float SaturationMin() const;

    PEAK_IPL_NO_DISCARD float SaturationMax() const;

    void SetSaturation(float saturation);

    void ApplyChromaticAdaption(const ChromaticAdapter& chromaticAdapter, uint32_t colorTemperature);

    PEAK_IPL_NO_DISCARD bool IsPixelFormatSupported(PixelFormatName pixelFormatName) const;

    void ProcessInPlace(Image& image) const;

    PEAK_IPL_NO_DISCARD 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(const ColorCorrector& other)
{
    if (other.m_backendHandle)
    {
        ExecuteAndMapReturnCodes([&] { return PEAK_IPL_C_ABI_PREFIX PEAK_IPL_ColorCorrector_Acquire(other.m_backendHandle); });
    }
 
    m_backendHandle = other.m_backendHandle;
}
 
inline ColorCorrector& ColorCorrector::operator=(const ColorCorrector& other)
{
    if (this != &other)
    {
        if (m_backendHandle)
        {
            (void)PEAK_IPL_C_ABI_PREFIX PEAK_IPL_ColorCorrector_Destruct(m_backendHandle);
        }
 
        if (other.m_backendHandle)
        {
            ExecuteAndMapReturnCodes(
                [&] { return PEAK_IPL_C_ABI_PREFIX PEAK_IPL_ColorCorrector_Acquire(other.m_backendHandle); });
        }
    }
 
    m_backendHandle = other.m_backendHandle;
 
    return *this;
}
 
inline ColorCorrector::ColorCorrector(ColorCorrector&& other) noexcept
{
    *this = std::move(other);
}
 
inline ColorCorrector& ColorCorrector::operator=(ColorCorrector&& other) noexcept
{
    if (this != &other)
    {
        if (m_backendHandle != nullptr)
        {
            (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);
}
 
inline void ColorCorrector::ApplyChromaticAdaption(const ChromaticAdapter& chromaticAdapter, uint32_t colorTemperature)
{
    const auto value = ColorCorrectionFactors();
    const auto calculatedMatrix = chromaticAdapter.CalculateColorCorrectionMatrix(colorTemperature, value);
    SetColorCorrectionFactors(calculatedMatrix);
}
 
} /* namespace ipl */
} /* namespace peak */