一.学习资料
1.官网下载安装MVS软件。
2.文件资料路径：C:\Program Files (x86)\MVS\Development\Documentations
3.引用的DLL路径：C:\Program Files (x86)\Common Files\MVS\Runtime\Win64_x64\MvCameraControl.dll（实测是这个路径，而非官方推荐的C:\Program Files (x86)\MVS\Development\DotNet\win64\MvCamCtrl.Net.dll）
4.官方示例程序：C:\Program Files (x86)\MVS\Development\Samples\C#
二、相机程序流程
1.枚举图像采集卡；【可选操作】
2.打开图像采集卡；【可选操作】
3.设置采集卡参数；【可选操作】
4.枚举相机设备；
5.判断相机可访问性；
6.创建相机句柄；
7.打开设备；
8.获取/设置参数；
9.开始采集取流；
10.触发取像：（1）注册回调函数（CallBack）获取图像数据；（2）主动式获取图像数据（获取、释放）；【两种方式只能使用一种】【相机取像在此环节循环操作】
11.停止采集取流；
12.关闭设备；
13.销毁句柄。
以上1，2，3为采集卡操作，如不涉及采集卡操作需要可忽略；10的取像方式两种只能使用其中一种，不支持复用，只要不是要关掉程序，软件即在此环节不断地循环并等待取像触发信号。
三、开发思路
1.将单个海康相机的信息和操作封装成一个类CCameraHik；
2.创建一个含有CCameraHik类的实例列表的全局用的操作类CHikVision，主要用于统一管理程序上的所有相机。
3.在主程序里创建类CHikVision的实例供程序使用。
四、代码展示
1.单个相机类CCameraHik
打开相机：
/// <summary>
/// 打开相机
/// </summary>
/// <returns></returns>
public override bool Open()
{
if (m_Camera == null)
{
m_Camera = new MyCamera();
if (m_Camera == null)
{
ShowAlarm(string.Format("创建相机{0}资源失败", m_Name));
return false;
}
}
//创建相机对象
int nRet = m_Camera.MV_CC_CreateDevice_NET(ref m_CameraInfo);
if (MyCamera.MV_OK != nRet)
{
ShowAlarm(string.Format("创建相机对象{0}失败,错误代码：{1}", m_Name, nRet));
return false;
}
//打开相机对象
nRet = m_Camera.MV_CC_OpenDevice_NET();
if (MyCamera.MV_OK != nRet)
{
ShowAlarm(string.Format("打开相机{0}失败,错误代码：{1}", m_Name, nRet));
return false;
}
else
{
//检测网络最佳包大小
if (m_CameraInfo.nTLayerType == MyCamera.MV_GIGE_DEVICE)
{
int nPacketSize = m_Camera.MV_CC_GetOptimalPacketSize_NET();
if (nPacketSize > 0)
{
nRet = m_Camera.MV_CC_SetIntValueEx_NET("GevSCPSPacketSize", nPacketSize);
if (nRet != MyCamera.MV_OK)
{
ShowAlarm(string.Format("设置相机{0}最佳数据包大小失败,错误代码：{1}", m_Name, nRet));
}
}
else
{
ShowAlarm(string.Format("获取相机{0}最佳数据包大小失败,错误代码：{1}", m_Name, nPacketSize));
}
}
//默认设置相机为触发模式
SetTriggerMode(true);
//默认设置相机为软触发
SetSoftTrigger(true);
//注册相机图像输出回调函数
m_Camera.MV_CC_RegisterImageCallBackEx_NET(CHikVision.ImageOutputCallBack, (IntPtr)m_ID);
return true;
}
}
/// <summary>
/// 设置触发模式
/// </summary>
/// <param name="isTrigger">触发模式：true；连续采集模式：false</param>
public override void SetTriggerMode(bool isTrigger)
{
if (isTrigger)
{
m_Camera.MV_CC_SetEnumValue_NET("TriggerMode", (uint)MyCamera.MV_CAM_TRIGGER_MODE.MV_TRIGGER_MODE_ON);
}
else
{
m_Camera.MV_CC_SetEnumValue_NET("TriggerMode", (uint)MyCamera.MV_CAM_TRIGGER_MODE.MV_TRIGGER_MODE_OFF);
}
}
/// <summary>
/// 设置软触发
/// </summary>
/// <param name="trigBySoft"></param>
public override void SetSoftTrigger(bool trigBySoft)
{
if (trigBySoft)
{
m_Camera.MV_CC_SetEnumValue_NET("TriggerSource", (uint)MyCamera.MV_CAM_TRIGGER_SOURCE.MV_TRIGGER_SOURCE_SOFTWARE);
}
else
{
//外部触发源：Line0~Line3，默认用Line0
m_Camera.MV_CC_SetEnumValue_NET("TriggerSource", (uint)MyCamera.MV_CAM_TRIGGER_SOURCE.MV_TRIGGER_SOURCE_LINE0);
}
}关闭相机：
/// <summary>
/// 关闭相机
/// </summary>
/// <returns></returns>
public override bool Close()
{
int nRet = m_Camera.MV_CC_CloseDevice_NET();
if (nRet != MyCamera.MV_OK)
{
ShowAlarm(string.Format("关闭相机{0}失败,错误代码：{1}", m_Name, nRet));
return false;
}
nRet = m_Camera.MV_CC_DestroyDevice_NET();
if (nRet != MyCamera.MV_OK)
{
ShowAlarm(string.Format("销毁相机对象{0}失败,错误代码：{1}", m_Name, nRet));
return false;
}
return true;
}开始采集取流：
/// <summary>
/// 开始采集
/// </summary>
public override void StartGrabbing()
{
int nRet;
//开始采集前配置相机
nRet = OperateBeforeGrab();
if (MyCamera.MV_OK != nRet)
{
ShowAlarm(string.Format("相机{0}配置失败,错误代码：{1}", m_Name, nRet));
return;
}
//取流之前先清除帧长度
nFrames = 0;
m_FrameInfo.nFrameLen = 0;
m_FrameInfo.enPixelType = MyCamera.MvGvspPixelType.PixelType_Gvsp_Undefined;
nRet = m_Camera.MV_CC_StartGrabbing_NET();
if (MyCamera.MV_OK != nRet)
{
ShowAlarm(string.Format("相机{0}开始采集失败,错误代码：{1}", m_Name, nRet));
}
}
/// <summary>
/// 取图前的必要配置操作
/// </summary>
/// <returns></returns>
private Int32 OperateBeforeGrab()
{
//取图像宽
MyCamera.MVCC_INTVALUE_EX stWidth = new MyCamera.MVCC_INTVALUE_EX();
int nRet = m_Camera.MV_CC_GetIntValueEx_NET("Width", ref stWidth);
if (MyCamera.MV_OK != nRet)
{
//获取图像宽度失败
return nRet;
}
//取图像高
MyCamera.MVCC_INTVALUE_EX stHeight = new MyCamera.MVCC_INTVALUE_EX();
nRet = m_Camera.MV_CC_GetIntValueEx_NET("Height", ref stHeight);
if (MyCamera.MV_OK != nRet)
{
//获取图像高度失败
return nRet;
}
//取像素格式
MyCamera.MVCC_ENUMVALUE stPixelFormat = new MyCamera.MVCC_ENUMVALUE();
nRet = m_Camera.MV_CC_GetEnumValue_NET("PixelFormat", ref stPixelFormat);
if (MyCamera.MV_OK != nRet)
{
//获取像素格式失败
return nRet;
}
//设置bitmap像素格式，申请相应大小内存
if ((Int32)MyCamera.MvGvspPixelType.PixelType_Gvsp_Undefined == stPixelFormat.nCurValue)
{
//未知错误
return MyCamera.MV_E_UNKNOW;
}
else if (IsMono(stPixelFormat.nCurValue))
{
m_BitmapPixelFormat = PixelFormat.Format8bppIndexed;
if (IntPtr.Zero != m_pConvertDstBuf)
{
Marshal.Release(m_pConvertDstBuf);
m_pConvertDstBuf = IntPtr.Zero;
}
// Mono8为单通道
m_nConvertDstBufLen = (UInt32)(stWidth.nCurValue * stHeight.nCurValue);
m_pConvertDstBuf = Marshal.AllocHGlobal((Int32)m_nConvertDstBufLen);
if (IntPtr.Zero == m_pConvertDstBuf)
{
//创建图像资源失败
return MyCamera.MV_E_RESOURCE;
}
}
else
{
m_BitmapPixelFormat = PixelFormat.Format24bppRgb;
if (IntPtr.Zero != m_pConvertDstBuf)
{
Marshal.FreeHGlobal(m_pConvertDstBuf);
m_pConvertDstBuf = IntPtr.Zero;
}
// RGB为三通道
m_nConvertDstBufLen = (UInt32)(3 * stWidth.nCurValue * stHeight.nCurValue);
m_pConvertDstBuf = Marshal.AllocHGlobal((Int32)m_nConvertDstBufLen);
if (IntPtr.Zero == m_pConvertDstBuf)
{
//创建资源失败
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>
public override void StopGrabbing()
{
int nRet = m_Camera.MV_CC_StopGrabbing_NET();
if (nRet != MyCamera.MV_OK)
{
ShowAlarm(string.Format("相机{0}结束采集失败,错误代码：{1}", m_Name, nRet));
}
}软件触发取像：
/// <summary>
/// 拍摄图像
/// </summary>
/// <returns></returns>
public override GrabImage()
{
lock (this)
{
grabSuccess = false;
int nRet = m_Camera.MV_CC_SetCommandValue_NET("TriggerSoftware");
if (MyCamera.MV_OK != nRet)
{
ShowAlarm(string.Format("相机{0}获取图像失败,错误代码：{1}", m_Name, nRet));
}
}
}设置曝光值：
/// <summary>
/// 设置相机曝光
/// </summary>
/// <param name="value"></param>
public override void SetExposure(float value)
{
m_Camera.MV_CC_SetEnumValue_NET("ExposureAuto", 0);
int nRet = m_Camera.MV_CC_SetFloatValue_NET("ExposureTime", value);
if (nRet != MyCamera.MV_OK)
{
ShowAlarm(string.Format("相机{0}设置曝光值失败,错误代码：{1}", m_Name, nRet));
}
}设置增益值：
/// <summary>
/// 设置相机增益
/// </summary>
/// <param name="value"></param>
public override void SetGainValue(float value)
{
m_Camera.MV_CC_SetEnumValue_NET("GainAuto", 0);
int nRet = m_Camera.MV_CC_SetFloatValue_NET("Gain", value);
if (nRet != MyCamera.MV_OK)
{
ShowAlarm(string.Format("相机{0}设置增益值失败,错误代码：{1}", m_Name, nRet));
}
}源海康帧数据转换成.NET的bitmap和Halcon的HImage：
/// <summary>
/// 转化像素为Bit图像
/// </summary>
/// <param name="pData"></param>
/// <param name="pFrameInfo"></param>
public void ConvertToBitmap()
{
//创建转换变量
MyCamera.MV_PIXEL_CONVERT_PARAM stConvertInfo = new MyCamera.MV_PIXEL_CONVERT_PARAM();
//设置图像宽度、高度
stConvertInfo.nWidth = m_FrameInfo.nWidth;
stConvertInfo.nHeight = m_FrameInfo.nHeight;
//源数据地址、数据包大小、像素类型
stConvertInfo.pSrcData = pSaveImageBuf;
stConvertInfo.nSrcDataLen = nSaveImageBufSize;
stConvertInfo.enSrcPixelType = m_FrameInfo.enPixelType;
//转换后的数据地址、数据包大小、像素类型
stConvertInfo.pDstBuffer = m_pConvertDstBuf;
stConvertInfo.nDstBufferSize = m_nConvertDstBufLen;
if (m_Bitmap.PixelFormat == PixelFormat.Format8bppIndexed)
{
stConvertInfo.enDstPixelType = MyCamera.MvGvspPixelType.PixelType_Gvsp_Mono8;
m_Camera.MV_CC_ConvertPixelType_NET(ref stConvertInfo);
}
else
{
stConvertInfo.enDstPixelType = MyCamera.MvGvspPixelType.PixelType_Gvsp_BGR8_Packed;
m_Camera.MV_CC_ConvertPixelType_NET(ref stConvertInfo);
}
//保存Bitmap数据
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);
}
/// <summary>
/// 将帧数据转成Halcon图像
/// </summary>
/// <param name="pData"></param>
/// <param name="pFrameInfo"></param>
public HImage ConvertToHImage()
{
HImage hImage = new HImage();
//创建转换变量
MyCamera.MV_PIXEL_CONVERT_PARAM stConvertInfo = new MyCamera.MV_PIXEL_CONVERT_PARAM();
//设置图像宽度、高度
stConvertInfo.nWidth = m_FrameInfo.nWidth;
stConvertInfo.nHeight = m_FrameInfo.nHeight;
//源数据地址、数据包大小、像素类型
stConvertInfo.pSrcData = pSaveImageBuf;
stConvertInfo.nSrcDataLen = nSaveImageBufSize;
stConvertInfo.enSrcPixelType = m_FrameInfo.enPixelType;
//转换后的数据地址、数据包大小、像素类型
stConvertInfo.pDstBuffer = m_pConvertDstBuf;
stConvertInfo.nDstBufferSize = m_nConvertDstBufLen;
if (m_Bitmap.PixelFormat == PixelFormat.Format8bppIndexed)
{
stConvertInfo.enDstPixelType = MyCamera.MvGvspPixelType.PixelType_Gvsp_Mono8;
m_Camera.MV_CC_ConvertPixelType_NET(ref stConvertInfo);
}
else
{
stConvertInfo.enDstPixelType = MyCamera.MvGvspPixelType.PixelType_Gvsp_BGR8_Packed;
m_Camera.MV_CC_ConvertPixelType_NET(ref stConvertInfo);
}
//彩色图像转换
if (IsColorPixelFormat(stConvertInfo.enDstPixelType))
{
try
{
hImage.GenImageInterleaved((HTuple)stConvertInfo.pDstBuffer, (HTuple)"rgb", (HTuple)stConvertInfo.nWidth, (HTuple)stConvertInfo.nHeight, -1, "byte", 0, 0, 0, 0, -1, 0);
}
catch (Exception ex)
{
SDKKernal.ShowAlarm("4100", string.Format("相机{0}帧数据转彩色图像失败:{1}", m_Name, ex.Message));
return null;
}
}
//黑白图像转换
else if (IsMonoPixelFormat(stConvertInfo.enDstPixelType))
{
try
{
hImage.GenImage1Extern("byte", stConvertInfo.nWidth , stConvertInfo.nHeight, stConvertInfo.pDstBuffer, IntPtr.Zero);
}
catch (Exception ex)
{
SDKKernal.ShowAlarm("4100", string.Format("相机{0}帧数据转黑白图像失败:{1}", m_Name, ex.Message));
return null;
}
}
return hImage;
}
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 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;
}
}2.全局操作类HikVision
获取相机列表：
/// <summary>
/// 获取相机列表
/// </summary>
public AcquireCameraList()
{
//强制回收即时垃圾
GC.Collect();
//枚举相机设备
m_CamList.nDeviceNum = 0;
int nRet = MyCamera.MV_CC_EnumDevices_NET(MyCamera.MV_GIGE_DEVICE, ref m_CamList);
//获取失败则退出程序
if (nRet != 0)
{
ShowAlarm("获取海康相机列表失败！");
return;
}
hikCameras = new CCameraHik[m_CamList.nDeviceNum];
strCameraName = new string[m_CamList.nDeviceNum];
//创建相机列表
for (int i = 0; i < m_CamList.nDeviceNum; i++)
{
MyCamera.MV_CC_DEVICE_INFO cam = (MyCamera.MV_CC_DEVICE_INFO)Marshal.PtrToStructure(m_CamList.pDeviceInfo[i],
typeof(MyCamera.MV_CC_DEVICE_INFO));
if (cam.nTLayerType == MyCamera.MV_GIGE_DEVICE)
{
MyCamera.MV_GIGE_DEVICE_INFO gigeInfo = (MyCamera.MV_GIGE_DEVICE_INFO)MyCamera.ByteToStruct(cam.SpecialInfo.stGigEInfo,
typeof(MyCamera.MV_GIGE_DEVICE_INFO));
hikCameras[i] = new CCameraHik();
hikCameras[i].ID = i;
hikCameras[i].SerialNumber = gigeInfo.chSerialNumber;
if (gigeInfo.chUserDefinedName != "")
hikCameras[i].Name = gigeInfo.chUserDefinedName;
else
hikCameras[i].Name = gigeInfo.chManufacturerName;
hikCameras[i].CameraInfo = cam;
}
}
}全局操作：
/// <summary>
/// 打开所有相机
/// </summary>
public void OpenAllCamera()
{
if (m_CamList.nDeviceNum == 0)
{
ShowAlarm( "相机列表为空，打开相机失败！");
}
//遍历所有相机
for (int i = 0; i < m_CamList.nDeviceNum; i++)
{
if (hikCameras[i].Open())
m_ConnectedCamNum++;
}
//判断连接相机是否与设备设计相等
if (m_ConnectedCamNum != m_CamCount)
{
ShowAlarm("已连接的相机数量与设备预设数量不同！");
}
}
/// <summary>
/// 开始所有相机采集
/// </summary>
public void StartAllGrabbing()
{
//开始采集
for (int i = 0; i < m_ConnectedCamNum; i++)
{
hikCameras[i].StartGrabbing();
}
//打开帧数监控标志位
bFrameTimerFlag = true;
//开始采集标志位
m_bGrabbing = true;
}
/// <summary>
/// 停止所有相机采集
/// </summary>
public void StopAllGrabbing()
{
for (int i = 0; i < m_ConnectedCamNum; ++i)
{
hikCameras[i].StopGrabbing();
}
//停止采集标志位
m_bGrabbing = false;
//关闭帧数监控标志位
bFrameTimerFlag = false;
}
/// <summary>
/// 关闭所有相机
/// </summary>
public void CloseAllCamera()
{
for (int i = 0; i < m_ConnectedCamNum; ++i)
{
hikCameras[i].Close();
}
//停止采集标志位
m_bGrabbing = false;
//重置成员变量
Initialize();
}相机取像回调函数：
/// <summary>
/// 取流回调函数
/// </summary>
/// <param name="pData">数据源指针</param>
/// <param name="pFrameInfo">单帧图像信息源</param>
/// <param name="pUser">相机ID</param>
public void ImageCallBack(IntPtr pData, ref MyCamera.MV_FRAME_OUT_INFO_EX pFrameInfo, IntPtr pUser)
{
int nIndex = (int)pUser;
//抓取的帧数
++hikCameras[nIndex].nFrames;
//按指针操作驱动数据时，进行锁保护
lock (hikCameras[nIndex].objForSaveImageLock)
{
//修改相机的图像缓存地址和尺寸
if (hikCameras[nIndex].pSaveImageBuf == IntPtr.Zero || pFrameInfo.nFrameLen > hikCameras[nIndex].nSaveImageBufSize)
{
if (hikCameras[nIndex].pSaveImageBuf != IntPtr.Zero)
{
Marshal.Release(hikCameras[nIndex].pSaveImageBuf);
hikCameras[nIndex].pSaveImageBuf = IntPtr.Zero;
}
hikCameras[nIndex].pSaveImageBuf = Marshal.AllocHGlobal((Int32)pFrameInfo.nFrameLen);
if (hikCameras[nIndex].pSaveImageBuf == IntPtr.Zero)
{
return;
}
hikCameras[nIndex].nSaveImageBufSize = pFrameInfo.nFrameLen;
}
//复制缓存图像
hikCameras[nIndex].FrameInfo = pFrameInfo;
CopyMemory(hikCameras[nIndex].pSaveImageBuf, pData, pFrameInfo.nFrameLen);
hikCameras[nIndex].grabSuccess = true;
}
}五、使用示例
private void btnFindCameras_Click(object sender, EventArgs e)
{
cameraList = hikVision.AcquireCameraList();
if (cameraList != null)
{
this.textCamName.Text = cameraList[0];
}
else
{
ShowAlarm("未找到相机");
}
}
private void btnOpenCamera_Click(object sender, EventArgs e)
{
hikVision.OpenAllCamera();
}
private void btnCloseCamera_Click(object sender, EventArgs e)
{
hikVision.CloseAllCamera();
}
private void btnStartGrab_Click(object sender, EventArgs e)
{
hikVision.StartAllGrabbing();
}
private void btnStopGrab_Click(object sender, EventArgs e)
{
hikVision.StopAllGrabbing();
}
private void btnTrigger_Click(object sender, EventArgs e)
{
hikVision.hikCameras[0].GrabImage();
}相互学习，共同富裕。
本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。
