TetraParkOCR/LibCamera/ImageCollector.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
using ThridLibray;

namespace LibCamera
{
    public class ImageCollector : IImageCollector
    {
        public event OnImageCollectorMessage OnImageCollectorMessage;
        public event OnImageCollectorInfo OnImageCollectorInfo;
        public event OnImageCollectorConnected OnImageCollectorConnected;
        public event OnImageCollectorDisConnected OnImageCollectorDisConnected;
        public event OnImageCollectorData OnImageCollectorData;
        private IDevice m_dev_cam;
        private bool m_abort = false;
        private DateTime m_start = DateTime.Now;
        private string m_serial;
        public ImageCollector(string serial)
        {
            m_serial = serial;
        }
        public void Start()
        {
            m_abort = false;
            Task.Run(() => { ConnectDevice(); });
        }
        private void ConnectDevice()
        {
            m_start = DateTime.Now.AddSeconds(-6);
            while (true)
            {
                if (m_abort)
                    return;
                Thread.Sleep(100);
                try
                {
                    if (m_dev_cam == null || (m_dev_cam.IsOpen == false && ((DateTime.Now - m_start).TotalSeconds >= 5)))
                    {
                        OnImageCollectorDisConnected?.Invoke(m_serial);
                        if (m_dev_cam != null && !m_dev_cam.IsOpen)
                            m_dev_cam.StreamGrabber.ImageGrabbed -= StreamGrabber_ImageGrabbed;
                        m_dev_cam = null;
                        Enumerator.EnumerateDevices();
                        m_dev_cam = Enumerator.GetDeviceByKey(m_serial);
                        if (m_dev_cam == null)
                            continue;
                        m_dev_cam.Open();
                        if (m_dev_cam.IsOpen)
                        {
                            m_dev_cam.StreamGrabber.ImageGrabbed += StreamGrabber_ImageGrabbed;
                            OnImageCollectorInfo?.Invoke($"Device {m_serial} connected.");
                            OnImageCollectorConnected?.Invoke(m_serial);
                        }
                    }
                }
                catch (Exception ex)
                {
                    m_dev_cam = null;
                    OnImageCollectorMessage?.Invoke($"ConnectDevice {m_serial} Exception: {ex.Message}");
                }
            }
        }

        private void StreamGrabber_ImageGrabbed(object sender, GrabbedEventArgs e)
        {
            OnImageCollectorData?.Invoke(e.GrabResult.Image);
        }
        public void Stop()
        {
            try
            {
                m_abort = true;
                if (m_dev_cam != null)
                {
                    m_dev_cam.StreamGrabber.ImageGrabbed -= StreamGrabber_ImageGrabbed;
                    if (m_dev_cam.IsOpen)
                    {
                        m_dev_cam.Close();
                    }
                    m_dev_cam = null;
                }
            }
            catch (Exception ex)
            {
                OnImageCollectorMessage?.Invoke($"Stop {m_serial} Exception: {ex.Message}");
            }
        }
        private bool IsDeviceConnected()
        {
            return m_dev_cam != null && m_dev_cam.IsOpen;
        }
        public void SetPixelFormat(string pixelFormat)
        {
            if (!IsDeviceConnected())
                return;
            using (IEnumParameter p = m_dev_cam.ParameterCollection[ParametrizeNameSet.ImagePixelFormat])
            {
                p.SetValue(pixelFormat);
            }
        }
        public void SetExposureTime(double exposureTime)
        {
            if (!IsDeviceConnected())
                return;
            using (IFloatParameter p = m_dev_cam.ParameterCollection[ParametrizeNameSet.ExposureTime])
            {
                p.SetValue(exposureTime);
            }
        }
        public void SetGainRawGain(double gain)
        {
            if (!IsDeviceConnected())
                return;
            using (IFloatParameter p = m_dev_cam.ParameterCollection[ParametrizeNameSet.GainRaw])
            {
                p.SetValue(gain);
            }
        }
        public void SetAcquisitionMode(string acquisitionMode)
        {
            if (!IsDeviceConnected())
                return;
            using (IEnumParameter p = m_dev_cam.ParameterCollection[ParametrizeNameSet.AcquisitionMode])
            {
                p.SetValue(acquisitionMode);
            }
        }
        public void SetTriggerMode(string triggerMode)
        {
            if (!IsDeviceConnected())
                return;
            using (IEnumParameter p = m_dev_cam.ParameterCollection[ParametrizeNameSet.TriggerMode])
            {
                p.SetValue(triggerMode);
            }
        }
        public void StartSoftwareGrabbing()
        {
            if (!IsDeviceConnected())
                return;
            m_dev_cam.TriggerSet.Open(TriggerSourceEnum.Software);
            if (!m_dev_cam.GrabUsingGrabLoopThread())
                OnImageCollectorMessage("开启采集失败");
            else
                OnImageCollectorInfo($"相机{m_serial}加载完毕");
        }
    }
}