driver.hpp

#pragma once
 
#include <codecvt>
#include <locale>
#include <vector>
#include <type_traits>
#include <tuple>
 
#include "../global.hpp"
#include "../string.hpp"
#include "../genapi/genapi.hpp"
 
namespace Cvb
{
 
CVB_BEGIN_INLINE_NS
 
 
namespace Driver
{
 
class FlowSetPool;
using FlowSetPoolPtr = std::shared_ptr<FlowSetPool>;
 
class DeviceControl;
using DeviceControlPtr = std::shared_ptr<DeviceControl>;
 
class RingBuffer;
using RingBufferPtr = std::shared_ptr<RingBuffer>;
 
class DigitalIO;
using DigitalIOPtr = std::shared_ptr<DigitalIO>;
 
class SoftwareTrigger;
using SoftwareTriggerPtr = std::shared_ptr<SoftwareTrigger>;
 
class NotifyObservable;
using NotifyObservablePtr = std::shared_ptr<NotifyObservable>;
 
class ImageRect;
using ImageRectPtr = std::shared_ptr<ImageRect>;
 
class DeviceImage;
using DeviceImagePtr = std::shared_ptr<DeviceImage>;
 
class VinDevice;
using VinDevicePtr = std::shared_ptr<VinDevice>;
 
class VideoDevice;
using VideoDevicePtr = std::shared_ptr<VideoDevice>;
 
class EmuDevice;
using EmuDevicePtr = std::shared_ptr<EmuDevice>;
 
class NonStreamingDevice;
using NonStreamingDevicePtr = std::shared_ptr<NonStreamingDevice>;
 
class GenICamDevice;
using GenICamDevicePtr = std::shared_ptr<GenICamDevice>;
 
class RingBufferImage;
using RingBufferImagePtr = std::shared_ptr<RingBufferImage>;
 
class StreamImage;
using StreamImagePtr = std::shared_ptr<StreamImage>;
 
class MultiPartImage;
using MultiPartImagePtr = std::shared_ptr<MultiPartImage>;
 
class BufferImage;
using BufferImagePtr = std::shared_ptr<BufferImage>;
 
class Stream;
using StreamPtr = std::shared_ptr<Stream>;
 
class IndexedStream;
using IndexedStreamPtr = std::shared_ptr<IndexedStream>;
 
class StreamBase;
using StreamBasePtr = std::shared_ptr<StreamBase>;
 
class CompositeStreamBase;
using CompositeStreamBasePtr = std::shared_ptr<CompositeStreamBase>;
 
class ImageStream;
using ImageStreamPtr = std::shared_ptr<ImageStream>;
 
class CompositeStream;
using CompositeStreamPtr = std::shared_ptr<CompositeStream>;
 
class PointCloudStream;
using PointCloudStreamPtr = std::shared_ptr<PointCloudStream>;
 
class VideoImage;
using VideoImagePtr = std::shared_ptr<VideoImage>;
 
class EmuImage;
using EmuImagePtr = std::shared_ptr<EmuImage>;
 
class VinImage;
using VinImagePtr = std::shared_ptr<VinImage>;
 
class FlowSetPool;
using FlowSetPoolPtr = std::shared_ptr<FlowSetPool>;
 
enum class StreamType
{
  Legacy,
  Composite,
  Image,
  PointCloud
};
 
 
struct Flow
{
  size_t Size;
 
  void* Buffer;
 
  explicit Flow(size_t size = 0, void* buffer = nullptr)
    : Size(size)
    , Buffer(buffer)
  {
  }
};
 
namespace Private
{
 
template <class T>
inline StreamType StreamTypeFor() noexcept
{
  static_assert(std::is_same<T, CompositeStream>::value ||
    std::is_same<T, ImageStream>::value ||
    std::is_same<T, PointCloudStream>::value ||
    std::is_same<T, class Stream>::value, "unsupported stream type");
  return StreamType::Legacy;
}
 
template <>
inline StreamType StreamTypeFor<class Stream>() noexcept
{
  return StreamType::Legacy;
}
 
template <>
inline StreamType StreamTypeFor<CompositeStream>() noexcept
{
  return StreamType::Composite;
}
 
template <>
inline StreamType StreamTypeFor<ImageStream>() noexcept
{
  return StreamType::Image;
}
 
template <>
inline StreamType StreamTypeFor<PointCloudStream>() noexcept
{
  return StreamType::PointCloud;
}
 
}
 
enum class DiscoveryProperties
{
  InterfaceSubNetList = CExports::DO_DISCOVER_INFO_INTERFACE_NET_LIST,
  InterfaceMac = CExports::DO_DISCOVER_INFO_INTERFACE_NET_MAC,
  InterfaceTLType = CExports::DO_DISCOVER_INFO_INTERFACE_TLTYPE,
  InterfaceDisplayName = CExports::DO_DISCOVER_INFO_INTERFACE_DISPLAYNAME,
  InterfaceDriverType = CExports::DO_DISCOVER_INFO_INTERFACE_DRIVERTYPE,
  InterfaceId = CExports::DO_DISCOVER_INFO_INTERFACE_ID,
  DeviceTransportLayerType = CExports::DO_DISCOVER_INFO_DEVICE_TLTYPE,
  DeviceUsername = CExports::DO_DISCOVER_INFO_DEVICE_USERNAME,
  DeviceSerialNumber = CExports::DO_DISCOVER_INFO_DEVICE_SERIALNUMBER,
  DeviceMac = CExports::DO_DISCOVER_INFO_DEVICE_NET_MAC,
  DeviceIP = CExports::DO_DISCOVER_INFO_DEVICE_NET_IP,
  DeviceSubnetMask = CExports::DO_DISCOVER_INFO_DEVICE_NET_SUBNETMASK,
  DeviceUsbVendorId = CExports::DO_DISCOVER_INFO_DEVICE_USB_VID,
  DeviceUsbProductId = CExports::DO_DISCOVER_INFO_DEVICE_USB_PID,
  DeviceVendor = CExports::DO_DISCOVER_INFO_DEVICE_VENDOR,
  DeviceModel = CExports::DO_DISCOVER_INFO_DEVICE_MODEL,
  DeviceId = CExports::DO_DISCOVER_INFO_DEVICE_ID,
  DeviceAccessStatus = CExports::DO_DISCOVER_INFO_DEVICE_ACCESS_STATUS,
  TransportLayerId = CExports::DO_DISCOVER_INFO_TRANSPORTLAYER_ID,
  TransportLayerPath = CExports::DO_DISCOVER_INFO_TRANSPORTLAYER_PATH,
  TransportLayerVendor = CExports::DO_DISCOVER_INFO_TRANSPORTLAYER_VENDOR,
  UsbPortPath = CExports::DO_DISCOVER_INFO_DEVICE_USB_PORT_PATH
};
 
enum class AcquisitionStack 
{
  Vin,
  PreferVin,
  GenTL,
  PreferGenTL
};
 
 
enum class DiscoverFlags : std::uint64_t
{
  FindAll = 0,
  IncludeEmpty = 1,
  IncludeInaccessible = 1 << 12,
  UpToLevelSystem = 1 << 1,
  UpToLevelVin = 2 << 1,
  UpToLevelTL = 3 << 1,
  UpToLevelInterface = 4 << 1,
  UpToLevelDevice = 5 << 1,
  UpToLevelStream = 6 << 1,
  IgnoreVins = 1 << 8,
  IgnoreTLs = 1 << 9,
  IgnoreGevSD = 1 << 10,
  IgnoreGevFD = 1 << 11,
  //  Normally MockTL.cti is filtered out: this flag includes it.
  IncludeMockTL = 1 << 13
};
 
inline DiscoverFlags operator|(DiscoverFlags a, DiscoverFlags b)
{
  return static_cast<DiscoverFlags>(static_cast<std::uint64_t>(a) | static_cast<std::uint64_t>(b));
}
 
inline DiscoverFlags& operator|=(DiscoverFlags& lhs, const DiscoverFlags& rhs)
{
  lhs = static_cast<DiscoverFlags>(static_cast<std::uint64_t>(lhs) | static_cast<std::uint64_t>(rhs));
  return lhs;
}
 
enum class ModuleLayer
{
  Unknown = CExports::DO_AT_LEVEL_UNKNOWN,
  System = CExports::DO_AT_LEVEL_SYSTEM,
  Vin = CExports::DO_AT_LEVEL_VIN,
  TransportLayerSystem = CExports::DO_AT_LEVEL_TLSYSTEM,
  TransportLayerInterface = CExports::DO_AT_LEVEL_TLIFACE,
  TransportLayerDevice = CExports::DO_AT_LEVEL_TLDEVICE,
  TransportLayerStream = CExports::DO_AT_LEVEL_TLSTREAM
};
 
enum class NotifyDataType
{
  Void = CExports::CVNO_DATA_VOID,
  Int64 = CExports::CVNO_DATA_INTEGER64,
  Float64 = CExports::CVNO_DATA_FLOAT64,
  String = CExports::CVNO_DATA_STRING,
  Binary = CExports::CVNO_DATA_BINARY,
  Boolean = CExports::CVNO_DATA_BOOL8,
};
 
enum class DeviceState
{
  DeviceDisconnected = 2,
  DeviceReconnect = 3,
  DeviceImageGeometryChanged = 4,
  NewMetaData = 5
};
 
 
template <class T> struct WaitResult
{
  WaitStatus Status = WaitStatus::Ok;
  std::shared_ptr<T> Image;
};
 
enum class RingBufferLockMode
{
  Auto = CExports::RINGBUFFER_LOCKMODE_AUTO,
 
  // lockmode off removed
 
  On = CExports::RINGBUFFER_LOCKMODE_ON
};
 
enum class PlaybackMode
{
  FrameByFrame,
  Stream
};
 
enum class AcquisitionInterface
{
  Grabber,
  Grab2,
  GenTL
};
 
 
enum class StreamInfo
{
  IsCameraDetected = CExports::GRAB_INFO_CAMERA_DETECTED,
  NumBuffersAcquired = CExports::GRAB_INFO_NUMBER_IMAGES_AQCUIRED,
  NumBuffersDelivered = CExports::G2INFO_NumBuffersDelivered,
  NumBuffersLost = CExports::G2INFO_NumBuffersLost,
  NumBuffersLostTransfer = CExports::GRAB_INFO_NUMBER_IMAGES_LOST,
  NumBuffersLostLocked = CExports::GRAB_INFO_NUMBER_IMAGES_LOST_LOCKED,
  NumBuffersLocked = CExports::GRAB_INFO_NUMBER_IMAGES_LOCKED,
  NumBuffersPending = CExports::GRAB_INFO_NUMBER_IMAGES_PENDIG,
  NumBuffersCorruptOnArrival = CExports::G2INFO_NumBuffersCorrupt,
  NumBuffersCorruptOnDelivery = CExports::G2INFO_NumBuffersCorruptOnDelivery,
  NumTriggersLost = CExports::GRAB_INFO_NUMBER_TRIGGERS_LOST,
  NumBuffersAnnounced = CExports::G2INFO_NumBuffersAnnounced,
  NumBuffersQueued = CExports::G2INFO_NumBuffersQueued,
  NumBuffersBeingFilled = CExports::G2INFO_NumBuffersInIncompleteList,
  NumPacketsReceived = CExports::G2INFO_NumPacketsReceived,
  NumResends = CExports::G2INFO_NumResends
};
 
enum class DeviceControlOperation
{
  Get = CExports::DC_GET,
  Set = CExports::DC_SET,
  GetMinimum = CExports::DC_GETMIN,
  GetMaxiumum = CExports::DC_GETMAX,
  Verify = CExports::DC_VERIFY
 
};
 
enum class AcquisitionState
{
  Started,
  Stopping,
  AbortingStop,
  Stopped
};
 
namespace NodeMapID
{
  static const Cvb::String Device = Cvb::String(CVB_LIT("Device")); // NOLINT(cert-err58-cpp)
  static const Cvb::String Factory = Cvb::String(CVB_LIT("TLFactory")); // NOLINT(cert-err58-cpp)
  static const Cvb::String System = Cvb::String(CVB_LIT("TLSystem")); // NOLINT(cert-err58-cpp)
  static const Cvb::String Interface = Cvb::String(CVB_LIT("TLInterface")); // NOLINT(cert-err58-cpp)
  static const Cvb::String TLDevice = Cvb::String(CVB_LIT("TLDevice")); // NOLINT(cert-err58-cpp)
  static const Cvb::String DataStream = Cvb::String(CVB_LIT("TLDatastream")); // NOLINT(cert-err58-cpp)
  static const Cvb::String VinDevice = Cvb::String(CVB_LIT("VinDevice")); // NOLINT(cert-err58-cpp)
  static const Cvb::String VinBuffer = Cvb::String(CVB_LIT("VinBuffer")); // NOLINT(cert-err58-cpp)
}
 
template<class T>
using WaitResultTuple = std::tuple<std::shared_ptr<T>, WaitStatus, NodeMapEnumerator>;
 
}
 
using Driver::DeviceControlPtr;
using Driver::DigitalIOPtr;
using Driver::ImageRectPtr;
using Driver::NotifyObservablePtr;
using Driver::RingBufferPtr;
using Driver::SoftwareTriggerPtr;
 
using Driver::BufferImagePtr;
using Driver::DeviceImagePtr;
using Driver::EmuDevicePtr;
using Driver::IndexedStream;
using Driver::IndexedStreamPtr;
using Driver::StreamBasePtr;
using Driver::CompositeStreamBase;
using Driver::CompositeStreamBasePtr;
using Driver::CompositeStream;
using Driver::CompositeStreamPtr;
using Driver::ImageStream;
using Driver::ImageStreamPtr;
using Driver::MultiPartImage;
using Driver::MultiPartImagePtr;
using Driver::PointCloudStream;
using Driver::PointCloudStreamPtr;
using Driver::NonStreamingDevicePtr;
using Driver::GenICamDevicePtr;
using Driver::RingBufferImagePtr;
using Driver::StreamImagePtr;
using Driver::Stream;
using Driver::StreamPtr;
using Driver::VideoDevicePtr;
using Driver::VinDevicePtr;
 
using Driver::StreamType;
using Driver::AcquisitionInterface;
using Driver::DeviceControlOperation;
using Driver::AcquisitionState;
using Driver::DeviceState;
using Driver::AcquisitionStack;
using Driver::DiscoverFlags;
using Driver::DiscoveryProperties;
using Driver::EmuImagePtr;
using Driver::ModuleLayer;
using Driver::NotifyDataType;
using Driver::PlaybackMode;
using Driver::RingBufferLockMode;
using Driver::StreamInfo;
using Driver::VideoImagePtr;
using Driver::VinImage;
using Driver::VinImagePtr;
using Driver::WaitResult;
using Driver::WaitResultTuple;
using Driver::FlowSetPool;
using Driver::FlowSetPoolPtr;
using Driver::Flow;
 
namespace NodeMapID = Driver::NodeMapID;
 
CVB_END_INLINE_NS
 
}