peak_icv_hdr.hpp

Go to the documentation of this file.

 
#pragma once
 
#include <peak_icv/types/peak_icv_image.hpp>
#include <peak_icv_c/algorithms/hdr/peak_icv_hdr.h>
#include <utility>
 
namespace peak
{
namespace icv
{
namespace experimental
{
 
enum class HDRAlgorithm
{
    Debevec = 0,
};
 
class HDR : detail::IBackendAccessible<HDR>
{
public:
    explicit HDR();
 
    ~HDR() override;
 
    PEAK_COMMON_NO_DISCARD HDRAlgorithm GetAlgorithm() const;
 
    void EstimateResponseCurve(const std::vector<Image>& images) const;
 
    PEAK_COMMON_NO_DISCARD Image Process(const std::vector<Image>& images) const;
 
private:
    friend peak::common::detail::BackendAccessor<HDR>;
 
    PEAK_COMMON_NO_DISCARD detail::handle_of_t<HDR> GetHandle() const override;
 
    peak_icv_hdr_handle m_handle{};
};
 
inline HDR::HDR()
{
    detail::ExecuteAndMapReturnCodes([&] {
        return PEAK_ICV_C_ABI_PREFIX peak_icv_HDR_Create(&m_handle);
    });
}
 
inline HDR::~HDR()
{
    if (m_handle != nullptr)
    {
        std::ignore = PEAK_ICV_C_ABI_PREFIX peak_icv_HDR_Destroy(m_handle);
    }
}
 
inline HDRAlgorithm HDR::GetAlgorithm() const
{
    peak_icv_hdr_algorithm algorithm;
 
    detail::ExecuteAndMapReturnCodes([&] {
        return PEAK_ICV_C_ABI_PREFIX peak_icv_HDR_GetAlgorithm(m_handle, &algorithm);
    });
 
    return static_cast<HDRAlgorithm>(algorithm);
}
 
inline detail::handle_of_t<HDR> HDR::GetHandle() const
{
    return m_handle;
}
 
inline void HDR::EstimateResponseCurve(const std::vector<Image>& images) const
{
    if (images.size() == 0)
    {
        throw NotPossibleException("Number of input images has to be greater than 0.");
    }
 
    std::vector<peak_icv_image_handle> imageHandles;
    imageHandles.reserve(images.size());
    std::transform(images.begin(), images.end(), std::back_inserter(imageHandles), [](const auto& image) {
        return peak::common::detail::BackendAccessor<Image>::BackendHandle(image);
    });
 
    detail::ExecuteAndMapReturnCodes([&] {
        return PEAK_ICV_C_ABI_PREFIX peak_icv_HDR_EstimateResponseCurve(m_handle, imageHandles.data(), imageHandles.size());
    });
}
 
inline Image HDR::Process(const std::vector<Image>& images) const
{
    if (images.empty())
    {
        throw NotPossibleException("Input image vector cannot be empty.");
    }
 
    std::vector<peak_icv_image_handle> imageHandles;
    imageHandles.reserve(images.size());
    std::transform(images.begin(), images.end(), std::back_inserter(imageHandles), [](const peak::icv::Image& image) {
        return peak::common::detail::BackendAccessor<Image>::BackendHandle(image);
    });
 
    peak_common_pixel_format outputPixelFormat;
    detail::ExecuteAndMapReturnCodes([&] {
        return PEAK_ICV_C_ABI_PREFIX peak_icv_HDR_Process_GetOutputPixelFormat(
            m_handle, peak::common::detail::CppPixelFormatToCPixelFormat(images.at(0).GetPixelFormat()), &outputPixelFormat);
    });
 
    Image outputImage{ peak::common::detail::CPixelFormatToCppPixelFormat(outputPixelFormat), images.at(0).GetSize() };
    auto* const outputImageHandle = peak::common::detail::BackendAccessor<Image>::BackendHandle(outputImage);
 
    detail::ExecuteAndMapReturnCodes([&] {
        return PEAK_ICV_C_ABI_PREFIX peak_icv_HDR_Process(m_handle, imageHandles.data(), imageHandles.size(), outputImageHandle);
    });
 
    return outputImage;
}
 
} // namespace experimental
} // namespace icv 
} // namespace peak