M071.git - Gitblit

			@@ -2,9 +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;
			@@ -78,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);
			});
			@@ -219,11 +222,10 @@
			if (camera == null)
			return;

			string imgSetId = "";
			HImage hImage = null;
			IImageSet set = null;
			try
			{
			hImage = CollectHImage(camera, s.CameraOp.OpConfig, out imgSetId);
			set = CollectHImage(camera, s.CameraOp.OpConfig);
			}
			catch (ProcessException pEx)
			{
			@@ -231,12 +233,12 @@
			throw pEx;
			}

			if (string.IsNullOrWhiteSpace(imgSetId))
			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 = "";
			@@ -346,7 +348,7 @@

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

			SaveKeyImages(pMeasure.Barcode, m);
			@@ -364,25 +366,172 @@

			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} 检测完成，结果 {(pResult ? "OK" : "NG")}", "");
			LogAsync(DateTime.Now, $"{pMeasure.Barcode} 检测完成，结果 {pMeasure.PResult}", "");

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

			var measurementUnitResultAndKeyUnitDataSet = GetMeasurementUnitResultAndKeyUnitData(pMeasure);

			//MES输出 todo

			//Excel报表输出 todo

			//数据库保存 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 图像保存
			@@ -468,7 +617,7 @@
			}
			#endregion

			private async void RunImageHandle(CameraBase camera, IOperationConfig opConfig, HImage hImage, string snapshotId, string snapshotName, List<MeasurementUnit> measureList)
			private async void RunImageHandle(CameraBase camera, IOperationConfig opConfig, IImageSet imgSet, string snapshotId, string snapshotName, List<MeasurementUnit> measureList)
			{
			await Task.Run(() =>
			{
			@@ -476,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))
			{
			@@ -488,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}", "");
			@@ -511,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);
			@@ -528,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
			{
			@@ -568,11 +720,11 @@
			image.Dispose();
			});

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