cube.hpp

#pragma once

#include "meta_data.hpp"
#include "../data_type.hpp"
#include "cube_range.hpp"
#include "../_cexports/c_spectral.h"
#include "spectral.hpp"
#include "../image.hpp"
#include "linear_access_data.hpp"

namespace Cvb
{
  CVB_BEGIN_INLINE_NS

    template <>
  inline HandleGuard<Spectral::Cube>::HandleGuard(void * handle) noexcept
    : HandleGuard<Spectral::Cube>(handle, [](void* handle) { CVB_CALL_CAPI(ReleaseObject(handle)); })
  {
  }

  namespace Spectral
  {


    class Cube
    {
    public:
      virtual ~Cube() {}; //virtual destructor to make this class polymorphic! --> dynamic_cast


      static std::unique_ptr<Cube> Create(int numSamples, int numLines, int numBands,
        DataType dataType, CubeEncoding bufferLayout = CubeEncoding::BandInterleavedByLine)
      {
        return Internal::DoResCallObjectOut<Cube>([&](void* & cubeOut)
        {
          return CVB_CALL_CAPI(CVSCreateContinuousCube(numSamples, numLines, numBands,
            dataType.NativeDescriptor(), static_cast<CExports::CVSCubeEncoding>(bufferLayout),
            cubeOut));
        });
      }



      std::unique_ptr<Cube> Clone()
      {
        return Internal::DoResCallObjectOut<Cube>([&](void* & cubeOut)
        {
          return CVB_CALL_CAPI(CVSCreateDuplicatedContinuousCube(handle_.Handle(),
            cubeOut));
        });
      }



      static std::unique_ptr<Cube> FromImages(const std::vector<ImagePtr>& images, CubeEncoding bufferLayout)
      {
        std::vector<CExports::IMG> imgArr;
        for (auto pImg : images)
          imgArr.push_back(pImg->Handle());
        return Internal::DoResCallObjectOut<Cube>([&](void* & cubeOut)
        {
          return CVB_CALL_CAPI(CVSCreateStackedCube(imgArr.data(),
            imgArr.size(), static_cast<CExports::CVSCubeEncoding>(bufferLayout),
            cubeOut));
        });
      }



      CubeType Type() const
      {
        CExports::CVSCubeType cType = Internal::DoResCallValueOut<CExports::CVSCubeType>([&](CExports::CVSCubeType& val)
        {
          return CVB_CALL_CAPI(CVSCubeGetType(handle_.Handle(), val));
        });
        return static_cast<CubeType>(cType);
      }



      class DataType DataType() const
      {
        CExports::cvbdatatype_t cType =
          Internal::DoResCallValueOut<CExports::cvbdatatype_t>([&](CExports::cvbdatatype_t& val)
        {
          return CVB_CALL_CAPI(CVSCubeGetDatatype(handle_.Handle(), val));
        });
        return Cvb::DataType::FromNativeDescriptor(cType);
      }



      std::unique_ptr<Cube> Transpose(CubeEncoding targetView) const
      {
        bool mapTarget = !(this->Type() == CubeType::StackedCube);
        return Internal::DoResCallObjectOut<Cube>([&](void* & obj)
        {
          return CVB_CALL_CAPI(CVSCreateTransposedCube(handle_.Handle(),
            static_cast<CExports::CVSCubeEncoding>(targetView),
            static_cast<CExports::cvbbool_t>(mapTarget),
            obj));
        });
      }



      std::unique_ptr<Cube> Map(CubeRange spectralCubeoid)
      {
        bool mapTarget = !(this->Type() == CubeType::StackedCube);
        CExports::CVSCuboid cCuboid;
        cCuboid.Samples = { static_cast<CExports::cvbdim_t>(spectralCubeoid.Samples().Min()), static_cast<CExports::cvbdim_t>(spectralCubeoid.Samples().Max()) };
        cCuboid.Lines = { static_cast<CExports::cvbdim_t>(spectralCubeoid.Lines().Min()), static_cast<CExports::cvbdim_t>(spectralCubeoid.Lines().Max()) };
        cCuboid.Bands = { static_cast<CExports::cvbdim_t>(spectralCubeoid.Bands().Min()), static_cast<CExports::cvbdim_t>(spectralCubeoid.Bands().Max()) };
        return Internal::DoResCallObjectOut<Cube>([&](void* & obj)
        {
          return CVB_CALL_CAPI(CVSCreateCroppedCube(handle_.Handle(),
            cCuboid,
            static_cast<CExports::cvbbool_t>(mapTarget),
            obj));
        });
      }



      Cvb::ImagePtr BufferView() const
      {
        return Internal::DoResCallObjectOut<Image>([&](void* & obj)
        {
          return CVB_CALL_CAPI(CVSCubeGetBufferView(handle_.Handle(),
            obj));
        });
      }



      MetaDataPtr MetaData() const
      {
        return Internal::DoResCallObjectOut<Spectral::MetaData>([&](void* & obj)
        {
          return CVB_CALL_CAPI(CVSCubeGetMetaData(handle_.Handle(),
            obj));
        });
      }



      bool TryLinearAccess(LinearAccessData& linearAccessOut) const noexcept
      {
        void* pBase = nullptr;
        intptr_t sampleInc = 0, lineInc = 0, bandInc = 0;
        auto code = CExports::MakeErrorCode(CVB_CALL_CAPI(CVSCubeGetLinearAccess(handle_.Handle(), pBase, sampleInc, lineInc, bandInc)));
        if (code < 0)
          return false;
        linearAccessOut = Spectral::LinearAccessData(reinterpret_cast<uintptr_t>(pBase), sampleInc, lineInc, bandInc);
        return true;
      }



      LinearAccessData LinearAccess() const
      {
        LinearAccessData linAcc_;
        if (!TryLinearAccess(linAcc_))
          Utilities::SystemInfo::ThrowLastError(static_cast<CExports::cvbres_t>(CExports::CVC_E_ERROR));
        return linAcc_;
      }



      template<typename T>
      std::vector<T> SpectralDensity(int sampleIndex, int lineIndex) const
      {
        std::vector<T> tmpSpecDens;
        SpectralDensity(sampleIndex, lineIndex, tmpSpecDens);
        return tmpSpecDens;
      }


      static std::unique_ptr<Cube> Load(Cvb::String EnviHeader, Cvb::String EnviBinary)
      {
        return Internal::DoResCallObjectOut<Cube>([&](void* & cubeOut)
        {
          return CVB_CALL_CAPI(CVSLoadEnviFileTyped(
            EnviHeader.c_str(), EnviBinary.c_str(),
            cubeOut));
        });
      }


      void Save(Cvb::String EnviHeader, Cvb::String EnviBinary) const
      {
        CVB_CALL_CAPI_CHECKED(CVSWriteEnviFileTyped(
          handle_.Handle(),
          EnviHeader.c_str(), EnviBinary.c_str()));
      }


      std::unique_ptr<Cube> SwapSamplesAndLines() const
      {
        return Internal::DoResCallObjectOut<Cube>([&](void* & cubeOut)
        {
          return CVB_CALL_CAPI(CVSCubeSwapSamplesAndLines(handle_.Handle(), cubeOut));
        });
      }




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



      static std::unique_ptr<Cube> FromHandle(HandleGuard<Cube>&& guard)
      {
        if (!guard.Handle())
          throw std::runtime_error("handle must not be null");
        return std::unique_ptr<Cube>(new Cube(std::move(guard)));
      }


    protected:


      Cube(HandleGuard<Cube>&& guard) noexcept
        : handle_(std::move(guard))
      {
      }

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

      Cube & operator=(Cube && other) = default;



      bool TryBufferView(ImagePtr& bufferViewOut) const noexcept
      {
        CExports::IMG objH = nullptr;
        if (CExports::MakeErrorCode(CVB_CALL_CAPI(CVSCubeGetBufferView(handle_.Handle(), objH))) < 0)
          return false;
        bufferViewOut = Image::FromHandle(HandleGuard<Image>(objH));
        return true;
      }



      bool TryMetaData(MetaDataPtr& metaDataOut) const noexcept
      {
        CExports::CVSMETADATA objH = nullptr;
        if (CExports::MakeErrorCode(CVB_CALL_CAPI(CVSCubeGetMetaData(handle_.Handle(), objH))) < 0)
          return false;
        metaDataOut = MetaData::FromHandle(HandleGuard<Spectral::MetaData>(objH));
        return true;
      }


    private:


      void SpectralDensity(int sampleIndex, int lineIndex, std::vector<int>& specDens) const noexcept
      {
        size_t sz = 0;
        CVB_CALL_CAPI_CHECKED(CVSCubeGetSpectrumAsInteger(handle_.Handle(), sampleIndex, lineIndex,
          reinterpret_cast<CExports::cvbval_t*>(0), sz));
        std::vector<CExports::cvbval_t> tmpBuff(sz);
        CVB_CALL_CAPI_CHECKED(CVSCubeGetSpectrumAsInteger(handle_.Handle(), sampleIndex, lineIndex,
          tmpBuff.data(), sz));
        // convert int64_t to int
        std::vector<int> tmpSpecDens(sz);
        for (auto e : tmpBuff)
          tmpSpecDens.push_back(static_cast<int>(e));
        specDens = tmpSpecDens;
      }

      void SpectralDensity(int sampleIndex, int lineIndex, std::vector<double>& specDens) const noexcept
      {
        size_t sz = 0;
        CVB_CALL_CAPI_CHECKED(CVSCubeGetSpectrumAsDouble(handle_.Handle(), sampleIndex, lineIndex,
          reinterpret_cast<double*>(0), sz));
        std::vector<double> tmpBuff(sz);
        CVB_CALL_CAPI_CHECKED(CVSCubeGetSpectrumAsDouble(handle_.Handle(), sampleIndex, lineIndex,
          tmpBuff.data(), sz));
        specDens = tmpBuff;
      }

    private:

      HandleGuard<Cube> handle_;
    };

  }

  using Spectral::Cube;

  CVB_END_INLINE_NS
}