887 lines
36 KiB
C#
887 lines
36 KiB
C#
using DevExpress.DataAccess.Excel;
|
|
using DevExpress.Export.Xl;
|
|
using DevExpress.Utils;
|
|
using DevExpress.XtraCharts;
|
|
using DevExpress.XtraPrinting;
|
|
using DevExpress.XtraVerticalGrid;
|
|
using DevExpress.XtraVerticalGrid.Rows;
|
|
using DevExpress.Spreadsheet;
|
|
using System;
|
|
using System.Collections.Generic;
|
|
using System.Data;
|
|
using System.Data.SqlClient;
|
|
using System.Drawing;
|
|
using System.Globalization;
|
|
using System.IO;
|
|
using System.Linq;
|
|
using System.Reflection;
|
|
using System.Threading;
|
|
using System.Threading.Tasks;
|
|
using System.Windows.Forms;
|
|
using SystemX.Net.Platform.Common.ExtensionMethods;
|
|
using SystemX.Product.ALIS.UI.Subs;
|
|
using SystemX.Product.TRA.DataManager;
|
|
using DevExpress.XtraGrid.Views.Grid;
|
|
using SystemX.Product.ALIS.Interface;
|
|
|
|
using static SystemX.Product.TRA.DataManager.DMTestHistory;
|
|
using static SystemX.Product.TRA.DataManager.DMTestSummary;
|
|
using static SystemX.Product.TRA.UIControl.UcTRAStepTrend.TrendDataResult;
|
|
using static SystemX.Product.CP.TRA.Commons;
|
|
using Newtonsoft.Json;
|
|
using CPXV2Log = SystemX.Net.Platform.SystemX.Net.XEFCore.DBContext.CPXV2Log;
|
|
using SystemX.Common.Util;
|
|
|
|
namespace SystemX.Product.TRA.UIControl
|
|
{
|
|
public partial class UcTRAStepTrend : UcTRABaseView
|
|
{
|
|
public enum eColDataTable
|
|
{
|
|
RowNo,
|
|
TestTime,
|
|
MO,
|
|
ProductID,
|
|
Min,
|
|
Value,
|
|
Max,
|
|
Result,
|
|
Duration
|
|
}
|
|
|
|
public enum eResultType
|
|
{
|
|
OK,
|
|
NG,
|
|
NONE
|
|
}
|
|
|
|
DMStepTrend DataManager { get; set; }
|
|
TestTrendDataCollection SelectedData { get; set; }
|
|
DataTable DTTestlistSrc { get; set; } = null;
|
|
DataTable DTTestLogList { get; set; } = null;
|
|
DataTable DTTestSummary { get; set; } = null;
|
|
|
|
WaitProgressForm SplashFormWaiting = null;
|
|
|
|
List<string> NoChartDispSpec = new List<string>();
|
|
|
|
delegate void evtDBQueryFinished();
|
|
event evtDBQueryFinished evtDBFin;
|
|
|
|
private string GridViewGetActiveFilterText;
|
|
|
|
private double dThisMaxLimit;
|
|
private double dThisMinLimit;
|
|
private double dThisUnitSize;
|
|
public UcTRAStepTrend()
|
|
{
|
|
ContentsType = eContents.TestTrend;
|
|
|
|
//this.ContextMenuStrip = base.contextMenuStripTest;
|
|
|
|
InitializeComponent();
|
|
|
|
FileStream fs = new FileStream("NoChartSpec.def", FileMode.Open, FileAccess.Read);
|
|
StreamReader sr = new StreamReader(fs);
|
|
|
|
while (!sr.EndOfStream)
|
|
NoChartDispSpec.Add(sr.ReadLine());
|
|
|
|
sr.Close();
|
|
fs.Close();
|
|
}
|
|
|
|
public void SetSQLConnection(eSelectDataView SelectView, IDataBaseController getDBController, DateTime dtStart)
|
|
{
|
|
DataManager = new DMStepTrend(SelectView, getDBController, dtStart);
|
|
}
|
|
|
|
public override void ExportData()
|
|
{
|
|
FolderBrowserDialog dlg = new FolderBrowserDialog();
|
|
|
|
if (dlg.ShowDialog() == DialogResult.OK)
|
|
{
|
|
|
|
string strFileName = CreateExportFileName();
|
|
string strExpPath = dlg.SelectedPath + "\\" + strFileName;
|
|
XlsxExportOptionsEx option = new XlsxExportOptionsEx();
|
|
string strFile = strExpPath + ".xlsx";
|
|
|
|
option.ShowGridLines = true;
|
|
option.ExportType = DevExpress.Export.ExportType.WYSIWYG;
|
|
option.ExportMode = XlsxExportMode.SingleFile;
|
|
option.SheetName = "Trend Data";
|
|
gridControlMain.ExportToXlsx(strFile, option);
|
|
|
|
|
|
Workbook wbook = new Workbook();
|
|
|
|
wbook.LoadDocument(strFile);
|
|
|
|
Worksheet worksheetInfo = wbook.Worksheets.Add("Test Trend Info.");
|
|
|
|
int nIdx = 0;
|
|
|
|
foreach (var row in vGridControlInfo.Rows)
|
|
{
|
|
if (row is CategoryRow)
|
|
{
|
|
worksheetInfo.Cells[nIdx, 0].Value = row.Properties.Caption.ToString();
|
|
|
|
CellRange cr = worksheetInfo.Range.FromLTRB(0, nIdx, 2, nIdx);
|
|
|
|
worksheetInfo.MergeCells(cr);
|
|
}
|
|
else
|
|
{
|
|
worksheetInfo.Cells[nIdx, 1].Value = row.Properties.Caption.ToString();
|
|
worksheetInfo.Cells[nIdx, 2].Value = row.Properties.Value.ToString();
|
|
}
|
|
|
|
nIdx++;
|
|
}
|
|
|
|
worksheetInfo.Cells[nIdx, 0].Value = "Test Step Analysis";
|
|
nIdx++;
|
|
|
|
foreach (var row in vGridControlStepSummary.Rows)
|
|
{
|
|
if (row is CategoryRow)
|
|
{
|
|
worksheetInfo.Cells[nIdx, 0].Value = row.Properties.Caption.ToString();
|
|
|
|
CellRange cr = worksheetInfo.Range.FromLTRB(0, nIdx, 2, nIdx);
|
|
|
|
worksheetInfo.MergeCells(cr);
|
|
}
|
|
else
|
|
{
|
|
worksheetInfo.Cells[nIdx, 1].Value = row.Properties.Caption.ToString();
|
|
worksheetInfo.Cells[nIdx, 2].Value = row.Properties.Value.ToString();
|
|
}
|
|
|
|
nIdx++;
|
|
}
|
|
|
|
worksheetInfo.Columns.AutoFit(0, 3);
|
|
worksheetInfo.AutoOutline();
|
|
wbook.SaveDocument(strFile);
|
|
}
|
|
}
|
|
|
|
public string CreateExportFileName()
|
|
{
|
|
string strFileName = $"{this.ContentsType.ToString()}_{SelectedData.SelectedData.ProductNo}_{SelectedData.SelectedData.TestCode}_{SelectedData.SelectedData.StationName}_{SelectedData.StepNo}";
|
|
|
|
strFileName += $"_{SelectedData.SelectedData.StartTime.ToString("yyyyMMddHHmmss")}-{SelectedData.SelectedData.StartTime.ToString("yyyyMMddHHmmss")}";
|
|
|
|
return strFileName;
|
|
}
|
|
|
|
public void ViewData(TestTrendDataCollection data)
|
|
{
|
|
if (data == null)
|
|
return;
|
|
|
|
SelectedData = data;
|
|
DTTestlistSrc = data.DTTestlistSrc;
|
|
DTTestLogList = data.DTTestLogList;
|
|
|
|
try
|
|
{
|
|
DataRow dtRow = GetTestStepInfo(data.StepNo, data.DTTestlistSrc);
|
|
List<DataRow> vdtRowLogs = DTTestLogList.AsEnumerable().Where(x =>
|
|
(!Enum.GetNames(typeof(DMOverview.eCommand)).Contains(x[DMTestHistory.eColList.ProductNo.ToString()].ToString())
|
|
&& !Enum.GetNames(typeof(DMOverview.eCommand)).Contains(x[DMTestHistory.eColList.ProductID.ToString()].ToString()))).ToList();
|
|
|
|
ShowProperties(data, dtRow);
|
|
|
|
DataRow dtRowLogFirst = vdtRowLogs[0];
|
|
DateTime dtTested = Convert.ToDateTime(dtRowLogFirst[DMTestHistory.eColList.TestDateTime.ToString()]);
|
|
ulong ulAccessNo = Convert.ToUInt64(dtRowLogFirst[DMTestHistory.eColList.No.ToString()]);
|
|
|
|
CPXV2Log.Tables.HIST_TestResult drStep = null;
|
|
|
|
for (int i = 0; i < vdtRowLogs.Count; i++)
|
|
{
|
|
dtRowLogFirst = vdtRowLogs[i];
|
|
dtTested = Convert.ToDateTime(dtRowLogFirst[DMTestHistory.eColList.TestDateTime.ToString()]);
|
|
ulAccessNo = Convert.ToUInt64(dtRowLogFirst[DMTestHistory.eColList.No.ToString()]);
|
|
|
|
DataTable dtFirstLog = DataManager.SearchTestResult(dtTested, ulAccessNo);
|
|
|
|
var logData = dtFirstLog.Rows[0]["LogData"].ToString();
|
|
var decompStr = logData.GzipDecompress();
|
|
|
|
var list = JsonConvert.DeserializeObject<List<CPXV2Log.Tables.HIST_TestResult>>(decompStr);
|
|
|
|
drStep = list.Where(x => x.StepID.ToString() == data.StepNo.ToString()).FirstOrDefault();
|
|
|
|
if (drStep != null)
|
|
break;
|
|
}
|
|
|
|
if (drStep == null)
|
|
return;
|
|
|
|
int nPoint = 0;
|
|
DataTable dtResult = GetTrendData(dtTested, vdtRowLogs);
|
|
|
|
nPoint = 1;
|
|
dtResult = CombineLogForm(dtResult, dtRow);
|
|
|
|
nPoint = 2;
|
|
TrendDataResult resultUnit = MakeTrendSummary(dtResult, dtRow, data);
|
|
|
|
nPoint = 3;
|
|
ShowDataTable(dtResult);
|
|
|
|
nPoint = 4;
|
|
ShowTestStepSummary(resultUnit);
|
|
|
|
nPoint = 5;
|
|
ShowTrendChart(resultUnit);
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
MessageBox.Show($"Searching Failure - {ex.Message}", "Test Trend - Error");
|
|
}
|
|
}
|
|
|
|
void CloseWaitingForm()
|
|
{
|
|
this.Do(() => SplashFormWaiting.Close());
|
|
}
|
|
|
|
DataTable GetTrendData(DateTime dtTested, List<DataRow> vnData)
|
|
{
|
|
DataTable dtResult = DataManager.GetTestStepResults(dtTested, vnData.Select(x => Convert.ToUInt64(x[0])).ToList());
|
|
|
|
dtResult.Columns.Add(eColDataTable.RowNo.ToString(), typeof(ulong));
|
|
|
|
for (int i = 0; i < dtResult.Rows.Count; i++)
|
|
dtResult.Rows[i][eColDataTable.RowNo.ToString()] = i + 1;
|
|
|
|
return dtResult;
|
|
}
|
|
|
|
DataTable CombineLogForm(DataTable dtResult, DataRow dtRowTestlistSpec)
|
|
{
|
|
DataTable dtFinal = new DataTable();
|
|
|
|
foreach (string strCol in Enum.GetNames(typeof(eColDataTable)))
|
|
{
|
|
Type typCol = strCol == eColDataTable.RowNo.ToString() ? typeof(int) : typeof(string);
|
|
|
|
dtFinal.Columns.Add(strCol, typCol);
|
|
}
|
|
|
|
int index = 0;
|
|
foreach (DataRow drLog in dtResult.AsEnumerable())
|
|
{
|
|
index += 1;
|
|
/*string strValue = drLog[DMTestHistory.eColList.TestID.ToString()].ToString();
|
|
DataRow drTL = DTTestLogList.AsEnumerable().Where(x =>
|
|
x[DMTestHistory.eColList.TestID.ToString()].ToString() == drLog[DMTestHistory.eColList.TestID.ToString()].ToString()).FirstOrDefault();*/
|
|
|
|
try
|
|
{
|
|
string logData = drLog["LogData"].ToString();
|
|
string decompStr = logData.GzipDecompress();
|
|
List<CPXV2Log.Tables.HIST_TestResult> list = JsonConvert.DeserializeObject<List<CPXV2Log.Tables.HIST_TestResult>>(decompStr);
|
|
|
|
long outValue = 0;
|
|
if (Int64.TryParse(dtRowTestlistSpec[2].ToString(), out outValue))
|
|
{
|
|
CPXV2Log.Tables.HIST_TestResult row = list.Where(x => x.StepID == outValue)?.First();
|
|
if(row == null)
|
|
{
|
|
continue;
|
|
}
|
|
|
|
if (string.IsNullOrEmpty(row.MeasValStr) == true)
|
|
{
|
|
if (//!string.IsNullOrEmpty(row.MeasValStr) ||
|
|
//!string.IsNullOrEmpty(row.Message) ||
|
|
((row.MeasVal == 0) ||
|
|
string.Compare(row.Result, "NONE") == 0))
|
|
continue;
|
|
}
|
|
|
|
//string strValue = drLog[DMTestHistory.eColList.No.ToString()].ToString();
|
|
try
|
|
{
|
|
DataRow drTL = DTTestLogList.AsEnumerable()
|
|
.Where(x => Convert.ToInt64(x[DMTestHistory.eColList.No.ToString()]) == Convert.ToInt64(drLog[0].ToString())).FirstOrDefault();
|
|
|
|
DataRow drDisp = dtFinal.NewRow();
|
|
|
|
if (drTL == null)
|
|
continue;
|
|
|
|
drDisp[0] = index;
|
|
drDisp[1] = drTL[1].ToString();
|
|
drDisp[2] = dtRowTestlistSpec[9].ToString();
|
|
drDisp[3] = drTL[5].ToString();
|
|
|
|
bool bIsGlobal = (Convert.ToInt32(dtRowTestlistSpec[eColTestlist.IsGlobal.ToString()])) > 0 ? true : false;
|
|
|
|
drDisp[4] = bIsGlobal ? row.GlobalMin.ToString() : dtRowTestlistSpec[eColTestlist.SpecMin.ToString()].ToString();
|
|
drDisp[6] = bIsGlobal ? row.GlobalMAx.ToString() : dtRowTestlistSpec[eColTestlist.SpecMax.ToString()].ToString();
|
|
|
|
string strMessage = row.Message.ToString();
|
|
string strMeasValStr = row.MeasValStr.ToString();
|
|
string strMeasVal = row.MeasVal.ToString();
|
|
|
|
drDisp[5] = string.IsNullOrWhiteSpace(strMessage) ? (string.IsNullOrWhiteSpace(strMeasValStr) ? strMeasVal : strMeasValStr) : strMessage;
|
|
drDisp[7] = row.Result.ToString();
|
|
|
|
/*
|
|
public enum eColDataTable
|
|
{
|
|
RowNo,
|
|
TestTime,
|
|
ProductID,
|
|
Min,
|
|
Value,
|
|
Max,
|
|
Result,
|
|
Duration
|
|
}
|
|
drDisp[eColDataTable.RowNo.ToString()] = drLog[eColDataTable.RowNo.ToString()];
|
|
drDisp[eColDataTable.TestTime.ToString()] = drTL[1].ToString();
|
|
drDisp[eColDataTable.ProductID.ToString()] = drTL[5].ToString();
|
|
drDisp[eColDataTable.Result.ToString()] = row.Result.ToString();
|
|
|
|
bool bIsGlobal = (Convert.ToInt32(dtRowTestlistSpec[eColTestlist.IsGlobal.ToString()])) > 0 ? true : false;
|
|
|
|
drDisp[eColDataTable.Min.ToString()] = bIsGlobal ? row.GlobalMin.ToString() : dtRowTestlistSpec[eColTestlist.SpecMin.ToString()].ToString();
|
|
drDisp[eColDataTable.Max.ToString()] = bIsGlobal ? row.GlobalMAx.ToString() : dtRowTestlistSpec[eColTestlist.SpecMax.ToString()].ToString();
|
|
|
|
string strMessage = row.Message.ToString();
|
|
string strMeasValStr = row.MeasValStr.ToString();
|
|
string strMeasVal = row.MeasVal.ToString();
|
|
|
|
drDisp[eColDataTable.Value.ToString()] = string.IsNullOrWhiteSpace(strMessage) ? (string.IsNullOrWhiteSpace(strMeasValStr) ? strMeasVal : strMeasValStr) : strMessage;
|
|
drDisp[eColDataTable.Result.ToString()] = row.Result.ToString();
|
|
*/
|
|
|
|
dtFinal.Rows.Add(drDisp);
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
|
|
}
|
|
}
|
|
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
|
|
}
|
|
}
|
|
|
|
|
|
|
|
return dtFinal;
|
|
}
|
|
|
|
void ShowDataTable(DataTable dtResult)
|
|
{
|
|
GridViewGetActiveFilterText = gridViewMain.ActiveFilterString;
|
|
|
|
gridControlMain.BeginInit();
|
|
|
|
gridControlMain.DataSource = dtResult;
|
|
|
|
gridControlMain.Update();
|
|
gridControlMain.RefreshDataSource();
|
|
gridControlMain.ForceInitialize();
|
|
gridViewMain.PopulateColumns(dtResult);
|
|
gridControlMain.EndInit();
|
|
|
|
gridViewMain.BestFitColumns();
|
|
|
|
gridViewMain.ActiveFilterString = GridViewGetActiveFilterText;
|
|
}
|
|
|
|
void ShowTrendChart(TrendDataResult resultUnit, bool bAutoRange = false)
|
|
{
|
|
foreach (Series srsData in chartControlMain.Series)
|
|
srsData.Points.Clear();
|
|
|
|
chartControlMain.Series.Clear();
|
|
|
|
if (resultUnit == null || resultUnit.DataElements == null || resultUnit.DataElements.Count <= 0)
|
|
return;
|
|
|
|
chartControlMain.CrosshairOptions.ArgumentLineColor = Color.Black;
|
|
chartControlMain.CrosshairOptions.CrosshairLabelTextOptions.TextColor = Color.Black;
|
|
chartControlMain.CrosshairOptions.CrosshairLabelBackColor = Color.White;
|
|
chartControlMain.CrosshairOptions.ValueLineColor = Color.Black;
|
|
chartControlMain.CrosshairOptions.GroupHeaderTextOptions.TextColor = Color.Blue;
|
|
|
|
int nSrsIdxValue = AddSeries("Value", ScaleType.Qualitative, ScaleType.Numerical, Color.Red);
|
|
int nSrsIdxMin = AddSeries("Lower Limit", ScaleType.Qualitative, ScaleType.Numerical, Color.Blue);
|
|
int nSrsIdxMax = AddSeries("Upper Limit", ScaleType.Qualitative, ScaleType.Numerical, Color.Blue);
|
|
|
|
AddToolTip("{HINT} \r\n {Value:#0.00}");
|
|
|
|
SetAxisXRange(DateTimeMeasureUnit.Second, DateTimeGridAlignment.Second);
|
|
AxisYRangeAuto(bAutoRange, resultUnit);
|
|
|
|
SwiftPlotDiagram diagram = (SwiftPlotDiagram)chartControlMain.Diagram;
|
|
|
|
foreach (StepDataElement item in resultUnit.DataElements)
|
|
{
|
|
if (item.Result == eResultType.NONE && item.Value == 0)
|
|
continue;
|
|
|
|
if (item.UseMin)
|
|
chartControlMain.Series[nSrsIdxMin].Points.Add(new SeriesPoint(item.RowNo, item.Min));
|
|
if (item.UseMax)
|
|
chartControlMain.Series[nSrsIdxMax].Points.Add(new SeriesPoint(item.RowNo, item.Max));
|
|
|
|
chartControlMain.Series[nSrsIdxValue].Points.Add(new SeriesPoint(item.RowNo, item.Value));
|
|
|
|
if (item.Value < item.Min || item.Value > item.Max)
|
|
{
|
|
if (diagram.AxisY.WholeRange.Auto != true)
|
|
{
|
|
//diagram.AxisY.WholeRange.Auto = true;
|
|
|
|
if (chartControlMain.BackColor != Color.WhiteSmoke)
|
|
chartControlMain.BackColor = Color.WhiteSmoke;
|
|
}
|
|
}
|
|
}
|
|
|
|
//diagram.AxisX.Interlaced = false;
|
|
diagram.DefaultPane.BackColor = Color.White;
|
|
diagram.DefaultPane.RuntimeCollapse = DefaultBoolean.False;
|
|
}
|
|
|
|
|
|
private void SetAxisXRange(DateTimeMeasureUnit dtimeUnit, DateTimeGridAlignment dtimeGrid)
|
|
{
|
|
SwiftPlotDiagram diagram = (SwiftPlotDiagram)chartControlMain.Diagram;
|
|
diagram.AxisX.NumericScaleOptions.ScaleMode = ScaleMode.Continuous;
|
|
diagram.AxisX.NumericScaleOptions.AutoGrid = true;
|
|
diagram.AxisX.Logarithmic = false;
|
|
|
|
//diagram.AxisX.DateTimeScaleOptions.MeasureUnit = dtimeUnit;
|
|
//.AxisX.DateTimeScaleOptions.GridAlignment = dtimeGrid;
|
|
|
|
diagram.AxisX.Interlaced = true;
|
|
diagram.AxisX.InterlacedColor = Color.GhostWhite;
|
|
diagram.AxisX.InterlacedFillStyle.FillMode = FillMode.Solid;
|
|
|
|
diagram.AxisX.NumericScaleOptions.ScaleMode = ScaleMode.Automatic;
|
|
diagram.AxisX.LabelPosition = AxisLabelPosition.Outside;
|
|
|
|
diagram.EnableAxisXScrolling = true;
|
|
diagram.EnableAxisXZooming = true;
|
|
//
|
|
diagram.EnableAxisYScrolling = true;
|
|
diagram.EnableAxisYZooming = true;
|
|
//
|
|
diagram.AxisX.Color = Color.Black;
|
|
diagram.AxisX.Label.TextColor = Color.Black;
|
|
|
|
diagram.AxisY.Color = Color.Black;
|
|
diagram.AxisY.Label.TextColor = Color.Black;
|
|
|
|
chartControlMain.BackColor = Color.White;
|
|
}
|
|
|
|
public void AxisYRangeAuto(bool bAuto, TrendDataResult resultUnit)
|
|
{
|
|
SwiftPlotDiagram diagram = (SwiftPlotDiagram)chartControlMain.Diagram;
|
|
if (diagram == null)
|
|
return;
|
|
|
|
diagram.AxisY.WholeRange.Auto = bAuto;
|
|
|
|
if (!bAuto)
|
|
{
|
|
dThisMaxLimit = resultUnit.MaxSpec == resultUnit.dSpecNotUse ? resultUnit.Max : resultUnit.MaxSpec;
|
|
dThisMinLimit = resultUnit.MinSpec == resultUnit.dSpecNotUse ? resultUnit.Min : resultUnit.MinSpec;
|
|
dThisUnitSize = Math.Abs((dThisMaxLimit - dThisMinLimit) / 10);
|
|
|
|
diagram.AxisY.WholeRange.SetMinMaxValues(dThisMinLimit - dThisUnitSize, dThisMaxLimit + dThisUnitSize);
|
|
}
|
|
}
|
|
public int AddSeries(string name, ScaleType ArgumentType, ScaleType ValueType, Color seriesColor)
|
|
{
|
|
Series series = new Series(name, ViewType.SwiftPlot);
|
|
chartControlMain.Series.Add(series);
|
|
series.ArgumentScaleType = ArgumentType;
|
|
series.ValueScaleType = ValueType;
|
|
|
|
SwiftPlotSeriesView plotSeriesView = new DevExpress.XtraCharts.SwiftPlotSeriesView();
|
|
plotSeriesView.Color = seriesColor;
|
|
//plotSeriesView.LineMarkerOptions.Color = seriesColor;
|
|
//plotSeriesView.LineMarkerOptions.Size = 3;
|
|
plotSeriesView.LineStyle.Thickness = 2;
|
|
//plotSeriesView.MarkerVisibility = DefaultBoolean.True;
|
|
series.View = plotSeriesView;
|
|
|
|
return chartControlMain.Series.Count - 1;
|
|
}
|
|
|
|
private void AddToolTip(string ToolTipPattern)
|
|
{
|
|
// Disable a crosshair cursor.
|
|
chartControlMain.CrosshairEnabled = DefaultBoolean.True;
|
|
|
|
// Enable chart tooltips.
|
|
chartControlMain.ToolTipEnabled = DefaultBoolean.True;
|
|
|
|
ToolTipController controller = new ToolTipController();
|
|
chartControlMain.ToolTipController = controller;
|
|
controller.ShowBeak = true;
|
|
|
|
// Change the default tooltip mouse position to relative position.
|
|
ToolTipRelativePosition relativePosition = new ToolTipRelativePosition();
|
|
chartControlMain.ToolTipOptions.ToolTipPosition = relativePosition;
|
|
|
|
// Specify the tooltip relative position offsets.
|
|
relativePosition.OffsetX = 2;
|
|
relativePosition.OffsetY = 2;
|
|
|
|
// Specify the tooltip point pattern.
|
|
chartControlMain.Series[0].ToolTipPointPattern = ToolTipPattern;
|
|
}
|
|
|
|
TrendDataResult MakeTrendSummary(DataTable dtResult, DataRow dtRowTestlist, TestTrendDataCollection data, bool bOKDataOnly = true)
|
|
{
|
|
string strDim = dtRowTestlist[DMTestDetail.eColTestlist.Dim.ToString()].ToString();
|
|
|
|
if (NoChartDispSpec.Contains(strDim))
|
|
return null;
|
|
|
|
bool bIsGlobal = (Convert.ToInt32(dtRowTestlist[DMTestDetail.eColTestlist.IsGlobal.ToString()])) > 0 ? true : false;
|
|
TrendDataResult resultUnit = new TrendDataResult();
|
|
StepDataElement elemUnit = null;
|
|
|
|
foreach (DataRow drValue in dtResult.AsEnumerable())
|
|
{
|
|
DateTime dtTestedTime = DateTime.Parse(drValue[eColDataTable.TestTime.ToString()].ToString());
|
|
string strProdID = drValue[eColDataTable.ProductID.ToString()].ToString();
|
|
string strValue = drValue[eColDataTable.Value.ToString()].ToString();
|
|
string strMin = drValue[eColDataTable.Min.ToString()].ToString();
|
|
string strMax = drValue[eColDataTable.Max.ToString()].ToString();
|
|
string strResult = drValue[eColDataTable.Result.ToString()].ToString();
|
|
double dValue = 0.0;
|
|
|
|
if (string.IsNullOrWhiteSpace(strValue))
|
|
continue;
|
|
if (!double.TryParse(strValue, out dValue))
|
|
continue;
|
|
|
|
elemUnit = new StepDataElement();
|
|
|
|
elemUnit.RowNo = (int)drValue[eColDataTable.RowNo.ToString()];
|
|
elemUnit.TestTime = dtTestedTime;
|
|
elemUnit.ProductID = strProdID;
|
|
elemUnit.Value = dValue;
|
|
|
|
if (string.IsNullOrWhiteSpace(strMin))
|
|
elemUnit.UseMin = false;
|
|
else
|
|
{
|
|
elemUnit.UseMin = true;
|
|
elemUnit.Min = Convert.ToDouble(strMin);
|
|
}
|
|
if (string.IsNullOrWhiteSpace(strMax))
|
|
elemUnit.UseMax = false;
|
|
else
|
|
{
|
|
elemUnit.UseMax = true;
|
|
elemUnit.Max = Convert.ToDouble(strMax);
|
|
}
|
|
|
|
if (elemUnit.UseMin && elemUnit.UseMax)
|
|
elemUnit.Tolerance = elemUnit.Max - elemUnit.Min;
|
|
|
|
elemUnit.Result = strResult == "NG" || strResult == "ERROR" ? eResultType.NG : strResult == "OK" ? eResultType.OK : eResultType.NONE;
|
|
|
|
if (bOKDataOnly && elemUnit.Result != eResultType.OK)
|
|
continue;
|
|
|
|
resultUnit.DataElements.Add(elemUnit);
|
|
}
|
|
|
|
if (resultUnit.DataElements == null || resultUnit.DataElements.Count <= 0)
|
|
return null;
|
|
|
|
double dSpecNotUse = -999999;
|
|
List<double> vdValue = (from elem in resultUnit.DataElements let dValue = elem.Value select dValue).ToList();
|
|
|
|
resultUnit.Average = vdValue.Average();
|
|
resultUnit.Min = vdValue.Min();
|
|
resultUnit.Max = vdValue.Max();
|
|
resultUnit.Variance = vdValue.Variance();
|
|
resultUnit.StdDev = vdValue.StandardDeviation();
|
|
|
|
resultUnit.MinSpec = resultUnit.DataElements[0].UseMin ?
|
|
(from elem in resultUnit.DataElements let dValue = elem.Min select dValue).Average() : dSpecNotUse;
|
|
resultUnit.MaxSpec = resultUnit.DataElements[0].UseMax ?
|
|
(from elem in resultUnit.DataElements let dValue = elem.Max select dValue).Average() : dSpecNotUse;
|
|
|
|
resultUnit.Cp = resultUnit.DataElements[0].UseMin && resultUnit.DataElements[0].UseMax ?
|
|
vdValue.Cp(resultUnit.MaxSpec - resultUnit.MinSpec) : 0.0;
|
|
resultUnit.Cpk = resultUnit.DataElements[0].UseMin && resultUnit.DataElements[0].UseMax ?
|
|
vdValue.Cpk(resultUnit.MaxSpec, resultUnit.MinSpec) : 0.0;
|
|
resultUnit.Cg = resultUnit.DataElements[0].UseMin && resultUnit.DataElements[0].UseMax ?
|
|
vdValue.Cg(resultUnit.MaxSpec - resultUnit.MinSpec) : 0.0;
|
|
|
|
return resultUnit;
|
|
}
|
|
|
|
|
|
DataRow GetTestStepInfo(string strStepID, DataTable dtTestlist)
|
|
{
|
|
int nStepID = Convert.ToInt32(strStepID);
|
|
|
|
DataRow dtRow = (from dtStepRow in dtTestlist.AsEnumerable()
|
|
where dtStepRow[eColTestlist.StepID.ToString()].ToString() == strStepID
|
|
select dtStepRow).FirstOrDefault();
|
|
|
|
return dtRow;
|
|
}
|
|
|
|
void ShowTestStepSummary(TrendDataResult resultUnit)
|
|
{
|
|
vGridControlStepSummary.Rows.Clear();
|
|
|
|
if (resultUnit == null || resultUnit.DataElements == null || resultUnit.DataElements.Count <= 0)
|
|
return;
|
|
|
|
EditorRow etRowStep;
|
|
|
|
etRowStep = new EditorRow();
|
|
etRowStep.Properties.Caption = "Average";
|
|
etRowStep.Properties.Value = resultUnit.Average.ToString();
|
|
vGridControlStepSummary.Rows.Add(etRowStep);
|
|
|
|
etRowStep = new EditorRow();
|
|
etRowStep.Properties.Caption = "Min";
|
|
etRowStep.Properties.Value = resultUnit.Min.ToString();
|
|
vGridControlStepSummary.Rows.Add(etRowStep);
|
|
|
|
etRowStep = new EditorRow();
|
|
etRowStep.Properties.Caption = "Max";
|
|
etRowStep.Properties.Value = resultUnit.Max.ToString();
|
|
vGridControlStepSummary.Rows.Add(etRowStep);
|
|
|
|
etRowStep = new EditorRow();
|
|
etRowStep.Properties.Caption = "Varaince";
|
|
etRowStep.Properties.Value = resultUnit.Variance.ToString();
|
|
vGridControlStepSummary.Rows.Add(etRowStep);
|
|
|
|
etRowStep = new EditorRow();
|
|
etRowStep.Properties.Caption = "Std. Dev.";
|
|
etRowStep.Properties.Value = resultUnit.StdDev.ToString();
|
|
vGridControlStepSummary.Rows.Add(etRowStep);
|
|
|
|
etRowStep = new EditorRow();
|
|
etRowStep.Properties.Caption = "Cp";
|
|
etRowStep.Properties.Value = resultUnit.Cp.ToString();
|
|
vGridControlStepSummary.Rows.Add(etRowStep);
|
|
|
|
etRowStep = new EditorRow();
|
|
etRowStep.Properties.Caption = "Cpk";
|
|
etRowStep.Properties.Value = resultUnit.Cpk.ToString();
|
|
vGridControlStepSummary.Rows.Add(etRowStep);
|
|
|
|
etRowStep = new EditorRow();
|
|
etRowStep.Properties.Caption = "Cg";
|
|
etRowStep.Properties.Value = resultUnit.Cg.ToString();
|
|
vGridControlStepSummary.Rows.Add(etRowStep);
|
|
|
|
OnSizeChanged(vGridControlStepSummary);
|
|
}
|
|
|
|
void ShowProperties(TestTrendDataCollection data, DataRow dtRow)
|
|
{
|
|
vGridControlInfo.Rows.Clear();
|
|
|
|
CategoryRow ctRow = new CategoryRow("Step Info.");
|
|
vGridControlInfo.Rows.Add(ctRow);
|
|
|
|
EditorRow etRowStep = new EditorRow();
|
|
etRowStep.Properties.Caption = eColTestlist.StepID.ToString();
|
|
etRowStep.Properties.Value = dtRow[eColTestlist.StepID.ToString()].ToString();
|
|
vGridControlInfo.Rows.Add(etRowStep);
|
|
|
|
etRowStep = new EditorRow();
|
|
etRowStep.Properties.Caption = eColTestlist.Variant.ToString();
|
|
etRowStep.Properties.Value = dtRow[eColTestlist.Variant.ToString()].ToString();
|
|
vGridControlInfo.Rows.Add(etRowStep);
|
|
|
|
etRowStep = new EditorRow();
|
|
etRowStep.Properties.Caption = eColTestlist.Gate.ToString();
|
|
etRowStep.Properties.Value = dtRow[eColTestlist.Gate.ToString()].ToString();
|
|
vGridControlInfo.Rows.Add(etRowStep);
|
|
|
|
etRowStep = new EditorRow();
|
|
etRowStep.Properties.Caption = eColTestlist.Position.ToString();
|
|
etRowStep.Properties.Value = dtRow[eColTestlist.Position.ToString()].ToString();
|
|
vGridControlInfo.Rows.Add(etRowStep);
|
|
|
|
etRowStep = new EditorRow();
|
|
etRowStep.Properties.Caption = eColTestlist.StepDesc.ToString();
|
|
etRowStep.Properties.Value = dtRow[eColTestlist.StepDesc.ToString()].ToString();
|
|
vGridControlInfo.Rows.Add(etRowStep);
|
|
|
|
etRowStep = new EditorRow();
|
|
etRowStep.Properties.Caption = eColTestlist.UseFunction.ToString();
|
|
etRowStep.Properties.Value = dtRow[eColTestlist.UseFunction.ToString()].ToString();
|
|
vGridControlInfo.Rows.Add(etRowStep);
|
|
|
|
etRowStep = new EditorRow();
|
|
etRowStep.Properties.Caption = eColTestlist.Dim.ToString();
|
|
etRowStep.Properties.Value = dtRow[eColTestlist.Dim.ToString()].ToString();
|
|
vGridControlInfo.Rows.Add(etRowStep);
|
|
|
|
etRowStep = new EditorRow();
|
|
etRowStep.Properties.Caption = "Total";
|
|
etRowStep.Properties.Value = data.Total.ToString();
|
|
vGridControlInfo.Rows.Add(etRowStep);
|
|
|
|
etRowStep = new EditorRow();
|
|
etRowStep.Properties.Caption = "OK";
|
|
etRowStep.Properties.Value = data.OK.ToString();
|
|
vGridControlInfo.Rows.Add(etRowStep);
|
|
|
|
etRowStep = new EditorRow();
|
|
etRowStep.Properties.Caption = "NG";
|
|
etRowStep.Properties.Value = data.NG.ToString();
|
|
vGridControlInfo.Rows.Add(etRowStep);
|
|
|
|
ctRow = new CategoryRow("Test Data Info.");
|
|
vGridControlInfo.Rows.Add(ctRow);
|
|
foreach (PropertyInfo propInf in data.SelectedData.GetType().GetProperties())
|
|
{
|
|
EditorRow etRow = new EditorRow();
|
|
|
|
etRow.Properties.FieldName = propInf.Name;
|
|
etRow.Name = propInf.Name;
|
|
etRow.Properties.Caption = propInf.Name;
|
|
|
|
if (propInf.Name == "TestRequestID")
|
|
etRow.Properties.Value = ((string[])propInf.GetValue(data.SelectedData, null))[0];
|
|
else
|
|
etRow.Properties.Value = propInf.GetValue(data.SelectedData, null)?.ToString();
|
|
|
|
//etRow.Properties.Value = propInf.GetValue(data.SelectedData, null)?.ToString();
|
|
|
|
vGridControlInfo.Rows.Add(etRow);
|
|
}
|
|
|
|
OnSizeChanged(vGridControlInfo);
|
|
}
|
|
|
|
void OnSizeChanged(VGridControl grid)
|
|
{
|
|
int width = grid.ClientSize.Width / (grid.RecordCount + 1);
|
|
grid.RecordWidth = width;
|
|
grid.RowHeaderWidth = width;
|
|
}
|
|
|
|
private void UcTRADetailTestResult_Load(object sender, System.EventArgs e)
|
|
{
|
|
}
|
|
|
|
private void simpleButtonAllData_Click(object sender, EventArgs e)
|
|
{
|
|
DataRow dtTestlistRow = GetTestStepInfo(SelectedData.StepNo, DTTestlistSrc);
|
|
DataTable dtResult = gridControlMain.DataSource as DataTable;
|
|
TrendDataResult resultUnit = MakeTrendSummary(dtResult, dtTestlistRow, SelectedData, false);
|
|
bool bAutoRange = toggleSwitchAutoRange.IsOn;
|
|
|
|
ShowTestStepSummary(resultUnit);
|
|
ShowTrendChart(resultUnit, bAutoRange);
|
|
}
|
|
|
|
private void simpleButtonOKDataOnly_Click(object sender, EventArgs e)
|
|
{
|
|
DataRow dtTestlistRow = GetTestStepInfo(SelectedData.StepNo, DTTestlistSrc);
|
|
DataTable dtResult = gridControlMain.DataSource as DataTable;
|
|
TrendDataResult resultUnit = MakeTrendSummary(dtResult, dtTestlistRow, SelectedData);
|
|
bool bAutoRange = toggleSwitchAutoRange.IsOn;
|
|
|
|
ShowTestStepSummary(resultUnit);
|
|
ShowTrendChart(resultUnit, bAutoRange);
|
|
}
|
|
|
|
public class TrendDataResult
|
|
{
|
|
public class StepDataElement
|
|
{
|
|
public int RowNo { get; set; }
|
|
public DateTime TestTime { get; set; }
|
|
public string ProductID { get; set; }
|
|
public double Value { get; set; }
|
|
public bool UseMin { get; set; }
|
|
public bool UseMax { get; set; }
|
|
public double Min { get; set; }
|
|
public double Max { get; set; }
|
|
public double Tolerance { get; set; }
|
|
public eResultType Result { get; set; }
|
|
}
|
|
|
|
public double dSpecNotUse = -999999;
|
|
public List<StepDataElement> DataElements { get; set; } = new List<StepDataElement>();
|
|
public double Average { get; set; }
|
|
public double Min { get; set; }
|
|
public double Max { get; set; }
|
|
public double Variance { get; set; }
|
|
public double StdDev { get; set; }
|
|
public double MinSpec { get; set; }
|
|
public double MaxSpec { get; set; }
|
|
public double Cp { get; set; }
|
|
public double Cpk { get; set; }
|
|
public double Cg { get; set; }
|
|
|
|
}
|
|
|
|
private void gridViewMain_RowCellClick(object sender, RowCellClickEventArgs e)
|
|
{
|
|
int nClickCnt = e.Clicks;
|
|
|
|
int nRowHndl = e.RowHandle;
|
|
|
|
if (nRowHndl < 0)
|
|
return;
|
|
|
|
string strGetId = DTTestLogList.Rows[e.RowHandle][18].ToString();
|
|
|
|
BaseRow br = vGridControlInfo.Rows.GetRowByFieldName("TestRequestID");
|
|
vGridControlInfo.SetCellValue(br, 0, strGetId);
|
|
}
|
|
|
|
private void chartControlMain_DoubleClick(object sender, EventArgs e)
|
|
{
|
|
SwiftPlotDiagram diagram = (SwiftPlotDiagram)chartControlMain.Diagram;
|
|
|
|
if (diagram != null)
|
|
{
|
|
diagram.AxisY.WholeRange.Auto = !diagram.AxisY.WholeRange.Auto;
|
|
|
|
if (diagram.AxisY.WholeRange.Auto)
|
|
chartControlMain.BackColor = Color.WhiteSmoke;
|
|
else
|
|
{
|
|
diagram.AxisY.WholeRange.SetMinMaxValues(dThisMinLimit - dThisUnitSize, dThisMaxLimit + dThisUnitSize);
|
|
|
|
chartControlMain.BackColor = Color.White;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|