peak_afl.hpp

Go to the documentation of this file.

 
#pragma once
 
 
#ifdef PEAK_AFL_DYNAMIC_LOADING
#    define PEAK_AFL_C_ABI_PREFIX peak::afl::dynamic::DynamicLoader::
#else
#    define PEAK_AFL_C_ABI_PREFIX // we could also set ::
#endif
 
#include <peak_afl/peak_afl.h>
#include <peak_common/exceptions/peak_common_exceptions.hpp>
#include <peak_ipl/algorithm/peak_ipl_gain.hpp>
#include <peak_ipl/types/peak_ipl_image.hpp>
#include <peak/node_map/peak_node_map.hpp>
 
#include <type_traits>
#include <array>
#include <cstdint>
#include <exception>
#include <functional>
#include <memory>
#include <string>
#include <tuple>
#include <utility>
#include <vector>
 
#if __cplusplus >= 201703L || (defined(_MSVC_LANG) && (_MSVC_LANG >= 201703L))
#    define PEAK_AFL_NO_DISCARD [[nodiscard]]
#    define PEAK_AFL_MAYBE_UNUSED [[maybe_unused]]
#else
#    ifdef _MSC_VER
#        define PEAK_AFL_NO_DISCARD _Check_return_
#        define PEAK_AFL_MAYBE_UNUSED
#    elif defined(__clang__) || defined(__GNUC__) || defined(__GNUG__)
#        define PEAK_AFL_NO_DISCARD __attribute__((warn_unused_result))
#        define PEAK_AFL_MAYBE_UNUSED __attribute__((unused))
#    else
#        define PEAK_AFL_NO_DISCARD
#        define PEAK_AFL_MAYBE_UNUSED
#    endif
#endif









 
 
namespace peak
{
namespace afl
{
namespace library
{
 
#include <string>
#include <cstdint>

struct Version_t
{
 
    PEAK_COMMON_BEGIN_DISABLE_DEPRECATED_WARNINGS
    Version_t() = default;
    Version_t(Version_t& other) = default;
    Version_t(Version_t&& other) noexcept = default;
    Version_t& operator=(const Version_t& other) = default;
    Version_t& operator=(Version_t&& other) noexcept = default;
 
    Version_t(std::uint32_t maj, std::uint32_t min, std::uint32_t pat)
        : major(maj), minor(min), patch(pat), m_major(maj), m_minor(min), m_patch(pat) {}

    PEAK_COMMON_DEPRECATED_MSG("Deprecated due to SemVer 2.0 migration. Use the 3-argument constructor instead.")
    Version_t(std::uint32_t maj, std::uint32_t min, std::uint32_t submin, std::uint32_t pat)
        : major(maj), minor(min), subminor(submin), patch(pat), m_major(maj), m_minor(min), m_patch(pat) {}
 
    PEAK_COMMON_END_DISABLE_DEPRECATED_WARNINGS

    PEAK_COMMON_DEPRECATED_MSG("Use Major() method instead.")
    std::uint32_t major{};

    PEAK_COMMON_DEPRECATED_MSG("Use Minor() method instead.")
    std::uint32_t minor{};

    PEAK_COMMON_DEPRECATED_MSG("Deprecated due to SemVer 2.0 migration.")
    std::uint32_t subminor{};

    PEAK_COMMON_DEPRECATED_MSG("Use Patch() method instead.")
    std::uint32_t patch{};

    PEAK_AFL_NO_DISCARD std::string ToString() const
    {
        return std::to_string(m_major) + "." + std::to_string(m_minor) + "." + std::to_string(m_patch);
    }

    PEAK_AFL_NO_DISCARD std::uint32_t Major() const
    {
        return m_major;
    }

    PEAK_AFL_NO_DISCARD std::uint32_t Minor() const
    {
        return m_minor;
    }

    PEAK_COMMON_DEPRECATED_MSG("Deprecated due to SemVer 2.0 migration. Use Major(), Minor() and Patch() methods.")
    PEAK_AFL_NO_DISCARD std::uint32_t Subminor() const
    {
        PEAK_COMMON_BEGIN_DISABLE_DEPRECATED_WARNINGS
        return subminor;
        PEAK_COMMON_END_DISABLE_DEPRECATED_WARNINGS
    }

    PEAK_AFL_NO_DISCARD std::uint32_t Patch() const
    {
        return m_patch;
    }
 
private:
    std::uint32_t m_major{};
    std::uint32_t m_minor{};
    std::uint32_t m_patch{};
};

inline void Init();

inline void Exit();

PEAK_AFL_NO_DISCARD inline std::string GetLastError();

PEAK_AFL_NO_DISCARD inline Version_t Version();
} // namespace library
 
 
namespace error
{

class Exception : public virtual peak::common::Exception
{
public:
    explicit Exception(const std::string& string, peak_afl_status code)
        : peak::common::Exception(string)
        , m_code(code)
    {}
 
    explicit Exception(const char* string, peak_afl_status code)
        : peak::common::Exception(string)
        , m_code(code)
    {}

    PEAK_AFL_NO_DISCARD peak_afl_status code() const
    {
        return m_code;
    }

    PEAK_AFL_NO_DISCARD static std::string translateCode(peak_afl_status status)
    {
        switch (status)
        {
        case PEAK_AFL_STATUS_SUCCESS:
            return "PEAK_AFL_STATUS_SUCCESS";
 
        case PEAK_AFL_STATUS_ERROR:
            return "PEAK_AFL_STATUS_ERROR";
 
        case PEAK_AFL_STATUS_NOT_INITIALIZED:
            return "PEAK_AFL_STATUS_NOT_INITIALIZED";
 
        case PEAK_AFL_STATUS_INVALID_PARAMETER:
            return "PEAK_AFL_STATUS_INVALID_PARAMETER";
 
        case PEAK_AFL_STATUS_ACCESS_DENIED:
            return "PEAK_AFL_STATUS_ACCESS_DENIED";
 
        case PEAK_AFL_STATUS_BUSY:
            return "PEAK_AFL_STATUS_BUSY";
 
        case PEAK_AFL_STATUS_BUFFER_TOO_SMALL:
            return "PEAK_AFL_STATUS_BUFFER_TOO_SMALL";
 
        case PEAK_AFL_STATUS_INVALID_IMAGE_FORMAT:
            return "PEAK_AFL_STATUS_INVALID_IMAGE_FORMAT";
 
        case PEAK_AFL_STATUS_NOT_SUPPORTED:
            return "PEAK_AFL_STATUS_NOT_SUPPORTED";
 
        case PEAK_AFL_STATUS_VALUE_ADJUSTED:
            return "PEAK_AFL_STATUS_VALUE_ADJUSTED";
        }
 
        return "Unknown Status code";
    }
 
private:
    peak_afl_status m_code{};
};

class InternalErrorException
    : public Exception
    , public peak::common::InternalErrorException
{
public:
    explicit InternalErrorException(const std::string& string, peak_afl_status code)
        : peak::common::Exception(string)
        , Exception(string, code)
        , peak::common::InternalErrorException(string)
    {}
 
    explicit InternalErrorException(const char* string, peak_afl_status code)
        : peak::common::Exception(string)
        , Exception(string, code)
        , peak::common::InternalErrorException(string)
    {}
};

class NotInitializedException
    : public Exception
    , public peak::common::LibraryNotInitializedException
{
public:
    explicit NotInitializedException(const std::string& string, peak_afl_status code)
        : peak::common::Exception(string)
        , Exception(string, code)
        , peak::common::LibraryNotInitializedException(string)
    {}
 
    explicit NotInitializedException(const char* string, peak_afl_status code)
        : peak::common::Exception(string)
        , Exception(string, code)
        , peak::common::LibraryNotInitializedException(string)
    {}
};

class InvalidParameterException
    : public Exception
    , public peak::common::InvalidParameterException
{
public:
    explicit InvalidParameterException(const std::string& string, peak_afl_status code)
        : peak::common::Exception(string)
        , Exception(string, code)
        , peak::common::InvalidParameterException(string)
    {}
 
    explicit InvalidParameterException(const char* string, peak_afl_status code)
        : peak::common::Exception(string)
        , Exception(string, code)
        , peak::common::InvalidParameterException(string)
    {}
};

class NotSupportedException
    : public Exception
    , public peak::common::NotSupportedException
{
public:
    explicit NotSupportedException(const std::string& string, peak_afl_status code)
        : peak::common::Exception(string)
        , Exception(string, code)
        , peak::common::NotSupportedException(string)
    {}
 
    explicit NotSupportedException(const char* string, peak_afl_status code)
        : peak::common::Exception(string)
        , Exception(string, code)
        , peak::common::NotSupportedException(string)
    {}
};

class BusyException : public Exception
{
public:
    explicit BusyException(const std::string& string, peak_afl_status code)
        : peak::common::Exception(string)
        , Exception(string, code)
    {}
 
    explicit BusyException(const char* string, peak_afl_status code)
        : peak::common::Exception(string)
        , Exception(string, code)
    {}
};

class InvalidImageFormatException : public Exception
{
public:
    explicit InvalidImageFormatException(const std::string& string, peak_afl_status code)
        : peak::common::Exception(string)
        , Exception(string, code)
    {}
 
    explicit InvalidImageFormatException(const char* string, peak_afl_status code)
        : peak::common::Exception(string)
        , Exception(string, code)
    {}
};

class BadAccessException : public Exception
{
public:
    explicit BadAccessException(const std::string& string, peak_afl_status code)
        : peak::common::Exception(string)
        , Exception(string, code)
    {}
 
    explicit BadAccessException(const char* string, peak_afl_status code)
        : peak::common::Exception(string)
        , Exception(string, code)
    {}
};

class BufferTooSmallException : public Exception
{
public:
    explicit BufferTooSmallException(const std::string& string, peak_afl_status code)
        : peak::common::Exception(string)
        , Exception(string, code)
    {}
 
    explicit BufferTooSmallException(const char* string, peak_afl_status code)
        : peak::common::Exception(string)
        , Exception(string, code)
    {}
};

class CorruptedDataException : public Exception
{
public:
    explicit CorruptedDataException(const std::string& string, peak_afl_status code)
        : peak::common::Exception(string)
        , Exception(string, code)
    {}
 
    explicit CorruptedDataException(const char* string, peak_afl_status code)
        : peak::common::Exception(string)
        , Exception(string, code)
    {}
};

class InvalidCastException
    : public Exception
    , public peak::common::InvalidCastException
{
public:
    explicit InvalidCastException(const std::string& string, peak_afl_status code)
        : peak::common::Exception(string)
        , Exception(string, code)
        , peak::common::InvalidCastException(string)
    {}
 
    explicit InvalidCastException(const char* string, peak_afl_status code)
        : peak::common::Exception(string)
        , Exception(string, code)
        , peak::common::InvalidCastException(string)
    {}
};

static void ThrowException(peak_afl_status code, bool get_text = true)
{
    const auto text = get_text ? library::GetLastError() : "No additional text";
 
    switch (code)
    {
    case PEAK_AFL_STATUS_ERROR:
        throw InternalErrorException(text, code);
 
    case PEAK_AFL_STATUS_NOT_INITIALIZED:
        throw NotInitializedException(text, code);
 
    case PEAK_AFL_STATUS_INVALID_PARAMETER:
        throw InvalidParameterException(text, code);
 
    case PEAK_AFL_STATUS_ACCESS_DENIED:
        throw BadAccessException(text, code);
 
    case PEAK_AFL_STATUS_BUSY:
        throw BusyException(text, code);
 
    case PEAK_AFL_STATUS_BUFFER_TOO_SMALL:
        throw BufferTooSmallException(text, code);
 
    case PEAK_AFL_STATUS_INVALID_IMAGE_FORMAT:
        throw InvalidImageFormatException(text, code);
 
    case PEAK_AFL_STATUS_NOT_SUPPORTED:
        throw NotSupportedException(text, code);
 
    case PEAK_AFL_STATUS_VALUE_ADJUSTED:
    case PEAK_AFL_STATUS_SUCCESS:
        break;
    }
}
 
} // namespace error
 
class Controller;

class Manager
{
public:
    inline explicit Manager(const std::shared_ptr<peak::core::NodeMap>& node_map);

    inline ~Manager();
 
    Manager(const Manager&) = delete;
    inline Manager(Manager&&) noexcept;
 
    Manager& operator=(const Manager&) noexcept = delete;
    inline Manager& operator=(Manager&&) noexcept;

    inline void AddController(const std::shared_ptr<Controller>& controller);

    inline void RemoveController(const std::shared_ptr<Controller>& controller);

    inline void Process(const peak::ipl::Image& image) const;

    PEAK_AFL_NO_DISCARD inline std::shared_ptr<Controller> CreateController(peak_afl_controllerType type);

    inline void DestroyAllController();

    inline void DestroyController(const std::shared_ptr<Controller>& controller);

    inline void SetGainIPL(const peak::ipl::Gain& gain);

    inline void SetCCM(std::array<float, 9> ccm);

    PEAK_AFL_NO_DISCARD inline bool Status() const;

    PEAK_AFL_NO_DISCARD inline std::vector<std::shared_ptr<Controller>> ControllerList() const;

    PEAK_AFL_NO_DISCARD inline size_t ControllerCount() const;

    PEAK_AFL_NO_DISCARD inline std::shared_ptr<Controller> GetController(peak_afl_controllerType type) const;

    PEAK_AFL_NO_DISCARD inline bool IsControllerSupported(peak_afl_controllerType type) const;
 
private:
    std::vector<std::shared_ptr<Controller>> m_controllerList;
    mutable std::mutex m_mutex{};
    peak_afl_manager_handle m_handle{};
};

template <typename... ControllerTypes>
std::tuple<Manager, std::vector<std::shared_ptr<Controller>>> CreateManager(
    const std::shared_ptr<peak::core::NodeMap>& node_map, ControllerTypes... types)
{
    constexpr int size = sizeof...(types);
    constexpr std::array<peak_afl_controllerType, size> controller_types{ types... };
    std::vector<std::shared_ptr<Controller>> controller{};
    Manager manager{ node_map };
    controller.reserve(size);
 
    std::for_each(controller_types.cbegin(), controller_types.cend(),
        [&manager, &controller](peak_afl_controllerType type) { controller.emplace_back(manager.CreateController(type)); });
 
    return { std::move(manager), std::move(controller) };
}
 

template <typename T, typename std::enable_if_t<std::is_arithmetic<T>::value, int> = 0>
struct Range
{
    T min;
    T max;
    T inc;
};
 
namespace callback
{
using FinishedCallback = std::function<void(void)>;
using DataProcessingCallback = std::function<void(int, int)>;
using ProcessingCallback = std::function<void(peak_afl_process_data*)>;
using ComponentCallback = std::function<void(void)>;
 
using RegisterFunction = std::function<peak_afl_status(void*, void*)>;
using UnRegisterFunction = std::function<void()>;
} // namespace callback

class Controller : public std::enable_shared_from_this<Controller>
{
    friend class Manager;
 
    template <class T>
    class Callback
    {
#ifndef SWIG
    public:
        template <typename R, typename... Args>
        Callback(const std::shared_ptr<peak::afl::Controller>& controller, callback::RegisterFunction register_function,
            callback::UnRegisterFunction unregister_function, std::function<R(Args...)> callback)
            : m_unregister_function(std::move(unregister_function))
            , m_callback(std::move(callback))
        {
            const auto ret = register_function(reinterpret_cast<void*>(&Callback::Func<Args...>), this);
            if (ret != PEAK_AFL_STATUS_SUCCESS)
            {
                error::ThrowException(ret);
            }
            m_controller = controller;
        }
 
        virtual ~Callback()
        {
            if (auto controller = m_controller.lock())
            {
                m_unregister_function();
            }
        }
 
    private:
        template <typename... Args>
        static void Func(Args... args, void* ptr)
        {
            static_cast<Callback*>(ptr)->m_callback(args...);
        };
#endif
 
        std::weak_ptr<peak::afl::Controller> m_controller{};
        callback::UnRegisterFunction m_unregister_function{};
        T m_callback{};
    };
 

    inline explicit Controller(peak_afl_controller_handle handle)
        : m_handle(handle) {};
 
public:
    inline ~Controller();
 
    Controller(const Controller&) = delete;
    Controller(Controller&&) = delete;
    Controller& operator=(const Controller&) = delete;
    Controller& operator=(Controller&&) = delete;

    PEAK_AFL_NO_DISCARD inline static std::shared_ptr<Controller> Create(peak_afl_controllerType type);

    PEAK_AFL_NO_DISCARD inline bool IsSkipFramesSupported() const;

    inline void SetSkipFrames(std::uint32_t count);

    PEAK_AFL_NO_DISCARD inline std::uint32_t GetSkipFrames() const;

    PEAK_AFL_NO_DISCARD inline Range<std::uint32_t> GetSkipFramesRange() const;

    PEAK_AFL_NO_DISCARD inline bool IsROISupported() const;

    inline void SetROI(peak_afl_rectangle rect);

    PEAK_AFL_NO_DISCARD inline peak_afl_rectangle GetROI() const;

    PEAK_AFL_NO_DISCARD inline bool IsROIPresetSupported() const;

    inline void SetROIPreset(peak_afl_roi_preset preset);

    PEAK_AFL_NO_DISCARD inline bool IsModeSupported() const;

    inline void SetMode(peak_afl_controller_automode mode);

    PEAK_AFL_NO_DISCARD inline peak_afl_controller_automode GetMode() const;

    PEAK_AFL_NO_DISCARD bool IsBrightnessAlgorithmSupported() const;

    void SetBrightnessAlgorithm(peak_afl_controller_brightness_algorithm algorithm);

    PEAK_AFL_NO_DISCARD peak_afl_controller_brightness_algorithm GetBrightnessAlgorithm() const;

    PEAK_AFL_NO_DISCARD inline peak_afl_controller_status Status() const;

    PEAK_AFL_NO_DISCARD inline std::uint8_t GetLastAutoAverage() const;

    PEAK_AFL_NO_DISCARD inline std::tuple<std::uint8_t, std::uint8_t, std::uint8_t> GetLastAutoAverages() const;

    PEAK_AFL_NO_DISCARD inline bool IsAutoTargetSupported() const;

    inline void SetAutoTarget(uint32_t target);

    PEAK_AFL_NO_DISCARD inline std::uint32_t GetAutoTarget() const;

    PEAK_AFL_NO_DISCARD inline Range<std::uint32_t> GetAutoTargetRange() const;

    PEAK_AFL_NO_DISCARD inline bool IsAutoToleranceSupported() const;

    inline void SetAutoTolerance(std::uint32_t tolerance);

    PEAK_AFL_NO_DISCARD inline std::uint32_t GetAutoTolerance() const;

    PEAK_AFL_NO_DISCARD inline Range<std::uint32_t> GetAutoToleranceRange() const;

    PEAK_AFL_NO_DISCARD inline bool IsAutoPercentileSupported() const;

    inline void SetAutoPercentile(double percentile);

    PEAK_AFL_NO_DISCARD inline double GetAutoPercentile() const;

    PEAK_AFL_NO_DISCARD inline Range<double> GetAutoPercentileRange() const;

    PEAK_AFL_NO_DISCARD inline peak_afl_controllerType Type() const;

    PEAK_AFL_NO_DISCARD inline bool IsAlgorithmSupported() const;

    inline void SetAlgorithm(peak_afl_controller_algorithm algorithm);

    PEAK_AFL_NO_DISCARD inline peak_afl_controller_algorithm GetAlgorithm() const;

    PEAK_AFL_NO_DISCARD inline std::vector<peak_afl_controller_algorithm> GetAlgorithmList() const;

    PEAK_AFL_NO_DISCARD inline bool IsSharpnessAlgorithmSupported() const;

    inline void SetSharpnessAlgorithm(peak_afl_controller_sharpness_algorithm algorithm);

    PEAK_AFL_NO_DISCARD inline peak_afl_controller_sharpness_algorithm GetSharpnessAlgorithm() const;

    PEAK_AFL_NO_DISCARD inline std::vector<peak_afl_controller_sharpness_algorithm> GetSharpnessAlgorithmList() const;

    inline void RegisterFinishedCallback(const callback::FinishedCallback& callback);

    inline void UnRegisterFinishedCallback();

    inline void RegisterComponentCallback(peak_afl_controller_brightness_component component, const callback::FinishedCallback& callback);

    inline void UnRegisterComponentCallback(peak_afl_controller_brightness_component component);

    PEAK_AFL_DEPRECATED_ATTR inline void RegisterDataProcessingCallback(const callback::DataProcessingCallback& callback);

    PEAK_AFL_DEPRECATED_ATTR inline void UnRegisterDataProcessingCallback();

    inline void RegisterProcessingCallback(const callback::ProcessingCallback& callback);

    inline void UnRegisterProcessingCallback();

    PEAK_AFL_NO_DISCARD inline bool IsWeightedROISupported() const;

    inline void SetWeightedROIs(const std::vector<peak_afl_weighted_rectangle>& list);

    inline void SetWeightedROI(const peak_afl_weighted_rectangle& rect);

    PEAK_AFL_NO_DISCARD inline peak_afl_size GetWeightedROIMinSize() const;

    PEAK_AFL_NO_DISCARD inline std::vector<peak_afl_weighted_rectangle> GetWeightedROIs() const;

    PEAK_AFL_NO_DISCARD inline bool IsLimitSupported() const;

    inline void SetLimit(peak_afl_controller_limit limit);

    PEAK_AFL_NO_DISCARD inline peak_afl_controller_limit GetLimit() const;

    PEAK_AFL_NO_DISCARD inline peak_afl_controller_limit GetDefaultLimit() const;

    PEAK_AFL_NO_DISCARD inline bool IsHysteresisSupported() const;

    inline void SetHysteresis(std::uint8_t hysteresis);

    PEAK_AFL_NO_DISCARD inline std::uint8_t GetHysteresis() const;

    PEAK_AFL_NO_DISCARD inline std::uint8_t GetDefaultHysteresis() const;

    PEAK_AFL_NO_DISCARD inline Range<std::uint8_t> GetHysteresisRange() const;

    PEAK_AFL_NO_DISCARD inline bool IsBrightnessComponentModeSupported() const;

    PEAK_AFL_NO_DISCARD inline bool IsBrightnessComponentUnitSupported(peak_afl_controller_brightness_component component) const;

    inline void BrightnessComponentSetMode(peak_afl_controller_brightness_component component, peak_afl_controller_automode mode);

    PEAK_AFL_NO_DISCARD inline peak_afl_controller_automode BrightnessComponentGetMode(
        peak_afl_controller_brightness_component component) const;

    PEAK_AFL_NO_DISCARD inline peak_afl_controller_status BrightnessComponentStatus(
        peak_afl_controller_brightness_component component) const;

    PEAK_AFL_NO_DISCARD inline bool IsGainLimitSupported() const;

    inline void SetGainLimit(peak_afl_double_limit limit);

    inline peak_afl_double_limit GetGainLimit() const;

    inline peak_afl_double_limit GetGainLimitRange() const;

    inline void SetGainAnalogLimit(peak_afl_double_limit limit);

    inline peak_afl_double_limit GetGainAnalogLimit() const;

    inline peak_afl_double_limit GetGainAnalogLimitRange() const;

    inline void SetGainDigitalLimit(peak_afl_double_limit limit);

    inline peak_afl_double_limit GetGainDigitalLimit() const;

    inline peak_afl_double_limit GetGainDigitalLimitRange() const;

    inline void SetGainCombinedLimit(peak_afl_double_limit limit);

    inline peak_afl_double_limit GetGainCombinedLimit() const;

    inline peak_afl_double_limit GetGainCombinedLimitRange() const;

    inline void SetGainHostLimit(peak_afl_double_limit limit);

    inline peak_afl_double_limit GetGainHostLimit() const;

    inline peak_afl_double_limit GetGainHostLimitRange() const;

    inline void SetExposureLimit(peak_afl_double_limit limit);

    inline peak_afl_double_limit GetExposureLimit() const;

    inline peak_afl_double_limit GetExposureLimitRange() const;
 
 
private:
    using FinishedCallbackType = Callback<callback::FinishedCallback>;
    using DataProcessingCallbackType = Callback<callback::DataProcessingCallback>;
    using ProcessingCallbackType = Callback<callback::ProcessingCallback>;
    using ComponentCallbackType = Callback<callback::ComponentCallback>;
 
    peak_afl_controller_handle m_handle{};
    std::unique_ptr<FinishedCallbackType> m_finishedCallback{};
    std::unique_ptr<DataProcessingCallbackType> m_dataProcessingCallback{};
    std::unique_ptr<ProcessingCallbackType> m_ProcessingCallback{};
    std::unique_ptr<ComponentCallbackType> m_finishedExposureCallback{};
 
    std::unique_ptr<ComponentCallbackType> m_finishedGainCallback{};
 
    std::unique_ptr<ComponentCallbackType> m_AnalogGainCallback{};
    std::unique_ptr<ComponentCallbackType> m_DigitalGainCallback{};
    std::unique_ptr<ComponentCallbackType> m_CombinedGainCallback{};
    std::unique_ptr<ComponentCallbackType> m_HostGainCallback{};
};
 
namespace library
{
inline void Init()
{
    const auto ret = PEAK_AFL_C_ABI_PREFIX peak_afl_Init();
    if (ret != PEAK_AFL_STATUS_SUCCESS)
 
    {
        error::ThrowException(ret, false);
    }
}
 
inline void Exit()
{
    const auto ret = PEAK_AFL_C_ABI_PREFIX peak_afl_Exit();
    if (ret != PEAK_AFL_STATUS_SUCCESS)
    {
        error::ThrowException(ret, false);
    }
}
 
inline Version_t Version()
{
    uint32_t major;
    uint32_t minor;
    uint32_t patch;
 
    const auto ret = PEAK_AFL_C_ABI_PREFIX peak_afl_GetVersion(&major, &minor, &patch, nullptr);
    if (ret != PEAK_AFL_STATUS_SUCCESS)
    {
        error::ThrowException(ret, false);
    }
 
    return Version_t{major, minor, patch};
}
 
inline std::string GetLastError()
{
    std::size_t lastErrorMessageSize;
    peak_afl_status code;
 
    auto ret = PEAK_AFL_C_ABI_PREFIX peak_afl_GetLastError(&code, nullptr, &lastErrorMessageSize);
    if (ret != PEAK_AFL_STATUS_SUCCESS)
    {
        return "Cannot get last error!";
    }
 
    std::vector<char> text;
    text.resize(lastErrorMessageSize);
 
    ret = PEAK_AFL_C_ABI_PREFIX peak_afl_GetLastError(&code, text.data(), &lastErrorMessageSize);
    if (ret != PEAK_AFL_STATUS_SUCCESS)
    {
        return "Cannot get last error!";
    }
 
    return { text.begin(), text.end() };
}
} // namespace library
 
inline Manager::Manager(const std::shared_ptr<peak::core::NodeMap>& node_map)
{
    if (node_map == nullptr)
    {
        throw error::InvalidParameterException("Invalid node map handle!", PEAK_AFL_STATUS_INVALID_PARAMETER);
    }
 
    const auto ret = PEAK_AFL_C_ABI_PREFIX peak_afl_AutoFeatureManager_Create(&m_handle, node_map->Handle());
    if (ret != PEAK_AFL_STATUS_SUCCESS)
    {
        error::ThrowException(ret);
    }
}
 
inline Manager::~Manager()
{
    if (m_handle != nullptr)
    {
        PEAK_AFL_C_ABI_PREFIX peak_afl_AutoFeatureManager_DestroyAllController(m_handle);
 
        {
            std::lock_guard<std::mutex> lck(m_mutex);
            for (auto& c : m_controllerList)
            {
                c->m_handle = nullptr;
            }
        }
 
        PEAK_AFL_C_ABI_PREFIX peak_afl_AutoFeatureManager_Destroy(m_handle);
        m_handle = nullptr;
    }
}
 
inline Manager::Manager(Manager&& other) noexcept
{
    m_handle = other.m_handle;
    other.m_handle = nullptr;
 
    std::lock_guard<std::mutex> lck(other.m_mutex);
    m_controllerList = std::move(other.m_controllerList);
}
 
inline Manager& Manager::operator=(Manager&& other) noexcept
{
    m_handle = other.m_handle;
    other.m_handle = nullptr;
 
    std::lock_guard<std::mutex> lck(other.m_mutex);
    m_controllerList = std::move(other.m_controllerList);
 
    return *this;
}
 
inline void Manager::AddController(const std::shared_ptr<Controller>& controller)
{
    std::lock_guard<std::mutex> lck(m_mutex);
 
    auto cnt = std::any_of(
        m_controllerList.begin(), m_controllerList.end(), [controller](const std::shared_ptr<Controller>& c) { return c == controller; });
 
    if (cnt)
    {
        return;
    }
 
    const auto ret = PEAK_AFL_C_ABI_PREFIX peak_afl_AutoFeatureManager_AddController(m_handle, controller->m_handle);
    if (ret != PEAK_AFL_STATUS_SUCCESS)
    {
        error::ThrowException(ret);
    }
 
    m_controllerList.emplace_back(controller);
}
 
inline void Manager::RemoveController(const std::shared_ptr<Controller>& controller)
{
    std::lock_guard<std::mutex> lck(m_mutex);
 
    const auto ret = PEAK_AFL_C_ABI_PREFIX peak_afl_AutoFeatureManager_RemoveController(m_handle, controller->m_handle);
    if (ret != PEAK_AFL_STATUS_SUCCESS)
    {
        error::ThrowException(ret);
    }
 
    auto it = std::remove_if(
        m_controllerList.begin(), m_controllerList.end(), [controller](const std::shared_ptr<Controller>& c) { return c == controller; });
 
    m_controllerList.erase(it, m_controllerList.end());
}
 
inline void Manager::Process(const peak::ipl::Image& image) const
{
    const auto ret = PEAK_AFL_C_ABI_PREFIX peak_afl_AutoFeatureManager_Process(m_handle, ImageBackendAccessor::BackendHandle(image));
    if (ret != PEAK_AFL_STATUS_SUCCESS)
    {
        error::ThrowException(ret);
    }
}
 
inline std::shared_ptr<Controller> Manager::CreateController(peak_afl_controllerType type)
{
    std::lock_guard<std::mutex> lck(m_mutex);
 
    peak_afl_controller_handle handle{};
    const auto ret = PEAK_AFL_C_ABI_PREFIX peak_afl_AutoFeatureManager_CreateController(m_handle, &handle, type);
    if (ret != PEAK_AFL_STATUS_SUCCESS)
    {
        error::ThrowException(ret);
    }
 
    auto shared = std::shared_ptr<Controller>(new Controller(handle));
    m_controllerList.emplace_back(shared);
 
    return shared;
}
 
inline void Manager::DestroyAllController()
{
    std::lock_guard<std::mutex> lck(m_mutex);
 
    const auto ret = PEAK_AFL_C_ABI_PREFIX peak_afl_AutoFeatureManager_DestroyAllController(m_handle);
    if (ret != PEAK_AFL_STATUS_SUCCESS)
    {
        error::ThrowException(ret);
    }
 
    for (auto& c : m_controllerList)
    {
        c->m_handle = nullptr;
    }
 
    m_controllerList.clear();
}
 
inline void Manager::DestroyController(const std::shared_ptr<Controller>& controller)
{
    std::lock_guard<std::mutex> lck(m_mutex);
 
    const auto ret = PEAK_AFL_C_ABI_PREFIX peak_afl_AutoFeatureManager_DestroyController(m_handle, controller->m_handle);
    if (ret != PEAK_AFL_STATUS_SUCCESS)
    {
        error::ThrowException(ret);
    }
 
    auto it = std::remove_if(
        m_controllerList.begin(), m_controllerList.end(), [controller](const std::shared_ptr<Controller>& c) { return c == controller; });
 
    m_controllerList.erase(it, m_controllerList.end());
 
    controller->m_handle = nullptr;
}
 
inline void Manager::SetGainIPL(const peak::ipl::Gain& gain)
{
    const auto ret = PEAK_AFL_C_ABI_PREFIX peak_afl_AutoFeatureManager_SetGainIPL(m_handle, GainBackendAccessor::BackendHandle(gain));
    if (ret != PEAK_AFL_STATUS_SUCCESS)
    {
        error::ThrowException(ret);
    }
}
 
inline void Manager::SetCCM(std::array<float, 9> ccm)
{
    const auto ret = PEAK_AFL_C_ABI_PREFIX peak_afl_AutoFeatureManager_SetCCM(m_handle, ccm.data(), ccm.size());
    if (ret != PEAK_AFL_STATUS_SUCCESS)
    {
        error::ThrowException(ret);
    }
}
 
inline bool Manager::Status() const
{
    std::uint8_t status;
    const auto ret = PEAK_AFL_C_ABI_PREFIX peak_afl_AutoFeatureManager_Status(m_handle, &status);
    if (ret != PEAK_AFL_STATUS_SUCCESS)
    {
        error::ThrowException(ret);
    }
 
    return status;
}
 
inline std::vector<std::shared_ptr<Controller>> Manager::ControllerList() const
{
    std::lock_guard<std::mutex> lck(m_mutex);
 
    std::vector<std::shared_ptr<Controller>> controller{};
 
    std::copy(m_controllerList.begin(), m_controllerList.end(), std::back_inserter(controller));
 
    return controller;
}
 
inline size_t Manager::ControllerCount() const
{
    return m_controllerList.size();
}
 
inline std::shared_ptr<Controller> Manager::GetController(peak_afl_controllerType type) const
{
    std::lock_guard<std::mutex> lck(m_mutex);
 
    auto it = std::find_if(m_controllerList.cbegin(), m_controllerList.cend(),
        [=](const std::shared_ptr<Controller>& controller) { return type == controller->Type(); });
 
    if (it != m_controllerList.cend())
    {
        return *it;
    }
    else
    {
        throw error::InternalErrorException("No controller found!", PEAK_AFL_STATUS_ERROR);
    }
}
 
inline bool Manager::IsControllerSupported(peak_afl_controllerType type) const
{
    peak_afl_BOOL8 supported{};
    const auto ret = PEAK_AFL_C_ABI_PREFIX peak_afl_AutoFeatureManager_Controller_IsSupported(m_handle, type, &supported);
    if (ret != PEAK_AFL_STATUS_SUCCESS)
    {
        error::ThrowException(ret);
    }
 
    return supported != PEAK_AFL_FALSE;
}
 
 
inline std::shared_ptr<Controller> Controller::Create(peak_afl_controllerType type)
{
    peak_afl_controller_handle handle{};
    const auto ret = PEAK_AFL_C_ABI_PREFIX peak_afl_AutoController_Create(&handle, type);
    if (ret != PEAK_AFL_STATUS_SUCCESS)
    {
        error::ThrowException(ret);
    }
 
    return std::shared_ptr<Controller>(new Controller(handle));
}
 
inline Controller::~Controller()
{
    if (m_handle != nullptr)
    {
        PEAK_AFL_C_ABI_PREFIX peak_afl_AutoController_Destroy(m_handle);
        m_handle = nullptr;
    }
}
 
inline bool Controller::IsSkipFramesSupported() const
{
    peak_afl_BOOL8 supported{};
    const auto ret = PEAK_AFL_C_ABI_PREFIX peak_afl_AutoController_SkipFrames_IsSupported(m_handle, &supported);
    if (ret != PEAK_AFL_STATUS_SUCCESS)
    {
        error::ThrowException(ret);
    }
 
    return supported;
}
 
inline void Controller::SetSkipFrames(std::uint32_t count)
{
    const auto ret = PEAK_AFL_C_ABI_PREFIX peak_afl_AutoController_SkipFrames_Set(m_handle, count);
    if (ret != PEAK_AFL_STATUS_SUCCESS)
    {
        error::ThrowException(ret);
    }
}
 
inline std::uint32_t Controller::GetSkipFrames() const
{
    std::uint32_t count{};
    const auto ret = PEAK_AFL_C_ABI_PREFIX peak_afl_AutoController_SkipFrames_Get(m_handle, &count);
    if (ret != PEAK_AFL_STATUS_SUCCESS)
    {
        error::ThrowException(ret);
    }
 
    return count;
}
 
inline Range<std::uint32_t> Controller::GetSkipFramesRange() const
{
    Range<std::uint32_t> range{};
    const auto ret = PEAK_AFL_C_ABI_PREFIX peak_afl_AutoController_SkipFrames_GetRange(m_handle, &range.min, &range.max, &range.inc);
    if (ret != PEAK_AFL_STATUS_SUCCESS)
    {
        error::ThrowException(ret);
    }
 
    return range;
}
 
inline bool Controller::IsROISupported() const
{
    peak_afl_BOOL8 supported{};
    const auto ret = PEAK_AFL_C_ABI_PREFIX peak_afl_AutoController_ROI_IsSupported(m_handle, &supported);
    if (ret != PEAK_AFL_STATUS_SUCCESS)
    {
        error::ThrowException(ret);
    }
 
    return supported;
}
 
inline void Controller::SetROI(peak_afl_rectangle rect)
{
    const auto ret = PEAK_AFL_C_ABI_PREFIX peak_afl_AutoController_ROI_Set(m_handle, rect);
    if (ret != PEAK_AFL_STATUS_SUCCESS)
    {
        error::ThrowException(ret);
    }
}
 
inline peak_afl_rectangle Controller::GetROI() const
{
    peak_afl_rectangle rect{};
    const auto ret = PEAK_AFL_C_ABI_PREFIX peak_afl_AutoController_ROI_Get(m_handle, &rect);
    if (ret != PEAK_AFL_STATUS_SUCCESS)
    {
        error::ThrowException(ret);
    }
    return rect;
}
 
inline bool Controller::IsROIPresetSupported() const
{
    peak_afl_BOOL8 supported{};
    const auto ret = PEAK_AFL_C_ABI_PREFIX peak_afl_AutoController_ROI_Preset_IsSupported(m_handle, &supported);
    if (ret != PEAK_AFL_STATUS_SUCCESS)
    {
        error::ThrowException(ret);
    }
 
    return supported;
}
 
inline void Controller::SetROIPreset(peak_afl_roi_preset preset)
{
    const auto ret = PEAK_AFL_C_ABI_PREFIX peak_afl_AutoController_ROI_Preset_Set(m_handle, preset);
    if (ret != PEAK_AFL_STATUS_SUCCESS)
    {
        error::ThrowException(ret);
    }
}
 
inline bool Controller::IsModeSupported() const
{
    peak_afl_BOOL8 supported{};
    const auto ret = PEAK_AFL_C_ABI_PREFIX peak_afl_AutoController_Mode_IsSupported(m_handle, &supported);
    if (ret != PEAK_AFL_STATUS_SUCCESS)
    {
        error::ThrowException(ret);
    }
 
    return supported;
}
 
inline void Controller::SetMode(peak_afl_controller_automode mode)
{
    const auto ret = PEAK_AFL_C_ABI_PREFIX peak_afl_AutoController_Mode_Set(m_handle, mode);
    if (ret != PEAK_AFL_STATUS_SUCCESS)
    {
        error::ThrowException(ret);
    }
}
 
inline peak_afl_controller_automode Controller::GetMode() const
{
    peak_afl_controller_automode mode{};
    const auto ret = PEAK_AFL_C_ABI_PREFIX peak_afl_AutoController_Mode_Get(m_handle, &mode);
    if (ret != PEAK_AFL_STATUS_SUCCESS)
    {
        error::ThrowException(ret);
    }
    return mode;
}
 
inline bool Controller::IsBrightnessAlgorithmSupported() const
{
    peak_afl_BOOL8 supported{};
    const auto ret = PEAK_AFL_C_ABI_PREFIX peak_afl_AutoController_BrightnessAlgorithm_IsSupported(m_handle, &supported);
    if (ret != PEAK_AFL_STATUS_SUCCESS)
    {
        error::ThrowException(ret);
    }
 
    return supported;
}
 
inline void Controller::SetBrightnessAlgorithm(peak_afl_controller_brightness_algorithm algorithm)
{
    const auto ret = PEAK_AFL_C_ABI_PREFIX peak_afl_AutoController_BrightnessAlgorithm_Set(m_handle, algorithm);
    if (ret != PEAK_AFL_STATUS_SUCCESS)
    {
        error::ThrowException(ret);
    }
}
 
inline peak_afl_controller_brightness_algorithm Controller::GetBrightnessAlgorithm() const
{
    peak_afl_controller_brightness_algorithm algorithm{};
    const auto ret = PEAK_AFL_C_ABI_PREFIX peak_afl_AutoController_BrightnessAlgorithm_Get(m_handle, &algorithm);
    if (ret != PEAK_AFL_STATUS_SUCCESS)
    {
        error::ThrowException(ret);
    }
    return algorithm;
}
 
inline peak_afl_controller_status Controller::Status() const
{
    peak_afl_controller_status status{};
    const auto ret = PEAK_AFL_C_ABI_PREFIX peak_afl_AutoController_Status(m_handle, &status);
    if (ret != PEAK_AFL_STATUS_SUCCESS)
    {
        error::ThrowException(ret);
    }
    return status;
}
 
 
inline std::uint8_t Controller::GetLastAutoAverage() const
{
    std::uint8_t average{};
    const auto ret = PEAK_AFL_C_ABI_PREFIX peak_afl_AutoController_GetLastAutoAverage(m_handle, &average);
    if (ret != PEAK_AFL_STATUS_SUCCESS)
    {
        error::ThrowException(ret);
    }
    return average;
}
 
inline std::tuple<std::uint8_t, std::uint8_t, std::uint8_t> Controller::GetLastAutoAverages() const
{
    std::uint8_t averageRed{}, averageGreen{}, averageBlue{};
    const auto ret = PEAK_AFL_C_ABI_PREFIX peak_afl_AutoController_GetLastAutoAverages(m_handle, &averageRed, &averageGreen, &averageBlue);
    if (ret != PEAK_AFL_STATUS_SUCCESS)
    {
        error::ThrowException(ret);
    }
    return { averageRed, averageGreen, averageBlue };
}
 
inline bool Controller::IsAutoTargetSupported() const
{
    peak_afl_BOOL8 supported{};
    const auto ret = PEAK_AFL_C_ABI_PREFIX peak_afl_AutoController_AutoTarget_IsSupported(m_handle, &supported);
    if (ret != PEAK_AFL_STATUS_SUCCESS)
    {
        error::ThrowException(ret);
    }
 
    return supported;
}
 
inline void Controller::SetAutoTarget(std::uint32_t target)
{
    const auto ret = PEAK_AFL_C_ABI_PREFIX peak_afl_AutoController_AutoTarget_Set(m_handle, target);
    if (ret != PEAK_AFL_STATUS_SUCCESS)
    {
        error::ThrowException(ret);
    }
}
 
inline std::uint32_t Controller::GetAutoTarget() const
{
    std::uint32_t target{};
    const auto ret = PEAK_AFL_C_ABI_PREFIX peak_afl_AutoController_AutoTarget_Get(m_handle, &target);
    if (ret != PEAK_AFL_STATUS_SUCCESS)
    {
        error::ThrowException(ret);
    }
    return target;
}
 
inline Range<std::uint32_t> Controller::GetAutoTargetRange() const
{
    Range<std::uint32_t> range{};
    const auto ret = PEAK_AFL_C_ABI_PREFIX peak_afl_AutoController_AutoTarget_GetRange(m_handle, &range.min, &range.max, &range.inc);
    if (ret != PEAK_AFL_STATUS_SUCCESS)
    {
        error::ThrowException(ret);
    }
    return range;
}
 
inline bool Controller::IsAutoToleranceSupported() const
{
    peak_afl_BOOL8 supported{};
    const auto ret = PEAK_AFL_C_ABI_PREFIX peak_afl_AutoController_AutoTolerance_IsSupported(m_handle, &supported);
    if (ret != PEAK_AFL_STATUS_SUCCESS)
    {
        error::ThrowException(ret);
    }
 
    return supported;
}
 
inline void Controller::SetAutoTolerance(uint32_t tolerance)
{
    const auto ret = PEAK_AFL_C_ABI_PREFIX peak_afl_AutoController_AutoTolerance_Set(m_handle, tolerance);
    if (ret != PEAK_AFL_STATUS_SUCCESS)
    {
        error::ThrowException(ret);
    }
}
 
inline uint32_t Controller::GetAutoTolerance() const
{
    std::uint32_t tolerance;
    const auto ret = PEAK_AFL_C_ABI_PREFIX peak_afl_AutoController_AutoTolerance_Get(m_handle, &tolerance);
    if (ret != PEAK_AFL_STATUS_SUCCESS)
    {
        error::ThrowException(ret);
    }
    return tolerance;
}
 
inline Range<uint32_t> Controller::GetAutoToleranceRange() const
{
    Range<uint32_t> range{};
    const auto ret = PEAK_AFL_C_ABI_PREFIX peak_afl_AutoController_AutoTolerance_GetRange(m_handle, &range.min, &range.max, &range.inc);
    if (ret != PEAK_AFL_STATUS_SUCCESS)
    {
        error::ThrowException(ret);
    }
    return range;
}
 
inline bool Controller::IsAutoPercentileSupported() const
{
    peak_afl_BOOL8 supported{};
    const auto ret = PEAK_AFL_C_ABI_PREFIX peak_afl_AutoController_AutoPercentile_IsSupported(m_handle, &supported);
    if (ret != PEAK_AFL_STATUS_SUCCESS)
    {
        error::ThrowException(ret);
    }
 
    return supported;
}
 
inline void Controller::SetAutoPercentile(double percentile)
{
    const auto ret = PEAK_AFL_C_ABI_PREFIX peak_afl_AutoController_AutoPercentile_Set(m_handle, percentile);
    if (ret != PEAK_AFL_STATUS_SUCCESS)
    {
        error::ThrowException(ret);
    }
}
 
inline double Controller::GetAutoPercentile() const
{
    double percentile;
    const auto ret = PEAK_AFL_C_ABI_PREFIX peak_afl_AutoController_AutoPercentile_Get(m_handle, &percentile);
    if (ret != PEAK_AFL_STATUS_SUCCESS)
    {
        error::ThrowException(ret);
    }
    return percentile;
}
 
inline Range<double> Controller::GetAutoPercentileRange() const
{
    Range<double> range{};
    const auto ret = PEAK_AFL_C_ABI_PREFIX peak_afl_AutoController_AutoPercentile_GetRange(m_handle, &range.min, &range.max, &range.inc);
    if (ret != PEAK_AFL_STATUS_SUCCESS)
    {
        error::ThrowException(ret);
    }
    return range;
}
 
inline peak_afl_controllerType Controller::Type() const
{
    peak_afl_controllerType type{};
    const auto ret = PEAK_AFL_C_ABI_PREFIX peak_afl_AutoController_Type_Get(m_handle, &type);
    if (ret != PEAK_AFL_STATUS_SUCCESS)
    {
        error::ThrowException(ret);
    }
    return type;
}
 
inline bool Controller::IsAlgorithmSupported() const
{
    peak_afl_BOOL8 supported{};
    const auto ret = PEAK_AFL_C_ABI_PREFIX peak_afl_AutoController_Algorithm_IsSupported(m_handle, &supported);
    if (ret != PEAK_AFL_STATUS_SUCCESS)
    {
        error::ThrowException(ret);
    }
 
    return supported;
}
 
inline void Controller::SetAlgorithm(peak_afl_controller_algorithm alg)
{
    const auto ret = PEAK_AFL_C_ABI_PREFIX peak_afl_AutoController_Algorithm_Set(m_handle, alg);
    if (ret != PEAK_AFL_STATUS_SUCCESS)
    {
        error::ThrowException(ret);
    }
}
 
inline peak_afl_controller_algorithm Controller::GetAlgorithm() const
{
    peak_afl_controller_algorithm alg{};
    const auto ret = PEAK_AFL_C_ABI_PREFIX peak_afl_AutoController_Algorithm_Get(m_handle, &alg);
    if (ret != PEAK_AFL_STATUS_SUCCESS)
    {
        error::ThrowException(ret);
    }
 
    return alg;
}
 
inline std::vector<peak_afl_controller_algorithm> Controller::GetAlgorithmList() const
{
    std::vector<peak_afl_controller_algorithm> algList{};
    std::uint32_t listSize{};
 
    auto ret = PEAK_AFL_C_ABI_PREFIX peak_afl_AutoController_Algorithm_GetList(m_handle, nullptr, &listSize);
    if (ret != PEAK_AFL_STATUS_SUCCESS)
    {
        error::ThrowException(ret);
    }
 
    algList.resize(listSize);
 
    ret = PEAK_AFL_C_ABI_PREFIX peak_afl_AutoController_Algorithm_GetList(m_handle, algList.data(), &listSize);
    if (ret != PEAK_AFL_STATUS_SUCCESS)
    {
        error::ThrowException(ret);
    }
 
    return algList;
}
 
inline bool Controller::IsSharpnessAlgorithmSupported() const
{
    peak_afl_BOOL8 supported{};
    const auto ret = PEAK_AFL_C_ABI_PREFIX peak_afl_AutoController_SharpnessAlgorithm_IsSupported(m_handle, &supported);
    if (ret != PEAK_AFL_STATUS_SUCCESS)
    {
        error::ThrowException(ret);
    }
 
    return supported;
}
 
inline void Controller::SetSharpnessAlgorithm(peak_afl_controller_sharpness_algorithm alg)
{
    const auto ret = PEAK_AFL_C_ABI_PREFIX peak_afl_AutoController_SharpnessAlgorithm_Set(m_handle, alg);
    if (ret != PEAK_AFL_STATUS_SUCCESS)
    {
        error::ThrowException(ret);
    }
}
 
inline peak_afl_controller_sharpness_algorithm Controller::GetSharpnessAlgorithm() const
{
    peak_afl_controller_sharpness_algorithm alg{};
    const auto ret = PEAK_AFL_C_ABI_PREFIX peak_afl_AutoController_SharpnessAlgorithm_Get(m_handle, &alg);
    if (ret != PEAK_AFL_STATUS_SUCCESS)
    {
        error::ThrowException(ret);
    }
 
    return alg;
}
 
inline std::vector<peak_afl_controller_sharpness_algorithm> Controller::GetSharpnessAlgorithmList() const
{
    std::vector<peak_afl_controller_sharpness_algorithm> algList{};
    std::uint32_t listSize{};
 
    auto ret = PEAK_AFL_C_ABI_PREFIX peak_afl_AutoController_SharpnessAlgorithm_GetList(m_handle, nullptr, &listSize);
    if (ret != PEAK_AFL_STATUS_SUCCESS)
    {
        error::ThrowException(ret);
    }
 
    algList.resize(listSize);
 
    ret = PEAK_AFL_C_ABI_PREFIX peak_afl_AutoController_SharpnessAlgorithm_GetList(m_handle, algList.data(), &listSize);
    if (ret != PEAK_AFL_STATUS_SUCCESS)
    {
        error::ThrowException(ret);
    }
 
    return algList;
}
 
inline void Controller::RegisterFinishedCallback(const callback::FinishedCallback& callback)
{
    m_finishedCallback = std::make_unique<FinishedCallbackType>(
        shared_from_this(),
        [handle = m_handle](void* ptr, void* ctx) {
            return PEAK_AFL_C_ABI_PREFIX peak_afl_AutoController_Callback_Set(handle, PEAK_AFL_CONTROLLER_CALLBACK_FINISHED, ptr, ctx);
        },
        [handle = m_handle] {
            PEAK_AFL_C_ABI_PREFIX peak_afl_AutoController_Callback_Set(
                handle, PEAK_AFL_CONTROLLER_CALLBACK_FINISHED, nullptr, nullptr);
        },
        callback);
}
 
inline void Controller::UnRegisterFinishedCallback()
{
    m_finishedCallback.reset();
}
 
inline void Controller::RegisterComponentCallback(
    peak_afl_controller_brightness_component component, const callback::FinishedCallback& callback)
{
    if (!IsBrightnessComponentModeSupported())
    {
        throw error::NotSupportedException("Brightness component not supported!", PEAK_AFL_STATUS_NOT_SUPPORTED);
    }
 
    const auto registerCallback = [&](peak_afl_controller_brightness_component component) {
        return std::make_unique<ComponentCallbackType>(
            shared_from_this(),
            [handle = m_handle, component](void* ptr, void* ctx) {
                return PEAK_AFL_C_ABI_PREFIX peak_afl_AutoController_BrightnessComponent_Callback_Set(
                    handle, component, PEAK_AFL_CONTROLLER_CALLBACK_FINISHED, ptr, ctx);
            },
            [handle = m_handle, component] {
                PEAK_AFL_C_ABI_PREFIX peak_afl_AutoController_BrightnessComponent_Callback_Set(
                    handle, component, PEAK_AFL_CONTROLLER_CALLBACK_FINISHED, nullptr, nullptr);
            },
            callback);
    };
 
    PEAK_AFL_BEGIN_DISABLE_DEPRECATED_WARNINGS
    if (PEAK_AFL_CONTROLLER_BRIGHTNESS_COMPONENT_EXPOSURE == component)
    {
        m_finishedExposureCallback = registerCallback(component);
    }
    else if (PEAK_AFL_CONTROLLER_BRIGHTNESS_COMPONENT_GAIN == component)
    {
        m_finishedGainCallback = registerCallback(component);
    }
    else if (PEAK_AFL_CONTROLLER_BRIGHTNESS_COMPONENT_ANALOG_GAIN == component)
    {
        m_AnalogGainCallback = registerCallback(component);
    }
    else if (PEAK_AFL_CONTROLLER_BRIGHTNESS_COMPONENT_DIGITAL_GAIN == component)
    {
        m_DigitalGainCallback = registerCallback(component);
    }
    else if (PEAK_AFL_CONTROLLER_BRIGHTNESS_COMPONENT_COMBINED_GAIN == component)
    {
        m_CombinedGainCallback = registerCallback(component);
    }
    else if (PEAK_AFL_CONTROLLER_BRIGHTNESS_COMPONENT_HOST_GAIN == component)
    {
        m_HostGainCallback = registerCallback(component);
    }
    else
    {
        throw error::InvalidParameterException("Brightness component type is invalid!", PEAK_AFL_STATUS_INVALID_PARAMETER);
    }
    PEAK_AFL_END_DISABLE_DEPRECATED_WARNINGS
}
 
inline void Controller::UnRegisterComponentCallback(peak_afl_controller_brightness_component component)
{
    PEAK_AFL_BEGIN_DISABLE_DEPRECATED_WARNINGS
    if (PEAK_AFL_CONTROLLER_BRIGHTNESS_COMPONENT_EXPOSURE == component)
    {
        m_finishedExposureCallback.reset();
    }
    else if (PEAK_AFL_CONTROLLER_BRIGHTNESS_COMPONENT_GAIN == component)
    {
        m_finishedGainCallback.reset();
    }
    else if (PEAK_AFL_CONTROLLER_BRIGHTNESS_COMPONENT_ANALOG_GAIN == component)
    {
        m_AnalogGainCallback.reset();
    }
    else if (PEAK_AFL_CONTROLLER_BRIGHTNESS_COMPONENT_DIGITAL_GAIN == component)
    {
        m_DigitalGainCallback.reset();
    }
    else if (PEAK_AFL_CONTROLLER_BRIGHTNESS_COMPONENT_COMBINED_GAIN == component)
    {
        m_CombinedGainCallback.reset();
    }
    else if (PEAK_AFL_CONTROLLER_BRIGHTNESS_COMPONENT_HOST_GAIN == component)
    {
        m_HostGainCallback.reset();
    }
    else
    {
        throw error::InvalidParameterException("Brightness component type is invalid!", PEAK_AFL_STATUS_INVALID_PARAMETER);
    }
    PEAK_AFL_END_DISABLE_DEPRECATED_WARNINGS
}
 
inline void Controller::RegisterDataProcessingCallback(const callback::DataProcessingCallback& callback)
{
    PEAK_AFL_BEGIN_DISABLE_DEPRECATED_WARNINGS
    m_dataProcessingCallback = std::make_unique<DataProcessingCallbackType>(
        shared_from_this(),
        [handle = m_handle](void* ptr, void* ctx) {
            return PEAK_AFL_C_ABI_PREFIX peak_afl_AutoController_Callback_Set(
                handle, PEAK_AFL_CONTROLLER_CALLBACK_PROCESSING_DATA, ptr, ctx);
        },
        [handle = m_handle] {
            PEAK_AFL_C_ABI_PREFIX peak_afl_AutoController_Callback_Set(
                handle, PEAK_AFL_CONTROLLER_CALLBACK_PROCESSING_DATA, nullptr, nullptr);
        },
        callback);
    PEAK_AFL_END_DISABLE_DEPRECATED_WARNINGS
}
 
inline void Controller::RegisterProcessingCallback(const callback::ProcessingCallback& callback)
{
    m_ProcessingCallback = std::make_unique<ProcessingCallbackType>(
        shared_from_this(),
        [handle = m_handle](void* ptr, void* ctx) {
            return PEAK_AFL_C_ABI_PREFIX peak_afl_AutoController_Callback_Set(
                handle, PEAK_AFL_CONTROLLER_CALLBACK_PROCESSING, ptr, ctx);
        },
        [handle = m_handle] {
            PEAK_AFL_C_ABI_PREFIX peak_afl_AutoController_Callback_Set(
                handle, PEAK_AFL_CONTROLLER_CALLBACK_PROCESSING, nullptr, nullptr);
        },
        callback);
}
 
inline void Controller::UnRegisterProcessingCallback()
{
    m_ProcessingCallback.reset();
}
 
inline void Controller::UnRegisterDataProcessingCallback()
{
    m_dataProcessingCallback.reset();
}
 
inline bool Controller::IsWeightedROISupported() const
{
    peak_afl_BOOL8 supported{};
    const auto ret = PEAK_AFL_C_ABI_PREFIX peak_afl_AutoController_Weighted_ROI_IsSupported(m_handle, &supported);
    if (ret != PEAK_AFL_STATUS_SUCCESS)
    {
        error::ThrowException(ret);
    }
 
    return supported;
}
 
inline void Controller::SetWeightedROIs(const std::vector<peak_afl_weighted_rectangle>& list)
{
    const auto ret = PEAK_AFL_C_ABI_PREFIX peak_afl_AutoController_Weighted_ROI_Set(
        m_handle, list.data(), static_cast<uint32_t>(list.size()));
    if (ret != PEAK_AFL_STATUS_SUCCESS)
    {
        error::ThrowException(ret);
    }
}
 
inline void Controller::SetWeightedROI(const peak_afl_weighted_rectangle& rect)
{
    const auto ret = PEAK_AFL_C_ABI_PREFIX peak_afl_AutoController_Weighted_ROI_Set(m_handle, &rect, 1);
    if (ret != PEAK_AFL_STATUS_SUCCESS)
    {
        error::ThrowException(ret);
    }
}
 
inline peak_afl_size Controller::GetWeightedROIMinSize() const
{
    peak_afl_size minSize{};
    const auto ret = PEAK_AFL_C_ABI_PREFIX peak_afl_AutoController_Weighted_ROI_Min_Size(m_handle, &minSize);
    if (ret != PEAK_AFL_STATUS_SUCCESS)
    {
        error::ThrowException(ret);
    }
    return minSize;
}
 
inline std::vector<peak_afl_weighted_rectangle> Controller::GetWeightedROIs() const
{
    std::vector<peak_afl_weighted_rectangle> list;
    std::uint32_t listSize{};
 
    auto ret = PEAK_AFL_C_ABI_PREFIX peak_afl_AutoController_Weighted_ROI_Get(m_handle, nullptr, &listSize);
    if (ret != PEAK_AFL_STATUS_SUCCESS)
    {
        error::ThrowException(ret);
    }
 
    list.resize(listSize);
 
    ret = PEAK_AFL_C_ABI_PREFIX peak_afl_AutoController_Weighted_ROI_Get(m_handle, list.data(), &listSize);
    if (ret != PEAK_AFL_STATUS_SUCCESS)
    {
        error::ThrowException(ret);
    }
 
    return list;
}
 
inline bool Controller::IsLimitSupported() const
{
    peak_afl_BOOL8 supported{};
    const auto ret = PEAK_AFL_C_ABI_PREFIX peak_afl_AutoController_Limit_IsSupported(m_handle, &supported);
    if (ret != PEAK_AFL_STATUS_SUCCESS)
    {
        error::ThrowException(ret);
    }
 
    return supported;
}
 
inline void Controller::SetLimit(peak_afl_controller_limit limit)
{
    const auto ret = PEAK_AFL_C_ABI_PREFIX peak_afl_AutoController_Limit_Set(m_handle, limit);
    if (ret != PEAK_AFL_STATUS_SUCCESS)
    {
        error::ThrowException(ret);
    }
}
 
inline peak_afl_controller_limit Controller::GetLimit() const
{
    peak_afl_controller_limit limit{};
    const auto ret = PEAK_AFL_C_ABI_PREFIX peak_afl_AutoController_Limit_Get(m_handle, &limit);
    if (ret != PEAK_AFL_STATUS_SUCCESS)
    {
        error::ThrowException(ret);
    }
    return limit;
}
 
inline peak_afl_controller_limit Controller::GetDefaultLimit() const
{
    peak_afl_controller_limit limit{};
    const auto ret = PEAK_AFL_C_ABI_PREFIX peak_afl_AutoController_Limit_Default(m_handle, &limit);
    if (ret != PEAK_AFL_STATUS_SUCCESS)
    {
        error::ThrowException(ret);
    }
    return limit;
}
 
inline bool Controller::IsHysteresisSupported() const
{
    peak_afl_BOOL8 supported{};
    const auto ret = PEAK_AFL_C_ABI_PREFIX peak_afl_AutoController_Hysteresis_IsSupported(m_handle, &supported);
    if (ret != PEAK_AFL_STATUS_SUCCESS)
    {
        error::ThrowException(ret);
    }
 
    return supported;
}
 
inline void Controller::SetHysteresis(std::uint8_t hysteresis)
{
    const auto ret = PEAK_AFL_C_ABI_PREFIX peak_afl_AutoController_Hysteresis_Set(m_handle, hysteresis);
    if (ret != PEAK_AFL_STATUS_SUCCESS)
    {
        error::ThrowException(ret);
    }
}
 
inline std::uint8_t Controller::GetHysteresis() const
{
    std::uint8_t hysteresis{};
    const auto ret = PEAK_AFL_C_ABI_PREFIX peak_afl_AutoController_Hysteresis_Get(m_handle, &hysteresis);
    if (ret != PEAK_AFL_STATUS_SUCCESS)
    {
        error::ThrowException(ret);
    }
 
    return hysteresis;
}
 
inline std::uint8_t Controller::GetDefaultHysteresis() const
{
    std::uint8_t hysteresis{};
    const auto ret = PEAK_AFL_C_ABI_PREFIX peak_afl_AutoController_Hysteresis_Default(m_handle, &hysteresis);
    if (ret != PEAK_AFL_STATUS_SUCCESS)
    {
        error::ThrowException(ret);
    }
 
    return hysteresis;
}
 
inline Range<std::uint8_t> Controller::GetHysteresisRange() const
{
    Range<std::uint8_t> hysteresis{};
    const auto ret = PEAK_AFL_C_ABI_PREFIX peak_afl_AutoController_Hysteresis_GetRange(
        m_handle, &hysteresis.min, &hysteresis.max, &hysteresis.inc);
    if (ret != PEAK_AFL_STATUS_SUCCESS)
    {
        error::ThrowException(ret);
    }
 
    return hysteresis;
}
 
PEAK_AFL_NO_DISCARD inline bool Controller::IsBrightnessComponentModeSupported() const
{
    peak_afl_BOOL8 supported{};
    const auto ret = PEAK_AFL_C_ABI_PREFIX peak_afl_AutoController_BrightnessComponent_Mode_IsSupported(m_handle, &supported);
    if (ret != PEAK_AFL_STATUS_SUCCESS)
    {
        error::ThrowException(ret);
    }
 
    return supported;
}
 
PEAK_AFL_NO_DISCARD inline bool Controller::IsBrightnessComponentUnitSupported(
    peak_afl_controller_brightness_component component) const
{
    peak_afl_BOOL8 supported{};
    const auto ret = PEAK_AFL_C_ABI_PREFIX peak_afl_AutoController_BrightnessComponent_Unit_IsSupported(m_handle, component, &supported);
    if (ret != PEAK_AFL_STATUS_SUCCESS)
    {
        error::ThrowException(ret);
    }
 
    return supported;
}
 
inline void Controller::BrightnessComponentSetMode(
    peak_afl_controller_brightness_component component, peak_afl_controller_automode mode)
{
    const auto ret = PEAK_AFL_C_ABI_PREFIX peak_afl_AutoController_BrightnessComponent_Mode_Set(m_handle, component, mode);
    if (ret != PEAK_AFL_STATUS_SUCCESS)
    {
        error::ThrowException(ret);
    }
}
 
PEAK_AFL_NO_DISCARD inline peak_afl_controller_automode Controller::BrightnessComponentGetMode(
    peak_afl_controller_brightness_component component) const
{
    peak_afl_controller_automode mode{};
    const auto ret = PEAK_AFL_C_ABI_PREFIX peak_afl_AutoController_BrightnessComponent_Mode_Get(m_handle, component, &mode);
    if (ret != PEAK_AFL_STATUS_SUCCESS)
    {
        error::ThrowException(ret);
    }
    return mode;
}
 
PEAK_AFL_NO_DISCARD inline peak_afl_controller_status Controller::BrightnessComponentStatus(
    peak_afl_controller_brightness_component component) const
{
    peak_afl_controller_status status{};
    const auto ret = PEAK_AFL_C_ABI_PREFIX peak_afl_AutoController_BrightnessComponent_Status(m_handle, component, &status);
    if (ret != PEAK_AFL_STATUS_SUCCESS)
    {
        error::ThrowException(ret);
    }
    return status;
}
 
inline bool Controller::IsGainLimitSupported() const
{
    peak_afl_BOOL8 supported{};
    const auto ret = PEAK_AFL_C_ABI_PREFIX peak_afl_AutoController_GainLimit_IsSupported(m_handle, &supported);
    if (ret != PEAK_AFL_STATUS_SUCCESS)
    {
        error::ThrowException(ret);
    }
 
    return supported;
}
 
inline void Controller::SetGainLimit(peak_afl_double_limit limit)
{
    const auto ret = PEAK_AFL_C_ABI_PREFIX peak_afl_AutoController_GainLimit_Set(m_handle, limit);
    if (ret == PEAK_AFL_STATUS_VALUE_ADJUSTED)
    {
        // Do nothing. Not an error.
    }
    else if (ret != PEAK_AFL_STATUS_SUCCESS)
    {
        error::ThrowException(ret);
    }
}
 
inline peak_afl_double_limit Controller::GetGainLimit() const
{
    peak_afl_double_limit limit{};
    const auto ret = PEAK_AFL_C_ABI_PREFIX peak_afl_AutoController_GainLimit_Get(m_handle, &limit);
    if (ret != PEAK_AFL_STATUS_SUCCESS)
    {
        error::ThrowException(ret);
    }
 
    return limit;
}
 
inline peak_afl_double_limit Controller::GetGainLimitRange() const
{
    peak_afl_double_limit limit{};
    const auto ret = PEAK_AFL_C_ABI_PREFIX peak_afl_AutoController_GainLimit_GetRange(m_handle, &limit);
    if (ret != PEAK_AFL_STATUS_SUCCESS)
    {
        error::ThrowException(ret);
    }
 
    return limit;
}
 
inline void Controller::SetGainAnalogLimit(peak_afl_double_limit limit)
{
    const auto ret = PEAK_AFL_C_ABI_PREFIX peak_afl_AutoController_GainAnalogLimit_Set(m_handle, limit);
    if (ret == PEAK_AFL_STATUS_VALUE_ADJUSTED)
    {
        // Do nothing. Not an error.
    }
    else if (ret != PEAK_AFL_STATUS_SUCCESS)
    {
        error::ThrowException(ret);
    }
}
 
inline peak_afl_double_limit Controller::GetGainAnalogLimit() const
{
    peak_afl_double_limit limit{};
    const auto ret = PEAK_AFL_C_ABI_PREFIX peak_afl_AutoController_GainAnalogLimit_Get(m_handle, &limit);
    if (ret != PEAK_AFL_STATUS_SUCCESS)
    {
        error::ThrowException(ret);
    }
 
    return limit;
}
 
inline peak_afl_double_limit Controller::GetGainAnalogLimitRange() const
{
    peak_afl_double_limit limit{};
    const auto ret = PEAK_AFL_C_ABI_PREFIX peak_afl_AutoController_GainAnalogLimit_GetRange(m_handle, &limit);
    if (ret != PEAK_AFL_STATUS_SUCCESS)
    {
        error::ThrowException(ret);
    }
 
    return limit;
}
 
inline void Controller::SetGainDigitalLimit(peak_afl_double_limit limit)
{
    const auto ret = PEAK_AFL_C_ABI_PREFIX peak_afl_AutoController_GainDigitalLimit_Set(m_handle, limit);
    if (ret == PEAK_AFL_STATUS_VALUE_ADJUSTED)
    {
        // Do nothing. Not an error.
    }
    else if (ret != PEAK_AFL_STATUS_SUCCESS)
    {
        error::ThrowException(ret);
    }
}
 
inline peak_afl_double_limit Controller::GetGainDigitalLimit() const
{
    peak_afl_double_limit limit{};
    const auto ret = PEAK_AFL_C_ABI_PREFIX peak_afl_AutoController_GainDigitalLimit_Get(m_handle, &limit);
    if (ret != PEAK_AFL_STATUS_SUCCESS)
    {
        error::ThrowException(ret);
    }
 
    return limit;
}
 
inline peak_afl_double_limit Controller::GetGainDigitalLimitRange() const
{
    peak_afl_double_limit limit{};
    const auto ret = PEAK_AFL_C_ABI_PREFIX peak_afl_AutoController_GainDigitalLimit_GetRange(m_handle, &limit);
    if (ret != PEAK_AFL_STATUS_SUCCESS)
    {
        error::ThrowException(ret);
    }
 
    return limit;
}
 
inline void Controller::SetGainCombinedLimit(peak_afl_double_limit limit)
{
    const auto ret = PEAK_AFL_C_ABI_PREFIX peak_afl_AutoController_GainCombinedLimit_Set(m_handle, limit);
    if (ret == PEAK_AFL_STATUS_VALUE_ADJUSTED)
    {
        // Do nothing. Not an error.
    }
    else if (ret != PEAK_AFL_STATUS_SUCCESS)
    {
        error::ThrowException(ret);
    }
}
 
inline peak_afl_double_limit Controller::GetGainCombinedLimit() const
{
    peak_afl_double_limit limit{};
    const auto ret = PEAK_AFL_C_ABI_PREFIX peak_afl_AutoController_GainCombinedLimit_Get(m_handle, &limit);
    if (ret != PEAK_AFL_STATUS_SUCCESS)
    {
        error::ThrowException(ret);
    }
 
    return limit;
}
 
inline peak_afl_double_limit Controller::GetGainCombinedLimitRange() const
{
    peak_afl_double_limit limit{};
    const auto ret = PEAK_AFL_C_ABI_PREFIX peak_afl_AutoController_GainCombinedLimit_GetRange(m_handle, &limit);
    if (ret != PEAK_AFL_STATUS_SUCCESS)
    {
        error::ThrowException(ret);
    }
 
    return limit;
}
 
inline void Controller::SetGainHostLimit(peak_afl_double_limit limit)
{
    const auto ret = PEAK_AFL_C_ABI_PREFIX peak_afl_AutoController_GainHostLimit_Set(m_handle, limit);
    if (ret == PEAK_AFL_STATUS_VALUE_ADJUSTED)
    {
        // Do nothing. Not an error.
    }
    else if (ret != PEAK_AFL_STATUS_SUCCESS)
    {
        error::ThrowException(ret);
    }
}
 
inline peak_afl_double_limit Controller::GetGainHostLimit() const
{
    peak_afl_double_limit limit{};
    const auto ret = PEAK_AFL_C_ABI_PREFIX peak_afl_AutoController_GainHostLimit_Get(m_handle, &limit);
    if (ret != PEAK_AFL_STATUS_SUCCESS)
    {
        error::ThrowException(ret);
    }
 
    return limit;
}
 
inline peak_afl_double_limit Controller::GetGainHostLimitRange() const
{
    peak_afl_double_limit limit{};
    const auto ret = PEAK_AFL_C_ABI_PREFIX peak_afl_AutoController_GainHostLimit_GetRange(m_handle, &limit);
    if (ret != PEAK_AFL_STATUS_SUCCESS)
    {
        error::ThrowException(ret);
    }
 
    return limit;
}
 
inline void Controller::SetExposureLimit(peak_afl_double_limit limit)
{
    const auto ret = PEAK_AFL_C_ABI_PREFIX peak_afl_AutoController_ExposureLimit_Set(m_handle, limit);
    if (ret != PEAK_AFL_STATUS_SUCCESS)
    {
        error::ThrowException(ret);
    }
}
 
inline peak_afl_double_limit Controller::GetExposureLimit() const
{
    peak_afl_double_limit limit{};
    const auto ret = PEAK_AFL_C_ABI_PREFIX peak_afl_AutoController_ExposureLimit_Get(m_handle, &limit);
    if (ret != PEAK_AFL_STATUS_SUCCESS)
    {
        error::ThrowException(ret);
    }
 
    return limit;
}
 
inline peak_afl_double_limit Controller::GetExposureLimitRange() const
{
    peak_afl_double_limit limit{};
    const auto ret = PEAK_AFL_C_ABI_PREFIX peak_afl_AutoController_ExposureLimit_GetRange(m_handle, &limit);
    if (ret != PEAK_AFL_STATUS_SUCCESS)
    {
        error::ThrowException(ret);
    }
 
    return limit;
}
 
} /* namespace afl */
} /* namespace peak */