decl_laser_plane_calibrator_3d.hpp

#pragma once
 
#include "../sensor_settings.hpp"
#include "../shims/stdoptional.hpp"
#include "decl_calibrator_3d.hpp"
 
namespace Cvb
{
 
  CVB_BEGIN_INLINE_NS

  class LaserPlaneCalibrator3D : public Calibrator3D
  {
    friend class Calibrator3DFactory;
    friend class Calibrator3D;
 
  public:
    LaserPlaneCalibrator3D(HandleGuard<Calibrator3D> &&guard, Calibrator3D::ProtectedTag) noexcept
        : Calibrator3D(std::move(guard), Calibrator3D::ProtectedTag{})
        , encoderStep_(1.0)
    {
      CVB_CALL_CAPI(CVC3DCalibratorGetSettings(
          Handle(), *reinterpret_cast<CExports::CVC3DSensorSettings *>(&sensorSettings_), encoderStep_));
    }


    std::pair<Cvb::optional<AffineMatrix3D>, Cvb::optional<AffineTransformationParameters>>
    CorrectionOfLaserPlaneInclination() const
    {
      AffineMatrix3D transformation;
      AffineTransformationParameters transformationParameters;
 
      auto result = CVB_CALL_CAPI(CVC3DCalibratorGetCorrectionOfLaserPlaneInclinationParameters(
          Handle(), *reinterpret_cast<CExports::CVC3DTransformation *>(&transformation),
          *reinterpret_cast<CExports::CVC3DAffineTransformationParameters *>(&transformationParameters)));
      if (result < 0)
      {
        if (result == ErrorCodes::CVB_NOTPRESENT)
        {
          result = CVB_CALL_CAPI(CVC3DCalibratorGetCorrectionOfLaserPlaneInclination(
              Handle(), *reinterpret_cast<CExports::CVC3DTransformation *>(&transformation)));
          if (result < 0)
          {
            if (result == ErrorCodes::CVB_NOTPRESENT)
            {
              return {};
            }
            Utilities::SystemInfo::ThrowLastError(result);
          }
          return std::make_pair(transformation, Cvb::optional<AffineTransformationParameters>{});
        }
      }
 
      return std::make_pair(transformation, transformationParameters);
    }
    CorrectionOfLaserPlaneInclination() const {…}


    void
    SetCorrectionOfLaserPlaneInclination(const Cvb::optional<AffineMatrix3D> &affineTransformation,
                                         const Cvb::optional<AffineTransformationParameters> &transformationParameters)
    {
      if (transformationParameters)
      {
        Internal::DoResCall([this, at = affineTransformation.value_or(AffineMatrix3D::Identity()),
                             transformationParameters]() {
          return CVB_CALL_CAPI(CVC3DCalibratorSetCorrectionOfLaserPlaneInclinationParameters(
              Handle(), *reinterpret_cast<const CExports::CVC3DTransformation *>(&at),
              *reinterpret_cast<const CExports::CVC3DAffineTransformationParameters *>(&(*transformationParameters))));
        });
      }
      else
      {
        Internal::DoResCall([this, at = affineTransformation.value_or(AffineMatrix3D::Identity())]() {
          return CVB_CALL_CAPI(CVC3DCalibratorSetCorrectionOfLaserPlaneInclination(
              Handle(), *reinterpret_cast<const CExports::CVC3DTransformation *>(&at)));
        });
      }
    }
    SetCorrectionOfLaserPlaneInclination(const Cvb::optional<AffineMatrix3D> &affineTransformation, {…}


    Cvb::SensorSettings SensorSettings() const noexcept
    {
      return sensorSettings_;
    }
    Cvb::SensorSettings SensorSettings() const noexcept {…}


    double YFactor() const noexcept
    {
      return encoderStep_;
    }
    double YFactor() const noexcept {…}
 
  private:
    Cvb::SensorSettings sensorSettings_;
    double encoderStep_ = 0;
  };
  class LaserPlaneCalibrator3D : public Calibrator3D {…};
  CVB_END_INLINE_NS
 
}  // namespace Cvb