peak_icv_calibration_result.hpp

Go to the documentation of this file.

 
#pragma once
 
#include <peak_common_c/detail/peak_common_defines.h>
#include <peak_icv/algorithms/calibration/peak_icv_calibration_parameters.hpp>
#include <peak_icv/algorithms/calibration/peak_icv_calibration_view.hpp>
#include <peak_icv/algorithms/calibration/peak_icv_intrinsic_parameters.hpp>
#include <peak_icv/exceptions/detail/peak_icv_exception_helpers.hpp>
#include <peak_icv/utils/peak_icv_backend_accessor.hpp>
#include <peak_icv/utils/peak_icv_type_traits.hpp>
#include <peak_icv_c/algorithms/calibration/peak_icv_camera_calibration.h>
 
#include <tuple>
 
namespace peak
{
namespace icv
{
class CalibrationResult
    : private detail::IBackendAccessible<CalibrationResult>
    , private detail::IBackendExchangeable<CalibrationResult>
{
public:
    explicit CalibrationResult(const std::string& filePath);
 
    ~CalibrationResult() override;
 
    CalibrationResult(const CalibrationResult& other);
 
    CalibrationResult(CalibrationResult&& other) noexcept;
 
    CalibrationResult& operator=(const CalibrationResult& other);
 
    CalibrationResult& operator=(CalibrationResult&& other) noexcept;
 
    PEAK_COMMON_NO_DISCARD double GetMeanReprojectionError() const;
 
    PEAK_COMMON_NO_DISCARD std::vector<CalibrationView> GetViews() const;
 
    PEAK_COMMON_NO_DISCARD CalibrationParameters GetCalibrationParameters() const;
 
    operator CalibrationParameters() const; // NOLINT
 
private:
    friend peak::common::detail::BackendAccessor<CalibrationResult>;
 
    CalibrationResult();
    explicit CalibrationResult(peak_icv_calibration_result_handle calibrationResultHandle);
    PEAK_COMMON_NO_DISCARD detail::handle_of_t<CalibrationResult> GetHandle() const override;
    PEAK_COMMON_NO_DISCARD detail::handle_of_t<CalibrationResult>* GetHandleAddress() override;
 
    peak_icv_calibration_result_handle m_calibrationResultHandle{};
};
 
inline CalibrationResult::CalibrationResult()
{
    detail::ExecuteAndMapReturnCodes([&] {
        return PEAK_ICV_C_ABI_PREFIX peak_icv_Calibration_Result_Create(&m_calibrationResultHandle);
    });
}
 
inline detail::handle_of_t<CalibrationResult> CalibrationResult::GetHandle() const
{
    return m_calibrationResultHandle;
}
 
inline detail::handle_of_t<CalibrationResult>* CalibrationResult::GetHandleAddress()
{
    return &m_calibrationResultHandle;
}
 
inline CalibrationResult::CalibrationResult(peak_icv_calibration_result_handle calibrationResultHandle)
    : m_calibrationResultHandle{ calibrationResultHandle }
{}
 
inline CalibrationResult::CalibrationResult(const CalibrationResult& other)
{
    detail::ExecuteAndMapReturnCodes([&] {
        return PEAK_ICV_C_ABI_PREFIX peak_icv_Calibration_Result_IncreaseUseCount(other.m_calibrationResultHandle);
    });
    m_calibrationResultHandle = other.m_calibrationResultHandle;
}
 
inline CalibrationResult::CalibrationResult(CalibrationResult&& other) noexcept
{
    m_calibrationResultHandle = other.m_calibrationResultHandle;
    other.m_calibrationResultHandle = nullptr;
}
 
inline CalibrationResult& CalibrationResult::operator=(const CalibrationResult& other)
{
    if (m_calibrationResultHandle != other.m_calibrationResultHandle)
    {
        if (m_calibrationResultHandle != nullptr)
        {
            detail::ExecuteAndMapReturnCodes([&] {
                return PEAK_ICV_C_ABI_PREFIX peak_icv_Calibration_Result_Destroy(m_calibrationResultHandle);
            });
        }
 
        detail::ExecuteAndMapReturnCodes([&] {
            return PEAK_ICV_C_ABI_PREFIX peak_icv_Calibration_Result_IncreaseUseCount(other.m_calibrationResultHandle);
        });
        m_calibrationResultHandle = other.m_calibrationResultHandle;
    }
 
    return *this;
}
 
inline CalibrationResult& CalibrationResult::operator=(CalibrationResult&& other) noexcept
{
    if (m_calibrationResultHandle != other.m_calibrationResultHandle)
    {
        if (m_calibrationResultHandle != nullptr)
        {
            detail::ExecuteAndMapReturnCodes([&] {
                return PEAK_ICV_C_ABI_PREFIX peak_icv_Calibration_Result_Destroy(m_calibrationResultHandle);
            });
        }
 
        m_calibrationResultHandle = other.m_calibrationResultHandle;
        other.m_calibrationResultHandle = nullptr;
    }
 
    return *this;
}
 
inline CalibrationResult::~CalibrationResult()
{
    if (m_calibrationResultHandle != nullptr)
    {
        std::ignore = PEAK_ICV_C_ABI_PREFIX peak_icv_Calibration_Result_Destroy(m_calibrationResultHandle);
    }
}
 
inline CalibrationResult::CalibrationResult(const std::string& filePath)
{
    detail::ExecuteAndMapReturnCodes([&] {
        return PEAK_ICV_C_ABI_PREFIX peak_icv_Calibration_Result_CreateFromFile(&m_calibrationResultHandle, filePath.c_str());
    });
}
 
inline double CalibrationResult::GetMeanReprojectionError() const
{
    double meanReprojectionError{};
 
    detail::ExecuteAndMapReturnCodes([&] {
        return PEAK_ICV_C_ABI_PREFIX peak_icv_Calibration_Result_GetMeanReprojectionError(
            m_calibrationResultHandle, &meanReprojectionError);
    });
    return meanReprojectionError;
}
 
inline std::vector<CalibrationView> CalibrationResult::GetViews() const
{
    size_t numViews{};
    detail::ExecuteAndMapReturnCodes([&] {
        return PEAK_ICV_C_ABI_PREFIX peak_icv_Calibration_Result_GetCalibrationViews_GetCount(m_calibrationResultHandle, &numViews);
    });
 
    if (numViews == 0)
    {
        return {};
    }
 
    std::vector<peak_icv_calibration_view_handle> viewHandles(numViews);
    detail::ExecuteAndMapReturnCodes([&] {
        return PEAK_ICV_C_ABI_PREFIX peak_icv_Calibration_View_Array_Create(viewHandles.data(), viewHandles.size());
    });
 
    try
    {
        detail::ExecuteAndMapReturnCodes([&] {
            return PEAK_ICV_C_ABI_PREFIX peak_icv_Calibration_Result_GetCalibrationViews(
                m_calibrationResultHandle, viewHandles.data(), viewHandles.size());
        });
        return peak::common::detail::BackendAccessor<CalibrationView>::CreateInstances(viewHandles);
    }
    catch (const std::exception&)
    {
        std::ignore = PEAK_ICV_C_ABI_PREFIX peak_icv_Calibration_View_Array_Destroy(viewHandles.data(), viewHandles.size());
        throw;
    }
}
 
inline CalibrationParameters CalibrationResult::GetCalibrationParameters() const
{
    peak_icv_calibration_parameters calibrationParameters{};
 
    detail::ExecuteAndMapReturnCodes([&] {
        return PEAK_ICV_C_ABI_PREFIX peak_icv_Calibration_Result_ToParameters(
            m_calibrationResultHandle, &calibrationParameters, sizeof(peak_icv_calibration_parameters));
    });
 
    return CalibrationParameters{ calibrationParameters };
}
 
inline CalibrationResult::operator CalibrationParameters() const
{
    return GetCalibrationParameters();
}
 
} /* namespace icv */
} /* namespace peak */