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:
      Cube(const Cube &other)            = delete;
      Cube &operator=(const Cube &other) = delete;
      Cube(Cube &&other)                 = default;
      Cube &operator=(Cube &&other)      = default;
      virtual ~Cube()                    = default;


      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));
        });
      }
      static std::unique_ptr<Cube> Create(int numSamples, int numLines, int numBands, DataType dataType, {…}


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


      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));
        });
      }
      static std::unique_ptr<Cube> FromImages(const std::vector<ImagePtr> &images, CubeEncoding bufferLayout) {…}


      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);
      }
      CubeType Type() const {…}


      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);
      }
      class DataType DataType() const {…}


      std::unique_ptr<Cube> Convert(CubeEncoding targetView) const
      {
        return Internal::DoResCallObjectOut<Cube>([&](void *&obj) {
          return CVB_CALL_CAPI(
              CVSCreateConvertedCube(handle_.Handle(), static_cast<CExports::CVSCubeEncoding>(targetView), obj));
        });
      }
      std::unique_ptr<Cube> Convert(CubeEncoding targetView) const {…}


      std::unique_ptr<Cube> Map(CubeRange spectralCubeoid)
      {
        bool mapTarget              = !(this->Type() == CubeType::StackedCube);
        CExports::CVSCuboid cCuboid = {0};
        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));
        });
      }
      std::unique_ptr<Cube> Map(CubeRange spectralCubeoid) {…}


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


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


      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;
      }
      bool TryLinearAccess(LinearAccessData &linearAccessOut) const noexcept {…}


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


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


      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));
        });
      }
      static std::unique_ptr<Cube> Load(Cvb::String EnviHeader, Cvb::String EnviBinary) {…}


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


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


      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)));
      }
      static std::unique_ptr<Cube> FromHandle(HandleGuard<Cube> &&guard) {…}


      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 TryBufferView(ImagePtr &bufferViewOut) const noexcept {…}


      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;
      }
      bool TryMetaData(MetaDataPtr &metaDataOut) const noexcept {…}
 
    protected:
      explicit Cube(HandleGuard<Cube> &&guard) noexcept
          : handle_(std::move(guard))
      {
      }
 
    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_;
    };
    class Cube {…};
 
  }  // namespace Spectral
 
  using Spectral::Cube;
 
  CVB_END_INLINE_NS
}  // namespace Cvb