Parts of the GenICamInterfaceLayout program are based on the SingleCapture example concerning the single snap of an image. The sample shows all GenICam™ interface properties which can be modified.

Program location: The source file GenICamInterfaceLayout.cs can be found under:

%INSTALLDIR%\apps\CSharp\GenICamInterfaceLayout\

Note: If you have installed the package without example applications, this file will not be available. On Windows® the sample application can be installed or removed from the target system at any time by simply restarting the installation package.

GenICamInterfaceLayout example:

Opens a Balluff device.
Shows some GenICam™ interface properties.
You can set some properties.
Snaps an image using these properties (without display using Linux).

Console Output

[0]: GX001559 (mvBlueCOUGAR-X122G, Family: mvBlueCOUGAR, interface layout: DeviceSpecific)

Please enter the number in front of the listed device followed by [ENTER] to open it: 0
Using device number 0.
Interface layout of device GX001559(mvBlueCOUGAR-X122G) set to 'GenICam'.

Acquisition start/stop behaviour(Defines the start/stop behaviour of the acquisition engine) of device 
GX001559(mvBlueCOUGAR-X122G) set to 'User'.
In 'Default' mode the acquisition engine will be started and stopped automatically, when set 
to 'User' it is up to the user to start and stop the acquisition engine. When this driver is
running with a 3rd party GenICam&trade; GenTL producer only 'User' will be available).

Initialising the device. This might take some time...

Property 'DeviceVendorName' currently specifies the following flags: cfAlwaysForceClone | cfFixedSize | cfReadAccess
The current value of 'DeviceVendorName' is: MATRIX VISION GmbH

Property 'DeviceModelName' currently specifies the following flags: cfAlwaysForceClone | cfFixedSize | cfReadAccess
The current value of 'DeviceModelName' is: mvBlueCOUGAR-X122G

Property 'ExposureTime' currently specifies the following flags: cfAlwaysForceClone | cfFixedSize | cfWriteAccess | cfReadAccess
The minimum value of 'ExposureTime' is 10.000
The maximum value of 'ExposureTime' is 10000000.000
The current value of 'ExposureTime' is: 20000.000
Enter the new value for 'ExposureTime': 20000

Property 'PixelFormat' currently specifies the following flags: cfShouldBeDisplayedAsEnumeration | cfAlwaysForceClone | cfFixedSize | cfWriteAccess | cfReadAcce
ss
'PixelFormat' defines a dictionary. Valid values are:
  [17301505]: Mono8
  [17825799]: Mono16
  [17563654]: Mono12Packed
The current value of 'PixelFormat' is: Mono8
Enter the new value for 'PixelFormat': Mono16

Property 'Width' currently specifies the following flags: cfAlwaysForceClone | cfFixedSize | cfWriteAccess | cfReadAccess
The minimum value of 'Width' is 16
The maximum value of 'Width' is 1280
The increment of 'Width' is 1
The current value of 'Width' is: 1280
Enter the new value for 'Width': 1280

Property 'Height' currently specifies the following flags: cfAlwaysForceClone | cfFixedSize | cfWriteAccess | cfReadAccess
The minimum value of 'Height' is 16
The maximum value of 'Height' is 960
The increment of 'Height' is 1
The current value of 'Height' is: 960
Enter the new value for 'Height': 960

Press [ENTER] to end the application
Info from GX001559: FramesPerSecond: 22.679294, ErrorCount: 0, CaptureTime_s: 0.394700
Info from GX001559: FramesPerSecond: 22.679315, ErrorCount: 0, CaptureTime_s: 0.394691
Info from GX001559: FramesPerSecond: 22.679311, ErrorCount: 0, CaptureTime_s: 0.394728
...

How it works: After getting the device from user input the sample tries to

set the mv.impact.acquire.Device.interfaceLayout to mv.impact.acquire.TDeviceInterfaceLayout (dilGenICam)
pDev.interfaceLayout.write(TDeviceInterfaceLayout.dilGenICam);

and to
open the device (
pDev.open();

).
The sample shows, how to work with SFNC (Standard Features Naming Convention).

DeviceControl dc = new DeviceControl(pDev);
ExampleHelper.displayPropertyDataWithValidation(dc.deviceVendorName, "DeviceVendorName");
Console.WriteLine();
ExampleHelper.displayPropertyDataWithValidation(dc.deviceModelName, "DeviceModelName");
Console.WriteLine();
 
// show the current exposure time allow the user to change it
AcquisitionControl ac = new AcquisitionControl(pDev);
ExampleHelper.displayAndModifyPropertyDataWithValidation(ac.exposureTime, "ExposureTime");
 
// show the current pixel format, width and height and allow the user to change it
ImageFormatControl ifc = new ImageFormatControl(pDev);
ExampleHelper.displayAndModifyPropertyDataWithValidation(ifc.pixelFormat, "PixelFormat");
ExampleHelper.displayAndModifyPropertyDataWithValidation(ifc.width, "Width");
ExampleHelper.displayAndModifyPropertyDataWithValidation(ifc.height, "Height");

Afterwards, the sample shows on Window®s system a live display (mv.impact.acquire.display) and you can end the application with [ENTER].

Source code

using System;
using System.Threading;
 
#if USE_DISPLAY
using mv.impact.acquire.display;
#endif // #if USE_DISPLAY
using mv.impact.acquire.examples.helper;
using mv.impact.acquire.GenICam;
 
namespace mv.impact.acquire.examples
{
    class GenICamInterfaceLayout
    {
        static void Main(string[] args)
        {
            mv.impact.acquire.LibraryPath.init(); // this will add the folders containing unmanaged libraries to the PATH variable.
            Device pDev = DeviceAccess.getDeviceFromUserInput();
            if (pDev == null)
            {
                Console.WriteLine("Unable to continue! Press any key to end the program.");
                Console.Read();
                Environment.Exit(1);
            }
 
            try
            {
                Console.WriteLine("Initialising the device. This might take some time...");
                Console.WriteLine();
                pDev.open();
            }
            catch (ImpactAcquireException e)
            {
                // this e.g. might happen if the same device is already opened in another process...
                Console.WriteLine("An error occurred while opening device " + pDev.serial + "(error code: " + e.Message + ").");
                Console.WriteLine("Press any key to end the application...");
                Console.ReadLine();
                Environment.Exit(1);
            }
 
            // now display some SFNC(Standard Features Naming Convention) compliant features(see http://www.emva.org to find out more
            // about the standard and to download the latest SFNC document version)
            //
            // IMPORTANT:
            //
            // The SFNC unfortunately does NOT define numerical values for enumerations, thus a device independent piece of software
            // should use the enum-strings defined in the SFNC to ensure interoperability between devices. This is slightly slower
            // but should not cause problems in real world applications. When the device type AND GenICam XML file version is
            // guaranteed to be constant for a certain version of software, the driver internal code generator can be used to create
            // and interface header, that has numerical constants for enumerations as well. Refer to the code generator chapter in 
            // the C++ documentation under 'Use Cases' for details.
            DeviceControl dc = new DeviceControl(pDev);
            FeatureAccess.displayPropertyDataWithValidation(dc.deviceVendorName, "DeviceVendorName");
            Console.WriteLine();
            FeatureAccess.displayPropertyDataWithValidation(dc.deviceModelName, "DeviceModelName");
            Console.WriteLine();
 
            // show the current exposure time allow the user to change it
            AcquisitionControl ac = new AcquisitionControl(pDev);
            FeatureAccess.displayAndModifyPropertyDataWithValidation(ac.exposureTime, "ExposureTime");
 
            // show the current pixel format, width and height and allow the user to change it
            ImageFormatControl ifc = new ImageFormatControl(pDev);
            FeatureAccess.displayAndModifyPropertyDataWithValidation(ifc.pixelFormat, "PixelFormat");
            FeatureAccess.displayAndModifyPropertyDataWithValidation(ifc.width, "Width");
            FeatureAccess.displayAndModifyPropertyDataWithValidation(ifc.height, "Height");
 
            // start the execution of the 'live' thread.
            Console.WriteLine("Press [ENTER] to end the application");
 
#if USE_DISPLAY
            ImageDisplayWindow window = new ImageDisplayWindow(String.Format("mvIMPACT_acquire sample, Device {0}", pDev.serial.read()));
#endif // #if USE_DISPLAY
 
            bool terminated = false;
 
            Thread thread = new Thread(delegate ()
            {
                // establish access to the statistic properties
                Statistics statistics = new Statistics(pDev);
                // create an interface to the device found
                FunctionInterface fi = new FunctionInterface(pDev);
 
                // Send all requests to the capture queue. There can be more than 1 queue for some devices, but for this sample
                // we will work with the default capture queue. If a device supports more than one capture or result
                // queue, this will be stated in the manual. If nothing is mentioned about it, the device supports one
                // queue only. This loop will send all requests currently available to the driver. To modify the number of requests
                // use the property mv.impact.acquire.SystemSettings.requestCount at runtime (note that some devices will
                // only allow to modify this parameter while NOT streaming data!) or the property
                // mv.impact.acquire.Device.defaultRequestCount BEFORE opening the device.
                TDMR_ERROR result = TDMR_ERROR.DMR_NO_ERROR;
                while ((result = (TDMR_ERROR)fi.imageRequestSingle()) == TDMR_ERROR.DMR_NO_ERROR) { };
                if (result != TDMR_ERROR.DEV_NO_FREE_REQUEST_AVAILABLE)
                {
                    Console.WriteLine("'FunctionInterface.imageRequestSingle' returned with an unexpected result: {0}({1})", result, ImpactAcquireException.getErrorCodeAsString(result));
                }
 
                DeviceAccess.manuallyStartAcquisitionIfNeeded(pDev, fi);
                // run thread loop
                Request pRequest = null;
                // we always have to keep at least 2 images as the display module might want to repaint the image, thus we
                // cannot free it unless we have a assigned the display to a new buffer.
                Request pPreviousRequest = null;
                int timeout_ms = 500;
                int cnt = 0;
                int requestNr = Device.INVALID_ID;
                while (!terminated)
                {
                    // wait for results from the default capture queue
                    requestNr = fi.imageRequestWaitFor(timeout_ms);
                    pRequest = fi.isRequestNrValid(requestNr) ? fi.getRequest(requestNr) : null;
                    if (pRequest != null)
                    {
                        if (pRequest.isOK)
                        {
                            ++cnt;
                            // here we can display some statistical information every 100th image
                            if (cnt % 100 == 0)
                            {
                                Console.WriteLine("Info from {0}: {1}: {2}, {3}: {4}, {5}: {6}", pDev.serial.read(),
                                    statistics.framesPerSecond.name, statistics.framesPerSecond.readS(),
                                    statistics.errorCount.name, statistics.errorCount.readS(),
                                    statistics.captureTime_s.name, statistics.captureTime_s.readS());
                            }
#if USE_DISPLAY
#   if CLR_AT_LEAST_3_DOT_5
                            // Extension methods are not supported by CLR versions smaller than 3.5 and this next function
                            // is therefore not available then.
                            window.imageDisplay.SetImage(pRequest);
#   else
                            // If extension methods are not available, the following function can be used instead. It is
                            // not as convenient and will only work for some pixel formats. For more complex pixel formats
                            // use other overloads of this method
                            window.imageDisplay.SetImage(pRequest.imageData.read(), pRequest.imageWidth.read(), pRequest.imageHeight.read(), pRequest.imageBytesPerPixel.read() * 8, pRequest.imageLinePitch.read());
#   endif
                            window.imageDisplay.Update();
#endif // #if USE_DISPLAY
                        }
                        else
                        {
                            Console.WriteLine("Error: {0}", pRequest.requestResult.readS());
                        }
                        if (pPreviousRequest != null)
                        {
                            // this image has been displayed thus the buffer is no longer needed...
                            pPreviousRequest.unlock();
                        }
                        pPreviousRequest = pRequest;
                        // send a new image request into the capture queue
                        fi.imageRequestSingle();
                    }
                    //else
                    //{
                        // Please note that slow systems or interface technologies in combination with high resolution sensors
                        // might need more time to transmit an image than the timeout value which has been passed to imageRequestWaitFor().
                        // If this is the case simply wait multiple times OR increase the timeout(not recommended as usually not necessary
                        // and potentially makes the capture thread less responsive) and rebuild this application.
                        // Once the device is configured for triggered image acquisition and the timeout elapsed before
                        // the device has been triggered this might happen as well.
                        // The return code would be -2119(DEV_WAIT_FOR_REQUEST_FAILED) in that case, the documentation will provide
                        // additional information under TDMR_ERROR in the interface reference.
                        // If waiting with an infinite timeout(-1) it will be necessary to call 'imageRequestReset' from another thread
                        // to force 'imageRequestWaitFor' to return when no data is coming from the device/can be captured.
                        // Console.WriteLine("imageRequestWaitFor failed ({0}, {1}), timeout value too small?", requestNr, ImpactAcquireException.getErrorCodeAsString(requestNr));
                    //}
                }
                DeviceAccess.manuallyStopAcquisitionIfNeeded(pDev, fi);
 
#if USE_DISPLAY
                // stop the display from showing freed memory
                window.imageDisplay.RemoveImage();
#endif // #if USE_DISPLAY
                // In this sample all the next lines are redundant as the device driver will be
                // closed now, but in a real world application a thread like this might be started
                // several times an then it becomes crucial to clean up correctly.
 
                // free the last potentially locked request
                if (pRequest != null)
                {
                    pRequest.unlock();
                }
                // clear all queues
                fi.imageRequestReset(0, 0);
            });
 
            thread.Start();
            Console.ReadLine();
            terminated = true;
            thread.Join();
#if USE_DISPLAY
            window.Dispose();
#endif // #if USE_DISPLAY
        }
    }
}