decl_metric_calibration_configuration.hpp

#pragma once
 
#include "../../_cexports/c_metric.h"
 
#include "decl_metric_aqs12_calibration_piece.hpp"
 
namespace Cvb
{
  CVB_BEGIN_INLINE_NS
 
  namespace Foundation
  {
    namespace Metric
    {
      class CalibrationConfiguration;
    }
  }  // namespace Foundation
 
  template <>
  inline HandleGuard<Foundation::Metric::CalibrationConfiguration>::HandleGuard(void *handle) noexcept
      : HandleGuard<Foundation::Metric::CalibrationConfiguration>(
            handle, [](void *handle) { CVB_CALL_CAPI(ReleaseObject(handle)); })
  {
  }
 
  namespace Foundation
  {
    namespace Metric
    {


      class CalibrationConfiguration final
      {
        struct PrivateTag
        {
        };
 
      public:

        enum class ExtrinsicCalibrationModel
        {
          None = CExports::CVMETM_None,

          AffineMatrix = CExports::CVMETM_AffineTransformation,

          SpecificTransformationParameters = CExports::CVMETM_SpecificTransformationParameters
        };
        enum class ExtrinsicCalibrationModel {…};
 
        CalibrationConfiguration(HandleGuard<CalibrationConfiguration> &&guard, PrivateTag) noexcept
            : handle_(std::move(guard))
        {
        }
 
      private:
        HandleGuard<CalibrationConfiguration> handle_;
 
      public:

        static std::unique_ptr<CalibrationConfiguration> Create(const AQS12Piece &aqs12)
        {
          auto calConfig = Internal::DoResCallObjectOut<CalibrationConfiguration>([&](void *&handle) {
            return CVB_CALL_CAPI(CVMAQS12CreateInstrinsicCalConfig(
                reinterpret_cast<const CExports::CVC3DPointD *>(aqs12.Points().data()), aqs12.TopBasePlaneDistance(),
                handle));
          });
 
          // recommended default model
          calConfig->SetExtrinsicCalibrationModel(ExtrinsicCalibrationModel::SpecificTransformationParameters);
          calConfig->SetEstimateEncoderStep(true);
          return calConfig;
        }
        static std::unique_ptr<CalibrationConfiguration> Create(const AQS12Piece &aqs12) {…}


        static std::unique_ptr<CalibrationConfiguration> CreateExtrinsic(const AQS12Piece &aqs12)
        {
          auto calConfig = Internal::DoResCallObjectOut<CalibrationConfiguration>([&](void *&handle) {
            return CVB_CALL_CAPI(
                CVMAQS12CreateExtrinsicCalConfig(reinterpret_cast<const CExports::CVC3DPointD *>(aqs12.Points().data()),
                                                 aqs12.TopBasePlaneDistance(), handle));
          });
 
          // recommended default model
          calConfig->SetExtrinsicCalibrationModel(ExtrinsicCalibrationModel::SpecificTransformationParameters);
          calConfig->SetEstimateEncoderStep(true);
          return calConfig;
        }
        static std::unique_ptr<CalibrationConfiguration> CreateExtrinsic(const AQS12Piece &aqs12) {…}


        AQS12Piece Aqs12Piece() const noexcept
        {
          CExports::CVC3DPointD points[12] = {0};  // NOLINT(cppcoreguidelines-avoid-c-arrays)
          double topBasePlaneDistance      = 0.0;
          CVB_CALL_CAPI(
              CVMAQS12CalConfigGetPointsAndTopBasePlaneDistance(handle_.Handle(), points, topBasePlaneDistance));
 
          std::array<Point3D<double>, 12> pointsAqs12;
          auto from = reinterpret_cast<const CExports::CVC3DVector *>(points);
          std::copy(from, from + 12, std::begin(pointsAqs12));
 
          return AQS12Piece(pointsAqs12, topBasePlaneDistance);
        }
        AQS12Piece Aqs12Piece() const noexcept {…}


        void SetHomographyCalculated(bool flag) noexcept
        {
          CVB_CALL_CAPI(
              CVMAQS12CalConfigSetCalculateHomography(handle_.Handle(), static_cast<CExports::cvbbool_t>(flag)));
        }
        void SetHomographyCalculated(bool flag) noexcept {…}


        bool IsHomographyCalculated() const noexcept
        {
          return Internal::DoResCallValueOut<CExports::cvbbool_t>([&](CExports::cvbbool_t &flag) {
            return CVB_CALL_CAPI(CVMAQS12CalConfigGetCalculateHomography(handle_.Handle(), flag));
          })
                     ? true
                     : false;
        }
        bool IsHomographyCalculated() const noexcept {…}


        void SetCorrectionOfLaserPlaneInclinationCalculated(bool flag) noexcept
        {
          if (flag)
          {
            SetExtrinsicCalibrationModel(ExtrinsicCalibrationModel::SpecificTransformationParameters);
            SetEstimateEncoderStep(true);
          }
          else
          {
            SetExtrinsicCalibrationModel(ExtrinsicCalibrationModel::None);
          }
        }
        void SetCorrectionOfLaserPlaneInclinationCalculated(bool flag) noexcept {…}


        bool IsCorrectionOfLaserPlaneInclinationCalculated() const noexcept
        {
          if (GetExtrinsicCalibrationModel() == ExtrinsicCalibrationModel::None)
            return false;
          else
            return true;
        }
        bool IsCorrectionOfLaserPlaneInclinationCalculated() const noexcept {…}


        void SetExtrinsicCalibrationModel(ExtrinsicCalibrationModel model) noexcept
        {
          Internal::DoResCall([&]() {
            return CVB_CALL_CAPI(CVMAQS12CalConfigSetExtrinsicTransformationModel(
                handle_.Handle(), static_cast<CExports::CVMExtrinsicTransformationModel>(model)));
          });
        }
        void SetExtrinsicCalibrationModel(ExtrinsicCalibrationModel model) noexcept {…}


        ExtrinsicCalibrationModel GetExtrinsicCalibrationModel() const noexcept
        {
          CExports::CVMExtrinsicTransformationModel model = CExports::CVMETM_None;
          Internal::DoResCall([&]() {
            return CVB_CALL_CAPI(CVMAQS12CalConfigGetExtrinsicTransformationModel(handle_.Handle(), model));
          });
 
          return static_cast<ExtrinsicCalibrationModel>(model);
        }
        ExtrinsicCalibrationModel GetExtrinsicCalibrationModel() const noexcept {…}


        void SetEstimateEncoderStep(bool flag)
        {
          Internal::DoResCall([&]() {
            return CVB_CALL_CAPI(
                CVMAQS12CalConfigSetCalculateEncoderStep(handle_.Handle(), static_cast<CExports::cvbbool_t>(flag)));
          });
        }
        void SetEstimateEncoderStep(bool flag) {…}


        bool IsEncoderStepEstimated() const noexcept
        {
          CExports::cvbbool_t flag = static_cast<CExports::cvbbool_t>(true);
          Internal::DoResCall(
              [&]() { return CVB_CALL_CAPI(CVMAQS12CalConfigGetCalculateEncoderStep(handle_.Handle(), flag)); });
 
          return static_cast<bool>(flag);
        }
        bool IsEncoderStepEstimated() const noexcept {…}


        static std::unique_ptr<CalibrationConfiguration> FromHandle(HandleGuard<CalibrationConfiguration> &&guard)
        {
          if (!guard.Handle())
            throw std::runtime_error("handle must not be null");
 
          return std::make_unique<CalibrationConfiguration>(std::move(guard), PrivateTag{});
        }
        static std::unique_ptr<CalibrationConfiguration> FromHandle(HandleGuard<CalibrationConfiguration> &&guard) {…}


        void *Handle() const noexcept
        {
          return handle_.Handle();
        }
        void *Handle() const noexcept {…}
 
        CalibrationConfiguration(const CalibrationConfiguration &other)                = delete;
        CalibrationConfiguration &operator=(const CalibrationConfiguration &other)     = delete;
        CalibrationConfiguration(CalibrationConfiguration &&other) noexcept            = default;
        CalibrationConfiguration &operator=(CalibrationConfiguration &&other) noexcept = default;
        ~CalibrationConfiguration()                                                    = default;
      };
      class CalibrationConfiguration final {…};
 
    }  // namespace Metric
    using namespace Metric;
  }  // namespace Foundation
 
  CVB_END_INLINE_NS
}  // namespace Cvb