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_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_defines.hpp>
#include <peak_icv_c/binary/peak_icv_binary_validator.h>
#include <peak_icv_c/binary/peak_icv_calibration_parameters_binary.h>
 
namespace peak
{
namespace icv
{
namespace experimental
{
 
class CalibrationParameters
{
public:
    explicit CalibrationParameters(const std::string& filePath);
 
    CalibrationParameters(const IntrinsicParameters& intrinsicParameters, const ExtrinsicParameters& extrinsicParameters);
 
    explicit CalibrationParameters(const peak_icv_calibration_parameters_binary& calibrationParametersBinary);
 
    PEAK_ICV_NO_DISCARD IntrinsicParameters GetIntrinsicParameters() const;
 
    PEAK_ICV_NO_DISCARD ExtrinsicParameters GetExtrinsicParameters() const;
 
    PEAK_ICV_NO_DISCARD peak_icv_calibration_parameters_binary 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_intrinsic;
    ExtrinsicParameters m_extrinsic;
};
 
inline CalibrationParameters::CalibrationParameters(const std::string& filePath)
    : CalibrationParameters(LoadFromFile(filePath))
{}
 
inline CalibrationParameters::CalibrationParameters(const peak_icv_calibration_parameters& calibrationParameters)
    : m_intrinsic{ peak::common::detail::BackendAccessor<IntrinsicParameters>::CreateInstance(
          calibrationParameters.intrinsic_parameters) }
    , m_extrinsic{ peak::common::detail::BackendAccessor<ExtrinsicParameters>::CreateInstance(
          calibrationParameters.extrinsic_parameters) }
{}
 
inline CalibrationParameters::CalibrationParameters(
    const IntrinsicParameters& intrinsicParameters, const ExtrinsicParameters& extrinsicParameters)
    : m_intrinsic{ intrinsicParameters }
    , m_extrinsic{ extrinsicParameters }
{}
 
inline CalibrationParameters::CalibrationParameters(const peak_icv_calibration_parameters_binary& calibrationParametersBinary)
    : CalibrationParameters{ calibrationParametersBinary.calibration_parameters }
{
    bool isValid{};
    detail::ExecuteAndMapReturnCodes([&] {
        return PEAK_ICV_C_ABI_PREFIX peak_icv_ValidateBinary(
            reinterpret_cast<const void*>(&calibrationParametersBinary), sizeof(calibrationParametersBinary), &isValid);
    });
 
    if (!isValid)
    {
        throw CorruptedException("The given binary data is invalid");
    }
}
 
inline CalibrationParameters::operator peak_icv_calibration_parameters() const
{
 
    return { peak::common::detail::BackendAccessor<IntrinsicParameters>::CreateCType(m_intrinsic),
        peak::common::detail::BackendAccessor<ExtrinsicParameters>::CreateCType(m_extrinsic) };
}
 
inline IntrinsicParameters CalibrationParameters::GetIntrinsicParameters() const
{
    return m_intrinsic;
}
 
inline ExtrinsicParameters CalibrationParameters::GetExtrinsicParameters() const
{
    return m_extrinsic;
}
 
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 peak_icv_calibration_parameters_binary CalibrationParameters::ToBinary() const
{
 
    peak_icv_calibration_parameters parameters{ peak::common::detail::BackendAccessor<IntrinsicParameters>::CreateCType(m_intrinsic),
        peak::common::detail::BackendAccessor<ExtrinsicParameters>::CreateCType(m_extrinsic) };
 
    peak_icv_calibration_parameters_binary binary{};
 
    detail::ExecuteAndMapReturnCodes([&] {
        return PEAK_ICV_C_ABI_PREFIX peak_icv_CalibrationParameters_ToBinary(parameters, sizeof(parameters), &binary, sizeof(binary));
    });
 
    return binary;
}
 
} /* namespace experimental */
} /* namespace icv */
} /* namespace peak */