LampInspectionMachine/Core/Management.cs

using Cognex.VisionPro;
using Cognex.VisionPro.QuickBuild;
using LampInspectionMachine.Cameralibs;
using LampInspectionMachine.Model;
using MvCamCtrl.NET;
using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using Prism.Mvvm;
using LampInspectionMachine.Log4xml;
using Cognex.VisionPro.ImageFile;
using System.Drawing;
using System.Windows.Forms;
using System.Web;
using System.ComponentModel;
using System.Windows.Media.Media3D;
using LampInspectionMachine.ViewModels;
using System.Collections.Concurrent;
using System.Threading;
using System.Windows.Controls;
using LampInspectionMachine.Views;
using System.Windows.Media.Imaging;
using System.Windows.Media;
using System.Windows;
using System.Runtime.InteropServices;
using SqlSugar.DistributedSystem.Snowflake;
using System.Windows.Threading;
using System.Windows.Ink;
using System.Data.SqlClient;
using System.Xml.Linq;
using System.Drawing.Imaging;
using System.IO.Packaging;
using Cognex.VisionPro.ToolBlock;
using System.Windows.Markup;
using System.Diagnostics;
using LampInspectionMachine.Cameralibs.HKCamera;
using Newtonsoft.Json.Linq;
using OpenCvSharp.Dnn;
using LampInspectionMachine.Interfaces;

namespace LampInspectionMachine.Core
{
    public class Management : BindableBase
    {




        private CameraView cameraView;
        private ICogImage image = new CogImage8Grey();
        private WriteableBitmap writeable;

        public WriteableBitmap Writeable { get => writeable; set { SetProperty(ref writeable, value); } }
        public ICogImage Image
        {
            get => image;
            set
            {
                SetProperty(ref image, value);
            }
        }

        // 使用泛型委托
        public event EventHandler<ICogImage> PropertyChanged;

        // 或者自定义委托
        public delegate void ChangeEventHandler(ICogImage e);
        public event ChangeEventHandler OnChange;

        public CameraService CameraService { get; set; }


        /// <summary>
        /// 相机列表
        /// </summary>
        public ObservableCollection<string> CameraList { get => _CameraList; set { SetProperty(ref _CameraList, value); } }


        /// <summary>
        /// 当前相机配置
        /// </summary>
       public CameraInfo CurrCamConfig { get => _CurrCamConfig; set { SetProperty(ref _CurrCamConfig, value); } }

        /// <summary>
        /// 相机配置列表
        /// </summary>
        public ObservableCollection<CameraInfo> CamConfigs { get => _CamConfigs; set { SetProperty(ref _CamConfigs, value); } }

      //  public bool IsTriggerModel { get => _isTriggerModel; set { SetProperty(ref _isTriggerModel, value); } }

        public ICamera CurrCamera { get => myCamera; set { SetProperty(ref myCamera, value); } }

        /// <summary>
        /// 相机对应模板工具
        /// </summary>
     //   public List<CogToolBlock> CamTemplateS { get => _CamTemplateS; set => _CamTemplateS = value; }

        public event Action<int> ToolBlockSwitched;
        /// <summary>
        /// 当前选中相机的SN
        /// </summary>
        public string CurrCameraSn { get => _CurrCameraSn; 
            set { SetProperty(ref _CurrCameraSn, value); } }

        public List<VisionProManager> VisionProManagers { get => _visionProManagers; set { SetProperty(ref _visionProManagers, value); } }

        public VisionProManager Currvision { get => _Currvision; set => _Currvision =  value ; }

        private ObservableCollection<CameraInfo> _CamConfigs = new ObservableCollection<CameraInfo>();

        private List<VisionProManager>  _visionProManagers=new List<VisionProManager>();

      //  private List<CogToolBlock> _CamTemplateS = new List<CogToolBlock>();

        private CogToolBlock cogToolBlock1;
        private VisionProManager _Currvision;
        private CameraInfo _CurrCamConfig = null;
        private ICamera myCamera;
        //private bool _isTriggerModel = false;


   

        private ObservableCollection<string> _CameraList = new ObservableCollection<string>();

        private string _CurrCameraSn = "";

        public Stopwatch stopwatch = new Stopwatch();

        public Management()
        {

        }




        /// <summary>
        /// 获取相机列表
        /// </summary>
        public void LoadCameraDevice()
        {
            CameraService = new CameraService();
            CameraList = FindLoadCamera();
            if (CamConfigs.Count == 0)
            {
                CamConfigs.Add(new CameraInfo() { CameraName="相机1", Id=new Guid(), SerialNumber="", VppIndex=0, VppFileName = "Cam1.vpp" });
                CamConfigs.Add(new CameraInfo() { CameraName = "相机2", Id = new Guid(), SerialNumber = "", VppIndex = 1, VppFileName = "Cam2.vpp" });
                CamConfigs.Add(new CameraInfo() { CameraName = "相机3", Id = new Guid(), SerialNumber = "", VppIndex = 2, VppFileName = "Cam3.vpp" });
                CamConfigs.Add(new CameraInfo() { CameraName = "相机4", Id = new Guid(), SerialNumber = "", VppIndex = 3, VppFileName = "Cam4.vpp" });
                CamConfigs.Add(new CameraInfo() { CameraName = "相机5", Id = new Guid(), SerialNumber = "", VppIndex = 4, VppFileName = "Cam5.vpp" });
                CamConfigs.Add(new CameraInfo() { CameraName = "相机6", Id = new Guid(), SerialNumber = "", VppIndex = 5, VppFileName = "Cam6.vpp" });
                CamConfigs.Add(new CameraInfo() { CameraName = "相机7", Id = new Guid(), SerialNumber = "", VppIndex = 6, VppFileName = "Cam7.vpp" });
                CamConfigs.Add(new CameraInfo() { CameraName = "相机8", Id = new Guid(), SerialNumber = "", VppIndex = 7, VppFileName = "Cam8.vpp" });
            }
        }


        public void SaveCameraDevice()
        {


        }
        /// <summary>
        /// 初始化相机管理
        /// </summary>
        public void InitTemplates(TipService tipService,Management management)
        {
            tipService.ShowMsg("相机模板加载2%");
            for ( int i = 0; i < 1; i++ )
            {
               
                CogToolBlock cogToolBlock = (CogToolBlock)CogSerializer.LoadObjectFromFile(Environment.CurrentDirectory + $"\\Vpp\\{CamConfigs[i].VppFileName}");
                VisionProManager vision=new VisionProManager();
                ICamera myCamera;
                myCamera = CreateCamera(CamConfigs[i]);
                if ( myCamera.IsConnected) 
                {
                    myCamera.ImageCallbackEvent += vision.CamCallBack;
                    myCamera.GrabImageCallbackEvent += vision.ImageCallback;
                }
                vision.Camera= myCamera;
                vision.CogToolBlock = cogToolBlock;
                vision.CameraInfo = CamConfigs[ i ];
                vision.Management=management;
                VisionProManagers.Add(vision);
                tipService.ShowMsg($"相机模板加载{(i+1)*10+2}%");
            }
            tipService.Tcolse();
        }

        /// <summary>
        /// 单张采集
        /// </summary>
        public void SoftTrigger()
        {
            if ( CurrCamera.IsConnected )
            {
                CurrCamera.StopGrabbing();
                LogHelper.Info($"软触发配置写入");
                CurrCamera.SetTriggerMode(false,7) ;
                CurrCamConfig.TriggerMode = false;
                LogHelper.Info($"软触发取图");
                CurrCamera.Grab();
            }
        }


        /// <summary>
        /// 连续采集写入
        /// </summary>
        public void SoftTrigger__Continue()
        {  CurrCamera.StopGrabbing();
            //MyCamera.SetTriggerModeOff();
            //CurrCamConfig.TriggerMode = false;
            //MyCamera.SetTriggerSoftware();
            //if (MyCamera.CheckImageCallbackEvent(CamCallBack))
            //    MyCamera.ImageCallbackEvent += CamCallBack;
            //if (!MyCamera.CheckImageCallbackEvent(CamVisionProCallBack))
            //    MyCamera.ImageCallbackEvent -= CamVisionProCallBack;
            LogHelper.Info($"连续采集启动");
            CurrCamera.StartGrabbing();
        }


        public void SetHardTrigger_CallBack()
        {
            LogHelper.Info($"硬触发模式 启动");
            //MyCamera.SetTriggerModeOn();
            //CurrCamConfig.TriggerMode = true;
            //MyCamera.SetTriggerSoftware(0);
            //if (!MyCamera.CheckImageCallbackEvent(CamCallBack))
            //    MyCamera.ImageCallbackEvent -= CamCallBack;
            //if (MyCamera.CheckImageCallbackEvent(CamVisionProCallBack))
            //    MyCamera.ImageCallbackEvent += CamVisionProCallBack;
            CurrCamera.StartGrabbing();
        }
        /// <summary>
        /// 查找相机
        /// </summary>
        public ObservableCollection<string> FindLoadCamera()
        {
            var listsn = MvCamera.GetDevices();
            if (listsn.Length > 0)
            {
                
                ObservableCollection<string> strings = new ObservableCollection<string>();
                strings.Add("");
                for (int i = 0; i < listsn.Length; i++)
                {
                    strings.Add(listsn[i].SerialNumber);
                }
                return strings;
            }
            else
            {

                System.Windows.Forms.MessageBox.Show("未查询到设备！", "提示", MessageBoxButtons.OK);
                return null;
            }
        }

        public bool InitCamera()
        {
            ICamera myCamera;
            if ( CurrCamera!=null&& CurrCamera.IsConnected )
            {
                CurrCamera.CloseDevice();
                myCamera = CameraService.GetCamera(CurrCamera.ID);
                bool res = myCamera.OpenDevice();

                if ( !res )
                {
                    myCamera.CloseDevice();
                    myCamera = null;
                    return false;
                }
                else
                {
                    CurrCamera = myCamera;
                    CurrCamConfig.SerialNumber = myCamera.SerialNumber;
                    if ( myCamera.IsConnected )
                    {
                        myCamera.ImageCallbackEvent -= Currvision.CamCallBack;
                        myCamera.GrabImageCallbackEvent -= Currvision.ImageCallback;
                        myCamera.ImageCallbackEvent += Currvision.CamCallBack;
                        myCamera.GrabImageCallbackEvent += Currvision.ImageCallback;
                    }
                    return true;
                }
            }
            else 
            {
                CurrCamera = null;
                myCamera=CreateCamera(new CameraInfo() { SerialNumber=CurrCameraSn });
                CurrCamera = myCamera;
                CurrCamConfig.SerialNumber = myCamera.SerialNumber;
                if ( myCamera.IsConnected )
                {
                    myCamera.ImageCallbackEvent -= Currvision.CamCallBack;
                    myCamera.GrabImageCallbackEvent -= Currvision.ImageCallback;
                    myCamera.ImageCallbackEvent += Currvision.CamCallBack;
                    myCamera.GrabImageCallbackEvent += Currvision.ImageCallback;
                }
                return true;
            }
            

        }

        public ICamera CreateCamera(CameraInfo  cameraInfo) 
        {
            Guid guid = Guid.NewGuid();
            CameraService.CreateCamera(guid, cameraInfo);
            ICamera myCamera = CameraService.GetCamera(guid);
            if ( myCamera != null )
            {
                try
                {
                    bool res = myCamera.OpenDevice();
                    if ( !res )
                    {
                        myCamera.CloseDevice();
                        myCamera = null;
                        return null;
                    }
                    else
                    {
                        return myCamera;
                    }
                }
                catch 
                {
                
                }
            }
            return myCamera;
        }





        public void CloseCamera()
        {
            CurrCamera?.StopGrabbing();
            CurrCamera?.CloseDevice();
            CurrCamera = null;

        }


      

        //    // 将海康相机帧数据转换为CogImage8Grey灰度图像
        //    public static ICogImage ConvertToCogImage(IntPtr pData, ref MyCamera.MV_FRAME_OUT_INFO_EX pFrameInfo)
        //    {

        //        // 验证像素格式（支持MONO8/RGB8转灰度）
        //        if (pFrameInfo.enPixelType != MvCamCtrl.NET.MyCamera.MvGvspPixelType.PixelType_Gvsp_Mono8 &&
        //            pFrameInfo.enPixelType != MvCamCtrl.NET.MyCamera.MvGvspPixelType.PixelType_Gvsp_RGB8_Packed)
        //        {
        //            throw new ArgumentException("Unsupported pixel format");
        //        }

        //        // 创建CogImage8Grey对象
        //        CogImage8Grey cogImage = new CogImage8Grey();
        //        int width = (int)pFrameInfo.nWidth;
        //        int height = (int)pFrameInfo.nHeight;

        //        // 分配内存并复制数据
        //        cogImage.Allocate(width, height);

        //        // 获取8位灰度图像像素内存区域
        //        ICogImage8PixelMemory pixelMemory = (cogImage).Get8GreyPixelMemory(
        //CogImageDataModeConstants.ReadWrite,
        //0, 0,
        //cogImage.Width, cogImage.Height);
        //        IntPtr destPtr = pixelMemory.Scan0;  // 获取像素数据指针

        //        // IntPtr destPtr = cogImage.GetPixelData(CogImageDataModeConstants.ReadWrite);

        //        if (pFrameInfo.enPixelType == MvCamCtrl.NET.MyCamera.MvGvspPixelType.PixelType_Gvsp_Mono8)
        //        {
        //            // 直接拷贝MONO8数据
        //            SafeMemoryCopy(destPtr, pData, width * height);
        //        }
        //        else // RGB转灰度
        //        {
        //            byte[] rgbBuffer = new byte[width * height * 3];
        //            Marshal.Copy(pData, rgbBuffer, 0, rgbBuffer.Length);

        //            unsafe
        //            {
        //                byte* pDest = (byte*)destPtr.ToPointer();
        //                for (int i = 0; i < rgbBuffer.Length; i += 3)
        //                {
        //                    // RGB转灰度公式：0.299*R + 0.587*G + 0.114*B
        //                    *pDest++ = (byte)(0.299 * rgbBuffer[i] +
        //                                     0.587 * rgbBuffer[i + 1] +
        //                                     0.114 * rgbBuffer[i + 2]);
        //                }
        //            }
        //        }
        //        return cogImage;
        //    }

        //    // 将海康相机帧数据转换为CogImage24PlanarColor彩色图像
        //    public static ICogImage ConvertToColorCogImage(IntPtr pData, ref MyCamera.MV_FRAME_OUT_INFO_EX pFrameInfo)
        //    {
        //        if (pFrameInfo.enPixelType != MvCamCtrl.NET.MyCamera.MvGvspPixelType.PixelType_Gvsp_RGB8_Packed)
        //        {
        //            throw new ArgumentException("Only RGB8 format supported for color conversion");
        //        }

        //        CogImage24PlanarColor cogColorImage = new CogImage24PlanarColor();
        //        int width = (int)pFrameInfo.nWidth;
        //        int height = (int)pFrameInfo.nHeight;

        //        // 分配内存
        //        cogColorImage.Allocate(width, height);

        //        // 获取三个颜色平面指针

        //        CogImage8Grey red = cogColorImage.GetPlane(CogImagePlaneConstants.Red);
        //        CogImage8Grey green = cogColorImage.GetPlane(CogImagePlaneConstants.Green);
        //        CogImage8Grey blue = cogColorImage.GetPlane(CogImagePlaneConstants.Blue);



        //        IntPtr redPtr = cogColorImage.GetPlane(CogImagePlaneConstants.Red).Get8GreyPixelMemory(
        //CogImageDataModeConstants.ReadWrite,
        //0, 0,
        //red.Width, red.Height).Scan0;  // 获取像素数据指针
        //        IntPtr greenPtr = cogColorImage.GetPlane(CogImagePlaneConstants.Green).Get8GreyPixelMemory(
        //CogImageDataModeConstants.ReadWrite,
        //0, 0,
        //red.Width, red.Height).Scan0; ;
        //        IntPtr bluePtr = cogColorImage.GetPlane(CogImagePlaneConstants.Blue).Get8GreyPixelMemory(
        //CogImageDataModeConstants.ReadWrite,
        //0, 0,
        //red.Width, red.Height).Scan0; ;

        //        // 转换RGB数据到平面格式
        //        byte[] rgbBuffer = new byte[width * height * 3];
        //        Marshal.Copy(pData, rgbBuffer, 0, rgbBuffer.Length);

        //        unsafe
        //        {
        //            byte* pRed = (byte*)redPtr.ToPointer();
        //            byte* pGreen = (byte*)greenPtr.ToPointer();
        //            byte* pBlue = (byte*)bluePtr.ToPointer();

        //            for (int i = 0; i < rgbBuffer.Length; i += 3)
        //            {
        //                *pRed++ = rgbBuffer[i];     // R
        //                *pGreen++ = rgbBuffer[i + 1]; // G
        //                *pBlue++ = rgbBuffer[i + 2];  // B
        //            }
        //        }
        //        return cogColorImage;
        //    }


        public void OnSwitchToolBlock(int index)
        {
            cogToolBlock1 = VisionProManagers[index].CogToolBlock;
            CurrCamera= VisionProManagers[ index ].Camera;
            CurrCamConfig = VisionProManagers[ index ].CameraInfo;

            ToolBlockSwitched?.Invoke(index); // 触发事件，传递索引参数。
        }

        /// <summary>
        /// 相机连接或者断开时
        /// </summary>
        /// <param name="id"></param>
        /// <param name="state"></param>
        private void Management_CameraConnectChangedEvent(Guid id, bool state)
        {
            // var sta = Status.FirstOrDefault(s => s.ID == id);
            //  var camera = DeviceConfig.Cameras.FirstOrDefault(c => c.Id == id);
            //if ( sta != null && camera != null )
            //{
            //    if ( state )
            //    {
            //        App.Current.Dispatcher.Invoke(new Action(() =>
            //        {
            //            sta.Message = $"{camera.CameraName}{connected}";
            //            sta.Background = new SolidColorBrush(Colors.Green);
            //        }));

            //    }
            //    else
            //    {
            //        App.Current.Dispatcher.Invoke(new Action(() =>
            //        {
            //            sta.Message = $"{camera.CameraName}{disconnected1}";
            //            sta.Background = new SolidColorBrush(Colors.Red);
            //        }));
            //    }
            //}
        }



    }





}