MvvmScaffoldFrame48/MvvmScaffoldFrame48.DLL/CameraTools/HikCamera.cs

// 海康相机实例类
using MvCameraControl;
using MvFGCtrlC.NET;
using MvvmScaffoldFrame48.DLL.ConfigTools;
using MvvmScaffoldFrame48.DLL.LogTools;
using MvvmScaffoldFrame48.Model.StorageModel.Configs;
using MvvmScaffoldFrame48.Model.StorageModel.HikVisionCamera;
using System;
using System.Collections.Generic;
using System.Diagnostics;
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;
        private DateTime _lastFrame = DateTime.MinValue;
        #endregion

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

        /// <summary>
        /// 帧率限制下最小帧间隔（单位ms）
        /// </summary>
        private double minIntervalMs;

        /// <summary>
        /// 是否进行取图帧率限制
        /// </summary>
        private bool isFrameRateLimit = false;
        public bool IsFrameRateLimit
        {
            get 
            {
                return isFrameRateLimit;
            }
            set
            {
                isFrameRateLimit = value;
            }
        }

        /// <summary>
        /// 取图帧率限制
        /// </summary>
        private int frameRateLimit;
        public int FrameRateLimit
        {
            get
            {
                return frameRateLimit;
            }
            set
            {
                frameRateLimit = value;
                minIntervalMs = 1000.0 / frameRateLimit;
            }
        }
        #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();
            }

            this._device = device ?? throw new Exception("相机实例不能为空");
        }

        /// <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)
            {
                Console.WriteLine("打开相机失败");
                return;
            }


            // 判断是否为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>
        /// <param name="cameraParameter"></param>
        /// <returns></returns>
        public int LoadLineCameraConfig(LinescanCameraParameterModel cameraParameter)
        {
            int result = 0;
            _device.Parameters.SetFloatValue("ExposureTime", cameraParameter.ExposureTimeValue);
            _device.Parameters.SetIntValue("AcquisitionLineRate", cameraParameter.AcquistionLineRateValue);
            _device.Parameters.SetIntValue("Width", cameraParameter.Width);
            _device.Parameters.SetIntValue("Height", cameraParameter.Height);
            _device.Parameters.SetIntValue("OffsetX", cameraParameter.OffsetX);
            return result;
        }

        /// <summary>
        /// 加载线阵相机参数（从序列化字符串读取）
        /// </summary>
        /// <param name="cameraParameter"></param>
        /// <returns></returns>
        public int LoadLineCameraConfig(string cameraParameter)
        {
            int result = 0;
            LinescanCameraParameterModel cameraParameterModel = XMLReadWrite.DeserializeFromString<LinescanCameraParameterModel>(cameraParameter);
            if (cameraParameterModel != null)
            {
                _device.Parameters.SetFloatValue("ExposureTime", cameraParameterModel.ExposureTimeValue);
                _device.Parameters.SetIntValue("AcquisitionLineRate", cameraParameterModel.AcquistionLineRateValue);
                _device.Parameters.SetIntValue("Width", cameraParameterModel.Width);
                _device.Parameters.SetIntValue("Height", cameraParameterModel.Height);
                _device.Parameters.SetIntValue("OffsetX", cameraParameterModel.OffsetX);
            }
            return result;
        }

        /// <summary>
        /// 回调型取图方法-开启采集
        /// </summary>
        /// <returns></returns>
        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>
        /// <returns></returns>
        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>
        /// <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 e)
        {
            if(isFrameRateLimit && frameRateLimit>0)
            {
                TimeSpan elapsed = DateTime.Now - _lastFrame;
                if (elapsed.TotalSeconds > minIntervalMs)
                {
                    // 触发外部注册的事件
                    FrameGrabbedEvent?.Invoke(this, e);
                    _lastFrame = DateTime.Now;
                }
            }
            else
            {
                // 触发外部注册的事件
                FrameGrabbedEvent?.Invoke(this, e);
                if (lastframeNum == -1)
                {
                    lastframeNum = e.FrameOut.FrameNum;
                }
                else if (lastframeNum == e.FrameOut.FrameNum - 1)
                {
                    lastframeNum = e.FrameOut.FrameNum;
                }
                else
                {
                    //丢帧记录
                    TxtLog.log(string.Format("lost frame: Width[{0}] , Height[{1}] , FrameNum[{2}] ，Frevous[{3}]",
                        e.FrameOut.Image.Width, e.FrameOut.Image.Height, e.FrameOut.FrameNum, lastframeNum), 6);
                    Console.WriteLine("lost frame: Width[{0}] , Height[{1}] , FrameNum[{2}] ，Frevous[{3}]",
                        e.FrameOut.Image.Width, e.FrameOut.Image.Height, e.FrameOut.FrameNum, lastframeNum);
                    lastframeNum = e.FrameOut.FrameNum;
                }
            }
            e.FrameOut.Dispose();
        }
        #endregion
    }
}