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:



      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:
      Interpolator(HandleGuard<Interpolator>&& guard) noexcept
        : handle_(std::move(guard))
      {
      }

      Interpolator(Interpolator && other) noexcept
        : handle_(std::move(other.handle_))
      {
      }

      Interpolator & operator=(Interpolator && other) = default;
    private:

      HandleGuard<Interpolator> handle_;
    };
  }

  using Spectral::Interpolator;

  CVB_END_INLINE_NS
}