decl_calibrator_3d.hpp

#pragma once
 
#include <limits>
#include <memory>
#include <numeric>
 
#include "../_cexports/c_core_3d.h"
 
#include "../string.hpp"
#include "../affine_matrix_3d.hpp"
#include "../matrix_3d.hpp"
#include "../matrix_3d_h.hpp"
#include "../rect.hpp"
#include "../size_2d.hpp"
#include "../point_2d.hpp"
 
#include "../core_3d.hpp"
#include "../utilities/system_info.hpp"
#include "../shims/stdoptional.hpp"
 
#include "../_detail/detail_dyn_loader.hpp"
 
namespace Cvb
{
 
  CVB_BEGIN_INLINE_NS
 
  class Calibrator3D;
  template <>
  inline HandleGuard<Calibrator3D>::HandleGuard(void *handle) noexcept
      : HandleGuard<Calibrator3D>(handle, [](void *handle) { CVB_CALL_CAPI(ReleaseObject(handle)); })
  {
  }
 
  namespace CExports
  {
 
    typedef cvbres_t(CVB_API *FP_CVMWrite3DCalibrator)(CVC3DCALIBRATOR Calibrator, const char *FileName);
    typedef cvbres_t(CVB_API *FP_CVMWrite3DCalibratorW)(CVC3DCALIBRATOR Calibrator, const wchar_t *FileName);
 
    inline cvbres_t _ppCVMWrite3DCalibratorTyped(CVC3DCALIBRATOR Calibrator, const char *FileName)
    {
      Internal::DynLoader loader(CVB_LIT("CVMetric"));
      auto call = reinterpret_cast<FP_CVMWrite3DCalibrator>(loader.LoadSymbol(CVB_LIT("CVMWrite3DCalibrator")));
      if (!call)
        throw std::runtime_error("failed to load symbol: CVMWrite3DCalibrator");
      return call(Calibrator, FileName);
    }
 
    inline cvbres_t _ppCVMWrite3DCalibratorTyped(CVC3DCALIBRATOR Calibrator, const wchar_t *FileName)
    {
      Internal::DynLoader loader(CVB_LIT("CVMetric"));
      auto call = reinterpret_cast<FP_CVMWrite3DCalibratorW>(loader.LoadSymbol(CVB_LIT("CVMWrite3DCalibratorW")));
      if (!call)
        throw std::runtime_error("failed to load symbol: CVMWrite3DCalibratorW");
      return call(Calibrator, FileName);
    }
 
  }  // namespace CExports

  class Calibrator3D
  {
    friend class Calibrator3DFactory;
 
  protected:
    struct ProtectedTag
    {
    };
 
  public:
    using GuardType = HandleGuard<Calibrator3D>;
 
    Calibrator3D(HandleGuard<Calibrator3D> &&guard, ProtectedTag) noexcept
        : handle_(std::move(guard))
    {
    }
 
    Calibrator3D(const Calibrator3D &otehr)            = delete;
    Calibrator3D &operator=(const Calibrator3D &otehr) = delete;
    Calibrator3D(Calibrator3D &&otehr)                 = delete;
    Calibrator3D &operator=(Calibrator3D &&otehr)      = delete;
    virtual ~Calibrator3D()                            = default;


    Cvb::optional<double> RangeMapIgnoreValue() const
    {
      const auto value = Internal::DoResCallValueOut<double>([&](double &rangeMapIgnoreValue) {
        return CVB_CALL_CAPI(CVC3DCalibratorGetRangeMapIgnoreValue(handle_.Handle(), rangeMapIgnoreValue));
      });
      if (std::isnan(value))
        return {};
      else
        return value;
    }
    Cvb::optional<double> RangeMapIgnoreValue() const {…}


    template <class T>
    static std::shared_ptr<T> Load(const String &fileName);


    void SetRangeMapIgnoreValue(Cvb::optional<double> rangeMapIgnoreValue)
    {
      CVB_CALL_CAPI(CVC3DCalibratorSetRangeMapIgnoreValue(
          handle_.Handle(), rangeMapIgnoreValue.value_or(std::numeric_limits<double>::quiet_NaN())));
    }
    void SetRangeMapIgnoreValue(Cvb::optional<double> rangeMapIgnoreValue) {…}


    AffineMatrix3D ExtrinsicMatrix() const
    {
      AffineMatrix3D transformation;
      Internal::DoResCall([&]() {
        return CVB_CALL_CAPI(CVC3DCalibratorGetExtrinsicMatrix(
            Handle(), *reinterpret_cast<CExports::CVC3DTransformation *>(&transformation)));
      });
      return transformation;
    }
    AffineMatrix3D ExtrinsicMatrix() const {…}


    void SetExtrinsicMatrix(const AffineMatrix3D &transformation)
    {
      Internal::DoResCall([&]() {
        return CVB_CALL_CAPI(CVC3DCalibratorSetExtrinsicMatrix(
            Handle(), *reinterpret_cast<const CExports::CVC3DTransformation *>(&transformation)));
      });
    }
    void SetExtrinsicMatrix(const AffineMatrix3D &transformation) {…}


    void Save(const String &fileName) const
    {
      Internal::DoResCall([&]() { return CVB_CALL_CAPI(CVMWrite3DCalibratorTyped(Handle(), fileName.c_str())); });
    }
    void Save(const String &fileName) const {…}


    static Calibrator3DPtr FromHandle(HandleGuard<Calibrator3D> &&guard);
 
    template <class T>
    static Calibrator3DPtr FromHandle(HandleGuard<Calibrator3D> &&guard)
    {
      return FromHandle(std::move(guard));
    }


    void *Handle() const noexcept
    {
      return handle_.Handle();
    }
    void *Handle() const noexcept {…}
 
  private:
    enum class CalibratorType
    {
      Unknown = 0,
      Factors,
      LaserPlaneMatrixH,
      LaserPlanePolynom,
      LaserPlaneZigZag,
      LaserPlaneAT,
      MatrixH,
      Pinhole
    };
 
    static CalibratorType TypeId(void *handle)
    {
      return static_cast<CalibratorType>(Internal::DoResCallValueOut<Cvb::CExports::CVC3DCalibratorType>(
          [&](Cvb::CExports::CVC3DCalibratorType &type) {
            return CVB_CALL_CAPI(CVC3DGetCalibratorType(handle, type));
          }));
    }
 
  private:
    HandleGuard<Calibrator3D> handle_;
  };
  class Calibrator3D {…};
 
  CVB_END_INLINE_NS
 
}  // namespace Cvb