Image Manager/Cvb++/CppMultiPartComposite

This example program is located in your CVB installation under %CVB%Tutorial/Image Manager/Cvb++/CppMultiPartComposite.

main.cpp:

// This MultiPart tutorial demonstrates an image acquisition where the received composite contains a
// Bayer image and a converted RGB8 image.
// ----------------------------------------------------------------------------
// ----------------------------------------------------------------------------
 
#include <iostream>
#include <string>
#include <vector>
 
#include <cvb/device_factory.hpp>
#include <cvb/global.hpp>
#include <cvb/driver/composite_stream.hpp>
#include <cvb/genapi/node_map_enumerator.hpp>
 
static const constexpr auto TIMEOUT = std::chrono::milliseconds(3000);
static const constexpr int NUM_ELEMENTS_TO_ACQUIRE = 10;
 
void PrintOutCompositePurpose(Cvb::CompositePtr composite);
void AnalyseCompositeAt(Cvb::CompositePtr composite, int index);
 
static std::map<Cvb::WaitStatus, const char*>
WAIT_ERROR_STATES
{
  {Cvb::WaitStatus::Timeout, "timeout"},
  {Cvb::WaitStatus::Abort, "abort"}
};
 
int main()
{
  try
  {
    // discover transport layers
    auto infoList = Cvb::DeviceFactory::Discover(Cvb::DiscoverFlags::IgnoreVins);
 
    // can't continue the demo if there's no available device
    if (infoList.empty())
      throw std::runtime_error("There is no available device for this demonstration.");
 
    // instantiate the first device in the discovered list
    auto device = Cvb::DeviceFactory::Open<Cvb::GenICamDevice>(infoList[0].AccessToken(), Cvb::AcquisitionStack::GenTL);
 
    // access the first data stream that belongs to the device and start
    auto dataStream = device->Stream<Cvb::CompositeStream>();
    dataStream->Start();
 
    // acquire data
    for (auto i = 0; i < NUM_ELEMENTS_TO_ACQUIRE; i++)
    {
      auto [composite, waitStatus, enumerator] = dataStream->WaitFor(TIMEOUT);
 
      switch (waitStatus)
      {
        default:
        {
          std::cout << "wait status unknown.\n";
          continue;
        }
        case Cvb::WaitStatus::Abort:
        case Cvb::WaitStatus::Timeout:
        {
          std::cout << "wait status not ok: " << WAIT_ERROR_STATES[waitStatus] << "\n";
          continue;
        }
        case Cvb::WaitStatus::Ok:
          break;
      }
 
      PrintOutCompositePurpose(composite);
      AnalyseCompositeAt(composite, i);
 
    }
 
    dataStream->Stop();
  }
  catch (const std::exception& e)
  {
    std::cout << e.what() << std::endl;
  }
  return 0;
}

void PrintOutCompositePurpose(Cvb::CompositePtr composite)
{
  auto purpose = composite->Purpose();
  std::cout << "Composite purpose: ";
  switch (purpose)
  {
    case Cvb::CompositePurpose::Custom: std::cout << "Custom\n"; break;
    case Cvb::CompositePurpose::Image: std::cout << "Image\n"; break;
    case Cvb::CompositePurpose::ImageList: std::cout << "Image List\n"; break;
    case Cvb::CompositePurpose::MultiAoi: std::cout << "MultiAoi\n"; break;
    case Cvb::CompositePurpose::RangeMap: std::cout << "RangeMap\n"; break;
    case Cvb::CompositePurpose::PointCloud: std::cout << "PointCloud\n"; break;
    case Cvb::CompositePurpose::ImageCube: std::cout << "ImageCube\n"; break;
    default: std::cout << "Unknown\n"; break;
  }
}

void AnalyseCompositeAt(Cvb::CompositePtr composite, int index)
{
  auto numberOfElements = composite->ItemCount();
  if (numberOfElements < 2)
  {
    std::cout << "Number of elements in composite #"<< index << " is less than expected (no multipart)\n";
    return;
  }
 
  std::cout << "Multipart data with " << numberOfElements << " elements\n";
 
  for (auto j = 0; j < numberOfElements; j++)
  {
    auto element = composite->ItemAt(j);
    if (Cvb::holds_alternative<Cvb::ImagePtr>(element))
    {
      auto image = Cvb::get<Cvb::ImagePtr>(element);
      auto linearAccess = image->Plane(0).LinearAccess();
      std::cout << "acquired image: " << index << " at memory location: "  << reinterpret_cast<intptr_t>(linearAccess.BasePtr()) << "\n";
    }
    else
      std::cout << "Element " << j << " in composite " << index << " is not an image" << "\n";
  }
}