Spectral/CubeAcquisition

// ---------------------------------------------------------------------------
// ---------------------------------------------------------------------------
 
#include <iostream>
 
#include <cvb/driver/stream.hpp>
#include <cvb/device_factory.hpp>
 
#include <cvb/spectral/spectral.hpp>
#include <cvb/spectral/cube.hpp>
#include <cvb/spectral/wrapped_cube.hpp>
 
// Get Images
std::vector<Cvb::ImagePtr> GrabImageVec(Cvb::String driverPath, int numImg)
{
  std::vector<Cvb::ImagePtr> imgVec;
  imgVec.reserve(numImg);
  // open a device
  driverPath = Cvb::ExpandPath(driverPath);
  auto device = Cvb::DeviceFactory::Open(driverPath, Cvb::AcquisitionStack::Vin);
 
  auto stream = device->Stream();
  stream->RingBuffer()->ChangeCount(numImg, Cvb::DeviceUpdateMode::NewDeviceImage);
  // start the stream - start the acquisition
  stream->Start();
 
  for (int i = 0; i < numImg; ++i)
  {
    Cvb::WaitStatus res;
    Cvb::ImagePtr img = stream->WaitFor(std::chrono::seconds(10), res);
    if (res == Cvb::WaitStatus::Timeout)
      throw std::runtime_error("acquisition timeout");
    if( i % 10 == 0)
      std::cout << ".";
    imgVec.push_back(img);
  }
  // synchronously stop the stream
  stream->Stop();
  return imgVec;
}
 
 
int main()
{
  try
  {
    // Create cube from stack of images
    int numberOfImages = 100;
    Cvb::String vinDriverPath(Cvb::ExpandPath(Cvb::InstallPath() + CVB_LIT("drivers/GenICam.vin")));
    std::cout << "Start acquiring " << numberOfImages << " images from:\n\t" << vinDriverPath << std::endl;
    std::vector<Cvb::ImagePtr> imgVec = GrabImageVec(vinDriverPath, numberOfImages);
 
    auto stackedCube = Cvb::Cube::FromImages(imgVec, Cvb::Spectral::CubeEncoding::BandInterleavedByLine);
 
    // .. MetaData
    auto metaData = stackedCube->MetaData();
    int bandsOut = metaData->ReadField<int>(Cvb::Spectral::FieldID::Bands);
    // Some imaginary wavelengths
    std::vector<double> wavelengths(bandsOut);
    for (int i = 0; i < bandsOut; ++i)
      wavelengths.at(i) = 400 + i;
    metaData->WriteField<std::vector<double>>(Cvb::Spectral::FieldID::Wavelength, wavelengths);
 
    Cvb::String enviHeaderFile(Cvb::ExpandPath(CVB_LIT("StackedCube.hdr")));
    Cvb::String enviBinaryFile(Cvb::ExpandPath(CVB_LIT("StackedCube.bin")));
    stackedCube->Save(enviHeaderFile, enviBinaryFile);
    std::cout << "\nSaved Cube to file:\n\t"
      << enviHeaderFile << "\n\t"
      << enviBinaryFile << std::endl;
  }
  catch (const std::exception& error)
  {
    std::cout << error.what() << std::endl;
  }
}