1304 lines
54 KiB
C#
1304 lines
54 KiB
C#
using OpenCvSharp;
|
||
using System;
|
||
using System.Collections.Generic;
|
||
using System.Drawing.Imaging;
|
||
using System.Drawing;
|
||
using System.Linq;
|
||
using System.Runtime.CompilerServices;
|
||
using System.Runtime.InteropServices;
|
||
using System.Text;
|
||
using System.Threading;
|
||
using System.Threading.Tasks;
|
||
using System.Windows.Forms;
|
||
using MvCamCtrl.NET;
|
||
using OpenCvSharp.Dnn;
|
||
using System.Diagnostics;
|
||
using HalconDotNet;
|
||
using System.Xml.Linq;
|
||
|
||
namespace GuideGraspSys
|
||
{
|
||
public class HikCamDriver: CameraBase
|
||
{
|
||
[DllImport("kernel32.dll", EntryPoint = "CopyMemory", SetLastError = false)]
|
||
public static extern void CopyMemory(IntPtr dest, IntPtr src, uint count);
|
||
/// <summary>
|
||
/// 创建相机集合，存放相机
|
||
/// </summary>
|
||
MyCamera.MV_CC_DEVICE_INFO_LIST m_pDeviceList;
|
||
MyCamera.MV_CC_DEVICE_INFO device;
|
||
|
||
MyCamera hkCamera = new MyCamera();
|
||
/// <summary>
|
||
/// 抓图回调
|
||
/// </summary>
|
||
MyCamera.cbOutputExdelegate ImageCallback;
|
||
|
||
Thread m_hReceiveThread = null;
|
||
|
||
/// <summary>
|
||
/// 异常回调
|
||
/// </summary>
|
||
MyCamera.cbExceptiondelegate pCallBackFunc;
|
||
HObject hPylonImage = new HObject();
|
||
List<string> CameraName = new List<string>();
|
||
|
||
MyCamera.MV_FRAME_OUT _frame = new MyCamera.MV_FRAME_OUT();
|
||
readonly ManualResetEvent _snapHandle = new ManualResetEvent(false);
|
||
bool _snapFlag = false;
|
||
|
||
// ch:Bitmap及其像素格式 | en:Bitmap and Pixel Format
|
||
Bitmap m_bitmap = null;
|
||
PixelFormat m_bitmapPixelFormat = PixelFormat.DontCare;
|
||
IntPtr m_ConvertDstBuf = IntPtr.Zero;
|
||
UInt32 m_nConvertDstBufLen = 0;
|
||
|
||
int nRet = MyCamera.MV_OK;
|
||
/// <summary>
|
||
/// 曝光时间
|
||
/// </summary>
|
||
public int ExposureTime { get; set; }
|
||
/// <summary>
|
||
/// 增益
|
||
/// </summary>
|
||
public int Gain { get; set; }
|
||
/// <summary>
|
||
/// 帧率
|
||
/// </summary>
|
||
public int FrameRate { get; set; }
|
||
|
||
|
||
public bool m_bGrabbing = false;
|
||
|
||
private static Object BufForDriverLock = new Object();
|
||
|
||
IntPtr m_BufForDriver = IntPtr.Zero;
|
||
|
||
UInt32 m_nBufSizeForDriver = 0;
|
||
MyCamera.MV_FRAME_OUT_INFO_EX m_stFrameInfo = new MyCamera.MV_FRAME_OUT_INFO_EX();
|
||
|
||
public delegate void MatImgTransferDelegate(Mat img);
|
||
public event MatImgTransferDelegate OnImgTransfer;
|
||
|
||
public delegate void BitmapTransferDelegate(Bitmap img);
|
||
public event BitmapTransferDelegate OnBitmapTransfer;
|
||
|
||
public Action<DateTime, Mat> OnHImageOutput { get; set; }
|
||
|
||
public static Dictionary<string,CameraInfor> allCamera=new Dictionary<string,CameraInfor>();
|
||
private CameraInfor currentCam;
|
||
|
||
public override bool CloserCamera()
|
||
{
|
||
m_bGrabbing = false;
|
||
hkCamera.MV_CC_StopGrabbing_NET();//停止采集
|
||
hkCamera.MV_CC_CloseDevice_NET();//关闭设备
|
||
hkCamera.MV_CC_DestroyDevice_NET();
|
||
return true;
|
||
}
|
||
/// <summary>
|
||
/// 开启硬触发
|
||
/// </summary>
|
||
/// <returns></returns>
|
||
public override bool EncoderGrap()
|
||
{
|
||
try
|
||
{
|
||
if (m_bGrabbing)
|
||
{
|
||
Console.WriteLine("Camera is now Continue Grabing Images！");
|
||
return false;
|
||
}
|
||
else
|
||
{
|
||
// ch:标志位置位true | en:Set position bit true
|
||
m_bGrabbing = true;
|
||
|
||
hkCamera.MV_CC_SetEnumValue_NET("TriggerMode", (uint)MyCamera.MV_CAM_TRIGGER_MODE.MV_TRIGGER_MODE_ON);
|
||
//设置使用硬触发模式
|
||
int nRet = hkCamera.MV_CC_SetEnumValue_NET("TriggerSource", (uint)MyCamera.MV_CAM_TRIGGER_SOURCE.MV_TRIGGER_SOURCE_LINE0);
|
||
|
||
|
||
if (MyCamera.MV_OK != nRet)
|
||
{
|
||
m_bGrabbing = false;
|
||
return false;
|
||
}
|
||
return true;
|
||
}
|
||
}
|
||
catch (Exception)
|
||
{
|
||
return false;
|
||
}
|
||
}
|
||
|
||
|
||
//public override List<string> FindCamera()
|
||
//{
|
||
// int nRet;
|
||
|
||
// System.GC.Collect();
|
||
// CameraName.Clear();
|
||
|
||
// nRet = MyCamera.MV_CC_EnumDevices_NET(MyCamera.MV_GIGE_DEVICE | MyCamera.MV_USB_DEVICE, ref m_pDeviceList);
|
||
// if (0 != nRet)
|
||
// {
|
||
// Console.WriteLine("Not Find Camera!{0:x8}", nRet);
|
||
// return null;
|
||
// }
|
||
// for (int i = 0; i < m_pDeviceList.nDeviceNum; i++)
|
||
// {
|
||
// MyCamera.MV_CC_DEVICE_INFO device = (MyCamera.MV_CC_DEVICE_INFO)Marshal.PtrToStructure(m_pDeviceList.pDeviceInfo[i], typeof(MyCamera.MV_CC_DEVICE_INFO));
|
||
// //网口相机
|
||
// if (device.nTLayerType == MyCamera.MV_GIGE_DEVICE)
|
||
// {
|
||
// IntPtr buffer = Marshal.UnsafeAddrOfPinnedArrayElement(device.SpecialInfo.stGigEInfo, 0);
|
||
// MyCamera.MV_GIGE_DEVICE_INFO gigeInfo = (MyCamera.MV_GIGE_DEVICE_INFO)Marshal.PtrToStructure(buffer, typeof(MyCamera.MV_GIGE_DEVICE_INFO));
|
||
// if (gigeInfo.chUserDefinedName != "")
|
||
// {
|
||
// Console.WriteLine("GigE:" + gigeInfo.chUserDefinedName + " (" + gigeInfo.chSerialNumber + ")");
|
||
// CameraName.Add("GigE:" + gigeInfo.chUserDefinedName + " (" + gigeInfo.chSerialNumber + ")");
|
||
// }
|
||
// else
|
||
// {
|
||
// Console.WriteLine("GigE: " + gigeInfo.chManufacturerName + " " + gigeInfo.chModelName + " (" + gigeInfo.chSerialNumber + ")");
|
||
// CameraName.Add("GigE: " + gigeInfo.chManufacturerName + " " + gigeInfo.chModelName + " (" + gigeInfo.chSerialNumber + ")");
|
||
// }
|
||
// }
|
||
// else if (device.nTLayerType == MyCamera.MV_USB_DEVICE)
|
||
// {
|
||
// IntPtr buffer = Marshal.UnsafeAddrOfPinnedArrayElement(device.SpecialInfo.stUsb3VInfo, 0);
|
||
// MyCamera.MV_USB3_DEVICE_INFO usbInfo = (MyCamera.MV_USB3_DEVICE_INFO)Marshal.PtrToStructure(buffer, typeof(MyCamera.MV_USB3_DEVICE_INFO));
|
||
// if (usbInfo.chUserDefinedName != "")
|
||
// {
|
||
// Console.WriteLine("USB: " + usbInfo.chUserDefinedName + " (" + usbInfo.chSerialNumber + ")");
|
||
// CameraName.Add("USB: " + usbInfo.chUserDefinedName + " (" + usbInfo.chSerialNumber + ")");
|
||
// }
|
||
// else
|
||
// {
|
||
// Console.WriteLine("USB: " + usbInfo.chManufacturerName + " " + usbInfo.chModelName + " (" + usbInfo.chSerialNumber + ")");
|
||
// CameraName.Add("USB: " + usbInfo.chManufacturerName + " " + usbInfo.chModelName + " (" + usbInfo.chSerialNumber + ")");
|
||
// }
|
||
// }
|
||
// }
|
||
// if (m_pDeviceList.nDeviceNum == 0)
|
||
// {
|
||
// Console.WriteLine("未能找到USB或者网线接口的相机", 0);
|
||
// return null;
|
||
// }
|
||
|
||
// return CameraName;
|
||
//}
|
||
public Dictionary<string, CameraInfor> EnumDevice()
|
||
{
|
||
System.GC.Collect();//强制对所有代进行及时垃圾回收
|
||
m_pDeviceList.nDeviceNum = 0; //初始化信息列表
|
||
int nRet = MyCamera.MV_CC_EnumDevices_NET(MyCamera.MV_GIGE_DEVICE | MyCamera.MV_USB_DEVICE, ref m_pDeviceList);
|
||
if (0 != nRet)
|
||
{
|
||
return null;
|
||
}
|
||
allCamera.Clear(); //清空设备列表
|
||
CameraInfor cameraInfor;
|
||
for (int i = 0; i < m_pDeviceList.nDeviceNum; i++)
|
||
{
|
||
MyCamera.MV_CC_DEVICE_INFO device = (MyCamera.MV_CC_DEVICE_INFO)Marshal.PtrToStructure(m_pDeviceList.pDeviceInfo[i], typeof(MyCamera.MV_CC_DEVICE_INFO));//获取第i个相机句柄的相机信息
|
||
cameraInfor = new CameraInfor();
|
||
cameraInfor.pDeviceInfo = m_pDeviceList.pDeviceInfo[i];//获取相机句柄
|
||
if (device.nTLayerType == MyCamera.MV_GIGE_DEVICE)
|
||
{
|
||
MyCamera.MV_GIGE_DEVICE_INFO gigeInfo = (MyCamera.MV_GIGE_DEVICE_INFO)MyCamera.ByteToStruct(device.SpecialInfo.stGigEInfo, typeof(MyCamera.MV_GIGE_DEVICE_INFO));//将通用相机信息结构体转化为Gige相机结构体
|
||
|
||
UInt32 nNetIp1 = (gigeInfo.nNetExport & 0xFF000000) >> 24;
|
||
UInt32 nNetIp2 = (gigeInfo.nNetExport & 0x00FF0000) >> 16;
|
||
UInt32 nNetIp3 = (gigeInfo.nNetExport & 0x0000FF00) >> 8;
|
||
UInt32 nNetIp4 = (gigeInfo.nNetExport & 0x000000FF);
|
||
|
||
// ch:显示IP | en:Display IP
|
||
UInt32 nIp1 = (gigeInfo.nCurrentIp & 0xFF000000) >> 24;
|
||
UInt32 nIp2 = (gigeInfo.nCurrentIp & 0x00FF0000) >> 16;
|
||
UInt32 nIp3 = (gigeInfo.nCurrentIp & 0x0000FF00) >> 8;
|
||
UInt32 nIp4 = (gigeInfo.nCurrentIp & 0x000000FF);
|
||
|
||
|
||
cameraInfor.serialNumber = gigeInfo.chSerialNumber;
|
||
cameraInfor.userDefinedName = gigeInfo.chUserDefinedName;
|
||
cameraInfor.manufacturerName = gigeInfo.chManufacturerName;
|
||
cameraInfor.modelName = gigeInfo.chModelName;
|
||
cameraInfor.deviceType = "GEV"; //千兆网工业相机技术之GigE Vision（GEV）
|
||
cameraInfor.deviceIPAdd = nIp1.ToString() + "." + nIp2.ToString() + "." + nIp3.ToString() + "." + nIp4.ToString();
|
||
allCamera.Add(cameraInfor.userDefinedName, cameraInfor);
|
||
}
|
||
else if (device.nTLayerType == MyCamera.MV_USB_DEVICE)
|
||
{
|
||
MyCamera.MV_USB3_DEVICE_INFO usbInfo = (MyCamera.MV_USB3_DEVICE_INFO)MyCamera.ByteToStruct(device.SpecialInfo.stUsb3VInfo, typeof(MyCamera.MV_USB3_DEVICE_INFO));
|
||
cameraInfor.serialNumber = usbInfo.chSerialNumber;
|
||
cameraInfor.userDefinedName = usbInfo.chUserDefinedName;
|
||
cameraInfor.manufacturerName = usbInfo.chManufacturerName;
|
||
cameraInfor.modelName = usbInfo.chModelName;
|
||
cameraInfor.deviceType = "U3V";
|
||
allCamera.Add(cameraInfor.deviceIPAdd, cameraInfor);
|
||
}
|
||
|
||
}
|
||
return allCamera;
|
||
}
|
||
/// <summary>
|
||
/// 根据相机序列号开启相机
|
||
/// </summary>
|
||
/// <param name="CameraName"></param>
|
||
/// int cameraIndex
|
||
/// <returns></returns>
|
||
public override bool OpenCamera(string userDefinedName, IntPtr hWnd)
|
||
{
|
||
int nRet = 0;
|
||
currentCam = allCamera[userDefinedName];
|
||
//m_pDeviceList.pDeviceInfo[cameraIndex]
|
||
device = (MyCamera.MV_CC_DEVICE_INFO)Marshal.PtrToStructure(allCamera[userDefinedName].pDeviceInfo, typeof(MyCamera.MV_CC_DEVICE_INFO));
|
||
IntPtr buffer = Marshal.UnsafeAddrOfPinnedArrayElement(device.SpecialInfo.stGigEInfo, 0);
|
||
MyCamera.MV_GIGE_DEVICE_INFO gigeInfo = (MyCamera.MV_GIGE_DEVICE_INFO)Marshal.PtrToStructure(buffer, typeof(MyCamera.MV_GIGE_DEVICE_INFO));
|
||
|
||
|
||
if (null == hkCamera)
|
||
{
|
||
hkCamera = new MyCamera();
|
||
if (null == hkCamera)
|
||
{
|
||
return false;
|
||
}
|
||
}
|
||
for (int i = 0; i < 10; i++)
|
||
{
|
||
nRet = hkCamera.MV_CC_CreateDevice_NET(ref device);
|
||
if (MyCamera.MV_OK != nRet)
|
||
{
|
||
Thread.Sleep(1);
|
||
if (i == 9) Console.WriteLine("创建相机失败！{0:x8}", nRet);
|
||
continue;
|
||
}
|
||
nRet = hkCamera.MV_CC_OpenDevice_NET();
|
||
if (MyCamera.MV_OK != nRet)
|
||
{
|
||
hkCamera.MV_CC_DestroyDevice_NET();
|
||
Thread.Sleep(10);
|
||
if (i == 9) Console.WriteLine("打开相机失败！{0:x8}", nRet);
|
||
}
|
||
else
|
||
{
|
||
break;
|
||
}
|
||
}
|
||
//探测网络最佳包大小（只对gige相机有效）
|
||
if (device.nTLayerType == MyCamera.MV_GIGE_DEVICE)
|
||
{
|
||
int nPacketSize = hkCamera.MV_CC_GetOptimalPacketSize_NET();
|
||
if (nPacketSize > 0)
|
||
{
|
||
nRet = hkCamera.MV_CC_SetIntValue_NET("GevSCPSPacketSize", (uint)nPacketSize);
|
||
if (nRet != MyCamera.MV_OK)
|
||
{
|
||
Console.WriteLine("Warning: Set Packet Size failed {0:x8}", nRet);
|
||
}
|
||
}
|
||
else
|
||
{
|
||
Console.WriteLine("Warning: Get Packet Size failed {0:x8}", nPacketSize);
|
||
}
|
||
}
|
||
|
||
SetTriggerMode(true);
|
||
SetSoftTrigger(true);
|
||
|
||
//注册断线重连回调函数
|
||
nRet = hkCamera.MV_CC_RegisterExceptionCallBack_NET(pCallBackFunc, IntPtr.Zero);
|
||
if (MyCamera.MV_OK != nRet)
|
||
{
|
||
return false;
|
||
}
|
||
GC.KeepAlive(pCallBackFunc);
|
||
//注册图像回调函数
|
||
//ImageCallback = new MyCamera.cbOutputExdelegate(ImageCallbackFunc);
|
||
//nRet = hkCamera.MV_CC_RegisterImageCallBackEx_NET(ImageCallback, IntPtr.Zero);
|
||
if (MyCamera.MV_OK != nRet)
|
||
{
|
||
Console.WriteLine("Register image callback failed!");
|
||
return false;
|
||
}
|
||
|
||
// ch:设置采集连续模式 | en:Set Continues Aquisition Mode
|
||
hkCamera.MV_CC_SetEnumValue_NET("AcquisitionMode", (uint)MyCamera.MV_CAM_ACQUISITION_MODE.MV_ACQ_MODE_CONTINUOUS);
|
||
//设置开启触发模式
|
||
nRet = hkCamera.MV_CC_SetEnumValue_NET("TriggerMode", (uint)MyCamera.MV_CAM_TRIGGER_MODE.MV_TRIGGER_MODE_OFF);
|
||
//设置开启软触发模式
|
||
//hkCamera.MV_CC_SetEnumValue_NET("TriggerSource", (uint)MyCamera.MV_CAM_TRIGGER_SOURCE.MV_TRIGGER_SOURCE_SOFTWARE);
|
||
//使用软触发命令
|
||
//nRet = hkCamera.MV_CC_SetCommandValue_NET("TriggerSoftware");
|
||
if (MyCamera.MV_OK != nRet)
|
||
{
|
||
m_bGrabbing = false;
|
||
return false;
|
||
}
|
||
//开始采集
|
||
// nRet = hkCamera.MV_CC_StartGrabbing_NET();
|
||
if (MyCamera.MV_OK != nRet)
|
||
{
|
||
Console.WriteLine("开启相机采集失败! {0:x8}", nRet);
|
||
return false;
|
||
}
|
||
|
||
|
||
|
||
return true;
|
||
}
|
||
|
||
|
||
/// <summary>
|
||
/// 设置触发模式
|
||
/// </summary>
|
||
/// <param name="isTrigger">触发模式：true；连续采集模式：false</param>
|
||
public void SetTriggerMode(bool isTrigger)
|
||
{
|
||
if (isTrigger)
|
||
{
|
||
hkCamera.MV_CC_SetEnumValue_NET("TriggerMode", (uint)MyCamera.MV_CAM_TRIGGER_MODE.MV_TRIGGER_MODE_ON);
|
||
}
|
||
else
|
||
{
|
||
hkCamera.MV_CC_SetEnumValue_NET("TriggerMode", (uint)MyCamera.MV_CAM_TRIGGER_MODE.MV_TRIGGER_MODE_OFF);
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// 设置软触发
|
||
/// </summary>
|
||
/// <param name="trigBySoft"></param>
|
||
public void SetSoftTrigger(bool trigBySoft)
|
||
{
|
||
if (trigBySoft)
|
||
{
|
||
hkCamera.MV_CC_SetEnumValue_NET("TriggerSource", (uint)MyCamera.MV_CAM_TRIGGER_SOURCE.MV_TRIGGER_SOURCE_SOFTWARE);
|
||
}
|
||
else
|
||
{
|
||
//外部触发源：Line0~Line3，默认用Line0
|
||
hkCamera.MV_CC_SetEnumValue_NET("TriggerSource", (uint)MyCamera.MV_CAM_TRIGGER_SOURCE.MV_TRIGGER_SOURCE_LINE0);
|
||
}
|
||
}
|
||
|
||
|
||
/// </summary>
|
||
/// <returns></returns>
|
||
//public override bool OneGrap()
|
||
//{
|
||
// try
|
||
// {
|
||
// if (m_bGrabbing)
|
||
// {
|
||
// Console.WriteLine("Camera is now Continue Grabing Images！");
|
||
|
||
// return false;
|
||
// }
|
||
// else
|
||
// {
|
||
// // ch:标志位置位true | en:Set position bit true
|
||
// //m_bGrabbing = true;
|
||
// int nRet;
|
||
// MyCamera.MV_FRAME_OUT frameInfo = new MyCamera.MV_FRAME_OUT();
|
||
// //设置开启触发模式
|
||
// nRet = hkCamera.MV_CC_SetEnumValue_NET("TriggerMode", (uint)MyCamera.MV_CAM_TRIGGER_MODE.MV_TRIGGER_MODE_ON);
|
||
// //设置开启软触发模式
|
||
// nRet = hkCamera.MV_CC_SetEnumValue_NET("TriggerSource", (uint)MyCamera.MV_CAM_TRIGGER_SOURCE.MV_TRIGGER_SOURCE_SOFTWARE);
|
||
|
||
// //使用软触发命令
|
||
// nRet = hkCamera.MV_CC_SetCommandValue_NET("TriggerSoftware");
|
||
|
||
|
||
// if (MyCamera.MV_OK != nRet)
|
||
// {
|
||
// throw new Exception($"相机拍照触发失败:{nRet}");
|
||
// }
|
||
// //nRet = hkCamera.MV_CC_GetImageBuffer_NET(ref frameInfo, 1000);
|
||
// //nRet = hkCamera.MV_CC_FreeImageBuffer_NET(ref frameInfo);
|
||
// if (MyCamera.MV_OK != nRet)
|
||
// {
|
||
// m_bGrabbing = false;
|
||
// return false;
|
||
// }
|
||
// else
|
||
// {
|
||
// //if (frameInfo.pBufAddr != IntPtr.Zero)
|
||
// //{
|
||
// if (nRet == MyCamera.MV_OK)
|
||
// {
|
||
// var pFrameInfo = frameInfo.stFrameInfo;
|
||
|
||
// //himg.GenImage1("byte", pFrameInfo.nWidth, pFrameInfo.nHeight, frameInfo.pBufAddr);
|
||
// Mat mat = Mat.FromPixelData(pFrameInfo.nWidth, pFrameInfo.nHeight, MatType.CV_8UC3, frameInfo.pBufAddr);
|
||
// //Bitmap a = OpenCvSharp.Extensions.BitmapConverter.ToBitmap(mat);
|
||
// //OnDeliverImg?.Invoke(_mat);
|
||
// Cv2.ImWrite("test.jpg", mat);
|
||
// OnImgTransfer?.Invoke(mat);
|
||
// }
|
||
// //}
|
||
// }
|
||
|
||
// // HeventSlim.Wait();
|
||
// return true;
|
||
// }
|
||
// }
|
||
// catch (Exception)
|
||
// {
|
||
// return false;
|
||
// }
|
||
|
||
//}
|
||
|
||
bool IsGrabImg;
|
||
public void GrabImg()
|
||
{
|
||
IsGrabImg = true;
|
||
int nRet = hkCamera.MV_CC_SetCommandValue_NET("TriggerSoftware");
|
||
MyCamera.MV_FRAME_OUT frameInfo = new MyCamera.MV_FRAME_OUT();
|
||
|
||
//nRet = m_MyCamera.MV_CC_GetImageBuffer_NET(ref frameInfo,10);
|
||
//nRet = m_MyCamera.MV_CC_FreeImageBuffer_NET(ref frameInfo);
|
||
if (MyCamera.MV_OK != nRet)
|
||
{
|
||
//ShowErrorMsg("Trigger Software Fail!", nRet);
|
||
}
|
||
}
|
||
|
||
|
||
public void StartGarb(IntPtr handle)
|
||
{
|
||
int nRet;
|
||
nRet = NecessaryOperBeforeGrab();
|
||
|
||
m_bGrabbing = true;
|
||
IsGrabImg = false;
|
||
m_hReceiveThread = new Thread(new ParameterizedThreadStart(ReceiveThreadProcess));
|
||
m_hReceiveThread.Start(handle);
|
||
|
||
m_stFrameInfo.nFrameLen = 0;
|
||
|
||
m_stFrameInfo.enPixelType = MyCamera.MvGvspPixelType.PixelType_Gvsp_Undefined;
|
||
// nRet = hkCamera.MV_CC_SetEnumValue_NET("TriggerMode", (uint)MyCamera.MV_CAM_TRIGGER_MODE.MV_TRIGGER_MODE_ON);
|
||
//设置开启软触发模式
|
||
//nRet = hkCamera.MV_CC_SetEnumValue_NET("TriggerSource", (uint)MyCamera.MV_CAM_TRIGGER_SOURCE.MV_TRIGGER_SOURCE_SOFTWARE);
|
||
// ch:开始采集 | en:Start Grabbing
|
||
nRet = hkCamera.MV_CC_StartGrabbing_NET();
|
||
if (MyCamera.MV_OK != nRet)
|
||
{
|
||
m_bGrabbing = false;
|
||
m_hReceiveThread.Join();
|
||
//ShowErrorMsg("Start Grabbing Fail!", nRet);
|
||
return;
|
||
}
|
||
}
|
||
|
||
//public void StopGrabbing()
|
||
//{
|
||
// int nRet = hkCamera.MV_CC_StopGrabbing_NET();
|
||
// if (nRet != MyCamera.MV_OK)
|
||
// {
|
||
// //ShowAlarm(string.Format("相机{0}结束采集失败,错误代码：{1}", m_Name, nRet));
|
||
// }
|
||
|
||
//}
|
||
|
||
public void ReceiveThreadProcess(object handle)
|
||
{
|
||
MyCamera.MV_FRAME_OUT stFrameInfo = new MyCamera.MV_FRAME_OUT();
|
||
MyCamera.MV_DISPLAY_FRAME_INFO stDisplayInfo = new MyCamera.MV_DISPLAY_FRAME_INFO();
|
||
MyCamera.MV_PIXEL_CONVERT_PARAM stConvertInfo = new MyCamera.MV_PIXEL_CONVERT_PARAM();
|
||
int nRet = MyCamera.MV_OK;
|
||
|
||
while (m_bGrabbing)
|
||
{
|
||
nRet = hkCamera.MV_CC_GetImageBuffer_NET(ref stFrameInfo, 1000);
|
||
if (nRet == MyCamera.MV_OK)
|
||
{
|
||
lock (BufForDriverLock)
|
||
{
|
||
if (m_BufForDriver == IntPtr.Zero || stFrameInfo.stFrameInfo.nFrameLen > m_nBufSizeForDriver)
|
||
{
|
||
if (m_BufForDriver != IntPtr.Zero)
|
||
{
|
||
Marshal.Release(m_BufForDriver);
|
||
m_BufForDriver = IntPtr.Zero;
|
||
}
|
||
|
||
m_BufForDriver = Marshal.AllocHGlobal((Int32)stFrameInfo.stFrameInfo.nFrameLen);
|
||
if (m_BufForDriver == IntPtr.Zero)
|
||
{
|
||
return;
|
||
}
|
||
m_nBufSizeForDriver = stFrameInfo.stFrameInfo.nFrameLen;
|
||
}
|
||
|
||
m_stFrameInfo = stFrameInfo.stFrameInfo;
|
||
CopyMemory(m_BufForDriver, stFrameInfo.pBufAddr, stFrameInfo.stFrameInfo.nFrameLen);
|
||
|
||
stConvertInfo.nWidth = stFrameInfo.stFrameInfo.nWidth;
|
||
stConvertInfo.nHeight = stFrameInfo.stFrameInfo.nHeight;
|
||
stConvertInfo.enSrcPixelType = stFrameInfo.stFrameInfo.enPixelType;
|
||
stConvertInfo.pSrcData = stFrameInfo.pBufAddr;
|
||
stConvertInfo.nSrcDataLen = stFrameInfo.stFrameInfo.nFrameLen;
|
||
stConvertInfo.pDstBuffer = m_ConvertDstBuf;
|
||
stConvertInfo.nDstBufferSize = m_nConvertDstBufLen;
|
||
if (PixelFormat.Format8bppIndexed == m_bitmap.PixelFormat)
|
||
{
|
||
stConvertInfo.enDstPixelType = MyCamera.MvGvspPixelType.PixelType_Gvsp_Mono8;
|
||
hkCamera.MV_CC_ConvertPixelType_NET(ref stConvertInfo);
|
||
}
|
||
else
|
||
{
|
||
stConvertInfo.enDstPixelType = MyCamera.MvGvspPixelType.PixelType_Gvsp_BGR8_Packed;
|
||
hkCamera.MV_CC_ConvertPixelType_NET(ref stConvertInfo);
|
||
}
|
||
|
||
// ch:保存Bitmap数据 | en:Save Bitmap Data
|
||
BitmapData bitmapData = m_bitmap.LockBits(new Rectangle(0, 0, stConvertInfo.nWidth, stConvertInfo.nHeight), ImageLockMode.ReadWrite, m_bitmap.PixelFormat);
|
||
CopyMemory(bitmapData.Scan0, stConvertInfo.pDstBuffer, (UInt32)(bitmapData.Stride * m_bitmap.Height));
|
||
m_bitmap.UnlockBits(bitmapData);
|
||
|
||
}
|
||
if (RemoveCustomPixelFormats(stFrameInfo.stFrameInfo.enPixelType))
|
||
{
|
||
hkCamera.MV_CC_FreeImageBuffer_NET(ref stFrameInfo);
|
||
continue;
|
||
}
|
||
|
||
nRet = hkCamera.MV_CC_FreeImageBuffer_NET(ref stFrameInfo);
|
||
if (IsGrabImg)
|
||
{
|
||
if (MyCamera.MV_OK == nRet)
|
||
{
|
||
if (stFrameInfo.pBufAddr != IntPtr.Zero)
|
||
{
|
||
stDisplayInfo.hWnd = (IntPtr)handle;
|
||
stDisplayInfo.pData = stFrameInfo.pBufAddr;
|
||
stDisplayInfo.nDataLen = stFrameInfo.stFrameInfo.nFrameLen;
|
||
stDisplayInfo.nWidth = stFrameInfo.stFrameInfo.nWidth;
|
||
stDisplayInfo.nHeight = stFrameInfo.stFrameInfo.nHeight;
|
||
stDisplayInfo.enPixelType = stFrameInfo.stFrameInfo.enPixelType;
|
||
hkCamera.MV_CC_DisplayOneFrame_NET(ref stDisplayInfo);
|
||
//nRet = hkCamera.MV_CC_FreeImageBuffer_NET(ref stFrameInfo);
|
||
var pFrameInfo = stFrameInfo.stFrameInfo;
|
||
Mat ab = new Mat(pFrameInfo.nHeight, pFrameInfo.nWidth, MatType.CV_8UC3, stFrameInfo.pBufAddr);
|
||
//OnImgTransfer?.Invoke(ab);
|
||
OnHImageOutput?.Invoke(DateTime.Now, ab);
|
||
//Cv2.ImWrite("test.jpg", ab);
|
||
|
||
}
|
||
}
|
||
}
|
||
|
||
|
||
}
|
||
else
|
||
{
|
||
|
||
}
|
||
}
|
||
}
|
||
public void ConvertToImage(IntPtr pData, ref MyCamera.MV_FRAME_OUT_INFO_EX pFrameInfo, IntPtr pUser)
|
||
{
|
||
int nRet;
|
||
//HObject img = new HObject();
|
||
Mat matImag = new Mat();
|
||
//Bitmap bitmap = new Bitmap();
|
||
IntPtr pImageBuf = IntPtr.Zero;
|
||
int nImageBufSize = 0;
|
||
//Bitmap cameraImg;
|
||
IntPtr pTemp = IntPtr.Zero;
|
||
if (IsColorPixelFormat(pFrameInfo.enPixelType))
|
||
{
|
||
//cameraImg = new Bitmap(pFrameInfo.nWidth, pFrameInfo.nHeight, pFrameInfo.nWidth * 3, System.Drawing.Imaging.PixelFormat.Format24bppRgb,pData);
|
||
|
||
//bmp.Save("1.bmp", System.Drawing.Imaging.ImageFormat.Bmp);
|
||
|
||
if (pFrameInfo.enPixelType == MyCamera.MvGvspPixelType.PixelType_Gvsp_RGB8_Packed)
|
||
{
|
||
pTemp = pData;
|
||
}
|
||
else
|
||
{
|
||
if (IntPtr.Zero == pImageBuf || nImageBufSize < (pFrameInfo.nWidth * pFrameInfo.nHeight * 3))
|
||
{
|
||
if (pImageBuf != IntPtr.Zero)
|
||
{
|
||
Marshal.FreeHGlobal(pImageBuf);
|
||
pImageBuf = IntPtr.Zero;
|
||
}
|
||
pImageBuf = Marshal.AllocHGlobal((int)pFrameInfo.nWidth * pFrameInfo.nHeight * 3);
|
||
if (IntPtr.Zero == pImageBuf)
|
||
{
|
||
Console.WriteLine("图像采集为空");
|
||
return;
|
||
}
|
||
nImageBufSize = pFrameInfo.nWidth * pFrameInfo.nHeight * 3;
|
||
}
|
||
MyCamera.MV_PIXEL_CONVERT_PARAM stPixelConvertParam = new MyCamera.MV_PIXEL_CONVERT_PARAM();
|
||
|
||
stPixelConvertParam.pSrcData = pData;//源数据
|
||
stPixelConvertParam.nWidth = pFrameInfo.nWidth;//图像宽度
|
||
stPixelConvertParam.nHeight = pFrameInfo.nHeight;//图像高度
|
||
stPixelConvertParam.enSrcPixelType = pFrameInfo.enPixelType;//源数据的格式
|
||
stPixelConvertParam.nSrcDataLen = pFrameInfo.nFrameLen;
|
||
|
||
stPixelConvertParam.nDstBufferSize = (uint)nImageBufSize;
|
||
stPixelConvertParam.pDstBuffer = pImageBuf;//转换后的数据
|
||
stPixelConvertParam.enDstPixelType = MyCamera.MvGvspPixelType.PixelType_Gvsp_RGB8_Packed;
|
||
|
||
|
||
nRet = hkCamera.MV_CC_ConvertPixelType_NET(ref stPixelConvertParam);//格式转换
|
||
if (MyCamera.MV_OK != nRet)
|
||
{
|
||
Console.WriteLine("图像转换异常");
|
||
return;
|
||
}
|
||
pTemp = stPixelConvertParam.pDstBuffer;
|
||
}
|
||
try
|
||
{
|
||
HOperatorSet.GenImageInterleaved(out hPylonImage, (HTuple)pTemp, (HTuple)"rgb", (HTuple)pFrameInfo.nWidth, (HTuple)pFrameInfo.nHeight, -1, "byte", 0, 0, 0, 0, -1, 0);
|
||
|
||
}
|
||
catch (System.Exception ex)
|
||
{
|
||
Console.WriteLine(ex.ToString());
|
||
return;
|
||
}
|
||
}
|
||
else if (IsMonoPixelFormat(pFrameInfo.enPixelType))
|
||
{
|
||
if (pFrameInfo.enPixelType == MyCamera.MvGvspPixelType.PixelType_Gvsp_Mono8)
|
||
{
|
||
pTemp = pData;
|
||
}
|
||
else
|
||
{
|
||
if (IntPtr.Zero == pImageBuf || nImageBufSize < (pFrameInfo.nWidth * pFrameInfo.nHeight))
|
||
{
|
||
if (pImageBuf != IntPtr.Zero)
|
||
{
|
||
Marshal.FreeHGlobal(pImageBuf);
|
||
pImageBuf = IntPtr.Zero;
|
||
}
|
||
|
||
pImageBuf = Marshal.AllocHGlobal((int)pFrameInfo.nWidth * pFrameInfo.nHeight);
|
||
if (IntPtr.Zero == pImageBuf)
|
||
{
|
||
Console.WriteLine("图像采集为空");
|
||
return;
|
||
}
|
||
nImageBufSize = pFrameInfo.nWidth * pFrameInfo.nHeight;
|
||
}
|
||
|
||
MyCamera.MV_PIXEL_CONVERT_PARAM stPixelConvertParam = new MyCamera.MV_PIXEL_CONVERT_PARAM();
|
||
|
||
stPixelConvertParam.pSrcData = pData;//源数据
|
||
stPixelConvertParam.nWidth = pFrameInfo.nWidth;//图像宽度
|
||
stPixelConvertParam.nHeight = pFrameInfo.nHeight;//图像高度
|
||
stPixelConvertParam.enSrcPixelType = pFrameInfo.enPixelType;//源数据的格式
|
||
stPixelConvertParam.nSrcDataLen = pFrameInfo.nFrameLen;
|
||
|
||
stPixelConvertParam.nDstBufferSize = (uint)nImageBufSize;
|
||
stPixelConvertParam.pDstBuffer = pImageBuf;//转换后的数据
|
||
stPixelConvertParam.enDstPixelType = MyCamera.MvGvspPixelType.PixelType_Gvsp_Mono8;
|
||
nRet = hkCamera.MV_CC_ConvertPixelType_NET(ref stPixelConvertParam);//格式转换
|
||
if (MyCamera.MV_OK != nRet)
|
||
{
|
||
Console.WriteLine("图像转换异常");
|
||
return;
|
||
}
|
||
pTemp = stPixelConvertParam.pDstBuffer; ;
|
||
}
|
||
try
|
||
{
|
||
//cameraImg = new Bitmap();
|
||
// HOperatorSet.GenImage1Extern(out hPylonImage, "byte", pFrameInfo.nWidth, pFrameInfo.nHeight, pTemp, IntPtr.Zero);
|
||
}
|
||
catch (System.Exception ex)
|
||
{
|
||
MessageBox.Show(ex.ToString());
|
||
return;
|
||
}
|
||
}
|
||
else
|
||
{
|
||
Console.WriteLine("采集图像格式错误，不为彩色和黑白图像");
|
||
return;
|
||
}
|
||
|
||
try
|
||
{
|
||
//GetImage(hPylonImage);//调用相机基类的函数，用于传出变量
|
||
//hPylonImage.Dispose();
|
||
m_bGrabbing = false;
|
||
}
|
||
catch (Exception e)
|
||
{
|
||
Console.WriteLine(e.ToString());
|
||
return;
|
||
}
|
||
}
|
||
private Boolean IsMono(UInt32 enPixelType)
|
||
{
|
||
switch (enPixelType)
|
||
{
|
||
case (UInt32)MyCamera.MvGvspPixelType.PixelType_Gvsp_Mono1p:
|
||
case (UInt32)MyCamera.MvGvspPixelType.PixelType_Gvsp_Mono2p:
|
||
case (UInt32)MyCamera.MvGvspPixelType.PixelType_Gvsp_Mono4p:
|
||
case (UInt32)MyCamera.MvGvspPixelType.PixelType_Gvsp_Mono8:
|
||
case (UInt32)MyCamera.MvGvspPixelType.PixelType_Gvsp_Mono8_Signed:
|
||
case (UInt32)MyCamera.MvGvspPixelType.PixelType_Gvsp_Mono10:
|
||
case (UInt32)MyCamera.MvGvspPixelType.PixelType_Gvsp_Mono10_Packed:
|
||
case (UInt32)MyCamera.MvGvspPixelType.PixelType_Gvsp_Mono12:
|
||
case (UInt32)MyCamera.MvGvspPixelType.PixelType_Gvsp_Mono12_Packed:
|
||
case (UInt32)MyCamera.MvGvspPixelType.PixelType_Gvsp_Mono14:
|
||
case (UInt32)MyCamera.MvGvspPixelType.PixelType_Gvsp_Mono16:
|
||
return true;
|
||
default:
|
||
return false;
|
||
}
|
||
}
|
||
private Int32 NecessaryOperBeforeGrab()
|
||
{
|
||
// ch:取图像宽 | en:Get Iamge Width
|
||
MyCamera.MVCC_INTVALUE_EX stWidth = new MyCamera.MVCC_INTVALUE_EX();
|
||
int nRet = hkCamera.MV_CC_GetIntValueEx_NET("Width", ref stWidth);
|
||
if (MyCamera.MV_OK != nRet)
|
||
{
|
||
//ShowErrorMsg("Get Width Info Fail!", nRet);
|
||
return nRet;
|
||
}
|
||
// ch:取图像高 | en:Get Iamge Height
|
||
MyCamera.MVCC_INTVALUE_EX stHeight = new MyCamera.MVCC_INTVALUE_EX();
|
||
nRet = hkCamera.MV_CC_GetIntValueEx_NET("Height", ref stHeight);
|
||
if (MyCamera.MV_OK != nRet)
|
||
{
|
||
//ShowErrorMsg("Get Height Info Fail!", nRet);
|
||
return nRet;
|
||
}
|
||
// ch:取像素格式 | en:Get Pixel Format
|
||
MyCamera.MVCC_ENUMVALUE stPixelFormat = new MyCamera.MVCC_ENUMVALUE();
|
||
nRet = hkCamera.MV_CC_GetEnumValue_NET("PixelFormat", ref stPixelFormat);
|
||
if (MyCamera.MV_OK != nRet)
|
||
{
|
||
//ShowErrorMsg("Get Pixel Format Fail!", nRet);
|
||
return nRet;
|
||
}
|
||
|
||
// ch:设置bitmap像素格式，申请相应大小内存 | en:Set Bitmap Pixel Format, alloc memory
|
||
if ((Int32)MyCamera.MvGvspPixelType.PixelType_Gvsp_Undefined == stPixelFormat.nCurValue)
|
||
{
|
||
//ShowErrorMsg("Unknown Pixel Format!", MyCamera.MV_E_UNKNOW);
|
||
return MyCamera.MV_E_UNKNOW;
|
||
}
|
||
else if (IsMono(stPixelFormat.nCurValue))
|
||
{
|
||
m_bitmapPixelFormat = PixelFormat.Format8bppIndexed;
|
||
|
||
if (IntPtr.Zero != m_ConvertDstBuf)
|
||
{
|
||
Marshal.Release(m_ConvertDstBuf);
|
||
m_ConvertDstBuf = IntPtr.Zero;
|
||
}
|
||
|
||
// Mono8为单通道
|
||
m_nConvertDstBufLen = (UInt32)(stWidth.nCurValue * stHeight.nCurValue);
|
||
m_ConvertDstBuf = Marshal.AllocHGlobal((Int32)m_nConvertDstBufLen);
|
||
if (IntPtr.Zero == m_ConvertDstBuf)
|
||
{
|
||
//ShowErrorMsg("Malloc Memory Fail!", MyCamera.MV_E_RESOURCE);
|
||
return MyCamera.MV_E_RESOURCE;
|
||
}
|
||
}
|
||
else
|
||
{
|
||
m_bitmapPixelFormat = PixelFormat.Format24bppRgb;
|
||
|
||
if (IntPtr.Zero != m_ConvertDstBuf)
|
||
{
|
||
Marshal.FreeHGlobal(m_ConvertDstBuf);
|
||
m_ConvertDstBuf = IntPtr.Zero;
|
||
}
|
||
|
||
// RGB为三通道
|
||
m_nConvertDstBufLen = (UInt32)(3 * stWidth.nCurValue * stHeight.nCurValue);
|
||
m_ConvertDstBuf = Marshal.AllocHGlobal((Int32)m_nConvertDstBufLen);
|
||
if (IntPtr.Zero == m_ConvertDstBuf)
|
||
{
|
||
//ShowErrorMsg("Malloc Memory Fail!", MyCamera.MV_E_RESOURCE);
|
||
return MyCamera.MV_E_RESOURCE;
|
||
}
|
||
}
|
||
|
||
// 确保释放保存了旧图像数据的bitmap实例，用新图像宽高等信息new一个新的bitmap实例
|
||
if (null != m_bitmap)
|
||
{
|
||
m_bitmap.Dispose();
|
||
m_bitmap = null;
|
||
}
|
||
m_bitmap = new Bitmap((Int32)stWidth.nCurValue, (Int32)stHeight.nCurValue, m_bitmapPixelFormat);
|
||
|
||
// ch:Mono8格式，设置为标准调色板 | en:Set Standard Palette in Mono8 Format
|
||
if (PixelFormat.Format8bppIndexed == m_bitmapPixelFormat)
|
||
{
|
||
ColorPalette palette = m_bitmap.Palette;
|
||
for (int i = 0; i < palette.Entries.Length; i++)
|
||
{
|
||
palette.Entries[i] = Color.FromArgb(i, i, i);
|
||
}
|
||
m_bitmap.Palette = palette;
|
||
}
|
||
|
||
return MyCamera.MV_OK;
|
||
}
|
||
|
||
|
||
|
||
/// <summary>
|
||
/// 相机重连开启
|
||
/// </summary>
|
||
/// <param name="CameraName"></param>
|
||
/// <returns></returns>
|
||
public override bool ReconnectCamera(string CameraName)
|
||
{
|
||
CloserCamera();
|
||
for (int i = 0; i < m_pDeviceList.nDeviceNum; i++)
|
||
{
|
||
device = (MyCamera.MV_CC_DEVICE_INFO)Marshal.PtrToStructure(m_pDeviceList.pDeviceInfo[i], typeof(MyCamera.MV_CC_DEVICE_INFO));
|
||
IntPtr buffer = Marshal.UnsafeAddrOfPinnedArrayElement(device.SpecialInfo.stGigEInfo, 0);
|
||
MyCamera.MV_GIGE_DEVICE_INFO gigeInfo = (MyCamera.MV_GIGE_DEVICE_INFO)Marshal.PtrToStructure(buffer, typeof(MyCamera.MV_GIGE_DEVICE_INFO));
|
||
if (gigeInfo.chSerialNumber == CameraName)
|
||
{
|
||
break;
|
||
}
|
||
}
|
||
int index = 0;
|
||
while (true)
|
||
{
|
||
int nRet = hkCamera.MV_CC_CreateDevice_NET(ref device);
|
||
index++;
|
||
if (index > 1000)
|
||
{
|
||
Console.WriteLine("相机重连超时，请检查相机安装");
|
||
nRet = -1;
|
||
break;
|
||
}
|
||
if (MyCamera.MV_OK != nRet)
|
||
{
|
||
Thread.Sleep(5);
|
||
continue;
|
||
}
|
||
nRet = hkCamera.MV_CC_OpenDevice_NET();
|
||
if (MyCamera.MV_OK != nRet)
|
||
{
|
||
Thread.Sleep(5);
|
||
hkCamera.MV_CC_DestroyDevice_NET();
|
||
continue;
|
||
}
|
||
else
|
||
{
|
||
if (MyCamera.MV_OK != nRet)
|
||
{
|
||
Thread.Sleep(5);
|
||
hkCamera.MV_CC_DestroyDevice_NET();
|
||
continue;
|
||
}
|
||
break;
|
||
}
|
||
}
|
||
return true;
|
||
}
|
||
|
||
void ImageCallbackFunc(IntPtr pData, ref MyCamera.MV_FRAME_OUT_INFO_EX pFrameInfo, IntPtr pUser)
|
||
{
|
||
//Console.WriteLine("Get one frame: Width[" + Convert.ToString(pFrameInfo.nWidth) + "] , Height[" + Convert.ToString(pFrameInfo.nHeight)
|
||
// + "] , FrameNum[" + Convert.ToString(pFrameInfo.nFrameNum) + "]");
|
||
|
||
ConvertToImage(pData, ref pFrameInfo, pUser);
|
||
}
|
||
|
||
|
||
public Action<Mat> OnDeliverImg { get; set; }
|
||
|
||
|
||
|
||
public void Snapshot()
|
||
{
|
||
Stopwatch sw = new Stopwatch();
|
||
sw.Start();
|
||
// ImageSet set = new ImageSet();
|
||
// set.SnapshotCount = SnapshotCount;
|
||
// set.SnapshotFileName = SnapshotFileNames;
|
||
|
||
//InitialImageSet(set);
|
||
MyCamera.MV_FRAME_OUT frameInfo = new MyCamera.MV_FRAME_OUT();
|
||
nRet = MyCamera.MV_OK;
|
||
if (true)
|
||
{
|
||
// ch: 触发命令 || en: Trigger command
|
||
nRet = hkCamera.MV_CC_SetCommandValue_NET("TriggerSoftware");
|
||
if (MyCamera.MV_OK != nRet)
|
||
{
|
||
throw new Exception($"相机拍照触发失败:{nRet}");
|
||
}
|
||
|
||
nRet = hkCamera.MV_CC_GetImageBuffer_NET(ref frameInfo, 1000);
|
||
nRet = hkCamera.MV_CC_FreeImageBuffer_NET(ref frameInfo);
|
||
}
|
||
else
|
||
{
|
||
_snapHandle.Reset();
|
||
_snapFlag = true;
|
||
_snapHandle.WaitOne();
|
||
//lock (_imgCallBackLock)
|
||
{
|
||
frameInfo.stFrameInfo = _frame.stFrameInfo;
|
||
frameInfo.pBufAddr = _frame.pBufAddr;
|
||
}
|
||
}
|
||
|
||
// ch:获取一帧图像 | en:Get one image
|
||
if (MyCamera.MV_OK == nRet)
|
||
{
|
||
if (frameInfo.pBufAddr != IntPtr.Zero)
|
||
{
|
||
if (nRet == MyCamera.MV_OK)
|
||
{
|
||
var pFrameInfo = frameInfo.stFrameInfo;
|
||
HImage hImage = new HImage();
|
||
hImage.GenImage1("byte", pFrameInfo.nWidth, pFrameInfo.nHeight, frameInfo.pBufAddr);
|
||
Mat mat = new Mat();
|
||
Bitmap a = hImage.ConvertHImageToBitmap();
|
||
OnBitmapTransfer?.Invoke(a);
|
||
|
||
}
|
||
}
|
||
}
|
||
else
|
||
{
|
||
throw new Exception($"Grap Image Failed:{nRet:x8}");
|
||
}
|
||
|
||
sw.Stop();
|
||
//LogAsync(DateTime.Now, LogLevel.Information, $"取像耗时：{sw.ElapsedMilliseconds} ms");
|
||
}
|
||
|
||
/// <summary>
|
||
/// 转化像素为Bit图像
|
||
/// </summary>
|
||
/// <param name="pData"></param>
|
||
/// <param name="pFrameInfo"></param>
|
||
public Bitmap GetBitmap(int nWidth, int nHeight, int nBpp, byte[] DataBuf, int nCompress = 1)
|
||
{
|
||
int nNewH = nHeight / nCompress;
|
||
int nNewW = nWidth / nCompress;
|
||
|
||
|
||
Bitmap BitmapImage = new Bitmap(nNewW, nNewH, PixelFormat.Format24bppRgb);
|
||
BitmapData srcBmpData =
|
||
BitmapImage.LockBits(
|
||
new Rectangle(0, 0, BitmapImage.Width, BitmapImage.Height),
|
||
ImageLockMode.ReadWrite, BitmapImage.PixelFormat);
|
||
|
||
switch (nBpp)
|
||
{
|
||
case 0:
|
||
unsafe
|
||
{
|
||
byte* psrcBuffer = (byte*)srcBmpData.Scan0.ToPointer();
|
||
|
||
int nIndex = 0;
|
||
|
||
for (int i = 0; i < nHeight; i += nCompress)
|
||
{
|
||
for (int j = 0; j < nWidth; j += nCompress)
|
||
{
|
||
psrcBuffer[nIndex++] = DataBuf[i * nWidth + j];
|
||
psrcBuffer[nIndex++] = DataBuf[i * nWidth + j];
|
||
psrcBuffer[nIndex++] = DataBuf[i * nWidth + j];
|
||
}
|
||
}
|
||
|
||
}
|
||
break;
|
||
|
||
case 1:
|
||
unsafe
|
||
{
|
||
byte* psrcBuffer = (byte*)srcBmpData.Scan0.ToPointer();
|
||
|
||
int nCount = nWidth * nHeight;
|
||
int nStep = nCount * 2;
|
||
int nIndex = 0;
|
||
|
||
for (int i = 0; i < nHeight; i += nCompress)
|
||
{
|
||
for (int j = 0; j < nWidth; j += nCompress)
|
||
{
|
||
psrcBuffer[nIndex++] = DataBuf[i * nWidth + j + nStep];
|
||
psrcBuffer[nIndex++] = DataBuf[i * nWidth + j + nCount];
|
||
psrcBuffer[nIndex++] = DataBuf[i * nWidth + j];
|
||
}
|
||
}
|
||
}
|
||
break;
|
||
}
|
||
BitmapImage.UnlockBits(srcBmpData);
|
||
return BitmapImage;
|
||
}
|
||
|
||
|
||
public void SetHeartBeatTime(uint value)
|
||
{
|
||
try
|
||
{
|
||
//判断是否是网口相机
|
||
if (device.nTLayerType == MyCamera.MV_GIGE_DEVICE)
|
||
{
|
||
hkCamera.MV_CC_SetHeartBeatTimeout_NET(value);
|
||
}
|
||
}
|
||
catch (Exception)
|
||
{
|
||
|
||
}
|
||
}
|
||
|
||
public override bool SetExpoureTime(int ExposureTime)
|
||
{
|
||
try
|
||
{
|
||
hkCamera.MV_CC_SetEnumValue_NET("ExposureAuto", 0);
|
||
int nRet = hkCamera.MV_CC_SetFloatValue_NET("ExposureTime", ExposureTime);
|
||
if (nRet != MyCamera.MV_OK)
|
||
{
|
||
return false;
|
||
}
|
||
return true;
|
||
}
|
||
catch (Exception)
|
||
{
|
||
return false;
|
||
}
|
||
}
|
||
/// <summary>
|
||
/// 判断是否为彩色图像
|
||
/// </summary>
|
||
/// <param name="mvGvspPixelType"></param>
|
||
/// <returns></returns>
|
||
private bool IsColorPixelFormat(MyCamera.MvGvspPixelType enType)
|
||
{
|
||
switch (enType)
|
||
{
|
||
case MyCamera.MvGvspPixelType.PixelType_Gvsp_RGB8_Packed:
|
||
case MyCamera.MvGvspPixelType.PixelType_Gvsp_BGR8_Packed:
|
||
case MyCamera.MvGvspPixelType.PixelType_Gvsp_RGBA8_Packed:
|
||
case MyCamera.MvGvspPixelType.PixelType_Gvsp_BGRA8_Packed:
|
||
case MyCamera.MvGvspPixelType.PixelType_Gvsp_YUV422_Packed:
|
||
case MyCamera.MvGvspPixelType.PixelType_Gvsp_YUV422_YUYV_Packed:
|
||
case MyCamera.MvGvspPixelType.PixelType_Gvsp_BayerGR8:
|
||
case MyCamera.MvGvspPixelType.PixelType_Gvsp_BayerRG8:
|
||
case MyCamera.MvGvspPixelType.PixelType_Gvsp_BayerGB8:
|
||
case MyCamera.MvGvspPixelType.PixelType_Gvsp_BayerBG8:
|
||
case MyCamera.MvGvspPixelType.PixelType_Gvsp_BayerGB10:
|
||
case MyCamera.MvGvspPixelType.PixelType_Gvsp_BayerGB10_Packed:
|
||
case MyCamera.MvGvspPixelType.PixelType_Gvsp_BayerBG10:
|
||
case MyCamera.MvGvspPixelType.PixelType_Gvsp_BayerBG10_Packed:
|
||
case MyCamera.MvGvspPixelType.PixelType_Gvsp_BayerRG10:
|
||
case MyCamera.MvGvspPixelType.PixelType_Gvsp_BayerRG10_Packed:
|
||
case MyCamera.MvGvspPixelType.PixelType_Gvsp_BayerGR10:
|
||
case MyCamera.MvGvspPixelType.PixelType_Gvsp_BayerGR10_Packed:
|
||
case MyCamera.MvGvspPixelType.PixelType_Gvsp_BayerGB12:
|
||
case MyCamera.MvGvspPixelType.PixelType_Gvsp_BayerGB12_Packed:
|
||
case MyCamera.MvGvspPixelType.PixelType_Gvsp_BayerBG12:
|
||
case MyCamera.MvGvspPixelType.PixelType_Gvsp_BayerBG12_Packed:
|
||
case MyCamera.MvGvspPixelType.PixelType_Gvsp_BayerRG12:
|
||
case MyCamera.MvGvspPixelType.PixelType_Gvsp_BayerRG12_Packed:
|
||
case MyCamera.MvGvspPixelType.PixelType_Gvsp_BayerGR12:
|
||
case MyCamera.MvGvspPixelType.PixelType_Gvsp_BayerGR12_Packed:
|
||
return true;
|
||
default:
|
||
return false;
|
||
}
|
||
}
|
||
private bool IsMonoPixelFormat(MyCamera.MvGvspPixelType enType)
|
||
{
|
||
switch (enType)
|
||
{
|
||
case MyCamera.MvGvspPixelType.PixelType_Gvsp_Mono8:
|
||
case MyCamera.MvGvspPixelType.PixelType_Gvsp_Mono10:
|
||
case MyCamera.MvGvspPixelType.PixelType_Gvsp_Mono10_Packed:
|
||
case MyCamera.MvGvspPixelType.PixelType_Gvsp_Mono12:
|
||
case MyCamera.MvGvspPixelType.PixelType_Gvsp_Mono12_Packed:
|
||
return true;
|
||
default:
|
||
return false;
|
||
}
|
||
}
|
||
private bool RemoveCustomPixelFormats(MyCamera.MvGvspPixelType enPixelFormat)
|
||
{
|
||
Int32 nResult = ((int)enPixelFormat) & (unchecked((Int32)0x80000000));
|
||
if (0x80000000 == nResult)
|
||
{
|
||
return true;
|
||
}
|
||
else
|
||
{
|
||
return false;
|
||
}
|
||
}
|
||
|
||
|
||
public void SetTriggerMode()
|
||
{
|
||
hkCamera.MV_CC_SetEnumValue_NET("TriggerMode", (uint)MyCamera.MV_CAM_TRIGGER_MODE.MV_TRIGGER_MODE_OFF);
|
||
}
|
||
public void SetTriggerModeON()
|
||
{
|
||
hkCamera.MV_CC_SetEnumValue_NET("TriggerMode", (uint)MyCamera.MV_CAM_TRIGGER_MODE.MV_TRIGGER_MODE_ON);
|
||
}
|
||
public void SetTriggerSource()
|
||
{
|
||
hkCamera.MV_CC_SetEnumValue_NET("TriggerSource", (uint)MyCamera.MV_CAM_TRIGGER_SOURCE.MV_TRIGGER_SOURCE_SOFTWARE);
|
||
}
|
||
public void SetTriggerSourceLine0()
|
||
{
|
||
hkCamera.MV_CC_SetEnumValue_NET("TriggerSource", (uint)MyCamera.MV_CAM_TRIGGER_SOURCE.MV_TRIGGER_SOURCE_LINE0);
|
||
}
|
||
public void SetTriggerMode1()
|
||
{
|
||
int nRet;
|
||
nRet = hkCamera.MV_CC_SetEnumValue_NET("TriggerMode", (uint)MyCamera.MV_CAM_TRIGGER_MODE.MV_TRIGGER_MODE_ON);
|
||
//设置开启软触发模式
|
||
nRet = hkCamera.MV_CC_SetEnumValue_NET("TriggerSource", (uint)MyCamera.MV_CAM_TRIGGER_SOURCE.MV_TRIGGER_SOURCE_SOFTWARE);
|
||
}
|
||
|
||
}
|
||
public static class HalconHelper
|
||
{
|
||
[DllImport("kernel32.dll", EntryPoint = "CopyMemory", SetLastError = false)]
|
||
public static extern void CopyMemory(IntPtr dest, IntPtr src, uint count);
|
||
public static Bitmap ConvertHImageToBitmap(this HObject hImage)
|
||
{
|
||
HOperatorSet.CountChannels(hImage, out HTuple chanels);
|
||
if (chanels.I == 1)
|
||
{
|
||
return hImage.ConvertHImageTo8GrayBitmap();
|
||
}
|
||
else
|
||
{
|
||
return hImage.ConvertHImageToRGBBitmap();
|
||
// return hImage.HObject2BitmapRGB();
|
||
}
|
||
}
|
||
public static Bitmap ConvertHImageTo8GrayBitmap(this HObject hImage)
|
||
{
|
||
try
|
||
{
|
||
HTuple type, width, height, pointer;
|
||
HOperatorSet.GetImagePointer1(hImage, out pointer, out type, out width, out height);
|
||
|
||
Bitmap bmp = new Bitmap(width.I, height.I, PixelFormat.Format8bppIndexed);
|
||
ColorPalette pal = bmp.Palette;
|
||
for (int i = 0; i <= 255; i++)
|
||
{
|
||
pal.Entries[i] = Color.FromArgb(255, i, i, i);
|
||
}
|
||
bmp.Palette = pal;
|
||
|
||
BitmapData bitmapData = bmp.LockBits(new Rectangle(0, 0, width, height), ImageLockMode.WriteOnly, PixelFormat.Format8bppIndexed);
|
||
|
||
if (width % 4 == 0)
|
||
{
|
||
CopyMemory(bitmapData.Scan0, (IntPtr)pointer.D, (uint)(bitmapData.Stride * height.I));
|
||
}
|
||
else
|
||
{
|
||
Parallel.For(0, height.I, h =>
|
||
{
|
||
CopyMemory(bitmapData.Scan0 + h * bitmapData.Stride, (IntPtr)(pointer.D + h * width.I), (uint)width.I);
|
||
});
|
||
}
|
||
|
||
bmp.UnlockBits(bitmapData);
|
||
return bmp;
|
||
}
|
||
catch (Exception ex)
|
||
{
|
||
return null;
|
||
}
|
||
}
|
||
public static Bitmap ConvertHImageToRGBBitmap(this HObject hImage)
|
||
{
|
||
try
|
||
{
|
||
HOperatorSet.GetImagePointer3(hImage, out HTuple pointRed, out HTuple pointGreen, out HTuple pointBlue, out HTuple type, out HTuple width, out HTuple height);
|
||
|
||
Bitmap image = new Bitmap(width.I, height.I, PixelFormat.Format24bppRgb);
|
||
BitmapData imageData = image.LockBits(new Rectangle(0, 0, width.I, height.I), ImageLockMode.ReadWrite, image.PixelFormat);
|
||
|
||
IntPtr pR = (IntPtr)pointRed.D;
|
||
IntPtr pG = (IntPtr)pointGreen.D;
|
||
IntPtr pB = (IntPtr)pointBlue.D;
|
||
|
||
Parallel.For(0, imageData.Height, h =>
|
||
{
|
||
Parallel.For(0, imageData.Width, w =>
|
||
{
|
||
int dest = h * imageData.Stride + w * 3;
|
||
int source = h * imageData.Width + w;
|
||
|
||
Marshal.WriteByte(imageData.Scan0, dest, Marshal.ReadByte(pB, source));
|
||
Marshal.WriteByte(imageData.Scan0, dest + 1, Marshal.ReadByte(pG, source));
|
||
Marshal.WriteByte(imageData.Scan0, dest + 2, Marshal.ReadByte(pR, source));
|
||
});
|
||
});
|
||
|
||
image.UnlockBits(imageData);
|
||
return image;
|
||
}
|
||
catch (Exception exc)
|
||
{
|
||
return null;
|
||
}
|
||
}
|
||
}
|
||
public class CameraInfor
|
||
{
|
||
public string userDefinedName { get; set; } //用户定义的名字
|
||
public string serialNumber { get; set; } //序列号
|
||
public string deviceIPAdd { get; set; } //设备IP地址
|
||
public string manufacturerName { get; set; }//制造厂商名
|
||
public string modelName { get; set; } //型号名称
|
||
public string deviceType { get; set; } //型号名称
|
||
public IntPtr pDeviceInfo; //相机句柄
|
||
public float ExposureTime { get; set; } //曝光时间
|
||
public float Gain { get; set; } //增益
|
||
public float ResultingFrameRate { get; set; } //帧率
|
||
public bool isOpenTriggerMode { get; set; } //是否打开触发方式
|
||
}
|
||
public class ASCameraParamInfor
|
||
{
|
||
/// <summary>
|
||
/// 曝光时间
|
||
/// </summary>
|
||
public float ExposureTime { get; set; }
|
||
/// <summary>
|
||
/// 增益
|
||
/// </summary>
|
||
public float Gain { get; set; }
|
||
/// <summary>
|
||
/// 获取帧率
|
||
/// </summary>
|
||
public float FrameRate { get; set; }
|
||
}
|
||
|
||
}
|