MvvmScaffoldFrame48/MvvmScaffoldFrame48.DLL/CameraTools/HikCamera.cs

// 海康相机实例类
using MvCameraControl;
using MvFGCtrlC.NET;
using MvvmScaffoldFrame48.Model.StorageModel.HikVisionCamera;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace MvvmScaffoldFrame48.DLL.CameraTools
{
    /// <summary>
    /// 海康相机操作类
    /// </summary>
    public class HikCamera
    {
        #region 实例
        /// <summary>
        /// 相机实例
        /// </summary>
        private IDevice _device = null;
        public IDevice Device
        {
            get
            {
                return _device;
            }
        }

        /// <summary>
        /// 设备事件委托
        /// </summary>
        public event EventHandler<FrameGrabbedEventArgs> FrameGrabbedEvent;

        #endregion

        #region 变量
        /// <summary>
        /// 最后一次帧号记录
        /// </summary>
        private long lastframeNum = -1;
        #endregion

        #region 构造函数
        
        /// <summary>
        /// 相机构造函数 不加载相机
        /// </summary>
        public HikCamera()
        {
            if (_device != null && _device.IsConnected)
            {
                _device.Close();
                _device.Dispose();
            }
        }
        /// <summary>
        /// 相机构造函数
        /// </summary>
        /// <param name="device">相机实例</param>
        public HikCamera(IDevice device)
        {
            if (_device != null && _device.IsConnected)
            {
                _device.Close();
                _device.Dispose();
            }
            if (device == null)
            {
                throw new Exception("相机实例不能为空");
            }
            this._device = device;
        }

        /// <summary>
        /// 相机构造函数
        /// </summary>
        /// <param name="deviceInfo">相机信息</param>
        public HikCamera(IDeviceInfo deviceInfo)
        {
            if (_device != null && _device.IsConnected)
            {
                _device.Close();
                _device.Dispose();
            }
            try
            {
                // 打开设备
                _device = DeviceFactory.CreateDevice(deviceInfo);
            }
            catch (Exception ex)
            {
                throw new Exception(ex.Message);
            }

            int result = _device.Open();
            if (result != MvError.MV_OK)
            {
                throw new Exception("打开相机失败");
            }


            // 判断是否为gige设备
            if (_device is IGigEDevice)
            {
                // 转换为gigE设备
                IGigEDevice gigEDevice = _device as IGigEDevice;

                // 探测网络最佳包大小(只对GigE相机有效)
                result = gigEDevice.GetOptimalPacketSize(out int optionPacketSize);

                if (result != MvError.MV_OK)
                {
                    //Log("Warning: Get Packet Size failed!", result);
                }
                else
                {
                    result = _device.Parameters.SetIntValue("GevSCPSPacketSize", (long)optionPacketSize);
                    if (result != MvError.MV_OK)
                    {
                        //Log("Warning: Set Packet Size failed!", result);
                    }
                }
            }
        }
        #endregion

        #region 共有方法
        /// <summary>
        /// 重新加载指定相机
        /// </summary>
        /// <param name="deviceInfo">相机信息</param>
        /// <returns>true为加载成功，false为加载失败</returns>
        public bool ReLoadCameraDevice(IDeviceInfo deviceInfo)
        {
            bool Blresult = false;
            if (_device != null && _device.IsConnected)
            {
                _device.Close();
                _device.Dispose();
            }
            try
            {
                // 打开设备
                _device = DeviceFactory.CreateDevice(deviceInfo);
                Blresult = true;
            }
            catch
            {
                return Blresult;
            }

            int result = _device.Open();
            if (result != MvError.MV_OK)
            {
                Blresult = false;
                return Blresult;
            }

            // 判断是否为gige设备
            if (_device is IGigEDevice)
            {
                // 转换为gigE设备
                IGigEDevice gigEDevice = _device as IGigEDevice;

                // 探测网络最佳包大小(只对GigE相机有效)
                result = gigEDevice.GetOptimalPacketSize(out int optionPacketSize);
                if (result != MvError.MV_OK)
                {
                    //Log("Warning: Get Packet Size failed!", result);
                }
                else
                {
                    result = _device.Parameters.SetIntValue("GevSCPSPacketSize", (long)optionPacketSize);
                    if (result != MvError.MV_OK)
                    {
                        //Log("Warning: Set Packet Size failed!", result);
                    }
                }
            }
            return Blresult;
        }

        /// <summary>
        /// 开启采集
        /// </summary>
        public bool StartReceiveFuntion()
        {
            bool result = false;
            try
            {
                if (_device == null) return result;
                _device.StreamGrabber.SetImageNodeNum(30);
                int ret = _device.StreamGrabber.StartGrabbing();
                if (ret == MvError.MV_OK)
                {
                    result = true;
                }
            }
            catch
            {
                result = false;
            }
            return result;
        }

        public bool StartReceiveFuntionSetFrameGrabedEvent()
        {
            bool result = false;
            try
            {
                if (_device == null) return result;
                _device.StreamGrabber.SetImageNodeNum(30);

                // 注册回调函数
                _device.StreamGrabber.FrameGrabedEvent += FrameGrabbedEventHandler;


                int ret = _device.StreamGrabber.StartGrabbing();
                if (ret == MvError.MV_OK)
                {
                    result = true;
                }
            }
            catch
            {
                result = false;
            }
            return result;
        }

        /// <summary>
        /// 关闭采集
        /// </summary>
        public bool StopReceiveFuntion()
        {
            bool result = false;
            try
            {
                if (_device == null) return result;
                int ret = _device.StreamGrabber.StopGrabbing();
                if (ret == MvError.MV_OK)
                {
                    result = true;
                }
            }
            catch
            {
                result = false;
            }
            return result;
        }

        public bool StopReceiveFuntionSetFrameGrabedEvent()
        {
            bool result = false;
            try
            {
                if (_device == null) return result;

                _device.StreamGrabber.FrameGrabedEvent -= FrameGrabbedEventHandler;

                int ret = _device.StreamGrabber.StopGrabbing();
                if (ret == MvError.MV_OK)
                {
                    result = true;
                }
            }
            catch
            {
                result = false;
            }
            return result;
        }

        /// <summary>
        /// 获取一次图片，需开启采集
        /// </summary>
        /// <param name="IFrameData">输出的帧数据</param>
        /// <returns>true为采集成功，false为采集失败</returns>
        public bool GetOnceImage(out IFrameOut IFrameData)
        {
            bool result = false;
            int BRet = _device.StreamGrabber.GetImageBuffer(1000, out IFrameData);
            if (BRet == 0 && IFrameData != null) result = true;
            else return result;
            if (lastframeNum == -1)
            {
                lastframeNum = IFrameData.FrameNum;
            }
            else if (lastframeNum == IFrameData.FrameNum - 1)
            {
                lastframeNum = IFrameData.FrameNum;
            }
            else
            {
                //丢帧记录，用于连续采集时的丢帧检测
                Console.WriteLine("lost frame: Width[{0}] , Height[{1}] , FrameNum[{2}] ，Frevous[{3}]",
                    IFrameData.Image.Width, IFrameData.Image.Height, IFrameData.FrameNum, lastframeNum);
                lastframeNum = IFrameData.FrameNum;
            }
            return result;
        }

        /// <summary>
        /// 获取相机图像尺寸信息
        /// </summary>
        /// <returns></returns>
        public CameraImageSizeCModel GetCamereImageSize()
        {
            CameraImageSizeCModel cameraImageSize = null;
            if (_device != null)
            {
                try
                {
                    _device.Parameters.GetIntValue("Width", out IIntValue PixWidth);
                    _device.Parameters.GetIntValue("Height", out IIntValue PixHeight);
                    cameraImageSize = new CameraImageSizeCModel()
                    {
                        Height = (int)PixHeight.CurValue,
                        Width = (int)PixWidth.CurValue
                    };
                }
                catch
                {
                    return null;
                }
            }
            return cameraImageSize;
        }
        #endregion

        #region 私有方法
        /// <summary>
        /// 图像抓取事件处理方法
        /// </summary>
        private void FrameGrabbedEventHandler(object sender,FrameGrabbedEventArgs frameData)
        {
            // 触发外部注册的事件
            FrameGrabbedEvent?.Invoke(this, frameData);
        }
        #endregion
    }
}