From 81480d62561dcb75a1fc968814ace1368fe5181b Mon Sep 17 00:00:00 2001
From: wells.liu <wells.liu@broconcentric.com>
Date: 星期四, 16 七月 2020 11:57:08 +0800
Subject: [PATCH] Merge branch 'master' of http://gitblit.broconcentric.com:8088/r/M071

---
 src/Bro.M071.Process/M071Process.cs |  412 +++++++++++++++++++++++++++++++++++++++++++++++++++++++---
 1 files changed, 389 insertions(+), 23 deletions(-)

diff --git a/src/Bro.M071.Process/M071Process.cs b/src/Bro.M071.Process/M071Process.cs
index 70d01cd..325cccc 100644
--- a/src/Bro.M071.Process/M071Process.cs
+++ b/src/Bro.M071.Process/M071Process.cs
@@ -9,6 +9,8 @@
 using Bro.Process;
 using HalconDotNet;
 using Newtonsoft.Json;
+using OfficeOpenXml;
+using OfficeOpenXml.Style;
 using System;
 using System.Collections.Generic;
 using System.ComponentModel;
@@ -61,7 +63,6 @@
 
             Reset(null, null, null);
             FullReset(null);
-
         }
 
         private void InitialMotionCardBaseAxisAlarm()
@@ -82,7 +83,7 @@
         private void InitialSetting()
         {
             //鏁版嵁搴撹縼绉绘鏌�
-            DatabaseInitialize.Initialize();
+            //DatabaseInitialize.Initialize();
 
             MotionCardSettingCheck();
 
@@ -196,7 +197,7 @@
             }
 
             MachineState = MachineState.Running;
-            OnMeasureStart?.BeginInvoke(null, null);
+            OnMeasureStart?.Invoke();
 
             var measurements = Config.MeasurementUnitCollection.Where(u => u.IsEnabled).ToList().DeepSerializeClone();
             measurements.ForEach(m =>
@@ -226,9 +227,12 @@
 
             Config.SnapshotPointCollection.Where(u => u.IsEnabled).ToList().ForEach(s =>
                   {
-                      _pauseHandle.WaitHandle.WaitOne();
+                      _pausedHandle.Wait();
 
-                      if (MachineState != MachineState.Running)
+                      if (MachineState == MachineState.Ready)
+                          return;
+
+                      if (MachineState != MachineState.Running && MachineState != MachineState.Pause)
                       {
                           throw new ProcessException("鏈哄彴鐘舵�佷笉鍦ㄨ繍琛屼腑锛岄��鍑烘娴�");
                       }
@@ -268,7 +272,7 @@
                           return;
                       }
 
-                      RunImageHandle(camera, s.CameraOp.OpConfig, set, s.Id, s.Name, pMeasure.Measurements);
+                      RunImageHandle(s.CameraOp.OpConfig, set, s.Id, s.Name, pMeasure.Measurements);
                   });
 
             BarCode = "";
@@ -336,10 +340,14 @@
         {
             if (sender is ProductionMeasurement pMeasure)
             {
-                lock (pMeasure)
+                var production = productionList.FirstOrDefault(u => u.Barcode == pMeasure.Barcode);
+                if (production == null)
+                    return;
+
+                lock (production)
                 {
                     //妫�鏌ユ槸鍚﹀叏閮ㄥ畬鎴�
-                    pMeasure.Measurements.ForEach(m =>
+                    pMeasure.Measurements?.ForEach(m =>
                     {
                         if (m.KeyUnitCollection.All(k => k.IsDone != null))
                         {
@@ -368,7 +376,7 @@
                                         }
                                         else
                                         {
-                                            m.Spec.ActualValue = _halconToolDict[toolKey].GetResultTuple("OUTPUT_Result").D;
+                                            m.Spec.ActualValue = double.Parse(_halconToolDict[toolKey].GetResultTuple("OUTPUT_Result").D.ToString("f2"));
                                             LogAsync(DateTime.Now, $"{m.GetDisplayText()}鏁版嵁{m.Spec.ActualValue}锛岀粨鏋渰(m.Spec.MeasureResult == null ? "TBD" : (m.Spec.MeasureResult == true ? "OK" : "NG"))}", "");
                                         }
                                     }
@@ -381,7 +389,7 @@
                                 indicator.ResultState = m.Spec.MeasureResult;
                                 pMeasure.ElementList.Add(indicator);
                                 //杈撳嚭鍥惧舰鍩哄厓鍒扮晫闈� 
-                                OnElementUpdated?.BeginInvoke(indicator, null, null);
+                                OnElementUpdated?.Invoke(indicator);
 
                                 SaveKeyImages(pMeasure.Barcode, m);
 
@@ -415,7 +423,9 @@
                 }
 
                 //Excel鎶ヨ〃杈撳嚭 锛堝崟涓骇鍝佺殑excel瀵煎嚭锛�
-                ExportProductionExcel(measurementUnitResultAndKeyUnitDataSet);
+                //ExportProductionExcel(measurementUnitResultAndKeyUnitDataSet);
+
+                ExportProductionInColumns(measurementUnitResultAndKeyUnitDataSet);
                 ////鏁版嵁搴撲繚瀛� 
                 //SaveProductionData(measurementUnitResultAndKeyUnitDataSet);
 
@@ -494,9 +504,20 @@
                     MeasurementUnitResult measurementUnitResult = new MeasurementUnitResult();
                     measurementUnitResult.ProductionMeasurementRecordsId = productionMeasurementRecords.ID;
                     measurementUnitResult.ProductionBarcode = productionMeasurementRecords.ProductionBarcode;
-                    measurementUnitResult.MeasurementName = measurementUnit.Name;
+                    measurementUnitResult.MeasurementName = measurementUnit.GetDisplayText();
+
+                    if (measurementUnit.MeasureType == "Alignment" || measurementUnit.MeasureType == "Slant")
+                    {
+                        measurementUnitResult.Keys = string.Join("-", measurementUnit.KeyUnitCollection.Select(u => u.Key));
+                        measurementUnitResult.Positions = string.Join("-", measurementUnit.KeyUnitCollection.Select(u => u.KeyResultId));
+                    }
+                    else if (measurementUnit.MeasureType == "RowAlignment")
+                    {
+                        measurementUnitResult.Keys = measurementUnit.KeyUnitCollection[0].Key + "~" + measurementUnit.KeyUnitCollection[measurementUnit.KeyUnitCollection.Count() - 1].Key;
+                        measurementUnitResult.Keys = measurementUnit.KeyUnitCollection[0].KeyResultId + "~" + measurementUnit.KeyUnitCollection[measurementUnit.KeyUnitCollection.Count() - 1].KeyResultId;
+                    }
                     measurementUnitResult.MeasurementType = measurementUnit.MeasureType;
-                    measurementUnitResult.MeasurementValue = measurementUnit.Spec.ActualValue.ToString();
+                    measurementUnitResult.MeasurementValue = measurementUnit.Spec.ActualValue == null ? "NA" : measurementUnit.Spec.ActualValue.Value.ToString("f2");
                     measurementUnitResult.MeasurementResult = measurementUnit.Spec.MeasureResult.Value ? "OK" : "NG";
 
                     measurementUnitResults.Add(measurementUnitResult);
@@ -512,7 +533,7 @@
                                 keyUnitData.ProductionBarcode = productionMeasurementRecords.ProductionBarcode;
                                 keyUnitData.Key = keyUnit.Key;
                                 keyUnitData.MeasurementItem = keyValue.Key;
-                                keyUnitData.ItemValue = keyValue.Value.ToString();
+                                keyUnitData.ItemValue = keyValue.Value == null ? "NA" : keyValue.Value.Value.ToString("f2");
                                 keyUnitDatas.Add(keyUnitData);
 
                                 MeasurementAndKeyDataRelation measurementAndKeyDataRelation = new MeasurementAndKeyDataRelation();
@@ -577,6 +598,342 @@
                 fs.Flush();
                 fs.Close();
             });
+        }
+
+        static object excelExportLock = new object();
+        private async void ExportProductionInColumns(ProductionMeasurementUnitResultAndKeyUnitDataSet exportData)
+        {
+            if (!Config.IsCSVOutputEnabled)
+                return;
+
+            await Task.Run(() =>
+            {
+                lock (excelExportLock)
+                {
+                    if (!Directory.Exists(Config.LogPath))
+                    {
+                        Directory.CreateDirectory(Config.LogPath);
+                    }
+                    var fileName = Path.Combine(Config.LogPath, $"LDSData_{DateTime.Now.ToString("yyyyMMdd")}.xlsx");
+                    //bool isExisted = File.Exists(fileName);
+                    using (ExcelPackage package = new ExcelPackage(new FileInfo(fileName)))
+                    {
+                        ExcelWorksheet rawDataSheet = null;
+                        ExcelWorksheet slantSheet = null;
+                        ExcelWorksheet alignmentSheet = null;
+                        ExcelWorksheet rowAlignmentSheet = null;
+
+                        if (!package.Workbook.Worksheets.Any(s => s.Name == "RawData"))
+                        {
+                            package.Workbook.Worksheets.Add("RawData");
+                            rawDataSheet = package.Workbook.Worksheets["RawData"];
+                            for (int i = 0; i < Config.KeyNameCollection.Count; i++)
+                            {
+                                var cell = rawDataSheet.Cells[i + 3, 1];
+                                cell.Value = Config.KeyNameCollection[i];
+                                SetTitleCell(cell, false);
+                            }
+                        }
+                        rawDataSheet = package.Workbook.Worksheets["RawData"];
+
+                        if (!package.Workbook.Worksheets.Any(s => s.Name == "Slant"))
+                        {
+                            package.Workbook.Worksheets.Add("Slant");
+                            slantSheet = package.Workbook.Worksheets["Slant"];
+
+                            var keyCell = slantSheet.Cells[2, 1];
+                            keyCell.Value = "Key";
+                            SetTitleCell(keyCell);
+
+                            for (int i = 0; i < Config.KeyNameCollection.Count; i++)
+                            {
+                                var cell = slantSheet.Cells[i + 3, 1];
+                                cell.Value = Config.KeyNameCollection[i];
+                                SetTitleCell(cell, false);
+                            }
+                        }
+                        slantSheet = package.Workbook.Worksheets["Slant"];
+
+                        if (!package.Workbook.Worksheets.Any(s => s.Name == "Alignment"))
+                        {
+                            package.Workbook.Worksheets.Add("Alignment");
+                            alignmentSheet = package.Workbook.Worksheets["Alignment"];
+
+                            var keysCell = alignmentSheet.Cells[2, 1];
+                            keysCell.Value = "Keys";
+                            SetTitleCell(keysCell);
+
+                            var positionCell = alignmentSheet.Cells[2, 2];
+                            positionCell.Value = "Positions";
+                            SetTitleCell(positionCell);
+
+                            var alignmentMeasures = exportData.MeasurementUnitResultList.Where(u => u.MeasurementType == "Alignment").ToList();
+                            for (int i = 0; i < alignmentMeasures.Count(); i++)
+                            {
+                                var cellKeys = alignmentSheet.Cells[i + 3, 1];
+                                cellKeys.Value = alignmentMeasures[i].Keys;
+                                SetTitleCell(cellKeys, false);
+
+                                var cellPosition = alignmentSheet.Cells[i + 3, 2];
+                                cellPosition.Value = alignmentMeasures[i].Positions;
+                                SetTitleCell(cellPosition, false);
+                            }
+                        }
+                        alignmentSheet = package.Workbook.Worksheets["Alignment"];
+
+                        if (!package.Workbook.Worksheets.Any(s => s.Name == "RowAlignment"))
+                        {
+                            package.Workbook.Worksheets.Add("RowAlignment");
+                            rowAlignmentSheet = package.Workbook.Worksheets["RowAlignment"];
+
+                            var keysCell = rowAlignmentSheet.Cells[2, 1];
+                            keysCell.Value = "Keys";
+                            SetTitleCell(keysCell);
+
+                            var positionCell = rowAlignmentSheet.Cells[2, 2];
+                            positionCell.Value = "Positions";
+                            SetTitleCell(positionCell);
+
+                            var rowAlignmentMeasures = exportData.MeasurementUnitResultList.Where(u => u.MeasurementType == "RowAlignment").ToList();
+                            for (int i = 0; i < rowAlignmentMeasures.Count(); i++)
+                            {
+                                var cellKeys = rowAlignmentSheet.Cells[i + 3, 1];
+                                cellKeys.Value = rowAlignmentMeasures[i].Keys;
+                                SetTitleCell(cellKeys, false);
+
+                                var cellPosition = rowAlignmentSheet.Cells[i + 3, 2];
+                                cellPosition.Value = rowAlignmentMeasures[i].Positions;
+                                SetTitleCell(cellPosition, false);
+                            }
+                        }
+                        rowAlignmentSheet = package.Workbook.Worksheets["RowAlignment"];
+
+                        #region RawData
+                        {
+                            //rawDataSheet = package.Workbook.Worksheets["RawData"];
+
+                            int rowDataStartCol = rawDataSheet.Dimension.Columns;
+                            var barcodeCell = rawDataSheet.Cells[1, rowDataStartCol + 1, 1, rowDataStartCol + 4];
+                            barcodeCell.Merge = true;
+                            barcodeCell.Style.HorizontalAlignment = ExcelHorizontalAlignment.Center;
+                            barcodeCell.Value = exportData.ProductionMeasurementRecord.ProductionBarcode;
+                            SetTitleCell(barcodeCell);
+
+                            var z1Cell = rawDataSheet.Cells[2, rowDataStartCol + 1];
+                            z1Cell.Value = "Z1";
+                            SetTitleCell(z1Cell);
+
+                            var z2Cell = rawDataSheet.Cells[2, rowDataStartCol + 2];
+                            z2Cell.Value = "Z2";
+                            SetTitleCell(z2Cell);
+
+                            var z3Cell = rawDataSheet.Cells[2, rowDataStartCol + 3];
+                            z3Cell.Value = "Z3";
+                            SetTitleCell(z3Cell);
+
+                            var z4Cell = rawDataSheet.Cells[2, rowDataStartCol + 4];
+                            z4Cell.Value = "Z4";
+                            SetTitleCell(z4Cell);
+
+                            exportData.KeyUnitDataList.ForEach(k =>
+                            {
+                                int keyIndex = Config.KeyNameCollection.IndexOf(k.Key);
+                                if (keyIndex < 0)
+                                {
+                                    LogAsync(DateTime.Now, "Excel瀵煎嚭閿欒", $"{k.Key}鐨凴awData鏈兘鑾峰彇琛屼俊鎭紝鏈鍑�");
+                                    return;
+                                }
+
+                                int zIndex = int.Parse(k.MeasurementItem.Substring(1));
+
+                                var cell = rawDataSheet.Cells[keyIndex + 1 + 2, rowDataStartCol + zIndex];
+                                cell.Value = string.IsNullOrWhiteSpace(k.ItemValue) ? "NA" : k.ItemValue;
+                            });
+                        }
+                        #endregion
+
+                        #region Slant
+                        var slantMeasures = exportData.MeasurementUnitResultList.Where(u => u.MeasurementType == "Slant").ToList();
+                        if (slantMeasures.Count > 0)
+                        {
+                            int slantStartCol = slantSheet.Dimension.Columns;
+
+                            var barcodeCell = slantSheet.Cells[1, slantStartCol + 1, 1, slantStartCol + 2];
+                            barcodeCell.Merge = true;
+                            barcodeCell.Value = exportData.ProductionMeasurementRecord.ProductionBarcode;
+                            SetTitleCell(barcodeCell);
+
+                            var valueCell = slantSheet.Cells[2, slantStartCol + 1];
+                            valueCell.Value = "Value";
+                            SetTitleCell(valueCell);
+
+                            var resultCell = slantSheet.Cells[2, slantStartCol + 2];
+                            resultCell.Value = "Result";
+                            SetTitleCell(resultCell);
+
+                            slantMeasures.ForEach(m =>
+                            {
+                                int rowIndex = Config.KeyNameCollection.IndexOf(m.Keys);
+                                if (rowIndex < 0)
+                                {
+                                    LogAsync(DateTime.Now, "Excel瀵煎嚭閿欒", $"{m.Keys}鐨凷lant鏈兘鑾峰彇琛屼俊鎭紝鏈鍑�");
+                                    return;
+                                }
+
+                                var cellValue = slantSheet.Cells[rowIndex + 1 + 2, slantStartCol + 1];
+                                var cellResult = slantSheet.Cells[rowIndex + 1 + 2, slantStartCol + 2];
+
+                                cellValue.Value = m.MeasurementValue;
+                                cellResult.Value = m.MeasurementResult;
+
+                                if (m.MeasurementResult != "OK")
+                                {
+                                    SetNGCell(cellValue);
+                                    SetNGCell(cellResult);
+                                }
+                            });
+                        }
+                        #endregion
+
+                        #region Alignment
+                        {
+                            var alignmentMeasures = exportData.MeasurementUnitResultList.Where(u => u.MeasurementType == "Alignment").ToList();
+                            if (alignmentMeasures.Count > 0)
+                            {
+                                List<string> keysList = new List<string>();
+                                int allRowNums = alignmentSheet.Dimension.Rows;
+                                int aligneStartCol = alignmentSheet.Dimension.Columns;
+
+                                for (int i = 3; i <= allRowNums; i++)
+                                {
+                                    string keys = alignmentSheet.Cells[i, 1].Value.ToString();
+                                    string position = alignmentSheet.Cells[i, 2].Value.ToString();
+
+                                    keysList.Add($"{keys}_{position}");
+                                }
+
+                                var barcodeCell = alignmentSheet.Cells[1, aligneStartCol + 1, 1, aligneStartCol + 2];
+                                barcodeCell.Merge = true;
+                                barcodeCell.Value = exportData.ProductionMeasurementRecord.ProductionBarcode;
+                                SetTitleCell(barcodeCell);
+
+                                var valueCell = alignmentSheet.Cells[2, aligneStartCol + 1];
+                                valueCell.Value = "Value";
+                                SetTitleCell(valueCell);
+
+                                var resultCell = alignmentSheet.Cells[2, aligneStartCol + 2];
+                                resultCell.Value = "Result";
+                                SetTitleCell(resultCell);
+
+                                alignmentMeasures.ForEach(a =>
+                                {
+                                    int rowIndex = keysList.IndexOf($"{a.Keys}_{a.Positions}");
+                                    if (rowIndex < 0)
+                                    {
+                                        LogAsync(DateTime.Now, "Excel瀵煎嚭閿欒", $"{a.Keys}_{a.Positions}鐨凙lignment鏈兘鑾峰彇琛屼俊鎭紝鏈鍑�");
+                                        return;
+                                    }
+
+                                    var cellValue = alignmentSheet.Cells[rowIndex + 1 + 2, aligneStartCol + 1];
+                                    var cellResult = alignmentSheet.Cells[rowIndex + 1 + 2, aligneStartCol + 2];
+
+                                    cellValue.Value = a.MeasurementValue;
+                                    cellResult.Value = a.MeasurementResult;
+
+                                    if (a.MeasurementResult != "OK")
+                                    {
+                                        SetNGCell(cellValue);
+                                        SetNGCell(cellResult);
+                                    }
+                                });
+                            }
+                        }
+                        #endregion
+
+                        #region RowAlignment
+                        {
+                            var rowAlignmentMeasures = exportData.MeasurementUnitResultList.Where(u => u.MeasurementType == "RowAlignment").ToList();
+                            if (rowAlignmentMeasures.Count > 0)
+                            {
+                                List<string> keysList = new List<string>();
+                                int allRowNums = rowAlignmentSheet.Dimension.Rows;
+                                int aligneStartCol = rowAlignmentSheet.Dimension.Columns;
+
+                                for (int i = 3; i <= allRowNums; i++)
+                                {
+                                    string keys = alignmentSheet.Cells[i, 1].Value.ToString();
+                                    string position = alignmentSheet.Cells[i, 2].Value.ToString();
+
+                                    keysList.Add($"{keys}_{position}");
+                                }
+
+                                var barcodeCell = rowAlignmentSheet.Cells[1, aligneStartCol + 1, 1, aligneStartCol + 2];
+                                barcodeCell.Merge = true;
+                                barcodeCell.Value = exportData.ProductionMeasurementRecord.ProductionBarcode;
+                                SetTitleCell(barcodeCell);
+
+                                var valueCell = rowAlignmentSheet.Cells[2, aligneStartCol + 1];
+                                valueCell.Value = "Value";
+                                SetTitleCell(valueCell);
+
+                                var resultCell = rowAlignmentSheet.Cells[2, aligneStartCol + 2];
+                                resultCell.Value = "Result";
+                                SetTitleCell(resultCell);
+
+                                rowAlignmentMeasures.ForEach(a =>
+                                {
+                                    int rowIndex = keysList.IndexOf($"{a.Keys}_{a.Positions}");
+                                    if (rowIndex < 0)
+                                    {
+                                        LogAsync(DateTime.Now, "Excel瀵煎嚭閿欒", $"{a.Keys}_{a.Positions}鐨凴owAlignment鏈兘鑾峰彇琛屼俊鎭紝鏈鍑�");
+                                        return;
+                                    }
+
+                                    var cellValue = rowAlignmentSheet.Cells[rowIndex + 1 + 2, aligneStartCol + 1];
+                                    var cellResult = rowAlignmentSheet.Cells[rowIndex + 1 + 2, aligneStartCol + 2];
+
+                                    cellValue.Value = a.MeasurementValue;
+                                    cellResult.Value = a.MeasurementResult;
+
+                                    if (a.MeasurementResult != "OK")
+                                    {
+                                        SetNGCell(cellValue);
+                                        SetNGCell(cellResult);
+                                    }
+                                });
+                            }
+                        }
+                        #endregion
+
+                        package.Save();
+                    };
+                }
+            });
+        }
+
+        private void SetNGCell(ExcelRange cell)
+        {
+            cell.Style.Font.Color.SetColor(Color.White);
+            cell.Style.Font.Bold = true;
+            cell.Style.Fill.PatternType = ExcelFillStyle.Solid;
+            cell.Style.Fill.BackgroundColor.SetColor(Color.Red);
+        }
+
+        private void SetTitleCell(ExcelRange cell, bool isCenterAlign = true)
+        {
+            cell.Style.Font.Color.SetColor(Color.White);
+            cell.Style.Font.Bold = true;
+            cell.Style.Fill.PatternType = ExcelFillStyle.Solid;
+            cell.Style.Fill.BackgroundColor.SetColor(Color.FromArgb(31, 73, 125));
+            cell.AutoFitColumns();
+            if (isCenterAlign)
+            {
+                cell.Style.HorizontalAlignment = ExcelHorizontalAlignment.Center;
+            }
+            else
+            {
+                cell.Style.HorizontalAlignment = ExcelHorizontalAlignment.Left;
+            }
         }
 
         #region 鍥惧儚淇濆瓨
@@ -670,7 +1027,7 @@
         }
         #endregion
 
-        private async void RunImageHandle(CameraBase camera, IOperationConfig opConfig, IImageSet imgSet, string snapshotId, string snapshotName, List<MeasurementUnit> measureList)
+        private async void RunImageHandle(IOperationConfig opConfig, IImageSet imgSet, string snapshotId, string snapshotName, List<MeasurementUnit> measureList)
         {
             await Task.Run(() =>
              {
@@ -691,6 +1048,9 @@
                          keyBindCollection.ForEach(k => k.FillKeyValues(null));
                          return;
                      }
+
+                     string fileName = Path.Combine(Config.ImageSaveFolder, "BeforeRun", $"{DateTime.Now.ToString("yyyyMMddHHmmssfff")}.tif");
+                     imgSet.HImage.WriteImage("tiff", 0, fileName);
 
                      _halconToolDict[toolKey].InputImageDic["INPUT_Image"] = imgSet.HImage;
                      if (!_halconToolDict[toolKey].RunProcedure(out string error))
@@ -723,19 +1083,22 @@
                           });
                  }
 
-                 string dir = Path.Combine(Config.ImageSaveFolder, "Clips", $"{snapshotName}_{DateTime.Now.ToString("HHmmss")}");
+                 string dir = Path.Combine(Config.ImageSaveFolder, "Clips", $"{DateTime.Now.ToString("yyyyMMdd")}", $"{snapshotName}_{DateTime.Now.ToString("HHmmss")}");
                  if (!Directory.Exists(dir))
                  {
                      Directory.CreateDirectory(dir);
                  }
 
-                 Parallel.For(1, count.I + 1, (i) =>
-                 //for (int i = 1; i <= count.I; i++)
+                 //Parallel.For(1, count.I + 1, (i) =>
+                 for (int i = 1; i <= count.I; i++)
                  {
                      HOperatorSet.SelectObj(images, out HObject image, i);
 
                      string fileName = Path.Combine(dir, $"{i}.tif");
-                     image.ConvertHObjectToHImage().WriteImage("tiff", 0, fileName);
+                     using (HImage temp = image.ConvertHObjectToHImage())
+                     {
+                         temp.WriteImage("tiff", 0, fileName);
+                     }
 
                      keys.Where(u => u.ImageSeq == i).ToList().ForEach(k =>
                          {
@@ -753,19 +1116,22 @@
                                  _halconToolDict[keyToolKey].InputImageDic["INPUT_Image"] = image;
                                  _halconToolDict[keyToolKey].InputTupleDic["INPUT_Resolution_X"] = scanParam.Resolution_X / 1000000.0;
                                  _halconToolDict[keyToolKey].InputTupleDic["INPUT_Resolution_Z"] = scanParam.Resolution_Z / 1000000.0;
+                                 _halconToolDict[keyToolKey].InputTupleDic["INPUT_ImageId"] = $"{k.AliasName}_{DateTime.Now.ToString("HHmmssfff")}.tif";
                                  if (!_halconToolDict[keyToolKey].RunProcedure(out string error))
                                  {
                                      LogAsync(DateTime.Now, $"{k.AliasName}妫�娴嬬畻娉曞紓甯革紝{error}", "");
                                  }
                                  else
                                  {
-                                     var results = _halconToolDict[keyToolKey].GetResultTuple("OUTPUT_Results").HTupleToDouble();
+                                     var results = _halconToolDict[keyToolKey].GetResultTuple("OUTPUT_Results").DArr.ToList();
                                      if (results.Count == 0 || results.Any(u => u < 0))
                                      {
-                                         LogAsync(DateTime.Now, $"{k.AliasName}妫�娴嬬粨鏋滃紓甯�", "");
+                                         LogAsync(DateTime.Now, $"{k.AliasName}鍘熷鏁版嵁寮傚父", "");
                                      }
                                      else
                                      {
+                                         //results = results.Select(u => double.Parse(u.ToString("f2"))).ToList();
+                                         LogAsync(DateTime.Now, $"{k.AliasName}鍘熷鏁版嵁", $"{string.Join(" ", results)}");
                                          resultDict = k.KeyResultList.ToDictionary(u => u, u =>
                                               {
                                                   int index = k.KeyResultList.IndexOf(u);
@@ -782,9 +1148,9 @@
                              });
                          });
 
-                     //image.Dispose();
+                     image.Dispose();
                  }
-                 );
+                 //);
 
                  //if (count.I != 1)
                  //{

--
Gitblit v1.8.0