M071.git - Gitblit

			@@ -2,8 +2,12 @@
			using Bro.Common.Helper;
			using Bro.Common.Interface;
			using Bro.Common.Model;
			using Bro.M071.DBManager;
			using Bro.M071.Model;
			using Bro.M071.Model.Model;
			using Bro.Process;
			using HalconDotNet;
			using Newtonsoft.Json;
			using System;
			using System.Collections.Generic;
			using System.ComponentModel;
			@@ -13,6 +17,7 @@
			using System.Text;
			using System.Threading;
			using System.Threading.Tasks;
			using static Bro.Common.Helper.EnumHelper;

			namespace Bro.M071.Process
			{
			@@ -35,6 +40,8 @@
			public event Action OnMeasureStart;
			public event Action OnClearBarcode;
			public event Action<IShapeElement> OnElementUpdated;
			public event Action<MachineState> OnMachineStateChanged;
			public event Action OnFullResetDone;
			#endregion

			public override void Open()
			@@ -43,19 +50,22 @@

			base.Open();

			CheckMachineState();
			}
			SwitchBeep(false);
			SwitchLightGreen(false);
			SwitchLightRed(false);
			SwitchLightYellow(false);

			/// <summary>
			/// 检查设备状态
			/// </summary>
			private void CheckMachineState()
			{
			//throw new NotImplementedException();
			Reset(null, null, null);
			FullReset(null);
			}

			private void InitialSetting()
			{
			//数据库迁移检查
			DatabaseInitialize.Initialize();

			MotionCardSettingCheck();

			Config.SnapshotPointCollection.ForEach(u =>
			{
			u.GetHalconToolPathList().ForEach(path =>
			@@ -71,21 +81,21 @@

			var snapshotPoint = Config.SnapshotPointCollection.FirstOrDefault(s => s.Id == u.SnapshotPointId && s.IsEnabled);
			if (snapshotPoint == null)
			throw new ProcessException($"{u.AlignName}未设置可用拍照点位");
			throw new ProcessException($"{u.AliasName}未设置可用拍照点位");

			if (u.ImageSeq < 1)
			throw new ProcessException($"{u.AlignName}图片序号小于1");
			throw new ProcessException($"{u.AliasName}图片序号小于1");

			var algo = Config.KeyAlgorithemCollection.FirstOrDefault(a => a.Id == u.KeyAlgorithemId);
			if (algo == null)
			throw new ProcessException($"{u.AlignName}未设置检测算法");
			throw new ProcessException($"{u.AliasName}未设置检测算法");

			u.KeyAlgorithemPath = algo.AlgorithemPath;
			LoadHalconTool(u.KeyAlgorithemPath, u.AlignName);
			LoadHalconTool(u.KeyAlgorithemPath, u.AliasName);

			var resultSet = Config.KeyResultCollection.FirstOrDefault(r => r.Id == u.KeyResultId);
			if (resultSet == null)
			throw new ProcessException($"{u.AlignName}未设置检测结果配置");
			throw new ProcessException($"{u.AliasName}未设置检测结果配置");

			u.KeyResultList = new List<string>(resultSet.Results);
			});
			@@ -125,29 +135,23 @@
			});
			}

			#region InitialHalconTool
			//protected override void InitialHalconTool()
			//{
			// base.InitialHalconTool();

			// Config.SnapshotPointCollection.ForEach(u =>
			// {
			// u.GetHalconToolPathList().ForEach(path =>
			// {
			// if (!string.IsNullOrWhiteSpace(path))
			// {
			// string directoryPath = Path.GetDirectoryName(path);
			// string fileName = Path.GetFileNameWithoutExtension(path);

			// HDevEngineTool tool = new HDevEngineTool(directoryPath);
			// tool.LoadProcedure(fileName);

			// //使用“\|”作为间隔符
			// _halconToolDict[u.Id + "\|" + path] = tool;
			// }
			// });
			// });
			//}
			#region 流程中抛出异常
			public override void ExceptionRaisedInMonitor(Exception ex)
			{
			if (ex is ProcessException pEx)
			{
			if (pEx.Level >= ExceptionLevel.Fatal)
			{
			RaisedAlarm(pEx.Message);
			MachineState = MachineState.Alarm;
			}
			}
			else
			{
			RaisedAlarm(ex.Message);
			MachineState = MachineState.Alarm;
			}
			}
			#endregion

			public string BarCode { get; set; }
			@@ -157,12 +161,16 @@
			[ProcessMethod("", "StartJob", "开始扫描", InvokeType.TestInvoke)]
			public ProcessResponse StartJob(IOperationConfig opConfig, IDevice invokeDevice, IDevice sourceDevice)
			{
			if (MachineState != MachineState.Ready)
			throw new ProcessException("机台未就绪，请勿开始测量", null, ExceptionLevel.Fatal);

			if (string.IsNullOrWhiteSpace(BarCode))
			{
			OnClearBarcode?.Invoke();
			throw new ProcessException("未输入产品条码，请勿开始测量");
			}

			MachineState = MachineState.Running;
			OnMeasureStart?.BeginInvoke(null, null);

			var measurements = Config.MeasurementUnitCollection.Where(u => u.IsEnabled).ToList().DeepSerializeClone();
			@@ -175,6 +183,7 @@
			{
			Barcode = BarCode,
			Measurements = measurements,
			StartTime = DateTime.Now,
			};

			var existedProduction = productionList.FirstOrDefault(u => u.Barcode == pMeasure.Barcode);
			@@ -206,26 +215,91 @@
			var response = motionDevice.Run(s.MotionOp.OpConfig);
			if (!response.Result)
			{
			throw new ProcessException($"{device.Name}异常，{response.Message}", null, ExceptionLevel.Info);
			throw new ProcessException($"{device.Name}异常，{response.Message}", null, ExceptionLevel.Fatal);
			}

			CameraBase camera = DeviceCollection.FirstOrDefault(u => u.Id == s.CameraOp.Device) as CameraBase;
			if (camera == null)
			return;

			HImage hImage = CollectHImage(camera, s.CameraOp.OpConfig, out string imgSetId);
			if (string.IsNullOrWhiteSpace(imgSetId))
			IImageSet set = null;
			try
			{
			set = CollectHImage(camera, s.CameraOp.OpConfig);
			}
			catch (ProcessException pEx)
			{
			pEx.Level = ExceptionLevel.Fatal;
			throw pEx;
			}

			if (set == null)
			{
			return;
			}

			RunImageHandle(camera, s.CameraOp.OpConfig, hImage, s.Id, s.Name, pMeasure.Measurements);
			RunImageHandle(camera, s.CameraOp.OpConfig, set, s.Id, s.Name, pMeasure.Measurements);
			});

			BarCode = "";
			LogAsync(DateTime.Now, $"{pMeasure.Barcode}测量动作完成", "");

			return new ProcessResponse(true);
			}

			#region 双手启动
			bool isLeftStart = false;
			bool IsLeftStart
			{
			get => isLeftStart;
			set
			{
			isLeftStart = value;
			StartCheck();
			}
			}

			bool isRightStart = false;
			bool IsRightStart
			{
			get => isRightStart;
			set
			{
			isRightStart = value;
			StartCheck();
			}
			}

			private void StartCheck()
			{
			if (isRightStart && isLeftStart)
			{
			StartJob(null, null, null);
			}
			}

			[ProcessMethod("", "Start_Left", "左手启动", InvokeType.TestInvoke)]
			public ProcessResponse Start_Left(IOperationConfig opConfig, IDevice invokeDevice, IDevice sourceDevice)
			{
			if (opConfig.InputPara != null && opConfig.InputPara.Count > 0)
			{
			IsLeftStart = opConfig.InputPara[0] == 1;
			}

			return new ProcessResponse();
			}

			[ProcessMethod("", "Start_Right", "右手启动", InvokeType.TestInvoke)]
			public ProcessResponse Start_Right(IOperationConfig opConfig, IDevice invokeDevice, IDevice sourceDevice)
			{
			if (opConfig.InputPara != null && opConfig.InputPara.Count > 0)
			{
			IsRightStart = opConfig.InputPara[0] == 1;
			}

			return new ProcessResponse();
			}
			#endregion

			#region 私有方法
			private void MeasureProduction_PropertyChanged(object sender, PropertyChangedEventArgs e)
			@@ -274,7 +348,7 @@

			IShapeElement indicator = null;
			pMeasure.ElementList.Add(indicator);
			//输出图形基元到界面 todo
			//输出图形基元到界面
			OnElementUpdated?.BeginInvoke(indicator, null, null);

			SaveKeyImages(pMeasure.Barcode, m);
			@@ -288,19 +362,176 @@
			{
			return;
			}

			//MES输出 todo

			//Excel报表输出 todo

			//数据库保存 todo

			SaveWholeImage(pMeasure);

			productionList.RemoveAll(p => p.Barcode == pMeasure.Barcode);
			pMeasure.Dispose();
			}

			pMeasure.EndTime = DateTime.Now;
			bool pResult = pMeasure.Measurements.All(u => u.Spec.MeasureResult == true);
			pMeasure.PResult = pResult ? "OK" : "NG";
			OnUpdateResult?.Invoke(DateTime.Now, pResult ? 1 : 0);
			OnUpdateCT?.Invoke((float)(pMeasure.EndTime.Value - pMeasure.StartTime.Value).TotalSeconds);

			LogAsync(DateTime.Now, $"{pMeasure.Barcode} 检测完成，结果 {pMeasure.PResult}", "");

			if (MachineState == MachineState.Running)
			MachineState = MachineState.Ready;

			var measurementUnitResultAndKeyUnitDataSet = GetMeasurementUnitResultAndKeyUnitData(pMeasure);

			//MES输出 todo

			//Excel报表输出（单个产品的excel导出）
			ExportProductionExcel(measurementUnitResultAndKeyUnitDataSet);
			//数据库保存
			SaveProductionData(measurementUnitResultAndKeyUnitDataSet);

			SaveWholeImage(pMeasure);

			productionList.RemoveAll(p => p.Barcode == pMeasure.Barcode);
			pMeasure.Dispose();
			}
			}

			KeyUnitDataManager keyUnitDataManager = new KeyUnitDataManager();
			MeasurementUnitResultManager measurementUnitResultManager = new MeasurementUnitResultManager();
			MeasurementAndKeyDataRelationManager measurementAndKeyDataRelationManager = new MeasurementAndKeyDataRelationManager();
			ProductionMeasurementRecordsManager productionMeasurementRecordsManager = new ProductionMeasurementRecordsManager();

			static object dataSaveLock = new object();

			private async void SaveProductionData(ProductionMeasurementUnitResultAndKeyUnitDataSet measurementUnitResultAndKeyUnitDataSet)
			{
			await Task.Run(() =>
			{
			try
			{
			lock (dataSaveLock)
			{
			// 获取产品数据并保存
			var productionMeasurementRecords = measurementUnitResultAndKeyUnitDataSet.ProductionMeasurementRecord;
			productionMeasurementRecordsManager.CreateModel(productionMeasurementRecords);

			// 获取原始数据并保存
			var keyUnitDatas = measurementUnitResultAndKeyUnitDataSet.KeyUnitDataList;
			keyUnitDataManager.BatchAddKeyUnitData(keyUnitDatas);

			// 获取检测结果数据并保存
			var measurementUnitResults = measurementUnitResultAndKeyUnitDataSet.MeasurementUnitResultList;
			measurementUnitResultManager.BatchAddMeasurementUnitResult(measurementUnitResults);

			// 获取关系数据并保存
			var measurementAndKeyDataRelationList = measurementUnitResultAndKeyUnitDataSet.MeasurementAndKeyDataRelationList;
			measurementAndKeyDataRelationManager.BatchAddMeasurementAndKeyDataRelation(measurementAndKeyDataRelationList);
			}
			}
			catch (Exception ex)
			{
			LogAsync(DateTime.Now, "数据保存异常", ex.GetExceptionMessage());
			}
			});
			}

			private ProductionMeasurementUnitResultAndKeyUnitDataSet GetMeasurementUnitResultAndKeyUnitData(ProductionMeasurement pData)
			{
			ProductionMeasurementUnitResultAndKeyUnitDataSet measurementUnitResultAndKeyUnitDataSet = new ProductionMeasurementUnitResultAndKeyUnitDataSet();

			try
			{

			//产品数据
			ProductionMeasurementRecords productionMeasurementRecords = new ProductionMeasurementRecords();
			//关系数据
			List<MeasurementAndKeyDataRelation> measurementAndKeyDataRelationList = new List<MeasurementAndKeyDataRelation>();
			//原始数据
			List<KeyUnitData> keyUnitDatas = new List<KeyUnitData>();
			// 单个产品的测量汇总
			List<MeasurementUnitResult> measurementUnitResults = new List<MeasurementUnitResult>();

			productionMeasurementRecords.ProductionBarcode = pData.Barcode;
			productionMeasurementRecords.ProductionCode = ProductionCode;
			productionMeasurementRecords.ProductionResult = pData.PResult;
			productionMeasurementRecords.OperationStartTime = pData.StartTime.GetValueOrDefault();
			productionMeasurementRecords.OperationEndTime = pData.EndTime.GetValueOrDefault();

			measurementUnitResultAndKeyUnitDataSet.ProductionMeasurementRecord = productionMeasurementRecords;

			foreach (var MeasurementUnitResult in pData.Measurements)//获取到单个测量项结果
			{
			MeasurementUnitResult measurementUnitResult = new MeasurementUnitResult();
			measurementUnitResult.ProductionMeasurementRecordsId = productionMeasurementRecords.ID;
			measurementUnitResult.MeasurementName = MeasurementUnitResult.Name;
			measurementUnitResult.MeasurementType = MeasurementUnitResult.MeasureType;
			measurementUnitResult.MeasurementValue = "";
			measurementUnitResult.MeasurementResult = MeasurementUnitResult.Spec.MeasureResult.Value ? "OK" : "NG";

			measurementUnitResults.Add(measurementUnitResult);

			foreach (var keyUnit in MeasurementUnitResult.KeyUnitCollection)//获取单个键的测量结果
			{
			foreach (var keyValue in keyUnit.MeasureValueDict)//获取单个键的单个测量item 结果
			{
			KeyUnitData keyUnitData = new KeyUnitData();
			keyUnitData.Key = keyUnit.Key;
			keyUnitData.MeasurementItem = keyValue.Key;
			keyUnitData.ItemValue = keyValue.Value.ToString();
			keyUnitDatas.Add(keyUnitData);

			MeasurementAndKeyDataRelation measurementAndKeyDataRelation = new MeasurementAndKeyDataRelation();
			measurementAndKeyDataRelation.MeasurementUnitResultId = measurementUnitResult.ID;
			measurementAndKeyDataRelation.KeyUnitDataId = keyUnitData.ID;
			measurementAndKeyDataRelationList.Add(measurementAndKeyDataRelation);

			}
			}
			}
			measurementUnitResultAndKeyUnitDataSet.ProductionMeasurementRecord = productionMeasurementRecords;
			measurementUnitResultAndKeyUnitDataSet.MeasurementAndKeyDataRelationList = measurementAndKeyDataRelationList;
			measurementUnitResultAndKeyUnitDataSet.KeyUnitDataList = keyUnitDatas;
			measurementUnitResultAndKeyUnitDataSet.MeasurementUnitResultList = measurementUnitResults;
			}
			catch (Exception ex)
			{
			LogAsync(DateTime.Now, "数据获取异常", ex.GetExceptionMessage());
			}
			return measurementUnitResultAndKeyUnitDataSet;
			}

			private async void ExportProductionExcel(ProductionMeasurementUnitResultAndKeyUnitDataSet measurementUnitResultAndKeyUnitDataSet)
			{
			await Task.Run(() =>
			{
			ExcelExportSet excelExportDto = new ExcelExportSet();
			excelExportDto.Worksheets = new List<string>() { "原始数据", "检测结果" };
			var keyUnitColumns = new Dictionary<string, string>()
			{
			{"Key", "键"},
			{"MeasurementItem", "检测项"},
			{"ItemValue", "检测值"}
			};
			var measurementUnitResultColumns = new Dictionary<string, string>()
			{
			{"MeasurementName", "检测名称"},
			{"MeasurementType", "检测类型"},
			{"MeasurementValue", "检测值"},
			{"MeasurementResult", "检测结果"},
			};
			excelExportDto.WorksheetColumns[excelExportDto.Worksheets[0]] = keyUnitColumns;
			excelExportDto.WorksheetColumns[excelExportDto.Worksheets[1]] = measurementUnitResultColumns;

			excelExportDto.WorksheetDataTable[excelExportDto.Worksheets[0]] = ExcelExportHelper.ListToDataTable(measurementUnitResultAndKeyUnitDataSet.KeyUnitDataList, keyUnitColumns);
			excelExportDto.WorksheetDataTable[excelExportDto.Worksheets[1]] = ExcelExportHelper.ListToDataTable(measurementUnitResultAndKeyUnitDataSet.MeasurementUnitResultList, measurementUnitResultColumns); ;

			byte[] filecontent = ExcelExportHelper.ExportExcel(excelExportDto, false);
			string dir = Path.Combine(Config.ImageSaveFolder, DateTime.Now.ToString("yyyyMMdd"));
			if (!Directory.Exists(dir))
			{
			Directory.CreateDirectory(dir);
			}

			FileStream fs = new FileStream(Path.Combine(dir, $"{measurementUnitResultAndKeyUnitDataSet.ProductionMeasurementRecord.ProductionBarcode}_{DateTime.Now.ToString("HHmmss")}.xlsx"), FileMode.Create, FileAccess.Write);
			fs.Write(filecontent, 0, filecontent.Length);
			fs.Flush();
			fs.Close();
			});
			}

			#region 图像保存
			@@ -335,7 +566,7 @@
			}
			}

			private void SaveKeyImages(string barCode, MeasurementUint measureUnit)
			private void SaveKeyImages(string barCode, MeasurementUnit measureUnit)
			{
			string measureName = measureUnit.GetDisplayText();
			if (Config.ImageSaveOption.IsSaveOriginImage)
			@@ -366,7 +597,7 @@
			}
			}

			private async void SaveKeyImages(MeasurementUint measureUnit, string measureName, string dir)
			private async void SaveKeyImages(MeasurementUnit measureUnit, string measureName, string dir)
			{
			await Task.Run(() =>
			{
			@@ -386,7 +617,7 @@
			}
			#endregion

			private async void RunImageHandle(CameraBase camera, IOperationConfig opConfig, HImage hImage, string snapshotId, string snapshotName, List<MeasurementUint> measureList)
			private async void RunImageHandle(CameraBase camera, IOperationConfig opConfig, IImageSet imgSet, string snapshotId, string snapshotName, List<MeasurementUnit> measureList)
			{
			await Task.Run(() =>
			{
			@@ -394,7 +625,8 @@
			var keyBindCollection = measureList.SelectMany(u => u.KeyUnitCollection).Where(u => keys.Any(k => k.Key == u.Key)).ToList();

			string toolKey = (opConfig as CameraOprerationConfigBase).AlgorithemPath;
			HObject images = hImage;
			HObject images = imgSet.HImage;
			LaserScanParam scanParam = JsonConvert.DeserializeObject<LaserScanParam>(imgSet.ImageData);

			if (!string.IsNullOrWhiteSpace(toolKey))
			{
			@@ -406,7 +638,7 @@
			return;
			}

			_halconToolDict[toolKey].InputImageDic["INPUT_Image"] = hImage;
			_halconToolDict[toolKey].InputImageDic["INPUT_Image"] = imgSet.HImage;
			if (!_halconToolDict[toolKey].RunProcedure(out string error))
			{
			LogAsync(DateTime.Now, $"{snapshotName}取图算法异常，{error}", "");
			@@ -429,7 +661,7 @@
			var excludeKeys = keys.Where(u => u.ImageSeq > count).ToList();
			if (excludeKeys.Count > 0)
			{
			LogAsync(DateTime.Now, $"{string.Join(" ", excludeKeys.Select(u => u.AlignName))}未在图片获取序列中", "");
			LogAsync(DateTime.Now, $"{string.Join(" ", excludeKeys.Select(u => u.AliasName))}未在图片获取序列中", "");
			keyBindCollection.Where(k => excludeKeys.Any(u => u.Key == k.Key)).ToList().ForEach(k =>
			{
			k.FillKeyValues(null);
			@@ -446,24 +678,26 @@

			var keyBindList = keyBindCollection.Where(u => u.Key == k.Key).ToList();

			string keyToolKey = k.AlignName + "\|" + k.KeyAlgorithemPath;
			string keyToolKey = k.AliasName + "\|" + k.KeyAlgorithemPath;
			if (!_halconToolDict.ContainsKey(keyToolKey))
			{
			LogAsync(DateTime.Now, $"{k.AlignName}检测算法未初始化", "");
			LogAsync(DateTime.Now, $"{k.AliasName}检测算法未初始化", "");
			}
			else
			{
			_halconToolDict[keyToolKey].InputImageDic["INPUT_Image"] = image;
			_halconToolDict[keyToolKey].InputTupleDic["INPUT_Resolution_X"] = scanParam.Resolution_X;
			_halconToolDict[keyToolKey].InputTupleDic["INPUT_Resolution_Z"] = scanParam.Resolution_Z;
			if (!_halconToolDict[keyToolKey].RunProcedure(out string error))
			{
			LogAsync(DateTime.Now, $"{k.AlignName}检测算法异常，{error}", "");
			LogAsync(DateTime.Now, $"{k.AliasName}检测算法异常，{error}", "");
			}
			else
			{
			var results = _halconToolDict[keyToolKey].GetResultTuple("OUTPUT_Results").HTupleToDouble();
			if (results.Count == 0 \|\| results.Any(u => u < 0))
			{
			LogAsync(DateTime.Now, $"{k.AlignName}检测结果异常", "");
			LogAsync(DateTime.Now, $"{k.AliasName}检测结果异常", "");
			}
			else
			{
			@@ -486,11 +720,11 @@
			image.Dispose();
			});

			if (count.I != 1)
			{
			hImage?.Dispose();
			hImage = null;
			}
			//if (count.I != 1)
			//{
			// hImage?.Dispose();
			// hImage = null;
			//}
			});
			}
			#endregion