Common Vision Blox 15.0
Loading...
Searching...
No Matches
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/driver/composite_stream.hpp>
#include <cvb/genapi/node_map_enumerator.hpp>
#include <cvb/global.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
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";
}
}
void Start() override
static std::vector< DiscoveryInformation > Discover()
static std::shared_ptr< T > Open(const String &provider, AcquisitionStack acquisitionStack=AcquisitionStack::PreferVin)
std::shared_ptr< Composite > CompositePtr