VmbNET C# API Function Reference

Main Interfaces

IVmbSystem

interface VmbNET.IVmbSystem : IDisposable

Interface for accessing the entirety of VmbC.

This interface provides access to all system features, connected cameras, interfaces and transport layers. The singleton pattern is used so that a maximum of one instance can exist during runtime. When used via the disposable pattern, the system will be shut down when IDisposable.Dispose() has been called on all references to the singleton instance.

Public Functions

ITransportLayer GetTransportLayerByID (string id)

Get a transport layer by its ID.

Param id:

The ID of the desired transport layer.

Return:

The transport layer corresponding to the ID.

IInterface GetInterfaceByID (string id)

Get an interface by its ID.

Param id:

The ID of the desired interface.

Return:

The interface corresponding to the ID.

ICamera GetCameraByID (string id)

Get a camera by its ID or extended ID.

Param id:

The ID or extended ID of the desired camera.

Return:

The camera corresponding to the ID or extended ID.

IOpenCamera OpenCameraByID (string id)

Open and get a camera by its ID or extended ID.

Param id:

The ID or extended ID of the desired camera.

Return:

The open camera corresponding to the ID or extended ID.

IReadOnlyList<ITransportLayer> GetTransportLayers ()

Method for getting the transport layers found by VmbC.

This list will not change while the IVmbSystem instance is not disposed.

<![CDATA[
    var transportLayers = vmbSystem.GetTransportLayers();
    foreach(var transportLayer in transportLayers)
    {
        Console.WriteLine($"transport layer ID: {transportLayer.Id}, transport layer name: {transportLayer.Name}");
    }
]]>

Return:

The found transport layers.

IReadOnlyList<IInterface> GetInterfaces ()

Method for getting the interfaces found by VmbC.

The list’s contents can change between calls.

<![CDATA[
    var ifaces = vmbSystem.GetInterfaces();
    foreach(var iface in ifaces)
    {
        Console.WriteLine($"interface ID: {iface.Id}, interface name: {iface.Name}");
    }
]]>

Return:

The found interfaces.

IReadOnlyList<ICamera> GetCameras ()

Method for getting the cameras found by VmbC.

This list can change between calls.

<![CDATA[
    var cameras = vmbSystem.GetCameras();
    foreach(var camera in cameras)
    {
        Console.WriteLine($"camera ID: {camera.Id}, camera name: {camera.Name}");
    }
]]>

Return:

The found cameras.

void RemoveAllInterfaceListEventHandlers ()

Remove all event handlers registered to the event InterfaceListChanged.

void RemoveAllCameraListEventHandlers ()

Remove all event handlers registered to the event CameraListChanged.

void Shutdown ()

Convenience method for shutting down VmbC in case the disposable pattern is not desired.

If called within a callback, VmbC will not be shut down. Once called, the next call to IVmbSystem.Startup() will initialize a new singleton and will start up VmbC. Using this method is discouraged in favor of the disposable pattern.

Properties

string > ConfigurationPaths { get; set; }

Get and set the list of paths and directories in which the system should search for transport layers on VmbC start up.

Paths of the .cti files and configuration .xml files can also be added. If empty or null, the paths specified in the configuration XML are considered. If there are none, the directories in GENICAM_GENTL64_PATH are searched as well as the directory containing the VmbC library. If set after a IVmbSystem instance is created it will be ignored until the next creation.

<![CDATA[
    IVmbSystem.ConfigurationPaths = new List<string> { "some-path", "some-directory" };
    IVmbSystem.ConfigurationPaths.Add("some-other-path-or-directory");
]]>

Return:

A list of directories and paths.

ILogger Logger { get; set; }

Get and set the system logger as an instance of Microsoft.Extensions.Logging.ILogger.

If not set by the application, no logging will be performed.

<![CDATA[
    // requires Serilog and Microsoft.Extensions.Logging
    Log.Logger = new LoggerConfiguration()
                .MinimumLevel.Debug()
                .Enrich.FromLogContext()
                .WriteTo.Console(outputTemplate: "[{Timestamp:HH:mm:ss} {Level:u3}] {Message} (at {Caller}){NewLine}{Exception}")
                .WriteTo.File("log.txt")
                .CreateLogger();
    ILoggerFactory factory = (new LoggerFactory()).AddSerilog(Log.Logger);
    var logger = factory.CreateLogger("ConsoleApp");
    IVmbSystem.Logger = logger;
]]>

Return:

A reference to the current logger.

Events

event EventHandler<InterfaceListEventArgs> InterfaceListChanged

Event for receiving updates to the interface list.

All registered event handlers can be removed by calling RemoveAllInterfaceListEventHandlers().

event EventHandler<CameraListEventArgs> CameraListChanged

Event for receiving updates to the camera list.

All registered event handlers can be removed by calling RemoveAllCameraListEventHandlers().

Public Static Functions

IVmbSystem Startup ()

Method for getting the singleton instance to access VmbC. VmbC is started up if the instance does not exist or is disposed.

<![CDATA[
    {
        using IVmbSystem vmbSystem = IVmbSystem.Startup(); // starts VmbC up
    } // VmbC is shut down when leaving the current scope
]]>

Return:

An instance for controlling VmbC.

Public Static Attributes

string VmbCVersion = > VmbSystem.VmbCVersion

The VmbC version.

Return:

The version as a string.

ITransportLayer

interface VmbNET.ITransportLayer : VmbNET.IPersistableFeatureContainer

Interface for accessing a transport layer.

Public Functions

IReadOnlyList<IInterface> GetInterfaces ()

Method for getting the interfaces related to this transport layer.

Return:

The interfaces related to this transport layer.

IReadOnlyList<ICamera> GetCameras ()

Method for getting the cameras related to this transport layer.

Return:

The cameras related to this transport layer.

Properties

string Id { get; set; }

The transport layer’s unique ID.

string Name { get; set; }

The transport layer’s name.

string ModelName { get; set; }

The transport layer’s model name.

string Vendor { get; set; }

The transport layer’s vendor.

string Version { get; set; }

The transport layer’s version.

string Path { get; set; }

The full path of the transport layer.

TransportLayerType Type { get; set; }

The transport layer’s type.

IInterface

interface VmbNET.IInterface : VmbNET.IPersistableFeatureContainer

Interface for accessing a general camera interface.

Public Functions

IReadOnlyList<ICamera> GetCameras ()

Method for getting all cameras related to this interface.

Return:

A list of all cameras related to this interface.

Properties

string Id { get; set; }

The interface’s identifier.

string Name { get; set; }

The interface’s name.

ITransportLayer TransportLayer { get; set; }

The related transport layer.

TransportLayerType Type { get; set; }

The interface technology.

ICameraInfo

interface VmbNET.ICameraInfo

Interface for accessing read-only metadata about a camera.

The camera can be open or closed.

Subclassed by VmbNET.ICamera, VmbNET.IOpenCamera

Public Types

enum AccessModeValue

Access mode for cameras.

Values:

None

No access.

Full

Read and write access.

Read

Read-only access.

Unknown

Access type unknown.

Exclusive

Read and write access without permitting access for other consumers.

Properties

string Id { get; set; }

The camera’s identifier.

string IdExtended { get; set; }

The camera’s globally unique identifier.

string Name { get; set; }

The camera’s display name.

string ModelName { get; set; }

The camera’s model name.

string Serial { get; set; }

The camera’s serial number.

AccessModeValue > AccessModes { get; set; }

The camera’s permitted access modes.

ITransportLayer TransportLayer { get; set; }

The camera’s related transport layer.

IInterface Interface { get; set; }

The camera’s related interface.

ICamera

interface VmbNET.ICamera : VmbNET.ICameraInfo

Interface for accessing a camera.

As well as providing the camera’s read-only metadata, this interface is used to open the camera and get the corresponding open camera instance.

Public Functions

IOpenCamera Open ()

Method for getting an instance of an open camera. If the camera isn’t already opened, it will be opened with read and write access, i.e. calling this method is equivalent to calling Open(AccessModeValue.Full)

Return:

An instance of an open camera.

IOpenCamera Open (AccessModeValue accessMode)

Method for getting an instance of an open camera. The camera will be opened if it isn’t already.

Param accessMode:

The access mode for opening the camera if the camera is not already opened. Only required for access modes other than full.

Return:

An instance of an open camera.

IOpenCamera

interface VmbNET.IOpenCamera : VmbNET.ICameraInfo, VmbNET.IPersistableFeatureContainer, VmbNET.ICapturingModule, IDisposable

Interface for accessing an open camera.

When used via the disposable pattern, the camera will be closed when IDisposable.Dispose() has been called on all instances of the camera.

Public Functions

List<byte> ReadMemory (UInt64 address, UInt32 byteCount)

Method for reading a list of bytes from an address in a camera’s memory.

Param address:

The address in the camera’s memory to read from.

Param byteCount:

The number of bytes to read.

Return:

The bytes that were read. The number of bytes returned may be less than byteCount .

UInt32 WriteMemory (UInt64 address, IReadOnlyList<byte> bytes)

Method for writing a list of bytes to an address in a camera’s memory.

Param address:

The address in the camera’s memory to write to.

Param bytes:

The bytes to write to the address.

Return:

The number of bytes that were actually written. This may be less than bytes.Count .

IStream OpenStream (UInt32 index)

Open a stream for acquisition.

Param index:

The index of the stream. Must be less than StreamCount.

Return:

An open stream as an instance of IStream.

IFrame AcquireSingleImage (AllocationModeValue allocationMode, TimeSpan timeout)

Convenience method for acquiring a single image synchronously.

Calling this method while a stream is opened via OpenStream is not supported. Assumes the camera has the GenICam Standard Features Naming Convention conforming command features “AcquisitionStart” and “AcquisitionStop” for starting and stopping the acquisition. The frame’s unmanaged data is deallocated when the corresponding instance of IFrame is disposed.

Param allocationMode:

Whether the VmbNET API or the transport layer should allocate the frame buffer.

Param timeout:

The maximum time to wait for a frame, regardless of whether a frame was filled.

Throws VmbTimeoutException:

Thrown if a timeout occurs.

Return:

A single frame.

IFrame AcquireSingleImage (TimeSpan timeout)

Convenience method for acquiring a single image synchronously.

This is a special case of AcquireSingleImage(AllocationModeValue, TimeSpan) in which allocationMode is set to ICapturingModule.AllocationModeValue.AnnounceFrame.

Return:

A single frame.

IFrameList AcquireMultipleImages (UInt32 frameCount, AllocationModeValue allocationMode, TimeSpan timeout)

Convenience method for acquiring multiple images synchronously.

Calling this method while a stream is opened via OpenStream is not supported. Assumes the camera has the GenICam Standard Features Naming Convention conforming command features “AcquisitionStart” and “AcquisitionStop” for starting and stopping the acquisition. Each frame’s unmanaged data is deallocated when the corresponding instance of IFrame is disposed.

Param frameCount:

The number of frames to fill.

Param allocationMode:

Whether the VmbNET API or the transport layer should allocate the frame buffers.

Param timeout:

The maximum time to wait for each frame, regardless of whether a frame was filled.

Throws VmbTimeoutException:

Thrown if a timeout occurs.

Return:

The filled frames. May be less than the number of frames requested if a timeout occurred.

IFrameList AcquireMultipleImages (UInt32 frameCount, TimeSpan timeout)

Convenience method for acquiring multiple images synchronously.

This is a special case of AcquireMultipleImages(UInt32, AllocationModeValue, TimeSpan) in which allocationMode is set to ICapturingModule.AllocationModeValue.AnnounceFrame.

Return:

The filled frames. May be less than the number of frames requested if a timeout occurred.

IAcquisition StartFrameAcquisition (AllocationModeValue allocationMode, UInt32 bufferCount)

Convenience method for acquiring and capturing frames asynchronously.

Event handlers registered on ICapturingModule.FrameReceived will receive frames when they are filled. Calling this method while a stream is opened via OpenStream is not supported. Assumes the camera has the GenICam Standard Features Naming Convention conforming command features “AcquisitionStart” and “AcquisitionStop” for starting and stopping the acquisition.

Param allocationMode:

Whether the VmbNET API or the transport layer should allocate the frame buffers.

Param bufferCount:

The number of frame buffers to use.

Return:

An instance for controlling the acquisition and capturing.

IAcquisition StartFrameAcquisition ()

Convenience method for acquiring and capturing frames asynchronously.

This is a special case of StartFrameAcquisition(AllocationModeValue, UInt32) in which allocationMode is set to ICapturingModule.AllocationModeValue.AnnounceFrame and bufferCount is set to 5.

Return:

An instance for controlling the acquisition and capturing.

void Close ()

Convenience method for closing an open camera in case the disposable pattern is not desired.

Once called, the next call to one of the ICamera.Open() methods will open the camera. Using this method is discouraged in favor of the disposable pattern.

Properties

ILocalDevice LocalDevice { get; set; }

The camera’s local device.

UInt32 StreamCount { get; set; }

The total number of available streams.

IStream Stream { get; set; }

Convenience property for accessing the camera’s main stream.

This property represents the first stream of the camera which is always implicitly opened.

Return:

The first stream.

ILocalDevice

VmbNET::ILocalDevice

Interface for accessing a local device.

IStream

interface VmbNET.IStream : VmbNET.IPersistableFeatureContainer, VmbNET.ICapturingModule, IDisposable

Interface for accessing an open stream.

When used via the disposable pattern, the stream will be closed when IDisposable.Dispose() has been called on all instances of the stream.

Public Functions

void Close ()

Convenience method for closing a stream in case the disposable pattern is not desired.

Once called, the next call to IOpenCamera.OpenStream(UInt32) with the same index will open the stream. Using this method is discouraged in favor of the disposable pattern.

IPersistableFeatureContainer

interface VmbNET.IPersistableFeatureContainer : VmbNET.IFeatureContainer

Interface for loading, saving and accessing features of a module.

Subclassed by VmbNET.IInterface, VmbNET.IOpenCamera, VmbNET.IStream, VmbNET.ITransportLayer

Public Functions

void LoadSettings (string xmlFilePath, FeaturePersistSettings featurePersistSettings)

Load a module’s settings (features’ states) from an XML file, controlling how the settings are loaded.

If an error occurs, some settings may have been set to those in the XML file.

Param xmlFilePath:

The absolute path, or path relative to the current working directory, to load the settings from.

Param featurePersistSettings:

Information controlling how the settings are loaded.

void LoadSettings (string xmlFilePath)

Load a module’s settings (features’ states) from an XML file.

The default values in FeaturePersistSettings are used to control how the settings are loaded: All settings will be loaded except LUT. A maximum of 5 iterations is performed. Only errors are logged. If an error occurs, some settings may have been set to those in the XML file.

Param xmlFilePath:

The absolute path, or path relative to the current working directory, to load the settings from.

void SaveSettings (string xmlFilePath, FeaturePersistSettings featurePersistSettings)

Save a module’s settings (features’ states) to an XML file, controlling how the settings are saved.

Param xmlFilePath:

The absolute path, or path relative to the current working directory, to save the settings to.

Param featurePersistSettings:

Information controlling how the settings are saved.

void SaveSettings (string xmlFilePath)

Save a module’s settings (features’ states) to an XML file.

The default values in FeaturePersistSettings are used to control how the settings are saved:

• All settings will be saved except LUT.

• A maximum of 5 iterations is performed.

• Only errors are logged.

Param xmlFilePath:

The absolute path, or path relative to the current working directory, to save the settings to.

IFeatureContainer

interface VmbNET.IFeatureContainer

Interface for accessing features of a module or chunk data.

Subclassed by VmbNET.IPersistableFeatureContainer

Properties

dynamic Features { get; set; }

Property containing all features of a module.

Exists as a dynamic type which, depending on the context, behaves like an instance of a class in which the module’s or chunk data’s features are exposed as dynamic properties each of whose underlying type is that of the feature itself (e.g. see “IFloatFeature”). This property can also be treated as an enumerable whose enumerator returns each dynamic feature.

<![CDATA[
    // Display and change a camera's exposure time, treating the exposure time feature as a dynamic type.
    try
    {
        Console.WriteLine($"Changing camera's ExposureTime from {openCamera.Features.ExposureTime} to 3000.0");
        openCamera.Features.ExposureTime = 3000.0;
    }
    catch(VmbNETException ex)
    {
        Console.WriteLine($"""Caught exception of type VmbNETException with message "{ex.Message}"""");
    }

    // Display and change a camera's exposure time, treating the exposure time feature as a static type.
    try
    {
        IFloatFeature exposureTimeFeature = openCamera.Features.ExposureTime;
        Console.WriteLine($"Changing camera's ExposureTime from {exposureTimeFeature.Value} to 4000.0");
        exposureTimeFeature.Value = 4000.0;
    }
    catch(VmbNETException ex)
    {
        Console.WriteLine($"""Caught exception of type VmbNETException with message "{ex.Message}"""");
    }

    // List all of a camera's features and also change its exposure time, treating the exposure time feature as a static type.
    foreach (var dynamicFeature in openCamera.Features)
    {
        IFeature feature = dynamicFeature;
        Console.WriteLine($"Camera has feature {feature.Name}");
        if (feature.FeatureDataType == VmbFeatureData.Float &&
            feature.FeatureFlags == VmbFeatureFlags.FlagsWrite &&
            feature.Name == "ExposureTime")
        {
            IFloatFeature exposureTimeFeature = dynamicFeature;
            Console.WriteLine($"Changing camera's ExposureTime from {exposureTimeFeature.Value} to 5000.0");
            exposureTime.Value = 5000.0;
        }
    }
]]>

Acquisition Interfaces

IStreamCapture

interface VmbNET.IStreamCapture : IDisposable

Interface for capturing.

Public Functions

IFrame WaitForFrame (TimeSpan timeout)

Block until a frame is received synchronously or the specified timeout occurs, whichever happens first.

A buffer to contain the received frame’s data is implicitly queued.

Param timeout:

The time after at least which this method shall return, regardless of whether a frame arrived.

Throws VmbTimeoutException:

Thrown if a timeout occurs.

Return:

The received frame.

void TearDown ()

Convenience method for tearing down the capturing in case the disposable pattern is not desired.

Once called, the next call to ICapturingModule.PrepareCapture(ICapturingModule.AllocationModeValue, UInt32) or ICapturingModule.PrepareCapture(IFrameBufferPool) will prepare the capturing. Using this method is discouraged in favor of the disposable pattern.

IAcquisition

interface VmbNET.IAcquisition : IDisposable

Interface for acquiring and capturing frames asynchronously.

Returned by IOpenCamera.StartFrameAcquisition(). When used via the disposable pattern, the acquisition and capturing will be stopped when IDisposable.Dispose() has been called on all instances.

Public Functions

void Stop ()

Convenience method for stopping the acquisition and capturing. Using this method is discouraged in favor of the disposable pattern.

ICapturingModule

interface VmbNET.ICapturingModule

Interface for capturing frames from a module.

Subclassed by VmbNET.IOpenCamera, VmbNET.IStream

Public Types

enum AllocationModeValue

Specify whether the VmbNET API or the transport layer should allocate the frame data.

Values:

AnnounceFrame

The API should allocate the frame data

AllocAndAnnounceFrame

The transport layer should allocate the frame data

Public Functions

IStreamCapture PrepareCapture (AllocationModeValue allocationMode, UInt32 bufferCount)

Prepare VmbC for capturing from the module.

Any event handlers that are registered on the ICapturingModule.FrameReceived event will receive frames that VmbC has received from the camera. Event handlers can be registered before or after this method is called. If is set to AllocationModeValue.AnnounceFrame, frame buffers are allocated internally by VmbNET, i.e., internally, the default implementation of IFrameBufferPool, FrameBufferPool, is used. The returned IStreamCapture instance can be used for either synchronous acquisition or asynchronous acquisition, but not both. Any event handlers for asynchronous acquisition that are registered on the ICapturingModule.FrameReceived event will receive frames that VmbC has received from the camera. Event handlers can be registered before or after this method is called.

Param allocationMode:

Whether the VmbNET API (AllocationModeValue.AnnounceFrame) or the transport layer (AllocationModeValue.AllocAndAnnounceFrame) should allocate the frame data.

Param bufferCount:

The number of frame buffers to use.

Return:

An instance for controlling the capturing.

IStreamCapture PrepareCapture ()

Prepare VmbC for capturing from the module with default settings.

This is a special case of PrepareCapture(AllocationModeValue, UInt32) in which allocationMode is set to AllocationModeValue.AnnounceFrame and bufferCount is set to 5.

Return:

An instance for controlling the capturing.

IStreamCapture PrepareCapture (IFrameBufferPool frameBufferPool)

Prepare VmbC for capturing from the module.

The procedure for allocating and deallocating frame buffers is implemented by the user. If one of the overloaded methods ICapturingModule.PrepareCapture() was called before and the returned instance was not disposed, the same IStreamCapture instance will be returned and no new capturing will be prepared.

Param frameBufferPool:

The user-defined implementation for managing a frame buffer pool.

Return:

An instance of IStreamCapture.

void RemoveAllFrameEventHandlers ()

Remove all event handlers registered to the event FrameReceived.

Properties

UInt32 StreamAlignment { get; set; }

Convenience method for getting the alignment to use when allocating frame buffers. Attempts to use the GenICam Standard Features Naming Convention conforming integer feature “StreamBufferAlignment”. If that feature is not present or has a negative value, a value of 1 will be assumed.

UInt32 PayloadSize { get; set; }

Get the required size in bytes of each frame buffer to be allocated.

Events

event EventHandler<FrameReceivedEventArgs> FrameReceived

Event for receiving filled frames.

All registered event handlers can be removed by calling RemoveAllFrameEventHandlers().

IFrameList

interface VmbNET.IFrameList : IReadOnlyList<IFrame>, IDisposable

Interface for accessing a list of filled frames.

An instance of this interface is returned by the convenience method IOpenCamera.AcquireMultipleImages(UInt32, TimeSpan). It must be disposed when access to the frames is completed. Disposing the instance will dispose each frame.

Public Functions

void ReleaseAllFramesAndClear ()

Convenience method for releasing all frames and clearing the list in case the disposable pattern is not desired.

Once called, the list should not be used again. Using this method is discouraged in favor of the disposable pattern.

IFrameBufferPool

interface VmbNET.IFrameBufferPool : IReadOnlyList<BufferTuple>, IDisposable

Interface for accessing a frame buffer pool.

Note that each buffer must be provided (via e.g. indexing) as a tuple of type ( IntPtr, UInt32 ), where the first field of type IntPtr is the pointer to the start of the buffer and the second field of type UInt32 is the buffer size. The concrete implementation is provided by the user so that she / he can specify how buffers should be acquired before being handed over to VmbC and how they should be released after the system has finished with them. For example, the buffers might be allocated on the heap and later deallocated, or are they are obtained from a third party library and later returned. The default implementation FrameBufferPool can be used and serves most needs, or the user can easily adapt it to her / his needs. The API using the disposable pattern internally to call Dispose() when it no longer has access to the frame buffers.

Subclassed by VmbNET.FrameBufferPool

class FrameBufferPoolEnumerator : public IEnumerator<BufferTuple>

Implementation of the enumerator returned by FrameBufferPool.GetEnumerator, which should serve most needs.

Public Functions

FrameBufferPoolEnumerator (IFrameBufferPool bufferPool)

Constructor.

Param bufferPool:

The instance of the user-implemented frame buffer pool.

void Dispose ()

Dispose the enumerator.

No action required.

bool MoveNext ()

Move to the next item in the list.

Return:

True if there was a next item.

void Reset ()

Reset the iterator such that the next call to MoveNext will move to the first position.

Public Members

IntPtr buffer

The buffer at the current position.

IFrameBufferPool

interface VmbNET.IFrameBufferPool : IReadOnlyList<BufferTuple>, IDisposable

Interface for accessing a frame buffer pool.

Note that each buffer must be provided (via e.g. indexing) as a tuple of type ( IntPtr, UInt32 ), where the first field of type IntPtr is the pointer to the start of the buffer and the second field of type UInt32 is the buffer size. The concrete implementation is provided by the user so that she / he can specify how buffers should be acquired before being handed over to VmbC and how they should be released after the system has finished with them. For example, the buffers might be allocated on the heap and later deallocated, or are they are obtained from a third party library and later returned. The default implementation FrameBufferPool can be used and serves most needs, or the user can easily adapt it to her / his needs. The API using the disposable pattern internally to call Dispose() when it no longer has access to the frame buffers.

Subclassed by VmbNET.FrameBufferPool

class FrameBufferPoolEnumerator : public IEnumerator<BufferTuple>

Implementation of the enumerator returned by FrameBufferPool.GetEnumerator, which should serve most needs.

Public Functions

FrameBufferPoolEnumerator (IFrameBufferPool bufferPool)

Constructor.

Param bufferPool:

The instance of the user-implemented frame buffer pool.

void Dispose ()

Dispose the enumerator.

No action required.

bool MoveNext ()

Move to the next item in the list.

Return:

True if there was a next item.

void Reset ()

Reset the iterator such that the next call to MoveNext will move to the first position.

Public Members

IntPtr buffer

The buffer at the current position.

IFrame

interface VmbNET.IFrame : IDisposable

Interface accessing frame data metadata.

When the frame data is no longer needed, IDisposable.Dispose() must be called on all instances of the frame.

Public Types

enum FrameStatusValue

Status of a received frame.

Values:

Completed

Frame was completely filled without errors

Incomplete

Frame could not be completely filled to the end

TooSmall

Frame buffer was too small

Invalid

Frame buffer was invalid

enum VmbPixelTypeValue

Indicates whether pixel data contains monochrome or RGB information.

Values:

Mono

Monochrome pixel

Color

RGB

enum VmbPixelOccupyTypeValue

Indicates the number of bits used for each pixel’s data.

Values:

Bit8

Pixel data effectively occupies 8 bits

Bit10

Pixel data effectively occupies 10 bits

Bit12

Pixel data effectively occupies 12 bits

Bit14

Pixel data effectively occupies 14 bits

Bit16

Pixel data effectively occupies 16 bits

Bit24

Pixel data effectively occupies 24 bits

Bit32

Pixel data effectively occupies 32 bits

Bit48

Pixel data effectively occupies 48 bits

Bit64

Pixel data effectively occupies 64 bits

enum PixelFormatValue

Pixel format types.

As far as possible, the Pixel Format Naming Convention (PFNC) has been followed, but allowing for a few deviations. This allows pixel formats returned as strings from GenICam-conforming cameras to be converted to enum types. If data spans more than one byte, it is always LSB aligned, except if stated differently.

Values:

Mono8

Monochrome, 8 bits (PFNC: Mono8)

Mono10

Monochrome, 10 bits in 16 bits (PFNC: Mono10)

Mono10p

Monochrome, 10 bits in 16 bits (PFNC: Mono10p)

Mono12

Monochrome, 12 bits in 16 bits (PFNC: Mono12)

Mono12Packed

Monochrome, 2x12 bits in 24 bits (GEV:Mono12Packed)

Mono12p

Monochrome, 2x12 bits in 24 bits (PFNC: MonoPacked)

Mono14

Monochrome, 14 bits in 16 bits (PFNC: Mono14)

Mono16

Monochrome, 16 bits (PFNC: Mono16)

BayerGR8

Bayer-color, 8 bits, starting with GR line (PFNC: BayerGR8)

BayerRG8

Bayer-color, 8 bits, starting with RG line (PFNC: BayerRG8)

BayerGB8

Bayer-color, 8 bits, starting with GB line (PFNC: BayerGB8)

BayerBG8

Bayer-color, 8 bits, starting with BG line (PFNC: BayerBG8)

BayerGR10

Bayer-color, 10 bits in 16 bits, starting with GR line (PFNC: BayerGR10)

BayerRG10

Bayer-color, 10 bits in 16 bits, starting with RG line (PFNC: BayerRG10)

BayerGB10

Bayer-color, 10 bits in 16 bits, starting with GB line (PFNC: BayerGB10)

BayerBG10

Bayer-color, 10 bits in 16 bits, starting with BG line (PFNC: BayerBG10)

BayerGR12

Bayer-color, 12 bits in 16 bits, starting with GR line (PFNC: BayerGR12)

BayerRG12

Bayer-color, 12 bits in 16 bits, starting with RG line (PFNC: BayerRG12)

BayerGB12

Bayer-color, 12 bits in 16 bits, starting with GB line (PFNC: BayerGB12)

BayerBG12

Bayer-color, 12 bits in 16 bits, starting with BG line (PFNC: BayerBG12)

BayerGR12Packed

Bayer-color, 2x12 bits in 24 bits, starting with GR line (GEV:BayerGR12Packed)

BayerRG12Packed

Bayer-color, 2x12 bits in 24 bits, starting with RG line (GEV:BayerRG12Packed)

BayerGB12Packed

Bayer-color, 2x12 bits in 24 bits, starting with GB line (GEV:BayerGB12Packed)

BayerBG12Packed

Bayer-color, 2x12 bits in 24 bits, starting with BG line (GEV:BayerBG12Packed)

BayerGR10p

Bayer-color, 10 bits continuous packed, starting with GR line (PFNC: BayerGR10p)

BayerRG10p

Bayer-color, 10 bits continuous packed, starting with RG line (PFNC: BayerRG10p)

BayerGB10p

Bayer-color, 10 bits continuous packed, starting with GB line (PFNC: BayerGB10p)

BayerBG10p

Bayer-color, 10 bits continuous packed, starting with BG line (PFNC: BayerBG10p)

BayerGR12p

Bayer-color, 12 bits continuous packed, starting with GR line (PFNC: BayerGR12p)

BayerRG12p

Bayer-color, 12 bits continuous packed, starting with RG line (PFNC: BayerRG12p)

BayerGB12p

Bayer-color, 12 bits continuous packed, starting with GB line (PFNC: BayerGB12p)

BayerBG12p

Bayer-color, 12 bits continuous packed, starting with BG line (PFNC: BayerBG12p)

BayerGR16

Bayer-color, 16 bits, starting with GR line (PFNC: BayerGR16)

BayerRG16

Bayer-color, 16 bits, starting with RG line (PFNC: BayerRG16)

BayerGB16

Bayer-color, 16 bits, starting with GB line (PFNC: BayerGB16)

BayerBG16

Bayer-color, 16 bits, starting with BG line (PFNC: BayerBG16)

RGB8

RGB, 8 bits x 3 (PFNC: RGB8)

BGR8

BGR, 8 bits x 3 (PFNC: BGR8)

RGB10

RGB, 12 bits in 16 bits x 3 (PFNC: RGB12)

BGR10

RGB, 12 bits in 16 bits x 3 (PFNC: RGB12)

RGB12

RGB, 12 bits in 16 bits x 3 (PFNC: RGB12)

BGR12

RGB, 12 bits in 16 bits x 3 (PFNC: RGB12)

RGB14

RGB, 14 bits in 16 bits x 3 (PFNC: RGB12)

BGR14

RGB, 14 bits in 16 bits x 3 (PFNC: RGB12)

RGB16

RGB, 16 bits x 3 (PFNC: RGB16)

BGR16

RGB, 16 bits x 3 (PFNC: RGB16)

aRGB8

ARGB, 8 bits x 4 (PFNC: RGBa8)

RGBa8

RGBA, 8 bits x 4, legacy name

BGRa8

BGRA, 8 bits x 4 (PFNC: BGRa8)

RGBa10

RGBA, 8 bits x 4, legacy name

BGRa10

RGBA, 8 bits x 4, legacy name

RGBa12

RGBA, 8 bits x 4, legacy name

BGRa12

RGBA, 8 bits x 4, legacy name

RGBa14

RGBA, 8 bits x 4, legacy name

BGRa14

RGBA, 8 bits x 4, legacy name

RGBa16

RGBA, 8 bits x 4, legacy name

BGRa16

RGBA, 8 bits x 4, legacy name

Yuv411

YUV 4:1:1 with 8 bits (PFNC: YUV411_8_UYYVYY, GEV:YUV411Packed)

Yuv422

YUV 4:2:2 with 8 bits (PFNC: YUV422_8_UYVY, GEV:YUV422Packed)

Yuv444

YUV 4:4:4 with 8 bits (PFNC: YUV8_UYV, GEV:YUV444Packed)

Yuv422_8

YUV 4:2:2 with 8 bits Channel order YUYV (PFNC: YUV422_8)

YCbCr8_CbYCr

YCbCr 4:4:4 with 8 bits (PFNC: YCbCr8_CbYCr) - identical to IFrame.PixelFormatValue.Yuv444

YCbCr422_8

YCbCr 4:2:2 8-bit YCbYCr (PFNC: YCbCr422_8)

YCbCr411_8_CbYYCrYY

YCbCr 4:1:1 with 8 bits (PFNC: YCbCr411_8_CbYYCrYY) - identical to IFrame.PixelFormatValue.Yuv411

YCbCr601_8_CbYCr

YCbCr601 4:4:4 8-bit CbYCrt (PFNC: YCbCr601_8_CbYCr)

YCbCr601_422_8

YCbCr601 4:2:2 8-bit YCbYCr (PFNC: YCbCr601_422_8)

YCbCr601_411_8_CbYYCrYY

YCbCr601 4:1:1 8-bit CbYYCrYY (PFNC: YCbCr601_411_8_CbYYCrYY)

YCbCr709_8_CbYCr

YCbCr709 4:4:4 8-bit CbYCr (PFNC: YCbCr709_8_CbYCr)

YCbCr709_422_8

YCbCr709 4:2:2 8-bit YCbYCr (PFNC: YCbCr709_422_8)

YCbCr709_411_8_CbYYCrYY

YCbCr709 4:1:1 8-bit CbYYCrYY (PFNC: YCbCr709_411_8_CbYYCrYY)

YCbCr422_8_CbYCrY

YCbCr 4:2:2 with 8 bits (PFNC: YCbCr422_8_CbYCrY) - identical to IFrame.PixelFormatValue.Yuv422

YCbCr601_422_8_CbYCrY

YCbCr601 4:2:2 8-bit CbYCrY (PFNC: YCbCr601_422_8_CbYCrY)

YCbCr709_422_8_CbYCrY

YCbCr709 4:2:2 8-bit CbYCrY (PFNC: YCbCr709_422_8_CbYCrY)

YCbCr411_8

YCbCr 4:1:1 8-bit YYCbYYCr (PFNC: YCbCr411_8)

YCbCr8

YCbCr 4:4:4 8-bit YCbCr (PFNC: YCbCr8)

enum PayloadTypeValue

Frame payload type.

Values:

Unknown

Unknown payload type

Image

image data

Raw

raw data

File

file data

JPEG

JPEG data as described in the GigEVision 2.0 specification

PEG2000

JPEG 2000 data as described in the GigEVision 2.0 specification

H264

H.264 data as described in the GigEVision 2.0 specification

ChunkOnly

Chunk data exclusively

DeviceSpecific

Device specific data format

GenDC

GenDC data

enum AvailableInfoValues

Values indicating information provided in the received frames.

Values:

None

No additional information is provided

Dimension

Width and Height are provided

Offset

OffsetX and OffsetY are provided

FrameId

FrameId is provided

Timestamp

Timestamp is provided

ImageData

ImageData is provided

PayloadType

PayloadType is provided

ContainsChunkData

ContainsChunkData is true

Public Functions

void AccessChunkData (Action<IFeatureContainer> chunkFeatureContainerAction)

Method to access chunk data.

The Action is executed on the same thread as the thread used to call this method, i.e. this method blocks until chunkFeatureContainerAction completes.

Param chunkFeatureContainerAction:

A user-provided Action whose implementation can access the frame’s chunk data from an instance of IFeatureContainer.

void Release ()

Convenience method for allowing VmbC to overwrite frame data again in case the disposable pattern is not desired.

Once called, the frame data should not be accessed until it has been received from VmbC again. Using this method is discouraged in favor of the disposable pattern.

Properties

UInt64 Id { get; set; }

The frame’s ID.

The ID is unique to the set of frames associated with a given stream.

IntPtr Buffer { get; set; }

The address of the start of the unmanaged buffer data.

UInt32 BufferSize { get; set; }

The size in bytes of the buffer data.

IntPtr ImageData { get; set; }

The address of the start of the unmanaged image data.

Usually this is Buffer plus the size of the chunk data, if present. It is null if no image data is present.

FrameStatusValue FrameStatus { get; set; }

The frame’s status.

PayloadTypeValue PayloadType { get; set; }

The payload’s type.

PixelFormatValue PixelFormat { get; set; }

The image’s pixel format.

UInt32 Width { get; set; }

The image’s width.

UInt32 Height { get; set; }

The image’s height.

UInt32 OffsetX { get; set; }

The image’s horizontal offset.

UInt32 OffsetY { get; set; }

The image’s vertical offset.

UInt64 Timestamp { get; set; }

The frame’s timestamp as set by the camera.

bool ContainsChunkData { get; set; }

Whether chunk data is present in the frame buffer.

Feature Interfaces

IFeature

interface VmbNET.IFeature

Interface for accessing a feature’s metadata.

Subclassed by VmbNET.IBoolFeature, VmbNET.ICommandFeature, VmbNET.IEnumFeature, VmbNET.IFloatFeature, VmbNET.IIntFeature, VmbNET.IRawFeature, VmbNET.IStringFeature

Public Types

enum TypeValue

Supported feature types.

Values:

Unknown

Unknown feature type

Int

64-bit integer feature

Float

64-bit floating point feature

Enum

Enumeration feature

String

String feature

Bool

Boolean feature

Command

Command feature

Raw

Raw (direct register access) feature

None

Feature with no data

enum VisibilityValue

Feature Visibility.

Values:

Unknown

Feature visibility is not known

Beginner

Feature is visible in feature list (beginner level)

Expert

Feature is visible in feature list (expert level)

Guru

Feature is visible in feature list (guru level)

Invisible

Feature is visible in the feature list, but should be hidden in GUI applications

enum AccessValues

Feature accessibility flags.

Values:

None

No additional information is provided.

Read

Static info about read access. Current status depends on access mode, check with IsReadable and IsWriteable.

Write

Static info about write access. Current status depends on access mode, check with IsReadable and IsWriteable.

Volatile

Value may change at any time.

ModifyWrite

Value may change after a write.

Public Functions

bool IsReadable ()

The dynamic read capability of this feature.

This may change between calls, depending on the camera status.

bool IsWriteable ()

The dynamic write capability of this feature.

This may change between calls, depending on the camera status.

void RemoveAllChangedEventHandlers ()

Remove all event handlers registered to the event Changed.

Properties

string Name { get; set; }

Name used in the API.

string DisplayName { get; set; }

Name to be used in GUIs.

string Tooltip { get; set; }

Short description, e.g. for a tooltip.

string Description { get; set; }

Longer description.

string Category { get; set; }

Category that this feature can be found in.

string SfncNamespace { get; set; }

GenICam Standard Features Naming Convention namespace that this feature resides in.

TypeValue Type { get; set; }

Type of this feature.

AccessValues AccessFlags { get; set; }

Access flags for this feature.

VisibilityValue Visibility { get; set; }

GUI visibility.

dynamic SelectedFeatures { get; set; }

Features that can be selected by this feature.

bool IsStreamable { get; set; }

Whether this feature can be stored to / loaded from a file.

UInt32 PollingTime { get; set; }

Predefined polling time for this feature if it is a volatile feature.

Events

event EventHandler<FeatureChangedEventArgs> Changed

Event for receiving updates to this feature.

All registered event handlers can be removed by calling RemoveAllChangedEventHandlers().

IBoolFeature

interface VmbNET.IBoolFeature : VmbNET.IFeature

Interface for accessing a boolean feature.

Properties

bool Value { get; set; }

Get the current value or set the value.

IIntFeature

interface VmbNET.IIntFeature : VmbNET.IFeature

Interface for accessing an integer feature.

Properties

Int64 Value { get; set; }

Get the current value or set the value.

Int64 Maximum { get; set; }

The maximum value.

Int64 Minimum { get; set; }

The minimum value.

Int64 Increment { get; set; }

The feature’s increment.

bool HasValidValues { get; set; }

Whether the feature’s valid values are specified.

Int64 > ValidValues { get; set; }

Get all valid integer values.

string Representation { get; set; }

Representation of this feature.

string Unit { get; set; }

Measuring unit that applies to the value of the feature.

IFloatFeature

interface VmbNET.IFloatFeature : VmbNET.IFeature

Interface for accessing a float feature.

Properties

double Value { get; set; }

Get the current value or set the value.

double Maximum { get; set; }

The maximum value.

double Minimum { get; set; }

The minimum value.

bool HasIncrement { get; set; }

Whether the feature has an increment.

double Increment { get; set; }

The feature’s increment.

string Representation { get; set; }

Representation of this feature.

string Unit { get; set; }

Measuring unit that applies to the value of the feature.

IStringFeature

interface VmbNET.IStringFeature : VmbNET.IFeature

Interface for accessing a string feature.

Properties

string Value { get; set; }

Get the current value or set the value.

UInt32 MaximumLength { get; set; }

The maximum possible length of the string returned by Value.

Useful for e.g. GUI applications.

IEnumFeature

interface VmbNET.IEnumFeature : VmbNET.IFeature

Interface for accessing an enum feature.

Properties

string Value { get; set; }

Get the value of the current enum entry’s name or set the enum entry via the enum entry’s name.

IEnumEntry EnumEntry { get; set; }

Get the current enum entry.

IEnumEntry > EnumEntriesByName { get; set; }

Get all valid enum entry values as a dictionary with the entry name as key.

IEnumEntry

interface VmbNET.IEnumEntry

Interface for accessing an enum feature’s value

Properties

string Name { get; set; }

Name used in the API.

string DisplayName { get; set; }

Name to be used in GUIs.

string Tooltip { get; set; }

Short description, e.g. for a tooltip.

string Description { get; set; }

Longer description.

string SfncNamespace { get; set; }

GenICam Standard Features Naming Convention namespace that this feature resides in.

IFeature.VisibilityValue Visibility { get; set; }

GUI visibility.

Int64 IntValue { get; set; }

The integer value for this enumeration entry.

bool IsAvailable { get; set; }

Whether this enumeration entry is available.

ICommandFeature

interface VmbNET.ICommandFeature : VmbNET.IFeature

Interface for accessing a command feature.

Public Functions

Task Run (TimeSpan timeout)

Run the command and wait on a background thread for the command to complete.

Param timeout:

The time to wait for the command to complete, regardless of whether a frame arrived.

Throws VmbTimeoutException:

Thrown if a timeout occurs.

Return:

An instance of Task to await for the background thread to complete.

void Run ()

Run the command.

The command may not have completed when this method returns. The property IsDone can be used at any time later to check whether the command has completed.

Properties

bool IsDone { get; set; }

Check whether the command is done or is still in progress.

This would be used after calling Run() (i.e. without a timeout). This will return true only after a sufficient amount of time has passed since the call to Run(), to allow the command to be done.

Return:

true if the command is done.

IRawFeature

interface VmbNET.IRawFeature : VmbNET.IFeature

Interface for accessing a raw feature (direct register access).

Properties

byte > Value { get; set; }

The entire contents currently in the register or set the contents.

UInt32 MaximumSize { get; set; }

Total byte count used by the register.

Classes

CameraListEventArgs

class VmbNET.CameraListEventArgs : EventArgs

Class providing information about a camera which has changed.

This type is used as the event arguments for IVmbSystem.CameraListChanged.

Properties

ICamera Camera { get; set; }

The camera’s instance.

ListChangedEventType ListChangedEventType { get; set; }

The camera’s event.

FeatureChangedEventArgs

class VmbNET.FeatureChangedEventArgs : EventArgs

Class for obtaining a feature that has changed.

This type is used as the event arguments for IFeature.Changed

Properties

dynamic Feature { get; set; }

The feature which has changed.

InterfaceListEventArgs

class VmbNET.InterfaceListEventArgs : EventArgs

Class providing information about an interface which has changed.

This type is used as the event arguments for IVmbSystem.InterfaceListChanged.

Properties

IInterface Interface { get; set; }

The interface’s instance.

ListChangedEventType ListChangedEventType { get; set; }

The interface’s event.

VmbNETException

class VmbNET.VmbNETException : Exception

General exceptions thrown by VmbNET.

Subclassed by VmbNET.VmbException< TSourceError >, VmbNET.VmbTimeoutException

VmbException

class VmbNET.VmbException<TSourceError> : VmbNET.VmbNETException

Exceptions thrown whenever VmbC functions return an error code.

Tparam TSourceError:

A type indicating the source of the error, e.g. SystemError.

Public Members

VmbException(ILogger logger, string message, VmbErrorCode errorCode) VmbErrorCode ErrorCode

The VmbC error code that caused the exception.

VmbTimeoutException

class VmbNET.VmbTimeoutException : VmbNET.VmbNETException

Exception thrown whenever VmbC functions return an error code whose value is VmbErrorCode.Timeout.

Public Members

VmbTimeoutException(ILogger logger, string message, VmbErrorCode errorCode) VmbTimeoutException(ILogger logger, string message) VmbErrorCode ErrorCode

The VmbC error code that caused the exception.

FeaturePersistSettings

class VmbNET.FeaturePersistSettings

Class storing information for controlling how module settings are loaded or saved.

Public Types

enum TypeValue

Values for the type of settings to be loaded or saved.

Used as the type for property Type.

Values:

All

All features including LUT.

Streamable

All features marked as streamable, excluding LUT.

NoLUT

All features excluding LUT.

enum ModuleValues

Flags for specifying which modules’ features are to be loaded or saved.

Values:

None

Load or save features for no module.

TransportLayer

Load or save the transport layer features.

Interface

Load or save the interface features.

Camera

Load or save the camera features.

LocalDevice

Load or save the local device features.

Streams

Load or save the stream features.

All

Load or save features for all modules.

enum LogLevelValue

Values for the type of logging while loading or saving settings.

Used as the type for property LogLevel.

Values:

None

No logging regardless of severity of the issue.

Error

Only error messages are logged.

Debug

Only error and debug messages are logged.

Warn

Only error, debug and warn messages are logged.

Trace

All messages are logged.

Properties

TypeValue Type { get; set; }

The type of settings to be loaded or saved.

ModuleValues Modules { get; set; }

The types of modules whose settings should be loaded or saved

UInt32 MaximumIterations { get; set; } = ModuleValues.All

Number of iterations when loading settings from the XML file.

LogLevelValue LogLevel { get; set; }

The type of logging to be done while loading or saving settings.

FrameBufferPool

class VmbNET.FrameBufferPool : VmbNET.IFrameBufferPool

Default implementation of IFrameBufferPool.

Provided for convenience. Used by VmbNET as the default pool. It should serve most needs, or the user can easily adapt it to her / his needs. Note that buffers are lazily allocated as unmanaged data on the heap.

Public Functions

FrameBufferPool (UInt32 bufferCount, UInt32 bufferSize, ILogger logger)

Constructor for the frame buffer pool.

Use the other contructor if logging is required.

Param bufferCount:

The number of buffers that the frame buffer pool should contain.

Param bufferSize:

The size of each buffer in bytes.

Param logger:

A logger for logging the behaviour and use of the instance.

FrameBufferPool (UInt32 bufferCount, UInt32 bufferSize, UInt32 bufferAlignment)

Constructor for the frame buffer pool with memory buffer alignment.

Param bufferCount:

The number of buffers that the frame buffer pool should contain.

Param bufferSize:

The size of each buffer in bytes.

Param bufferAlignment:

The alignment in bytes to use for each buffer.

FrameBufferPool (UInt32 bufferCount, UInt32 bufferSize, UInt32 bufferAlignment, ILogger logger)

Constructor for the frame buffer pool with logging included.

Param bufferCount:

The number of buffers that the frame buffer pool should contain.

Param bufferSize:

The size of each buffer in bytes.

Param bufferAlignment:

The alignment in bytes to use for each buffer.

Param logger:

A logger for logging the behaviour and use of the instance.

void Dispose ()

Dispose the buffer pool.

Deallocates all buffers allocated so far.

IEnumerator<(IntPtr buffer, UInt32 bufferSize)> GetEnumerator ()

Get the enumerator for iteration over the buffers.

Return:

The enumerator as an instance of IFrameBufferPool.FrameBufferPoolEnumerator.

Public Members

IntPtr buffer

Get the buffer corresponding to a given pool index.

Param index:

The pool index.

Return:

The buffer start and buffer size as a ValueTuple<IntPtr, UInt32>.

int Count = > _buffers.Count

Get the number of buffers in the pool.

FrameReceivedEventArgs

class VmbNET.FrameReceivedEventArgs : EventArgs

Class providing information about a received frame.

Public Members

IFrame Frame = > _frame.PrepareForDispose(false)

Get the frame data. When the frame data is no longer required, the frame must be disposed via the disposable pattern so that it can be refilled with new data.

Properties

IOpenCamera OpenCamera { get; set; }

Get the open camera from which this frame originated.

IStream Stream { get; set; }

Get the stream from which this frame originated.

Other Enums

TransportLayerType

enum VmbNET.TransportLayerType

Camera or transport layer type (for instance U3V or GEV).

Values:

Unknown

Interface is not known to this version of the API

GEV

GigE Vision

CL

Camera Link

IIDC

IIDC 1394

UVC

USB video class

CXP

CoaXPress

CLHS

Camera Link HS

U3V

USB3 Vision Standard

Ethernet

Generic Ethernet

PCI

PCI / PCIe

Custom

Non standard

Mixed

Mixed (transport layer only)

ListChangedEventType

enum VmbNET.ListChangedEventType

Events that can be fired as a result of a change in a module.

Values:

Missing

A known module disappeared from the bus.

Detected

A new module was discovered.

Reachable

A known module can be accessed.

Unreachable

A known module cannot be accessed anymore.

Unknown

An unknown event occurred.