/* A device has been opened. Update the control. */
private void DeviceOpenedEventHandler()
{
if (InvokeRequired)
{
/* If called from a different thread, we must use the Invoke method to marshal the call to the proper thread. */
BeginInvoke(new ImageProvider.DeviceOpenedEventHandler(DeviceOpenedEventHandler));
return;
}
try
{
/* Get the node. */
m_hNode = m_imageProvider.GetNodeFromDevice(name);
/* Register for changes. */
m_hCallbackHandle = GenApi.NodeRegisterCallback(m_hNode, m_nodeCallbackHandler);
/* Update the displayed name. */
labelName.Text = GenApi.NodeGetDisplayName(m_hNode) + ":";
/* Update the control values. */
UpdateValues();
}
catch
{
/* If errors occurred disable the control. */
Reset();
}
}
public void OneFrame()
{
try
{
lock (dev)
{
Pylon.DeviceOpen(dev, Pylon.cPylonAccessModeControl | Pylon.cPylonAccessModeStream);
PylonGrabResult_t grabResult;
PylonBuffer <Byte> imgBuf = null;
if (!Pylon.DeviceGrabSingleFrame(dev, 0, ref imgBuf, out grabResult, 500))
{
Console.WriteLine("timeout");
}
if (grabResult.Status == EPylonGrabStatus.Grabbed)
{
OnGrabAndDispose(GrabResultToImage(grabResult, imgBuf));
}
else if (grabResult.Status == EPylonGrabStatus.Failed)
{
Console.Error.WriteLine("Frame wasn't grabbed successfully. Error code = {1}", grabResult.ErrorCode);
}
Pylon.DeviceClose(dev);
}
}
catch
{
Console.WriteLine(GenApi.GetLastErrorDetail());
}
}
/* If the device provides a heartbeat timeout, this function will set the heartbeat timeout.
* When the device provides the parameter, the old value is returned, -1 otherwise.
* The heartbeat timeout is a parameter provided by the transport layer.
* The transport layer parameters are exposed as a GenApi node map that
* can be retrieved from the device.
*/
private static long setHeartbeatTimeout(PYLON_DEVICE_HANDLE hDev, long timeout_ms)
{
NODEMAP_HANDLE hNodemap; /* Handle to the node map. */
NODE_HANDLE hNode; /* Handle to a node, i.e., a feature. */
long oldTimeout; /* The current timeout value. */
/* Get the node map for the transport layer parameters. */
hNodemap = Pylon.DeviceGetTLNodeMap(hDev);
if (!hNodemap.IsValid)
{
/* The device doesn't provide a transport layer node map. Nothing to do. */
Console.WriteLine("The device doesn't provide a transport layer node map. Cannot set heartbeat timeout.");
return(-1);
}
/* Get the node for the heartbeat timeout parameter. */
hNode = GenApi.NodeMapGetNode(hNodemap, "HeartbeatTimeout");
if (!hNode.IsValid)
{
/* There is no heartbeat timeout parameter. Nothing to do. */
Console.WriteLine("There is no heartbeat timeout parameter. Cannot set heartbeat timeout.");
return(-1);
}
/* Get the current value. */
oldTimeout = GenApi.IntegerGetValue(hNode);
/* Set the new value. */
GenApi.IntegerSetValue(hNode, timeout_ms);
/* Return the old value. */
return(oldTimeout);
}
private static CameraProperty ReadFloatProperty(PYLON_DEVICE_HANDLE deviceHandle, string symbol)
{
CameraProperty p = new CameraProperty();
p.Identifier = symbol;
NODEMAP_HANDLE nodeMapHandle = Pylon.DeviceGetNodeMap(deviceHandle);
NODE_HANDLE nodeHandle = GenApi.NodeMapGetNode(nodeMapHandle, symbol);
if (!nodeHandle.IsValid)
{
return(p);
}
EGenApiAccessMode accessMode = GenApi.NodeGetAccessMode(nodeHandle);
if (accessMode == EGenApiAccessMode._UndefinedAccesMode || accessMode == EGenApiAccessMode.NA ||
accessMode == EGenApiAccessMode.NI || accessMode == EGenApiAccessMode.WO)
{
return(p);
}
p.Supported = true;
p.ReadOnly = accessMode != EGenApiAccessMode.RW;
EGenApiNodeType type = GenApi.NodeGetType(nodeHandle);
if (type != EGenApiNodeType.FloatNode)
{
return(p);
}
p.Type = CameraPropertyType.Float;
double min = GenApi.FloatGetMin(nodeHandle);
double max = GenApi.FloatGetMax(nodeHandle);
EGenApiRepresentation repr = GenApi.FloatGetRepresentation(nodeHandle);
double currentValue = GenApi.FloatGetValue(nodeHandle);
// We don't support a dedicated control for "pure numbers" just use the regular slider.
if (repr == EGenApiRepresentation.PureNumber)
{
repr = EGenApiRepresentation.Linear;
}
// Fix values that should be log.
double range = Math.Log(max - min, 10);
if (range > 4 && repr == EGenApiRepresentation.Linear)
{
repr = EGenApiRepresentation.Logarithmic;
}
p.Minimum = min.ToString(CultureInfo.InvariantCulture);
p.Maximum = max.ToString(CultureInfo.InvariantCulture);
p.Representation = ConvertRepresentation(repr);
p.CurrentValue = currentValue.ToString(CultureInfo.InvariantCulture);
return(p);
}
/*
* Regardless of the parameter's type, any parameter value can be retrieved as a string. Likewise, each parameter
* can be set by passing in a string. This function illustrates how to set and get the
* Width parameter as a string. As demonstrated above, the Width parameter is of the integer type.
*/
private static void demonstrateFromStringToString(PYLON_DEVICE_HANDLE hDev)
{
string featureName = "Width"; /* The name of the feature. */
string value;
/* Get the value of a feature as a string. */
value = Pylon.DeviceFeatureToString(hDev, featureName);
Console.WriteLine("{0}: {1}", featureName, value);
/* A feature can be set as a string using the PylonDeviceFeatureFromString() function.
* If the content of a string can not be converted to the type of the feature, an
* error is returned. */
try
{
Pylon.DeviceFeatureFromString(hDev, featureName, "fourty-two"); /* Cannot be converted to an integer. */
}
catch (Exception e)
{
/* Retrieve the error message. */
string msg = GenApi.GetLastErrorMessage() + "\n" + GenApi.GetLastErrorDetail();
Console.WriteLine("Exception caught:");
Console.WriteLine(e.Message);
if (msg != "\n")
{
Console.WriteLine("Last error message:");
Console.WriteLine(msg);
}
}
}
public static void WriteEnum(PYLON_DEVICE_HANDLE deviceHandle, string enumerationName, string enumerationValue)
{
NODEMAP_HANDLE nodeMapHandle = Pylon.DeviceGetNodeMap(deviceHandle);
NODE_HANDLE nodeHandle = GenApi.NodeMapGetNode(nodeMapHandle, enumerationName);
WriteEnum(nodeHandle, enumerationName, enumerationValue);
}
/* Handle slider position changes. */
private void slider_Scroll(object sender, EventArgs e)
{
if (m_hNode.IsValid)
{
try {
if (GenApi.NodeIsWritable(m_hNode))
{
/* Correct the increment of the new value. */
//int value = slider.Value - ((slider.Value - slider.Minimum) % slider.SmallChange);
float divided = slider.Value / 1000f;
var lerped = Lerp(maxValue, minValue, divided);
/* Set the value. */
Pylon.DeviceSetFloatFeature(m_imageProvider.m_hDevice, NodeName, lerped);
}
}
catch {
/* Ignore any errors here. */
}
}
}
/* Loads config nodes and configures the basler camera. */
private void LoadConfigNodes(params string[] nodeNames)
{
foreach (var name in nodeNames)
{
var nodeConf = Config.GetConfig(name);
if (nodeConf == null || string.IsNullOrWhiteSpace(nodeConf))
{
continue;
}
if (!long.TryParse(nodeConf, out long value))
{
continue;
}
var node = ImageProvider.GetNodeFromDevice(name);
if (node.IsValid)
{
/* Is Writtable. */
if (GenApi.NodeIsWritable(node))
{
GenApi.IntegerSetValue(node, value);
}
}
}
}
public void SetExposure(int value)
{
bool bval;
//ExposureTimeRaw
NODE_HANDLE m_hNode = new NODE_HANDLE();
m_hNode = m_imageProvider.GetNodeFromDevice("ExposureTimeRaw");
if (m_hNode.IsValid)
{
int inc = checked ((int)GenApi.IntegerGetInc(m_hNode));
int min = checked ((int)GenApi.IntegerGetMin(m_hNode));
int max = checked ((int)GenApi.IntegerGetMax(m_hNode));
int expVal = (value) - (value % inc);
if (expVal < min)
{
expVal = min;
}
if (expVal > max)
{
expVal = max;
}
if (!m_hNode.IsValid)
{
return;
}
bval = GenApi.NodeIsWritable(m_hNode);
if (!bval)
{
return;
}
GenApi.IntegerSetValue(m_hNode, expVal);
}
}
/* Load a boolean node. */
private void LoadBooleanNode(string nodeName)
{
var nodeConf = Config.GetConfig(nodeName);
if (nodeConf == null || string.IsNullOrWhiteSpace(nodeConf))
{
return;
}
if (!bool.TryParse(nodeConf, out bool value))
{
return;
}
var node = ImageProvider.GetNodeFromDevice(nodeName);
if (node.IsValid)
{
if (GenApi.NodeIsWritable(node))
{
GenApi.BooleanSetValue(node, value);
}
}
}
private static CameraProperty ReadIntegerProperty(PYLON_DEVICE_HANDLE deviceHandle, string symbol)
{
CameraProperty p = new CameraProperty();
p.Identifier = symbol;
NODEMAP_HANDLE nodeMapHandle = Pylon.DeviceGetNodeMap(deviceHandle);
NODE_HANDLE nodeHandle = GenApi.NodeMapGetNode(nodeMapHandle, symbol);
if (!nodeHandle.IsValid)
{
log.WarnFormat("Could not read Basler property {0}: node handle is not valid. (The property is not supported).", symbol);
return(p);
}
EGenApiAccessMode accessMode = GenApi.NodeGetAccessMode(nodeHandle);
if (accessMode == EGenApiAccessMode._UndefinedAccesMode || accessMode == EGenApiAccessMode.NA ||
accessMode == EGenApiAccessMode.NI || accessMode == EGenApiAccessMode.WO)
{
log.WarnFormat("Could not read Basler property {0}: Access mode not supported. (The property is not readable).", symbol);
return(p);
}
EGenApiNodeType type = GenApi.NodeGetType(nodeHandle);
if (type != EGenApiNodeType.IntegerNode)
{
log.WarnFormat("Could not read Basler property {0}: the node is of the wrong type. Expected: Integer. Received:{1}", symbol, type.ToString());
return(p);
}
p.Supported = true;
p.Type = CameraPropertyType.Integer;
p.ReadOnly = accessMode != EGenApiAccessMode.RW;
long min = GenApi.IntegerGetMin(nodeHandle);
long max = GenApi.IntegerGetMax(nodeHandle);
long step = GenApi.IntegerGetInc(nodeHandle);
EGenApiRepresentation repr = GenApi.IntegerGetRepresentation(nodeHandle);
// Fix values that should be log.
double range = Math.Log10(max) - Math.Log10(min);
if (range > 4 && repr == EGenApiRepresentation.Linear)
{
repr = EGenApiRepresentation.Logarithmic;
}
long currentValue = GenApi.IntegerGetValue(nodeHandle);
p.Minimum = min.ToString(CultureInfo.InvariantCulture);
p.Maximum = max.ToString(CultureInfo.InvariantCulture);
p.Step = step.ToString(CultureInfo.InvariantCulture);
p.Representation = ConvertRepresentation(repr);
p.CurrentValue = currentValue.ToString(CultureInfo.InvariantCulture);
return(p);
}
/* Some features are floating point features. This function illustrates how to set and get floating
* point parameters. */
private static void demonstrateFloatFeature(PYLON_DEVICE_HANDLE hDev)
{
NODEMAP_HANDLE hNodeMap;
NODE_HANDLE hNode;
string featureName = "Gamma"; /* The name of the feature used. */
bool bval; /* Is the feature available? */
double min, max, value; /* Value range and current value. */
EGenApiNodeType nodeType;
/* Get a handle for the device's node map. */
hNodeMap = Pylon.DeviceGetNodeMap(hDev);
/* Look up the feature node. */
hNode = GenApi.NodeMapGetNode(hNodeMap, featureName);
if (!hNode.IsValid)
{
Console.WriteLine("There is no feature named '" + featureName + "'.");
return;
}
/* We want a float feature node. */
nodeType = GenApi.NodeGetType(hNode);
if (EGenApiNodeType.FloatNode != nodeType)
{
Console.WriteLine("'" + featureName + "' is not an floating-point feature.");
return;
}
bval = GenApi.NodeIsReadable(hNode);
if (bval)
{
/* Query the value range and the current value. */
min = GenApi.FloatGetMin(hNode);
max = GenApi.FloatGetMax(hNode);
value = GenApi.FloatGetValue(hNode);
Console.WriteLine("{0}: min = {1}, max = {2}, value = {3}", featureName, min, max, value);
/* Set a new value. */
bval = GenApi.NodeIsWritable(hNode);
if (bval)
{
value = 0.5 * (min + max);
Console.WriteLine("Setting {0} to {1}", featureName, value);
GenApi.FloatSetValue(hNode, value);
}
else
{
Console.WriteLine("Cannot set value for feature '{0}' - node not writable.", featureName);
}
}
else
{
Console.WriteLine("Cannot read feature '{0}' - node not readable.", featureName);
}
}
/* Returns a GenICam parameter node handle of the device identified by the name of the node. */
public NODE_HANDLE GetNodeFromDevice( string name )
{
if( m_open && !m_removed ) {
NODEMAP_HANDLE hNodemap = Pylon.DeviceGetNodeMap( m_hDevice );
return GenApi.NodeMapGetNode( hNodemap, name );
}
return new NODE_HANDLE();
}
public static string DeviceGetStringFeature(PYLON_DEVICE_HANDLE handle, string featureName)
{
NODEMAP_HANDLE nodeMapHandle = Pylon.DeviceGetNodeMap(handle);
NODE_HANDLE nodeHandle = GenApi.NodeMapGetNode(nodeMapHandle, featureName);
string featureValue = GenApi.NodeToString(nodeHandle);
return(featureValue);
}
/* Get the current values from the node and display them. */
private void UpdateValues()
{
try {
if (m_hNode.IsValid)
{
/* Check if proper node type. */
if (GenApi.NodeGetType(m_hNode) == EGenApiNodeType.IntegerNode)
{
/* Get the values. */
bool writable = GenApi.NodeIsWritable(m_hNode);
int min = checked ((int)GenApi.IntegerGetMin(m_hNode));
int max = checked ((int)GenApi.IntegerGetMax(m_hNode));
int val = checked ((int)GenApi.IntegerGetValue(m_hNode));
int inc = checked ((int)GenApi.IntegerGetInc(m_hNode));
if (name == "ExposureTimeRaw")
{
max = MaximumExposure;
if (val > max)
{
val = max;
}
}
/* Update the slider. */
slider.Minimum = min;
slider.Maximum = max;
slider.Value = val;
slider.SmallChange = inc;
slider.TickFrequency = (max - min + 5) / 10;
labelCurrentValue.Maximum = max;
labelCurrentValue.Minimum = min;
/* Update the values. */
labelMin.Text = "" + min;
labelMax.Text = "" + max;
labelCurrentValue.Text = "" + val;
/* Update accessibility. */
slider.Enabled = writable;
labelMin.Enabled = writable;
labelMax.Enabled = writable;
labelName.Enabled = writable;
labelCurrentValue.Enabled = writable;
return;
}
}
}
catch {
/* If errors occurred disable the control. */
}
//Reset ();
}
private static CameraProperty ReadIntegerProperty(PYLON_DEVICE_HANDLE deviceHandle, string symbol)
{
CameraProperty p = new CameraProperty();
p.Identifier = symbol;
NODEMAP_HANDLE nodeMapHandle = Pylon.DeviceGetNodeMap(deviceHandle);
NODE_HANDLE nodeHandle = GenApi.NodeMapGetNode(nodeMapHandle, symbol);
if (!nodeHandle.IsValid)
{
return(p);
}
EGenApiAccessMode accessMode = GenApi.NodeGetAccessMode(nodeHandle);
if (accessMode == EGenApiAccessMode._UndefinedAccesMode || accessMode == EGenApiAccessMode.NA ||
accessMode == EGenApiAccessMode.NI || accessMode == EGenApiAccessMode.WO)
{
return(p);
}
p.Supported = true;
p.ReadOnly = accessMode != EGenApiAccessMode.RW;
EGenApiNodeType type = GenApi.NodeGetType(nodeHandle);
if (type != EGenApiNodeType.IntegerNode)
{
return(p);
}
p.Type = CameraPropertyType.Integer;
long min = GenApi.IntegerGetMin(nodeHandle);
long max = GenApi.IntegerGetMax(nodeHandle);
long step = GenApi.IntegerGetInc(nodeHandle);
EGenApiRepresentation repr = GenApi.IntegerGetRepresentation(nodeHandle);
// Fix values that should be log.
double range = Math.Log(max - min, 10);
if (range > 4 && repr == EGenApiRepresentation.Linear)
{
repr = EGenApiRepresentation.Logarithmic;
}
long currentValue = GenApi.IntegerGetValue(nodeHandle);
p.Minimum = min.ToString(CultureInfo.InvariantCulture);
p.Maximum = max.ToString(CultureInfo.InvariantCulture);
p.Step = step.ToString(CultureInfo.InvariantCulture);
p.Representation = ConvertRepresentation(repr);
p.CurrentValue = currentValue.ToString(CultureInfo.InvariantCulture);
return(p);
}
/* Some features are boolean features that can be switched on and off.
* This function illustrates how to access boolean features. */
private static void demonstrateBooleanFeature(PYLON_DEVICE_HANDLE hDev)
{
NODEMAP_HANDLE hNodeMap;
NODE_HANDLE hNode;
string featureName = "GammaEnable"; /* The name of the feature. */
bool value, bval; /* The value of the feature. */
EGenApiNodeType nodeType;
/* Get a handle for the device's node map. */
hNodeMap = Pylon.DeviceGetNodeMap(hDev);
/* Look up the feature node. */
hNode = GenApi.NodeMapGetNode(hNodeMap, featureName);
if (!hNode.IsValid)
{
Console.WriteLine("There is no feature named '" + featureName + "'.");
return;
}
/* We want a boolean feature node. */
nodeType = GenApi.NodeGetType(hNode);
if (EGenApiNodeType.BooleanNode != nodeType)
{
Console.WriteLine("'" + featureName + "' is not a boolean feature.");
return;
}
/* Check to see if the feature is readable. */
bval = GenApi.NodeIsReadable(hNode);
if (bval)
{
/* Retrieve the current state of the feature. */
value = GenApi.BooleanGetValue(hNode);
Console.WriteLine("The {0} feature is {1}.", featureName, value ? "on" : "off");
/* Set a new value. */
bval = GenApi.NodeIsWritable(hNode);
if (bval)
{
value = (bool)!value; /* New value. */
Console.WriteLine("Switching the {0} feature {1}.", featureName, value ? "on" : "off");
GenApi.BooleanSetValue(hNode, value);
}
else
{
Console.WriteLine("Cannot set value for feature '{0}' - node not writable.", featureName);
}
}
else
{
Console.WriteLine("Cannot read feature '{0}' - node not readable.", featureName);
}
}
public static void Write(PYLON_DEVICE_HANDLE deviceHandle, CameraProperty property)
{
if (!property.Supported || string.IsNullOrEmpty(property.Identifier))
{
return;
}
NODEMAP_HANDLE nodeMapHandle = Pylon.DeviceGetNodeMap(deviceHandle);
NODE_HANDLE nodeHandle = GenApi.NodeMapGetNode(nodeMapHandle, property.Identifier);
if (!nodeHandle.IsValid)
{
return;
}
EGenApiAccessMode accessMode = GenApi.NodeGetAccessMode(nodeHandle);
if (accessMode != EGenApiAccessMode.RW)
{
return;
}
switch (property.Type)
{
case CameraPropertyType.Integer:
{
long value = long.Parse(property.CurrentValue, CultureInfo.InvariantCulture);
long step = long.Parse(property.Step, CultureInfo.InvariantCulture);
long remainder = value % step;
if (remainder > 0)
{
value = value - remainder;
}
GenApi.IntegerSetValue(nodeHandle, value);
break;
}
case CameraPropertyType.Float:
{
double value = double.Parse(property.CurrentValue, CultureInfo.InvariantCulture);
GenApi.FloatSetValue(nodeHandle, value);
break;
}
case CameraPropertyType.Boolean:
{
bool value = bool.Parse(property.CurrentValue);
GenApi.BooleanSetValue(nodeHandle, value);
break;
}
default:
break;
}
}
/// <summary>
/// Statistic_Failed_Packet_Count 読み出し
/// </summary>
public long Get_Statistic_Failed_Packet_Count()
{
try
{
NODE_HANDLE hNode;
EGenApiNodeType nodeType;
bool bval; /* Is the feature available? */
string featureName; /* Name of the feature used in this sample: AOI Width. */
//bool isAvailable; /* Is the feature available? */
//double val = 0; /* Properties of the feature. */
long val, min, max, incr; /* Properties of the feature. */
featureName = "Statistic_Failed_Packet_Count";
hNode = m_imageProvider.GetNodeFromDevice(featureName);
if (!hNode.IsValid)
{
Console.WriteLine("There is no feature named '" + featureName + "'.");
return(0);
}
/* We want a float feature node. */
nodeType = GenApi.NodeGetType(hNode);
if (EGenApiNodeType.FloatNode != nodeType)
{
Console.WriteLine("'" + featureName + "' is not an floating-point feature.");
return(0);
}
bval = GenApi.NodeIsReadable(hNode);
if (bval)
{
min = GenApi.IntegerGetMin(hNode); /* Get the minimum value. */
max = GenApi.IntegerGetMax(hNode); /* Get the maximum value. */
incr = GenApi.IntegerGetInc(hNode); /* Get the increment value. */
val = GenApi.IntegerGetValue(hNode); /* Get the current value. */
return(val);
}
return(0);
}
catch
{
// UpdateLastError(); /* Get the last error message here, because it could be overwritten by cleaning up. */
try
{
Close(); /* Try to close any open handles. */
}
catch
{
/* Another exception cannot be handled. */
}
throw;
}
}
/// <summary>
/// Expo値読み出し[us]
/// </summary>
public double GetExposureTime()
{
try
{
NODE_HANDLE hNode;
EGenApiNodeType nodeType;
bool bval; /* Is the feature available? */
string featureName; /* Name of the feature used in this sample: AOI Width. */
//bool isAvailable; /* Is the feature available? */
double val = 0; /* Properties of the feature. */
featureName = "ExposureTimeAbs";
hNode = m_imageProvider.GetNodeFromDevice(featureName);
if (!hNode.IsValid)
{
Console.WriteLine("There is no feature named '" + featureName + "'.");
return(0);
}
/* We want a float feature node. */
nodeType = GenApi.NodeGetType(hNode);
if (EGenApiNodeType.FloatNode != nodeType)
{
Console.WriteLine("'" + featureName + "' is not an floating-point feature.");
return(0);
}
bval = GenApi.NodeIsReadable(hNode);
if (bval)
{
/* Query the value range and the current value. */
val = GenApi.FloatGetValue(hNode);
return(val); // [us]
}
return(0);
}
catch
{
// UpdateLastError(); /* Get the last error message here, because it could be overwritten by cleaning up. */
try
{
Close(); /* Try to close any open handles. */
}
catch
{
/* Another exception cannot be handled. */
}
throw;
}
}
/* Creates the last error text from message and detailed text. */
private string GetLastErrorText()
{
string lastErrorMessage = GenApi.GetLastErrorMessage();
string lastErrorDetail = GenApi.GetLastErrorDetail();
string lastErrorText = lastErrorMessage;
if( lastErrorDetail.Length > 0 ) {
lastErrorText += "\n\nDetails:\n";
}
lastErrorText += lastErrorDetail;
return lastErrorText;
}
/* Saves enumeration node. */
private void SaveStringNode(string nodeName)
{
var node = managedCamera.ImageProvider.GetNodeFromDevice(nodeName);
if (node.IsValid)
{
var value = GenApi.NodeToString(node);
config.SetConfig(nodeName, value.ToString());
}
}
private static void demonstrateCategory(PYLON_DEVICE_HANDLE hDev)
{
NODEMAP_HANDLE hNodeMap;
NODE_HANDLE hNode;
/* Get a handle for the device's node map. */
hNodeMap = Pylon.DeviceGetNodeMap(hDev);
/* Look up the root node. */
hNode = GenApi.NodeMapGetNode(hNodeMap, "Root");
handleCategory(hNode, "");
}
public static void WriteStreamFormat(PYLON_DEVICE_HANDLE deviceHandle, string selectedFormatSymbol)
{
string enumerationName = "PixelFormat";
NODEMAP_HANDLE nodeMapHandle = Pylon.DeviceGetNodeMap(deviceHandle);
NODE_HANDLE nodeHandle = GenApi.NodeMapGetNode(nodeMapHandle, enumerationName);
if (!nodeHandle.IsValid)
{
return;
}
try
{
bool available = GenApi.NodeIsAvailable(nodeHandle);
if (!available)
{
return;
}
uint itemCount = GenApi.EnumerationGetNumEntries(nodeHandle);
for (uint i = 0; i < itemCount; i++)
{
NODE_HANDLE entryHandle = GenApi.EnumerationGetEntryByIndex(nodeHandle, i);
if (!GenApi.NodeIsAvailable(entryHandle))
{
continue;
}
string value = GenApi.EnumerationEntryGetSymbolic(entryHandle);
if (value != selectedFormatSymbol)
{
continue;
}
if (GenApi.NodeToString(nodeHandle) == value)
{
continue;
}
GenApi.NodeFromString(nodeHandle, value);
break;
}
}
catch
{
// Silent catch.
}
}
/* Saves float nodes. */
private void SaveFloatNode(params string [] nodeNames)
{
foreach (var name in nodeNames)
{
var node = managedCamera.ImageProvider.GetNodeFromDevice(name);
if (node.IsValid)
{
var value = GenApi.FloatGetValue(node);
config.SetConfig(name, value.ToString());
}
}
}
public static string GetLastError()
{
// Similar to ImageProvider.GetLastError().
string lastErrorMessage = GenApi.GetLastErrorMessage();
string lastErrorDetail = GenApi.GetLastErrorDetail();
string lastErrorText = lastErrorMessage;
if (lastErrorDetail.Length > 0)
{
lastErrorText += "\n\nDetails:\n";
}
lastErrorText += lastErrorDetail;
return(lastErrorText);
}
/* Checkbox changed for auto brightness. */
private void AutoBrightnessChanged(object sender, EventArgs e)
{
var nodeAutoExposure = managedCamera.ImageProvider.GetNodeFromDevice("ExposureAuto");
if (nodeAutoExposure.IsValid)
{
bool writable = GenApi.NodeIsWritable(nodeAutoExposure);
if (writable)
{
GenApi.NodeFromString(nodeAutoExposure, autoBrightnessCheckbox.Checked ? "Continuous" : "Off");
}
}
}
private void OnInit(object sender, EventArgs e)
{
var imageProvider = managedCamera.ImageProvider;
var autoNode = imageProvider.GetNodeFromDevice("ExposureAuto");
if (autoNode.IsValid)
{
string selected = GenApi.NodeToString(autoNode);
if (selected == "Off")
{
autoBrightnessCheckbox.Checked = false;
}
else
{
autoBrightnessCheckbox.Checked = true;
}
}
ExposureSlider.MyImageProvider = imageProvider;
GainSlider.MyImageProvider = imageProvider;
WidthSlider.MyImageProvider = imageProvider;
HeightSlider.MyImageProvider = imageProvider;
xPosBar.MyImageProvider = imageProvider;
yPosBar.MyImageProvider = imageProvider;
BrightnessBar.MyImageProvider = imageProvider;
ExposureSlider.MaximumExposure = maxExposure;
ExposureSlider.DeviceOpenedEventHandler();
GainSlider.DeviceOpenedEventHandler();
WidthSlider.DeviceOpenedEventHandler();
HeightSlider.DeviceOpenedEventHandler();
xPosBar.DeviceOpenedEventHandler();
yPosBar.DeviceOpenedEventHandler();
BrightnessBar.DeviceOpenedEventHandler();
cameraLabel.Text = managedCamera.Name;
}
/* Get the current values from the node and display them. */
private void UpdateValues()
{
try
{
if (m_hNode.IsValid)
{
if (GenApi.NodeGetType(m_hNode) == EGenApiNodeType.EnumerationNode) /* Check is proper node type. */
{
/* Check is writable. */
bool writable = GenApi.NodeIsWritable(m_hNode);
/* Get the number of enumeration values. */
uint itemCount = GenApi.EnumerationGetNumEntries(m_hNode);
/* Clear the combo box. */
comboBox.Items.Clear();
/* Get all enumeration values, add them to the combo box, and set the selected item. */
string aa = PylonC.NET.Pylon.DeviceFeatureToString((PylonC.NET.PYLON_DEVICE_HANDLE)m_imageProvider.m_hDevice, NodeName);
string selected = GenApi.NodeToString(m_hNode);
for (uint i = 0; i < itemCount; i++)
{
NODE_HANDLE hEntry = GenApi.EnumerationGetEntryByIndex(m_hNode, i);
if (GenApi.NodeIsAvailable(hEntry))
{
comboBox.Items.Add(GenApi.NodeGetDisplayName(hEntry));
if (selected == GenApi.EnumerationEntryGetSymbolic(hEntry))
{
comboBox.SelectedIndex = comboBox.Items.Count - 1;
}
}
}
/* Update accessibility. */
comboBox.Enabled = writable;
labelName.Enabled = writable;
return;
}
}
}
catch
{
/* If errors occurred disable the control. */
}
Reset();
}
public static List <StreamFormat> GetSupportedStreamFormats(PYLON_DEVICE_HANDLE deviceHandle)
{
// We get a list of all possible values from GenICam API.
// We cannot use the Pylon .NET enum names because of casing mismatches.
// Then for each possible value, we poll for availability through Pylon API.
string enumerationName = "PixelFormat";
NODEMAP_HANDLE nodeMapHandle = Pylon.DeviceGetNodeMap(deviceHandle);
NODE_HANDLE nodeHandle = GenApi.NodeMapGetNode(nodeMapHandle, enumerationName);
if (!nodeHandle.IsValid)
{
return(null);
}
EGenApiNodeType nodeType = GenApi.NodeGetType(nodeHandle);
if (nodeType != EGenApiNodeType.EnumerationNode)
{
return(null);
}
List <StreamFormat> supportedList = new List <StreamFormat>();
uint total = GenApi.EnumerationGetNumEntries(nodeHandle);
for (uint i = 0; i < total; i++)
{
NODE_HANDLE enumEntryHandle = GenApi.EnumerationGetEntryByIndex(nodeHandle, i);
string symbol = GenApi.EnumerationEntryGetSymbolic(enumEntryHandle);
//string symbol = GenApi.NodeGetDisplayName(entryHandle);
//string featureName = string.Format("EnumEntry_{0}_{1}", enumerationName, symbol);
//bool supported = Pylon.DeviceFeatureIsAvailable(deviceHandle, featureName);
bool supported = GenApi.NodeIsAvailable(enumEntryHandle);
if (supported)
{
string displayName = GenApi.NodeGetDisplayName(enumEntryHandle);
supportedList.Add(new StreamFormat(symbol, displayName));
}
}
return(supportedList);
}
