#define MVCAMERA
|
|
using MvCameraControl;
|
using LB_VisionProcesses;
|
using System.Diagnostics;
|
using System.Runtime.InteropServices;
|
using LB_VisionProcesses.Cameras;
|
|
namespace LB_VisionProcesses.Cameras.HikCameras
|
{
|
public class HikCamera : BaseCamera
|
{
|
readonly DeviceTLayerType enumTLayerType = DeviceTLayerType.MvGigEDevice | DeviceTLayerType.MvUsbDevice
|
| DeviceTLayerType.MvGenTLGigEDevice | DeviceTLayerType.MvGenTLCXPDevice | DeviceTLayerType.MvGenTLCameraLinkDevice | DeviceTLayerType.MvGenTLXoFDevice;
|
public HikCamera() : base()
|
{
|
Brand = CameraBrand.HikCamera;
|
}
|
|
#region param
|
[DllImport("kernel32.dll", EntryPoint = "RtlMoveMemory", SetLastError = false)]
|
public static extern void CopyMemory(IntPtr dest, IntPtr src, uint count);
|
|
List<IDeviceInfo> deviceInfoList = new List<IDeviceInfo>();
|
List<string> deviceSNList = new List<string>();
|
|
IDevice device = null;
|
IInterface _ifInstance;
|
|
IntPtr m_BufForDriver = IntPtr.Zero;
|
UInt32 _bufferSize = 3072 * 2048 * 3;
|
private byte[] _buffer;
|
private uint _buffSizeForSaveImage = 3072 * 2048 * (16 * 3 + 4) + 2048;
|
private byte[] _bufForSaveImage;
|
private Object m_BufForSaveImageLock = new Object();
|
public IntPtr m_pSaveImageBuf = IntPtr.Zero;
|
#endregion
|
|
#region operate
|
public override List<string> GetListEnum()
|
{
|
List<string> deviceList = new List<string>();
|
foreach (var item in GetListInfoEnum())
|
{
|
IDeviceInfo deviceInfo = item;
|
if (deviceInfo.UserDefinedName != "")
|
{
|
//deviceList.Add(deviceInfo.TLayerType.ToString() + ": " + deviceInfo.UserDefinedName + " (" + deviceInfo.SerialNumber + ")");
|
deviceList.Add(deviceInfo.SerialNumber);
|
}
|
else
|
{
|
//deviceList.Add(deviceInfo.TLayerType.ToString() + ": " + deviceInfo.ManufacturerName + " " + deviceInfo.ModelName + " (" + deviceInfo.SerialNumber + ")");
|
deviceList.Add(deviceInfo.SerialNumber);
|
}
|
}
|
return deviceList;
|
}
|
|
public override bool InitDevice(string CamSN, object handle = null)
|
{
|
try
|
{
|
int nRet;
|
if (string.IsNullOrEmpty(CamSN)) return false;
|
var infolist = GetListInfoEnum();
|
if (infolist.Count < 1) return false;
|
|
IDeviceInfo deviceInfo = infolist[0];
|
bool selectSNflag = false;
|
foreach (var item in infolist)
|
{
|
if (item.SerialNumber.Equals(CamSN))
|
{
|
deviceInfo = item;
|
selectSNflag = true;
|
break;
|
}
|
}
|
if (!selectSNflag) return false;
|
|
try
|
{
|
// ch:打开设备 | en:Open device
|
device = DeviceFactory.CreateDevice(deviceInfo);
|
}
|
catch (Exception ex)
|
{
|
MessageBox.Show("Create Device fail!" + ex.Message, "异常");
|
return false;
|
}
|
|
|
nRet = device.Open();
|
if (nRet != MvError.MV_OK)
|
{
|
ShowErrorMsg("Open Device fail!", nRet);
|
return false;
|
}
|
|
// ch:探测网络最佳包大小(只对GigE相机有效) | en:Detection network optimal package size(It only works for the GigE camera)
|
if (device is IGigEDevice)
|
{
|
int packetSize;
|
nRet = (device as IGigEDevice).GetOptimalPacketSize(out packetSize);
|
if (packetSize > 0)
|
{
|
nRet = device.Parameters.SetIntValue("GevSCPSPacketSize", packetSize);
|
if (nRet != MvError.MV_OK)
|
{
|
Debug.WriteLine("Warning: Set Packet Size failed {0:x8}", nRet);
|
}
|
else
|
{
|
Debug.WriteLine("Set PacketSize to {0}", packetSize);
|
}
|
}
|
else
|
{
|
Debug.WriteLine("Warning: Get Packet Size failed {0:x8}", nRet);
|
}
|
}
|
|
// ch:设置触发模式为On || en:set trigger mode as On
|
// 设置为Off会一直触发回调
|
SetTriggerMode(TriggerMode.On, TriggerSource.Software);
|
device.Parameters.SetEnumValueByString("AcquisitionMode", "Continuous");
|
|
// ch:注册回调函数 | en:Register image callback
|
// 注册回调函数操作应放在打开采集流操作之前
|
device.StreamGrabber.FrameGrabedEvent += CallBackEventHandler;
|
|
if (nRet != MvError.MV_OK)
|
{
|
Debug.WriteLine("Set TriggerMode failed:{0:x8}", nRet);
|
return false;
|
}
|
|
if (!StartGrabbing())
|
{
|
Debug.WriteLine("开始采集失败");
|
return false;
|
}
|
|
//ch: 设置合适的缓存节点数量 | en: Setting the appropriate number of image nodes
|
device.StreamGrabber.SetImageNodeNum(5);
|
|
SN = CamSN;
|
Brand = CameraBrand.HikCamera;
|
return true;
|
}
|
catch { return false; }
|
}
|
|
public override bool CloseDevice()
|
{
|
if (device == null)
|
{
|
return false;
|
}
|
try
|
{
|
isGrabbing = false;
|
if (m_BufForDriver != IntPtr.Zero)
|
{
|
Marshal.Release(m_BufForDriver);
|
}
|
|
// ch:关闭设备 | en:Close device
|
var nRet = device.Close();
|
if (MvError.MV_OK == nRet)
|
{
|
// ch:销毁设备 | en:Destroy device
|
device.Dispose();
|
return true;
|
}
|
nRet = device.Close();
|
if (MvError.MV_OK != nRet)
|
{
|
Debug.WriteLine("Close device failed:{0:x8}", nRet);
|
return false;
|
}
|
|
// ch:销毁设备 | en:Destroy device
|
device.Dispose();
|
|
device = null;
|
return true;
|
}
|
catch
|
{
|
device = null;
|
return false;
|
}
|
}
|
|
/// <summary>
|
/// ch:软触发执行一次 | en:Trigger once by software
|
/// </summary>
|
public override bool SoftTrigger()
|
{
|
int nRet;
|
// ch:触发命令 | en:Trigger command
|
nRet = device.Parameters.SetCommandValue("TriggerSoftware");
|
|
return (MvError.MV_OK == nRet);
|
}
|
#endregion
|
|
#region SettingConfig
|
public override bool SetTriggerMode(TriggerMode mode = TriggerMode.On, TriggerSource triggerEnum = TriggerSource.None)
|
{
|
try
|
{
|
int nRet;
|
switch (mode)
|
{
|
case TriggerMode.Off:
|
nRet = device.Parameters.SetEnumValueByString("TriggerMode", "Off");
|
break;
|
case TriggerMode.On:
|
nRet = device.Parameters.SetEnumValueByString("TriggerMode", "On");
|
break;
|
default:
|
nRet = device.Parameters.SetEnumValueByString("TriggerMode", "On");
|
break;
|
}
|
bool flag1 = (MvError.MV_OK == nRet);
|
switch (triggerEnum)
|
{
|
case TriggerSource.Software:
|
nRet = device.Parameters.SetEnumValueByString("TriggerSource", "Software");
|
break;
|
case TriggerSource.Line0:
|
nRet = device.Parameters.SetEnumValueByString("TriggerSource", "Line0");
|
break;
|
case TriggerSource.Line1:
|
nRet = device.Parameters.SetEnumValueByString("TriggerSource", "Line1");
|
break;
|
case TriggerSource.Line2:
|
nRet = device.Parameters.SetEnumValueByString("TriggerSource", "Line2");
|
break;
|
case TriggerSource.Line3:
|
nRet = device.Parameters.SetEnumValueByString("TriggerSource", "Line3");
|
break;
|
case TriggerSource.Line4:
|
nRet = device.Parameters.SetEnumValueByString("TriggerSource", "Line4");
|
break;
|
default:
|
break;
|
}
|
bool flag2 = (MvError.MV_OK == nRet);
|
return flag1 && flag2;
|
}
|
catch { return false; }
|
}
|
|
public override bool GetTriggerMode(out TriggerMode mode, out TriggerSource source)
|
{
|
int nRet;
|
mode = TriggerMode.On;
|
source = TriggerSource.Software;
|
|
IEnumValue enumValue;
|
nRet = device.Parameters.GetEnumValue("TriggerMode", out enumValue);
|
bool flag1 = (MvError.MV_OK == nRet);
|
if (flag1)
|
{
|
switch (enumValue.CurEnumEntry.Symbolic)
|
{
|
case "On":
|
mode = TriggerMode.On;
|
break;
|
case "Off":
|
mode = TriggerMode.Off;
|
break;
|
default:
|
mode = TriggerMode.On;
|
break;
|
}
|
}
|
|
nRet = device.Parameters.GetEnumValue("TriggerSource", out enumValue);
|
bool flag2 = (MvError.MV_OK == nRet);
|
if (flag2)
|
{
|
switch (enumValue.CurEnumEntry.Symbolic)
|
{
|
case "TriggerSoftware":
|
case "Software":
|
source = TriggerSource.Software;
|
break;
|
case "Line0":
|
source = TriggerSource.Line0;
|
break;
|
case "Line1":
|
source = TriggerSource.Line1;
|
break;
|
case "Line2":
|
source = TriggerSource.Line2;
|
break;
|
default:
|
source = TriggerSource.Line0;
|
break;
|
}
|
}
|
return flag1 && flag2;
|
}
|
|
public override bool SetExpouseTime(double value)
|
{
|
try
|
{
|
int nRet = device.Parameters.SetFloatValue("ExposureTime", Convert.ToSingle(value));
|
return (MvError.MV_OK == nRet);
|
}
|
catch { return false; }
|
|
}
|
|
public override bool GetExpouseTime(out double value)
|
{
|
IFloatValue floatValue;
|
int nRet = device.Parameters.GetFloatValue("ExposureTime", out floatValue);
|
value = Convert.ToDouble(floatValue.CurValue);
|
return (MvError.MV_OK == nRet);
|
}
|
|
public override bool SetTriggerPolarity(TriggerPolarity polarity)
|
{
|
//return true;
|
|
IEnumValue enumValue;
|
int nRet = device.Parameters.GetEnumValue("TimerTriggerActivation", out enumValue);
|
if (nRet != MvError.MV_OK)
|
return false;
|
|
for (int i = 0; i < enumValue.SupportedNum; ++i)
|
{
|
if (polarity.ToString().Equals(enumValue.SupportEnumEntries[i].Symbolic, StringComparison.OrdinalIgnoreCase))
|
{
|
nRet = device.Parameters.SetEnumValue("TimerTriggerActivation", enumValue.SupportEnumEntries[i].Value);
|
if (nRet != MvError.MV_OK)
|
return false;
|
|
break;
|
}
|
}
|
return (MvError.MV_OK == nRet);
|
}
|
|
public override bool GetTriggerPolarity(out TriggerPolarity polarity)
|
{
|
polarity = TriggerPolarity.RisingEdge;
|
//return true;
|
|
IEnumValue enumValue;
|
int nRet = device.Parameters.GetEnumValue("TimerTriggerActivation", out enumValue);
|
if (nRet != MvError.MV_OK)
|
{
|
return false;
|
}
|
string activate = enumValue.CurEnumEntry.Symbolic;
|
//1下降沿 0上升沿
|
|
//上升沿
|
if (activate == "RisingEdge")
|
polarity = TriggerPolarity.RisingEdge;
|
//下降沿
|
else if (activate == "FallingEdge")
|
|
polarity = TriggerPolarity.FallingEdge;
|
return (MvError.MV_OK == nRet);
|
}
|
|
public override bool SetTriggerFliter(double flitertime)
|
{
|
try
|
{
|
int nRet = device.Parameters.SetIntValue("LineDebouncerTimeNs", (uint)flitertime);
|
//nRet = device.Parameters.SetIntValue("LineDebouncerTime", (uint)flitertime);
|
return (MvError.MV_OK == nRet);
|
}
|
catch { return false; }
|
}
|
|
public override bool GetTriggerFliter(out double flitertime)
|
{
|
flitertime = 1000;
|
IFloatValue floatValue;
|
int nRet = device.Parameters.GetFloatValue("ExposureTime", out floatValue);
|
flitertime = Convert.ToDouble(floatValue.CurValue);
|
return (MvError.MV_OK == nRet);
|
}
|
|
public override bool SetTriggerDelay(double delay)
|
{
|
try
|
{
|
int nRet = device.Parameters.SetFloatValue("TriggerDelay", Convert.ToSingle(delay));
|
return (MvError.MV_OK == nRet);
|
}
|
catch { return false; }
|
}
|
|
public override bool GetTriggerDelay(out double delay)
|
{
|
delay = 0;
|
IFloatValue floatValue;
|
int nRet = device.Parameters.GetFloatValue("TriggerDelay", out floatValue);
|
delay = Convert.ToDouble(floatValue.CurValue);
|
return (MvError.MV_OK == nRet);
|
}
|
|
public override bool SetGain(double gain)
|
{
|
try
|
{
|
int nRet = device.Parameters.SetFloatValue("Gain", Convert.ToSingle(gain));
|
return (MvError.MV_OK == nRet);
|
}
|
catch { return false; }
|
}
|
|
public override bool GetGain(out double gain)
|
{
|
gain = 0;
|
IFloatValue floatValue;
|
int nRet = device.Parameters.GetFloatValue("Gain", out floatValue);
|
gain = Convert.ToDouble(floatValue.CurValue);
|
return (MvError.MV_OK == nRet);
|
}
|
|
public override bool SetLineMode(IOLines line, LineMode mode)
|
{
|
int nRet = device.Parameters.SetEnumValueByString(line.ToString(), mode.ToString());
|
return (MvError.MV_OK == nRet);
|
}
|
|
public override bool SetLineStatus(IOLines line, LineStatus linestatus)
|
{
|
int nRet = device.Parameters.SetBoolValue(line.ToString(), linestatus.Equals(LineStatus.Hight));
|
return (MvError.MV_OK == nRet);
|
}
|
|
public override bool GetLineStatus(IOLines line, out LineStatus linestatus)
|
{
|
bool resultsignal = false;
|
int nRet = device.Parameters.GetBoolValue(line.ToString(), out resultsignal);
|
linestatus = resultsignal ? LineStatus.Hight : LineStatus.Low;
|
return (MvError.MV_OK == nRet);
|
}
|
|
public override bool AutoBalanceWhite()
|
{
|
int nRet = device.Parameters.SetEnumValueByString("BalanceWhiteAuto", "Once");
|
return (MvError.MV_OK == nRet);
|
}
|
|
#endregion
|
|
#region helper
|
// ch:显示错误信息 | en:Show error message
|
private void ShowErrorMsg(string message, int errorCode)
|
{
|
string errorMsg;
|
if (errorCode == 0)
|
errorMsg = message;
|
else
|
errorMsg = message + ": Error =" + String.Format("{0:X}", errorCode);
|
|
switch (errorCode)
|
{
|
case MvError.MV_E_HANDLE: errorMsg += " Error or invalid handle "; break;
|
case MvError.MV_E_SUPPORT: errorMsg += " Not supported function "; break;
|
case MvError.MV_E_BUFOVER: errorMsg += " Cache is full "; break;
|
case MvError.MV_E_CALLORDER: errorMsg += " Function calling order error "; break;
|
case MvError.MV_E_PARAMETER: errorMsg += " Incorrect parameter "; break;
|
case MvError.MV_E_RESOURCE: errorMsg += " Applying resource failed "; break;
|
case MvError.MV_E_NODATA: errorMsg += " No data "; break;
|
case MvError.MV_E_PRECONDITION: errorMsg += " Precondition error, or running environment changed "; break;
|
case MvError.MV_E_VERSION: errorMsg += " Version mismatches "; break;
|
case MvError.MV_E_NOENOUGH_BUF: errorMsg += " Insufficient memory "; break;
|
case MvError.MV_E_UNKNOW: errorMsg += " Unknown error "; break;
|
case MvError.MV_E_GC_GENERIC: errorMsg += " General error "; break;
|
case MvError.MV_E_GC_ACCESS: errorMsg += " Node accessing condition error "; break;
|
case MvError.MV_E_ACCESS_DENIED: errorMsg += " No permission "; break;
|
case MvError.MV_E_BUSY: errorMsg += " Device is busy, or network disconnected "; break;
|
case MvError.MV_E_NETER: errorMsg += " Network error "; break;
|
}
|
|
MessageBox.Show(errorMsg, "异常");
|
}
|
public override bool StartGrabbing()
|
{
|
try
|
{
|
// Set default state after grabbing starts
|
// Turn off real-time mode which is default
|
// 0: real-time
|
// 1: trigger
|
|
CallBackImg = null;
|
int nRet = device.StreamGrabber.StartGrabbing();
|
if (MvError.MV_OK != nRet) Debug.WriteLine("Grab start failed");
|
isGrabbing = true;
|
return (MvError.MV_OK == nRet);
|
}
|
catch (Exception ex)
|
{
|
Debug.WriteLine("StartGrabbing failed: " + ex.Message);
|
return false;
|
}
|
}
|
|
public override bool StopGrabbing()
|
{
|
int nRet = device.StreamGrabber.StopGrabbing();
|
if (MvError.MV_OK != nRet) Debug.WriteLine("Grab stop failed");
|
isGrabbing = false;
|
CallBackImg = null;
|
|
return (MvError.MV_OK == nRet);
|
}
|
|
private List<IDeviceInfo> GetListInfoEnum()
|
{
|
System.GC.Collect();
|
deviceInfoList.Clear();
|
// ch:创建设备列表 | en:Create Device List
|
int nRet = DeviceEnumerator.EnumDevices(enumTLayerType, out deviceInfoList);
|
if (nRet != MvError.MV_OK)
|
{
|
ShowErrorMsg("Enumerate devices fail!", nRet);
|
return new List<IDeviceInfo>();
|
}
|
|
// ch:在窗体列表中显示设备名 | en:Display device name in the form list
|
for (int i = 0; i < deviceInfoList.Count; i++)
|
{
|
IDeviceInfo deviceInfo = deviceInfoList[i];
|
if (deviceInfo.UserDefinedName != "")
|
deviceSNList.Add(deviceInfo.TLayerType.ToString() + ": " + deviceInfo.UserDefinedName + " (" + deviceInfo.SerialNumber + ")");
|
else
|
deviceSNList.Add(deviceInfo.TLayerType.ToString() + ": " + deviceInfo.ManufacturerName + " " + deviceInfo.ModelName + " (" + deviceInfo.SerialNumber + ")");
|
}
|
|
// ch:选择第一项 | en:Select the first item
|
if (deviceInfoList.Count != 0)
|
{
|
deviceSNList[0] = deviceSNList[0];
|
}
|
return deviceInfoList;
|
}
|
|
static bool IsMonoPixelFormat(MvGvspPixelType enType)
|
{
|
switch (enType)
|
{
|
case MvGvspPixelType.PixelType_Gvsp_Mono10:
|
case MvGvspPixelType.PixelType_Gvsp_Mono10_Packed:
|
case MvGvspPixelType.PixelType_Gvsp_Mono12:
|
case MvGvspPixelType.PixelType_Gvsp_Mono12_Packed:
|
return true;
|
default:
|
return false;
|
}
|
}
|
|
static bool IsColorPixelFormat(MvGvspPixelType enType)
|
{
|
switch (enType)
|
{
|
case MvGvspPixelType.PixelType_Gvsp_BGR8_Packed:
|
case MvGvspPixelType.PixelType_Gvsp_YUV422_Packed:
|
case MvGvspPixelType.PixelType_Gvsp_YUV422_YUYV_Packed:
|
case MvGvspPixelType.PixelType_Gvsp_BayerGR8:
|
case MvGvspPixelType.PixelType_Gvsp_BayerRG8:
|
case MvGvspPixelType.PixelType_Gvsp_BayerGB8:
|
case MvGvspPixelType.PixelType_Gvsp_BayerBG8:
|
case MvGvspPixelType.PixelType_Gvsp_BayerGB10:
|
case MvGvspPixelType.PixelType_Gvsp_BayerGB10_Packed:
|
case MvGvspPixelType.PixelType_Gvsp_BayerBG10:
|
case MvGvspPixelType.PixelType_Gvsp_BayerBG10_Packed:
|
case MvGvspPixelType.PixelType_Gvsp_BayerRG10:
|
case MvGvspPixelType.PixelType_Gvsp_BayerRG10_Packed:
|
case MvGvspPixelType.PixelType_Gvsp_BayerGR10:
|
case MvGvspPixelType.PixelType_Gvsp_BayerGR10_Packed:
|
case MvGvspPixelType.PixelType_Gvsp_BayerGB12:
|
case MvGvspPixelType.PixelType_Gvsp_BayerGB12_Packed:
|
case MvGvspPixelType.PixelType_Gvsp_BayerBG12:
|
case MvGvspPixelType.PixelType_Gvsp_BayerBG12_Packed:
|
case MvGvspPixelType.PixelType_Gvsp_BayerRG12:
|
case MvGvspPixelType.PixelType_Gvsp_BayerRG12_Packed:
|
case MvGvspPixelType.PixelType_Gvsp_BayerGR12:
|
case MvGvspPixelType.PixelType_Gvsp_BayerGR12_Packed:
|
return true;
|
default:
|
return false;
|
}
|
}
|
|
/// <summary>
|
/// 回调函数(不要在内部增加耗时操作)
|
/// </summary>
|
/// <param name="sender"></param>
|
/// <param name="e"></param>
|
private void CallBackEventHandler(object sender, FrameGrabbedEventArgs e)
|
{
|
try
|
{
|
int nRet;
|
//Debug.WriteLine("Get Image Buffer: Width[{0}] , Height[{1}] , FrameNum[{2}]"
|
//, e.FrameOut.Image.Width, e.FrameOut.Image.Height, e.FrameOut.FrameNum);
|
|
IImage inputImage = e.FrameOut.Image;
|
IImage outImage = inputImage;
|
MvGvspPixelType dstPixelType = MvGvspPixelType.PixelType_Gvsp_Undefined;
|
|
if (IsColorPixelFormat(e.FrameOut.Image.PixelType))
|
dstPixelType = MvGvspPixelType.PixelType_Gvsp_RGB8_Packed;
|
else if (IsMonoPixelFormat(e.FrameOut.Image.PixelType))
|
dstPixelType = MvGvspPixelType.PixelType_Gvsp_Mono8;
|
else
|
Debug.WriteLine($"【{DateTime.Now:HH:mm:ss.fff}】Don't need to convert!");
|
|
if (dstPixelType != MvGvspPixelType.PixelType_Gvsp_Undefined)
|
{
|
// ch:像素格式转换 | en:Pixel type convert
|
nRet = device.PixelTypeConverter.ConvertPixelType(inputImage, out outImage, dstPixelType);
|
if (nRet != MvError.MV_OK)
|
{
|
Debug.WriteLine($"【{DateTime.Now:HH:mm:ss.fff}】Image Convert failed:{0:x8}", nRet);
|
return;
|
}
|
//Debug.WriteLine($"【{DateTime.Now:HH:mm:ss.fff}】Image Convert success!");
|
}
|
//ch: 释放图像缓存 | en: Release image buffer
|
device.StreamGrabber.FreeImageBuffer(e.FrameOut);
|
|
if (this.ImageGrabbed != null)
|
this.ImageGrabbed(this, new CameraEventArgs(SN, outImage.ToBitmap()));
|
|
try
|
{
|
CallBackImg = outImage.ToBitmap();
|
if (CallBackImg == null) return;
|
if (GetTriggerMode(out TriggerMode mode, out TriggerSource source))
|
{
|
if (mode == TriggerMode.On && source != TriggerSource.Software)
|
TriggerRunMessageReceived?.Invoke(SN, source.ToString()); // 触发运行事件
|
}
|
}
|
catch { }
|
|
//ActionGetImage?.Invoke(SN, outImage.ToBitmap());
|
}
|
catch { }
|
}
|
|
public override bool GetImage(out Bitmap bitmap, int outtime = 3000)
|
{
|
bitmap = null;
|
|
try
|
{
|
// 设置超时时间
|
DateTime lastTime = DateTime.Now.AddMilliseconds(outtime);
|
// 判断是否超时
|
while (lastTime > DateTime.Now)// 设置超时时间为 3 秒
|
{
|
try
|
{
|
if (CallBackImg != null)
|
{
|
// 保存旧 Bitmap 并释放
|
bitmap = CallBackImg.Clone() as Bitmap; // 创建副本
|
|
// 释放旧资源
|
CallBackImg.Dispose();
|
CallBackImg = null;
|
return true;
|
}
|
}
|
catch { }
|
Thread.Sleep(10);
|
}
|
return false;
|
}
|
catch { return bitmap == null ? false : true; }
|
}
|
|
public override bool GetImageWithSoftTrigger(out Bitmap bitmap, int outtime = 3000)
|
{
|
if (!isGrabbing)
|
{
|
StartGrabbing();
|
}
|
GetTriggerMode(out TriggerMode triggerMode, out TriggerSource triggerSource);
|
if (triggerMode != TriggerMode.On && triggerSource != TriggerSource.Software)
|
{
|
SetTriggerMode(TriggerMode.On, TriggerSource.Software);
|
}
|
bitmap = null;
|
CallBackImg = null;
|
if (!SoftTrigger())
|
{
|
return false;
|
}
|
// 开始时间
|
DateTime startTime = DateTime.Now; // 当前时间
|
// 判断是否超时
|
while (DateTime.Now < startTime.AddMilliseconds(outtime))// 设置超时时间为 3 秒
|
{
|
GetImage(out bitmap, 50);
|
if (bitmap != null)
|
{
|
break;
|
}
|
Thread.Sleep(10);
|
}
|
if (triggerMode != TriggerMode.On)
|
{
|
SetTriggerMode(TriggerMode.On, triggerSource);
|
}
|
return (bitmap != null);
|
}
|
|
|
public override void SetCamConfig(CameraConfig config)
|
{
|
if (Enum.TryParse(config.Params.Inputs["触发模式"].ToString(), out TriggerMode TriggerMode)
|
&& Enum.TryParse(config.Params.Inputs["触发方式"].ToString(), out TriggerSource TriggerSource)
|
&& Enum.TryParse(config.Params.Inputs["触发极性"].ToString(), out TriggerPolarity TriggerPolarity)
|
)
|
{
|
SetTriggerMode(TriggerMode, TriggerSource);
|
SetTriggerPolarity(TriggerPolarity);
|
//SetTriggerFliter(Convert.ToDouble(config.Params.Inputs["触发消抖"].ToString()));
|
//SetTriggerDelay(Convert.ToDouble(config.Params.Inputs["触发延时"].ToString()));
|
SetExpouseTime(Convert.ToDouble(config.Params.Inputs["曝光时间"].ToString()));
|
SetGain(Convert.ToDouble(config.Params.Inputs["增益"].ToString()));
|
}
|
}
|
|
public override void GetCamConfig(out CameraConfig config)
|
{
|
GetTriggerMode(out TriggerMode triggerMode, out TriggerSource triggerSource);
|
GetTriggerPolarity(out TriggerPolarity triggerPolarity);
|
//GetTriggerFliter(out double triggerfilter);
|
//GetTriggerDelay(out double triggerdelay);
|
GetExpouseTime(out double expouseTime);
|
GetGain(out double gain);
|
|
config = new CameraConfig(null);
|
config.Params.Inputs.Add("触发模式", triggerMode);
|
config.Params.Inputs.Add("触发方式", triggerSource);
|
config.Params.Inputs.Add("触发极性", triggerPolarity);
|
//config.Params.Inputs.Add("触发消抖", triggerfilter);
|
//config.Params.Inputs.Add("触发延时", triggerdelay);
|
config.Params.Inputs.Add("曝光时间", expouseTime);
|
config.Params.Inputs.Add("增益", gain);
|
}
|
|
public override bool StartWith_SoftTriggerModel()
|
{
|
SetTriggerMode(TriggerMode.Off, TriggerSource.Software);
|
return StartGrabbing();
|
}
|
|
public override bool StartWith_HardTriggerModel(TriggerSource hardtriggeritem = TriggerSource.Line0)
|
{
|
if (hardtriggeritem == TriggerSource.Software) hardtriggeritem = TriggerSource.Line0;
|
SetTriggerMode(TriggerMode.On, hardtriggeritem);
|
return StartGrabbing();
|
}
|
|
public override bool StartContinuousGrab()
|
{
|
throw new NotImplementedException();
|
}
|
|
#endregion
|
}
|
}
|
