Cvb/CppStreamConsoleWithMock

// ----------------------------------------------------------------------------
// ----------------------------------------------------------------------------
 
#include <iostream>
#include <string>
 
#include <cvb/device_factory.hpp>
#include <cvb/global.hpp>
#include <cvb/driver/image_stream.hpp>
 
static const constexpr int DELIVERABLE_COUNT = 10;  // Number of deliverables to be acquired
 
int main()
{
  try
  {
    // Retrieve CVMockTL in the given system.
    auto infoList = Cvb::DeviceFactory::Discover(Cvb::DiscoverFlags::IgnoreVins |   // Ignores all of the CVB VINs.
      Cvb::DiscoverFlags::IncludeMockTL  // Include CVMockTL.
    );
 
    // Make sure if CVMockTL is on the candidate list.
    Cvb::String accessToken;
    for (auto n = 0; (n < infoList.size()) && accessToken.empty(); ++n)
      if (infoList.at(n).AccessToken().find("MockTL") != std::string::npos)
        accessToken = infoList.at(n).AccessToken();
 
    if (accessToken.empty())
      throw std::runtime_error("Could not find CVMockTL.");
 
    // Instantiate a GenICam device from the CVMockTL.
    auto device = Cvb::DeviceFactory::Open<Cvb::GenICamDevice>(accessToken, Cvb::AcquisitionStack::GenTL);
 
    // Get the first stream of the device and start data streaming.
    auto stream = device->Stream<Cvb::ImageStream>();
    stream->Start();
 
    for (auto m = 0; m < DELIVERABLE_COUNT; ++m)
    {
      std::cout << "Acquisition #" << m <<"\t";
 
      // Wait for a single deliverable with a 10-second timeout value.
      auto waitResult = stream->WaitFor(std::chrono::seconds(10));
      if (std::get<Cvb::WaitStatus>(waitResult) == Cvb::WaitStatus::Timeout)
        throw std::runtime_error("Acquisition timeout.");
 
      // Verify the acquired deliverable contents.
      auto deliverable = std::get<Cvb::MultiPartImagePtr>(waitResult);
 
      // Retrieve the images in the deliverable.
      for (auto n = 0; n < deliverable->NumParts(); ++n)
      {
        auto item = deliverable->GetPartAt(n);
        if (Cvb::holds_alternative<Cvb::ImagePtr>(item))
        {
          auto& image = Cvb::get<Cvb::ImagePtr>(item);
          std::cout << "Image property: Part index: " << n << ", Width : " << image->Width()
            << ", Height : " << image->Height()<<", ";
        }
      }
      // Retrieve VinBuffer node map
      auto& enumerator = std::get<Cvb::NodeMapEnumerator>(waitResult);
      const auto names = enumerator.Names();
      if (std::all_of(names.begin(), names.end(), [](const Cvb::String& name) { return name != "VinBuffer"; }))
        throw std::runtime_error("The nodemap enumerator of this container does not contain a VinBuffer node map.");
      auto nodeMap = enumerator.NodeMap(CVB_LIT("VinBuffer"));
      // Incompleteness indicates a corrupt buffer
      auto isIncompleteNode = nodeMap->TryGetNode<Cvb::BooleanNode>(CVB_LIT("IsIncomplete"));
      std::cout << "IsIncomplete: " << isIncompleteNode->Value() << ", ";
      // The ID of the frame that is transported in the corresponding buffer
      auto frameIDNode = nodeMap->TryGetNode<Cvb::IntegerNode>(CVB_LIT("FrameID"));
      std::cout << "FrameID: " << frameIDNode->Value() << ", ";
      // The total number of bytes written into the buffer
      auto sizeFilledNode = nodeMap->TryGetNode<Cvb::IntegerNode>(CVB_LIT("SizeFilled"));
      std::cout << "SizeFilled: " << sizeFilledNode->Value() << ", ";
      // The width of the frame transported in the corresponding buffer
      auto widthNode = nodeMap->TryGetNode<Cvb::IntegerNode>(CVB_LIT("Width"));
      std::cout << "Width: " << widthNode->Value() << ", ";
      // The height of the frame transported in the corresponding buffer
      auto heightNode = nodeMap->TryGetNode<Cvb::IntegerNode>(CVB_LIT("Height"));
      std::cout << "Height: " << heightNode->Value() << ", ";
      // Padding in x-direction
      auto xPaddingNode = nodeMap->TryGetNode<Cvb::IntegerNode>(CVB_LIT("XPadding"));
      std::cout << "XPadding: " << xPaddingNode->Value() << ", ";
      // Padding in y-direction
      auto yPaddingNode = nodeMap->TryGetNode<Cvb::IntegerNode>(CVB_LIT("YPadding"));
      std::cout << "YPadding: " << yPaddingNode->Value() << ", ";
      // Timestamp (UINT64) the buffer was acquired
      auto timestampNode = nodeMap->TryGetNode<Cvb::IntegerNode>(CVB_LIT("Timestamp"));
      std::cout << "Timestamp: " << timestampNode->Value()<<std::endl;    
    }
    // Try aborting data streaming.
    stream->TryAbort();
  }
  catch (const std::exception& e)
  {
    std::cout << e.what() << std::endl;
  }
  return 0;
}