interpolator.hpp

#pragma once
 
#include "../_cexports/c_spectral.h"
#include "spectral.hpp"
#include "cube.hpp"
 
namespace Cvb
{
  CVB_BEGIN_INLINE_NS
 
  template <>
  inline HandleGuard<Spectral::Interpolator>::HandleGuard(void *handle) noexcept
      : HandleGuard<Spectral::Interpolator>(handle, [](void *handle) { CVB_CALL_CAPI(ReleaseObject(handle)); })
  {
  }
 
  namespace Spectral
  {

    class Interpolator final
    {
    public:
      Interpolator(const Interpolator &other) noexcept            = delete;
      Interpolator &operator=(const Interpolator &other) noexcept = delete;
      Interpolator(Interpolator &&other) noexcept                 = default;
      Interpolator &operator=(Interpolator &&other) noexcept      = default;
      ~Interpolator()                                             = default;


      static std::unique_ptr<Interpolator> Create(const Cube &cube, StdObserver stdObserver,
                                                  StdIlluminant stdIlluminant, InterpolationMethod interpolationMethod)
      {
        return Internal::DoResCallObjectOut<Interpolator>([&](void *&obj) {
          return CVB_CALL_CAPI(CVSCreateInterpolator(cube.Handle(), static_cast<CExports::CVSStdObserver>(stdObserver),
                                                     static_cast<CExports::CVSStdIlluminant>(stdIlluminant),
                                                     static_cast<CExports::CVSInterpolationMethod>(interpolationMethod),
                                                     obj));
        });
      }
      static std::unique_ptr<Interpolator> Create(const Cube &cube, StdObserver stdObserver, {…}


      Spectral::StdObserver StdObserver() const
      {
        auto cVal = Internal::DoResCallValueOut<CExports::CVSStdObserver>([&](CExports::CVSStdObserver val) {
          return CVB_CALL_CAPI(CVSInterpolatorGetObserver(this->Handle(), val));
        });
        return static_cast<Spectral::StdObserver>(cVal);
      }
      Spectral::StdObserver StdObserver() const {…}


      Spectral::StdIlluminant StdIlluminant() const
      {
        auto cVal = Internal::DoResCallValueOut<CExports::CVSStdIlluminant>([&](CExports::CVSStdIlluminant val) {
          return CVB_CALL_CAPI(CVSInterpolatorGetIlluminant(this->Handle(), val));
        });
        return static_cast<Spectral::StdIlluminant>(cVal);
      }
      Spectral::StdIlluminant StdIlluminant() const {…}


      std::vector<double> Wavelengths() const
      {
        size_t sz = 0;
        CVB_CALL_CAPI_CHECKED(CVSInterpolatorGetWavelengths(this->Handle(), reinterpret_cast<double *>(NULL), sz));
        std::vector<double> waves(sz);
        CVB_CALL_CAPI_CHECKED(CVSInterpolatorGetWavelengths(this->Handle(), waves.data(), sz));
        return waves;
      }
      std::vector<double> Wavelengths() const {…}


      void *Handle() const noexcept
      {
        return handle_.Handle();
      }
      void *Handle() const noexcept {…}


      static std::unique_ptr<Interpolator> FromHandle(HandleGuard<Interpolator> &&guard)
      {
        if (!guard.Handle())
          throw std::runtime_error("handle must not be null");
        return std::unique_ptr<Interpolator>(new Interpolator(std::move(guard)));
      }
      static std::unique_ptr<Interpolator> FromHandle(HandleGuard<Interpolator> &&guard) {…}
 
    private:
      explicit Interpolator(HandleGuard<Interpolator> &&guard) noexcept
          : handle_(std::move(guard))
      {
      }
 
    private:
      HandleGuard<Interpolator> handle_;
    };
    class Interpolator final {…};
  }  // namespace Spectral
 
  using Spectral::Interpolator;
 
  CVB_END_INLINE_NS
}  // namespace Cvb