peak_icv_calibration_parameters.hpp

Go to the documentation of this file.

 
#pragma once
 
#include <peak_common/types/geometry/peak_common_size.hpp>
#include <peak_common_c/detail/peak_common_defines.h>
#include <peak_icv/algorithms/calibration/peak_icv_extrinsic_parameters.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_calibration_parameters.h>
#include <peak_icv_c/binary/peak_icv_binary_validator.h>
 
namespace peak
{
namespace icv
{
 
class CalibrationParameters
{
public:
    explicit CalibrationParameters(const std::string& filePath);
 
    CalibrationParameters(const IntrinsicParameters& intrinsicParameters, const ExtrinsicParameters& extrinsicParameters);
 
    template <class Container
        ,
        typename = std::enable_if_t<detail::is_contiguous_container<Container, uint8_t>::value>
        >
    explicit CalibrationParameters(const Container& binaryData)
        : CalibrationParameters{ CreateFromBinary(binaryData) }
    {}
 
    PEAK_COMMON_NO_DISCARD IntrinsicParameters GetIntrinsicParameters() const;
 
    PEAK_COMMON_NO_DISCARD ExtrinsicParameters GetExtrinsicParameters() const;
 
    PEAK_COMMON_NO_DISCARD std::vector<uint8_t> ToBinary() const;
 
 
private:
    friend peak::common::detail::BackendAccessor<CalibrationParameters>;
    friend class CalibrationResult;
 
    explicit CalibrationParameters(const peak_icv_calibration_parameters& calibrationParameters);
    explicit operator peak_icv_calibration_parameters() const;
    static peak_icv_calibration_parameters LoadFromFile(const std::string& filePath);
 
    IntrinsicParameters m_intrinsicParameters;
    ExtrinsicParameters m_extrinsicParameters;
 
    template <class Container, typename = std::enable_if_t<detail::is_contiguous_container<Container, uint8_t>::value>>
    static peak_icv_calibration_parameters CreateFromBinary(const Container& binaryData)
    {
        bool isValid{};
        detail::ExecuteAndMapReturnCodes([&] {
            return PEAK_ICV_C_ABI_PREFIX peak_icv_ValidateBinary(binaryData.data(), binaryData.size(), &isValid);
        });
 
        if (!isValid)
        {
            throw CorruptedException("The given binary data is invalid");
        }
 
        peak_icv_calibration_parameters calibration_parameters{};
        detail::ExecuteAndMapReturnCodes([&] {
            return PEAK_ICV_C_ABI_PREFIX peak_icv_CalibrationParameters_CreateFromBinary(
                binaryData.data(), binaryData.size(), &calibration_parameters, sizeof(peak_icv_calibration_parameters));
        });
 
        return calibration_parameters;
    }
};
 
inline CalibrationParameters::CalibrationParameters(const std::string& filePath)
    : CalibrationParameters(LoadFromFile(filePath))
{}
 
inline CalibrationParameters::CalibrationParameters(const peak_icv_calibration_parameters& calibrationParameters)
    : m_intrinsicParameters{ peak::common::detail::BackendAccessor<IntrinsicParameters>::CreateInstance(
          calibrationParameters.intrinsic_parameters) }
    , m_extrinsicParameters{ peak::common::detail::BackendAccessor<ExtrinsicParameters>::CreateInstance(
          calibrationParameters.extrinsic_parameters) }
{}
 
inline CalibrationParameters::CalibrationParameters(
    const IntrinsicParameters& intrinsicParameters, const ExtrinsicParameters& extrinsicParameters)
    : m_intrinsicParameters{ intrinsicParameters }
    , m_extrinsicParameters{ extrinsicParameters }
{}
 
inline CalibrationParameters::operator peak_icv_calibration_parameters() const
{
    return { peak::common::detail::BackendAccessor<IntrinsicParameters>::CreateCType(m_intrinsicParameters),
        peak::common::detail::BackendAccessor<ExtrinsicParameters>::CreateCType(m_extrinsicParameters) };
}
 
inline IntrinsicParameters CalibrationParameters::GetIntrinsicParameters() const
{
    return m_intrinsicParameters;
}
 
inline ExtrinsicParameters CalibrationParameters::GetExtrinsicParameters() const
{
    return m_extrinsicParameters;
}
 
inline peak_icv_calibration_parameters CalibrationParameters::LoadFromFile(const std::string& filePath)
{
    peak_icv_calibration_parameters parameters{};
 
    detail::ExecuteAndMapReturnCodes([&parameters, &filePath] {
        return PEAK_ICV_C_ABI_PREFIX peak_icv_CalibrationParameters_CreateFromFile(&parameters, sizeof(parameters), filePath.c_str());
    });
 
    return parameters;
}
 
inline std::vector<uint8_t> CalibrationParameters::ToBinary() const
{
    peak_icv_calibration_parameters parameters{ peak::common::detail::BackendAccessor<IntrinsicParameters>::CreateCType(
                                                      m_intrinsicParameters),
        peak::common::detail::BackendAccessor<ExtrinsicParameters>::CreateCType(m_extrinsicParameters) };
 
 
    size_t binarySize{};
    detail::ExecuteAndMapReturnCodes([&] {
        return PEAK_ICV_C_ABI_PREFIX peak_icv_CalibrationParameters_ToBinaryGetSizeInBytes(sizeof(parameters), &binarySize);
    });
 
    std::vector<uint8_t> binary(binarySize);
    detail::ExecuteAndMapReturnCodes([&] {
        return PEAK_ICV_C_ABI_PREFIX peak_icv_CalibrationParameters_ToBinary(parameters, sizeof(parameters), binary.data(), binarySize);
    });
 
    return binary;
}
 
} /* namespace icv */
} /* namespace peak */