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));
        });
      }
 
 
 
      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::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);
      }
 
 
 
      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;
      }
 
 
 
      void* Handle() const noexcept
      {
        return handle_.Handle();
      }
 
 
 
      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)));
      }
 
 
    private:
      explicit Interpolator(HandleGuard<Interpolator>&& guard) noexcept
        : handle_(std::move(guard))
      {
      }
 
      
    private:
 
      HandleGuard<Interpolator> handle_;
    };
  }
 
  using Spectral::Interpolator;
 
  CVB_END_INLINE_NS
}