板卡+数据库保存+excel导出

wells.liu

2020-07-09 6caa156ba8be9728b4cb67c7c7be326b0316f773

 src/Bro.M071.Process/M071Process.cs

@@ -2,7 +2,9 @@
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 System;
@@ -47,6 +49,11 @@

            base.Open();

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

            Reset(null, null, null);
            FullReset(null);
        }
@@ -73,21 +80,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);
            });
@@ -359,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 图像保存
@@ -506,7 +660,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);
@@ -523,24 +677,24 @@

                             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;
                                 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
                                     {