Impact Acquire SDK .NET
GenICamCommonSettingsUsage.cs

The GenICamCommonSettingsUsage example is intended as an example for people who do not have that much experience with the Impact Acquire SDK or did not use the classes which wrap the GenICam™ properties of the camera yet. It shows the basic procedure of handling device settings, how the camera is being configured with the most common settings and which steps are important to configure a camera in an efficient way.

Program location
The source file GenICamCommonSettingsUsage.cs can be found under:
%INSTALLDIR%\apps\CSharp\GenICamCommonSettingsUsage\
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.
Please be aware that this example utilizes the digital outputs of the camera to show how they can be used in a real application. Please make sure not to run this application once there is some hardware connected to the digital outputs of the camera.
GenICamCommonSettingsUsage example:
  1. Opens a Balluff device.
  2. Loads the default UserSet.
  3. Reads out some GenICam™ interface properties.
  4. Modifies some GenICam™ interface properties (Exposure Time, Analog Gain, Triggers, AOI, ...)
  5. Snaps some images using these properties and changing the analog gain every 100 frames (without display using Linux).
Console Output
--------------------------------------------!!! ATTENTION !!!--------------------------------------------
Please be aware that the digital outputs of the camera might be enabled during the test. This might lead to unexpected behavior in case of devices which are connected to one of the digital outputs, so only proceed if you are sure that this will not cause any issue with connected hardware!
---------------------------------------------------------------------------------------------------------

[0]: FF000026 (mvBlueFOX3-2024aC , family: mvBlueFOX3, interface layout: GenICam, acquisition start/stop behaviour: User)
[1]: GX005930 (mvBlueCOUGAR-X102eG , family: mvBlueCOUGAR, interface layout: GenICam, acquisition start/stop behaviour: User)
Please enter the number in front of the listed device followed by [ENTER] to open it: 0
Using device number 0
Initialising the device. This might take some time...

The camera will be configured now!

Loading the camera's default user set to avoid undefined settings!

Currently the exposure time is set to 20000 us. Changing to 10000us

The sensor has a max resolution of about 1936x1216  pixels
The resolution will now be adjusted to the half of width and height. The resulting AOI will be: 968x608 pixels

To avoid some cabling work, we will use an internal timer for triggering in this sample!
The trigger frequency will be configured to half of the max frequency the sensor would be capable of in your setup.

Available Digital IOs:
Line 0 - LineMode: Output - LineStatus: 0 - LineSource: mvExposureAndAcquisitionActive
Line 1 - LineMode: Output - LineStatus: 0 - LineSource: Off
Line 2 - LineMode: Output - LineStatus: 0 - LineSource: Off
Line 3 - LineMode: Output - LineStatus: 0 - LineSource: Off
Line 4 - LineMode: Input - LineStatus: 0 - LineSource: Off
Line 5 - LineMode: Input - LineStatus: 0 - LineSource: Off

Press [ENTER] to end the application
Info from FF000026: FramesPerSecond: 71.216323, ErrorCount: 0, CaptureTime_s: 0.122820, LineStatusAll: 0x0
Info from FF000026: FramesPerSecond: 71.209240, ErrorCount: 0, CaptureTime_s: 0.121911, LineStatusAll: 0x0
Info from FF000026: FramesPerSecond: 71.212820, ErrorCount: 0, CaptureTime_s: 0.122391, LineStatusAll: 0x0
...
How it works
After getting the device from user input the sample tries to
  1. set the mv.impact.acquire.Device.interfaceLayout to mv.impact.acquire.TDeviceInterfaceLayout (dilGenICam)
    pDev.interfaceLayout.write(TDeviceInterfaceLayout.dilGenICam);
    and to
  2. open the device
    pDev.open();
  3. The sample shows, how to work with SFNC (Standard Features Naming Convention) compliant properties and their corresponding Impact Acquire classes without using helper functions
Note
More details regarding the GenICam™ interface can be found here: Changing Device Settings

At first the Default UserSet is loaded to make sure the camera works on a specific set of settings before starting. This is a good idea once you want to bring the camera to a defined state after using different settings e.g. once you used different software before.

The UserSet is selected using the UserSetSelector and using the writeS() function to assign the string value Default to the UserSetSelector property. Afterwards the UserSetLoad function is called by using it's call() function. More details regarding the usage of UserSets can be found here.

if(canRestoreFactoryDefault(pDev))
{
// Make sure the default user set and the load method exist
// In general it is a good idea to verify if the GenICam™ class which should be used exists and is of the expected type
if (usc.userSetSelector.isValid && usc.userSetSelector.isWriteable && usc.userSetLoad.isValid)
{
Console.WriteLine("Loading the camera's default user set to avoid undefined settings!");
// selecting the default user set which includes the factory settings of the camera
usc.userSetSelector.writeS("Default");
// call the userSetLoad method to load the currently selected user set
usc.userSetLoad.call();
}
else
{
Console.WriteLine("The camera seems not to support user sets!");
}
Console.WriteLine();
}

In the next step the exposure time is modified after it is verified that the property is supported by the camera and it is currently writable.

Note
Usually it is a good idea to check if a property is available and if it is writable, since not every device supports every feature and not every feature is writable at every time.
double dExposureTime = 10000;
// initialise the AcquisitionControl class to get access to the exposure time property
AcquisitionControl acq = new AcquisitionControl(pDev);
// Make sure the exposure time property does exist and is currently not "read only"
if (acq.exposureTime.isValid && acq.exposureTime.isWriteable)
{
Console.WriteLine("Currently the exposure time is set to {0} us. Changing to {1}us ", acq.exposureTime.read(), dExposureTime);
Console.WriteLine();
acq.exposureTime.write(dExposureTime);
}

Afterwards the AOI of the camera is set to half of the sensor's size.

// check if the sensors properties are available and modifying the AOI settings if width and height are valid properties
if (ifc.width.isValid && ifc.height.isValid)
{
Console.WriteLine("The sensor has a max resolution of about {0}x{1} pixels", ifc.width.maxValue, ifc.height.maxValue);
Console.WriteLine("The resolution will now be adjusted to the half of width and height. The resulting AOI will be: {0}x{1} pixels", ifc.width.maxValue / 2, ifc.height.maxValue / 2);
// the AOI settings are usually not writable once the senor is exposing images so make sure width and height are not read-only at the moment
if (!ifc.width.isWriteable || !ifc.height.isWriteable)
{
Console.WriteLine("Width or Height are not writable at the moment.");
}
else
{
ifc.width.write(ifc.width.maxValue / 2);
ifc.height.write(ifc.height.maxValue / 2);
}
Console.WriteLine();
}

To simulate an external trigger the timers of the camera are used to generate trigger signals for the camera. Since it is possible that not every device supports as much timers or TimerTriggerSource values, some more complex checks are necessary to make sure everything works as expected.

CounterAndTimerControl ctc = new CounterAndTimerControl(pDev);
// Since the camera's settings have a huge impact on the frame rate of the sensor, we need the camera almost configured at this step. Otherwise the max frame rate would not be correct.
Console.WriteLine("To avoid some cabling work, we will use an internal timer for triggering in this sample!");
Console.WriteLine("The trigger frequency will be configured to half of the max frequency the sensor would be capable of in your setup.");
Console.WriteLine();
// Figuring out how many timers are available
List<string> availableTimers = new List<string>();
if(ctc.timerSelector.isValid)
{
ctc.timerSelector.getTranslationDictStrings(availableTimers);
}
double dPeriod = 0;
if (ctc.timerSelector.isValid && ctc.timerSelector.isWriteable && (availableTimers.Count >= 2) && acq.triggerSelector.isValid)
{
// Making sure that Timer2End as TimerTriggerSource does exist
ctc.timerSelector.writeS("Timer1");
List<string> availableTriggerSources = new List<string>();
ctc.timerTriggerSource.getTranslationDictStrings( availableTriggerSources );
if(availableTriggerSources.Contains("Timer2End") && acq.mvResultingFrameRate.isValid)
{
dPeriod = 1000000 / (acq.mvResultingFrameRate.read() / 2);
if (dPeriod >= 300)
{
// Defining the duration the trigger signal is "low"
ctc.timerDuration.write(1000);
ctc.timerTriggerSource.writeS("Timer2End");
// Defining the duration the trigger signal is "high"
ctc.timerTriggerSource.writeS("Timer1End");
ctc.timerSelector.writeS("Timer2");
ctc.timerDuration.write(dPeriod - 1000);
// Configuring the FrameStart trigger to use the start signal of Timer1 and enabling the trigger mode
acq.triggerSelector.writeS("FrameStart");
acq.triggerSource.writeS("Timer1Start");
acq.triggerMode.writeS("On");
}
else
{
Console.WriteLine("This camera does not support expected timer trigger sources! The camera will work in free run mode instead!");
}
}
}
else
{
Console.WriteLine("This camera does not support timers! The camera will work in free run mode instead!");
}

The next step shows how the analog gain of the camera's sensor can be modified. In this sample the value is set to its maximum.

AnalogControl anc = new AnalogControl(pDev);
// Applying some gain to the signal provided by the camera's sensor
if(anc.gain.isValid && anc.gain.isWriteable)
{
anc.gain.write(anc.gain.maxValue);
}

As the last configuration step the digital I/Os of the camera are shown and summarized by iterating over all string elements within the property lineSelector which defines the input or output line of the digital I/Os. The first digital output is configured to use the mvExposureAndAcquisitionActive signal to make sure the digital output is set to 'high' once the camera acquires images and exposes one.

Note
Since every line might be an input, output or bidirectional (depends on the hardware), the lineMode property for each line has to be read out.
DigitalIOControl dio = new DigitalIOControl(pDev);
// Figuring out how many digital IOs are available
List<string> availableIOs = new List<string>();
dio.lineSelector.getTranslationDictStrings(availableIOs);
Console.WriteLine("Available Digital IOs:");
bool boConfiguredFirstOutput = false;
// iterating over the vector of digital IOs to read out the lineMode, lineStatus and lineSource properties
for (int i = 0; i < availableIOs.Count; i++)
{
dio.lineSelector.writeS("Line" + i.ToString());
// using mvExposureAndAcquisitionActive as the lineSource for the first digital output found
if (!boConfiguredFirstOutput && dio.lineMode.readS() == "Output")
{
dio.lineSource.writeS("mvExposureAndAcquisitionActive");
boConfiguredFirstOutput = true;
}
Console.WriteLine("Line {0} - LineMode: {1} - LineStatus: {2} - LineSource: {3}", i.ToString(), dio.lineMode.readS(), dio.lineStatus.readS(), dio.lineSource.readS());
}

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

Source code
using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Threading;
#if USE_DISPLAY
#endif // #if USE_DISPLAY
using mv.impact.acquire.examples.helper;
namespace mv.impact.acquire.examples
{
class GenICamInterfaceLayout
{
private static bool canRestoreFactoryDefault(Device pDev)
{
GenICam.UserSetControl usc = new GenICam.UserSetControl(pDev);
if (!usc.userSetSelector.isValid || !usc.userSetLoad.isValid)
{
return false;
}
ReadOnlyCollection<String> validUserSetSelectorStrings = usc.userSetSelector.listOfValidStrings;
if (!validUserSetSelectorStrings.Contains("Default"))
{
return false;
}
return true;
}
static void Main(string[] args)
{
mv.impact.acquire.LibraryPath.init(); // this will add the folders containing unmanaged libraries to the PATH variable.
Console.WriteLine("--------------------------------------------!!! ATTENTION !!!--------------------------------------------");
Console.WriteLine("Please be aware that the digital outputs of the camera might be enabled during the test. This might lead to unexpected behavior in case of devices which are connected to one of the digital outputs, so only proceed if you are sure that this will not cause any issue with connected hardware!");
Console.WriteLine("---------------------------------------------------------------------------------------------------------");
Console.WriteLine();
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();
}
{
// 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.
// To make sure the camera will be configured based on a defined state, the default user set will be loaded
UserSetControl usc = new UserSetControl(pDev);
Console.WriteLine("The camera will be configured now!");
Console.WriteLine();
if (canRestoreFactoryDefault(pDev))
{
// Make sure the default user set and the load method exist
// In general it is a good idea to verify if the GenICam class which should be used exists and is of the expected type
if (usc.userSetSelector.isValid && usc.userSetSelector.isWriteable && usc.userSetLoad.isValid)
{
Console.WriteLine("Loading the camera's default user set to avoid undefined settings!");
// selecting the default user set which includes the factory settings of the camera
usc.userSetSelector.writeS("Default");
// call the userSetLoad method to load the currently selected user set
}
else
{
Console.WriteLine("The camera seems not to support user sets!");
}
Console.WriteLine();
}
double dExposureTime = 10000;
// initialise the AcquisitionControl class to get access to the exposure time property
// Make sure the exposure time property does exist and is currently not "read only"
if (acq.exposureTime.isValid && acq.exposureTime.isWriteable)
{
Console.WriteLine("Currently the exposure time is set to {0} us. Changing to {1}us ", acq.exposureTime.read(), dExposureTime);
Console.WriteLine();
acq.exposureTime.write(dExposureTime);
}
// initialising the ImageFormatControl class to get access to the sensor's AOI settings
// check if the sensors properties are available and modifying the AOI settings if width and height are valid properties
if (ifc.width.isValid && ifc.height.isValid)
{
Console.WriteLine("The sensor has a max resolution of about {0}x{1} pixels", ifc.width.maxValue, ifc.height.maxValue);
Console.WriteLine("The resolution will now be adjusted to the half of width and height. The resulting AOI will be: {0}x{1} pixels", ifc.width.maxValue / 2, ifc.height.maxValue / 2);
// the AOI settings are usually not writable once the senor is exposing images so make sure width and height are not read-only at the moment
if (!ifc.width.isWriteable || !ifc.height.isWriteable)
{
Console.WriteLine("Width or Height are not writable at the moment.");
}
else
{
ifc.width.write(ifc.width.maxValue / 2);
ifc.height.write(ifc.height.maxValue / 2);
}
Console.WriteLine();
}
// Since the camera's settings have a huge impact on the frame rate of the sensor, we need the camera almost configured at this step. Otherwise the max frame rate would not be correct.
Console.WriteLine("To avoid some cabling work, we will use an internal timer for triggering in this sample!");
Console.WriteLine("The trigger frequency will be configured to half of the max frequency the sensor would be capable of in your setup.");
Console.WriteLine();
// Figuring out how many timers are available
List<string> availableTimers = new List<string>();
if (ctc.timerSelector.isValid)
{
}
double dPeriod = 0;
if (ctc.timerSelector.isValid && ctc.timerSelector.isWriteable && (availableTimers.Count >= 2) && acq.triggerSelector.isValid)
{
// Making sure that Timer2End as TimerTriggerSource does exist
ctc.timerSelector.writeS("Timer1");
List<string> availableTriggerSources = new List<string>();
ctc.timerTriggerSource.getTranslationDictStrings(availableTriggerSources);
if (availableTriggerSources.Contains("Timer2End") && acq.mvResultingFrameRate.isValid)
{
dPeriod = 1000000 / (acq.mvResultingFrameRate.read() / 2);
if (dPeriod >= 300)
{
// Defining the duration the trigger signal is "low"
ctc.timerDuration.write(1000);
ctc.timerTriggerSource.writeS("Timer2End");
// Defining the duration the trigger signal is "high"
ctc.timerTriggerSource.writeS("Timer1End");
ctc.timerSelector.writeS("Timer2");
ctc.timerDuration.write(dPeriod - 1000);
// Configuring the FrameStart trigger to use the start signal of Timer1 and enabling the trigger mode
acq.triggerSelector.writeS("FrameStart");
acq.triggerSource.writeS("Timer1Start");
acq.triggerMode.writeS("On");
}
else
{
Console.WriteLine("This camera does not support expected timer trigger sources! The camera will work in free run mode instead!");
}
}
}
else
{
Console.WriteLine("This camera does not support timers! The camera will work in free run mode instead!");
}
AnalogControl anc = new AnalogControl(pDev);
// Applying some gain to the signal provided by the camera's sensor
if (anc.gain.isValid && anc.gain.isWriteable)
{
anc.gain.write(anc.gain.maxValue);
}
// Figuring out how many digital IOs are available
List<string> availableIOs = new List<string>();
Console.WriteLine("Available Digital IOs:");
bool boConfiguredFirstOutput = false;
// iterating over the vector of digital IOs to read out the lineMode, lineStatus and lineSource properties
for (int i = 0; i < availableIOs.Count; i++)
{
dio.lineSelector.writeS("Line" + i.ToString());
// using mvExposureAndAcquisitionActive as the lineSource for the first digital output found
if (!boConfiguredFirstOutput && dio.lineMode.readS() == "Output")
{
dio.lineSource.writeS("mvExposureAndAcquisitionActive");
boConfiguredFirstOutput = true;
}
Console.WriteLine("Line {0} - LineMode: {1} - LineStatus: {2} - LineSource: {3}", i.ToString(), dio.lineMode.readS(), dio.lineStatus.readS(), dio.lineSource.readS());
}
Console.WriteLine();
// 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
// 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}, LineStatusAll: {7}", pDev.serial.read(),
statistics.framesPerSecond.name, statistics.framesPerSecond.readS(),
statistics.errorCount.name, statistics.errorCount.readS(),
statistics.captureTime_s.name, statistics.captureTime_s.readS(),
dio.lineStatusAll.readS());
if (anc.gain.read() == anc.gain.maxValue)
{
anc.gain.write(anc.gain.minValue);
}
else
{
anc.gain.write(anc.gain.maxValue);
}
}
#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
}
//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
#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
});
thread.Start();
Console.ReadLine();
terminated = true;
thread.Join();
#if USE_DISPLAY
window.Dispose();
#endif // #if USE_DISPLAY
}
}
}
bool isValid
Checks if the internal component referenced by this object is still valid.
Definition Component.cs:727
This class and its functions represent an actual device detected by this interface in the current sys...
Definition Device.cs:91
const int INVALID_ID
A symbolic constant to define an invalid handle.
Definition Device.cs:177
void open()
Opens a device.
Definition Device.cs:208
readonly PropertyS serial
A string property (read-only) containing the serial number of this device.
Definition Device.cs:515
EnumPropertyF< T > write(T value)
Writes one value to the property.
Definition EnumPropertyF.cs:430
T read()
Reads a value from a property.
Definition EnumPropertyF.cs:323
T maxValue
Reads the maximum value from a property.
Definition EnumPropertyF.cs:546
T minValue
Reads the minimum value from a property.
Definition EnumPropertyF.cs:567
EnumPropertyI64< T > write(T value)
Writes one value to the property.
Definition EnumPropertyI64.cs:432
T maxValue
Reads the maximum value from a property.
Definition EnumPropertyI64.cs:548
EnumPropertyI64< T > getTranslationDictStrings(List< String > sequence)
This function queries a list of valid strings for this property.
Definition EnumPropertyI64.cs:198
ReadOnlyCollection< String > listOfValidStrings
Returns a list of valid strings for this property.
Definition EnumPropertyI64.cs:617
T read()
Reads a value from a property.
Definition EnumPropertyI.cs:342
The function interface to devices supported by this interface.
Definition FunctionInterface.cs:21
int imageRequestSingle()
Sends an image request to the mv.impact.acquire.Device driver.
Definition FunctionInterface.cs:656
Request getRequest(int nr)
Returns a const pointer to the desired mv.impact.acquire.Request.
Definition FunctionInterface.cs:452
int imageRequestWaitFor(int timeout_ms)
Waits for a request object to become ready.
Definition FunctionInterface.cs:1021
int imageRequestReset(int requestCtrlNr)
Deletes all requests currently queued for the specified mv.impact.acquire.ImageRequestControl.
Definition FunctionInterface.cs:575
bool isRequestNrValid(int nr)
Check if nr specifies a valid mv.impact.acquire.Request.
Definition FunctionInterface.cs:1098
Category for the acquisition and trigger control features.
Definition mvIMPACT_acquire_GenICam.autogen.cs:1934
readonly mv.impact.acquire.PropertyI64 triggerSource
An enumerated integer property. Specifies the internal signal or physical input Line to use as the tr...
Definition mvIMPACT_acquire_GenICam.autogen.cs:2362
readonly mv.impact.acquire.PropertyF mvResultingFrameRate
A floating point property. Shows the resulting frame rate.
Definition mvIMPACT_acquire_GenICam.autogen.cs:2621
readonly mv.impact.acquire.PropertyI64 triggerSelector
An enumerated integer property. Selects the type of trigger to configure.
Definition mvIMPACT_acquire_GenICam.autogen.cs:2191
readonly mv.impact.acquire.PropertyI64 triggerMode
An enumerated integer property. Controls if the selected trigger is active.
Definition mvIMPACT_acquire_GenICam.autogen.cs:2203
readonly mv.impact.acquire.PropertyF exposureTime
A floating point property. Sets the Exposure time when ExposureMode is Timed and ExposureAuto is Off.
Definition mvIMPACT_acquire_GenICam.autogen.cs:2462
Category that contains the Analog control features.
Definition mvIMPACT_acquire_GenICam.autogen.cs:2833
readonly mv.impact.acquire.PropertyF gain
A floating point property. Controls the selected gain as an absolute physical value.
Definition mvIMPACT_acquire_GenICam.autogen.cs:3026
Category that contains the Counter and Timer control features.
Definition mvIMPACT_acquire_GenICam.autogen.cs:3994
readonly mv.impact.acquire.PropertyF timerDuration
A floating point property. Sets the duration (in microseconds) of the Timer pulse.
Definition mvIMPACT_acquire_GenICam.autogen.cs:4583
readonly mv.impact.acquire.PropertyI64 timerSelector
An enumerated integer property. Selects which Timer to configure.
Definition mvIMPACT_acquire_GenICam.autogen.cs:4578
readonly mv.impact.acquire.PropertyI64 timerTriggerSource
An enumerated integer property. Selects the source of the trigger to start the Timer.
Definition mvIMPACT_acquire_GenICam.autogen.cs:4733
Category that contains the digital input and output control features.
Definition mvIMPACT_acquire_GenICam.autogen.cs:3628
readonly mv.impact.acquire.PropertyI64 lineSource
An enumerated integer property. Selects which internal acquisition or I/O source signal to output on ...
Definition mvIMPACT_acquire_GenICam.autogen.cs:3862
readonly mv.impact.acquire.PropertyI64 lineMode
An enumerated integer property. Controls if the physical Line is used to Input or Output a signal.
Definition mvIMPACT_acquire_GenICam.autogen.cs:3730
readonly mv.impact.acquire.PropertyI64 lineSelector
An enumerated integer property. Selects the physical line (or pin) of the external device connector o...
Definition mvIMPACT_acquire_GenICam.autogen.cs:3718
readonly mv.impact.acquire.PropertyI64 lineStatusAll
An integer property. Returns the current status of all available Line signals at time of polling in a...
Definition mvIMPACT_acquire_GenICam.autogen.cs:3783
readonly mv.impact.acquire.PropertyIBoolean lineStatus
A boolean property. Returns the current status of the selected input or output Line.
Definition mvIMPACT_acquire_GenICam.autogen.cs:3740
Category for Image Format Control features.
Definition mvIMPACT_acquire_GenICam.autogen.cs:1021
readonly mv.impact.acquire.PropertyI64 width
An integer property. Width of the image provided by the device (in pixels).
Definition mvIMPACT_acquire_GenICam.autogen.cs:1341
readonly mv.impact.acquire.PropertyI64 height
An integer property. Height of the image provided by the device (in pixels).
Definition mvIMPACT_acquire_GenICam.autogen.cs:1346
Category that contains the User Set control features.
Definition mvIMPACT_acquire_GenICam.autogen.cs:8782
readonly mv.impact.acquire.PropertyI64 userSetSelector
An enumerated integer property. Selects the feature User Set to load, save or configure.
Definition mvIMPACT_acquire_GenICam.autogen.cs:8848
readonly mv.impact.acquire.Method userSetLoad
A method object. Loads the User Set specified by UserSetSelector to the device and makes it active.
Definition mvIMPACT_acquire_GenICam.autogen.cs:8858
UserSetControl(mv.impact.acquire.Device device)
Constructs a new mv.impact.acquire.GenICam.UserSetControl object.
Definition mvIMPACT_acquire_GenICam.autogen.cs:8786
An base class for exceptions generated by Impact Acquire.
Definition Exceptions.cs:9
static String getErrorCodeAsString(int errorCode)
Returns a string representation of a error.
Definition Exceptions.cs:48
A small helper class to administer various library search path related variables and paths.
Definition LibraryPath.cs:14
static void init()
Calling this method will add the folders containing unmanaged libraries to the systems library search...
Definition LibraryPath.cs:251
int call(List< String > callParams)
Calls an underlying driver function.
Definition Method.cs:94
IntPtr read()
Reads a value from a property.
Definition PropertyPtr.cs:49
String read()
Reads a value from a property.
Definition PropertyS.cs:144
Contains information about a captured buffer.
Definition Request.cs:77
readonly PropertyPtr imageData
A pointer property (read-only) containing the start address of the image data.
Definition Request.cs:1556
readonly PropertyI imageLinePitch
An integer property (read-only) containing the offset (in bytes) to the next line of each channel bel...
Definition Request.cs:1630
readonly EnumPropertyI< TRequestResult > requestResult
An enumerated integer property (read-only) defining the result of this request.
Definition Request.cs:1210
readonly PropertyI imageWidth
An integer property (read-only) containing the width of the image in pixels.
Definition Request.cs:1668
readonly PropertyI imageBytesPerPixel
An integer property (read-only) containing the number of bytes per pixel in this image.
Definition Request.cs:1654
bool isOK
Convenience function to check if a request has been processed successfully.
Definition Request.cs:1172
readonly PropertyI imageHeight
An integer property (read-only) containing the height of the image in pixels.
Definition Request.cs:1679
int unlock()
Unlocks the request for the driver again.
Definition Request.cs:618
Contains statistical information.
Definition Statistics.cs:10
readonly PropertyI errorCount
An integer property (read-only) containing the overall count of image requests which returned with an...
Definition Statistics.cs:82
readonly PropertyF framesPerSecond
A float property (read-only) containing the current number of frames captured per second.
Definition Statistics.cs:88
readonly PropertyF captureTime_s
A float property (read-only) containing the average time needed to capture an image.
Definition Statistics.cs:75
A class that can be used to display images in a window.
Definition ImageDisplayWindow.cs:15
readonly ImageDisplay imageDisplay
Returns a reference to the actual display object associated with this window.
Definition ImageDisplayWindow.cs:108
void Dispose()
Performs application-defined tasks associated with freeing, releasing, or resetting unmanaged resourc...
Definition ImageDisplayWindow.cs:85
void RemoveImage()
Removes the current image from the display.
Definition ImageDisplay.cs:302
void SetImage(IntPtr pData, int width, int height, int bipp, int pitch)
Sets the next image to display.
Definition ImageDisplay.cs:257
void Update()
Immediately redraws the current image.
Definition ImageDisplay.cs:308
TDMR_ERROR
Errors reported by the device manager.
Definition mvDriverBaseEnums.cs:2374
This namespace contains classes and functions belonging to the GenICam specific part of the image acq...
Definition GenTLDriverConfigurator.cs:6
This namespace contains classes and functions that can be used to display images.
Definition Enumerations.cs:2
This namespace contains classes and functions belonging to the image acquisition module of this SDK.
Definition Enumerations.cs:2
Definition Enumerations.cs:2
Definition Enumerations.cs:2